1 require("../env");

     2 require("../../d3");

     3 

     4 var vows = require("vows"),

     5     assert = require("assert");

     6 

     7 var suite = vows.describe("selection.call");

     8 

     9 suite.addBatch({

    10   "select(body)": {

    11     topic: function() {

    12       return d3.select("body").html("");

    13     },

    14     "adds a missing class as true": function(body) {

    15       body.attr("class", null);

    16       body.classed("foo", true);

    17       assert.equal(document.body.className, "foo");

    18       body.classed("bar", true);

    19       assert.equal(document.body.className, "foo bar");

    20     },

    21     "adds a missing class as a function": function(body) {

    22       body.attr("class", null);

    23       body.classed("foo", function() { return true; });

    24       assert.equal(document.body.className, "foo");

    25       body.classed("bar", function() { return true; });

    26       assert.equal(document.body.className, "foo bar");

    27     },

    28     "removes an existing class as false": function(body) {

    29       body.attr("class", "bar foo");

    30       body.classed("foo", false);

    31       assert.equal(document.body.className, "bar");

    32       body.classed("bar", false);

    33       assert.equal(document.body.className, "");

    34     },

    35     "removes an existing class as a function": function(body) {

    36       body.attr("class", "bar foo");

    37       body.classed("foo", function() { return false; });

    38       assert.equal(document.body.className, "bar");

    39       body.classed("bar", function() { return false; });

    40       assert.equal(document.body.className, "");

    41     },

    42     "preserves an existing class as true": function(body) {

    43       body.attr("class", "bar foo");

    44       body.classed("foo", true);

    45       assert.equal(document.body.className, "bar foo");

    46       body.classed("bar", true);

    47       assert.equal(document.body.className, "bar foo");

    48     },

    49     "preserves an existing class as a function": function(body) {

    50       body.attr("class", "bar foo");

    51       body.classed("foo", function() { return true; });

    52       assert.equal(document.body.className, "bar foo");

    53       body.classed("bar", function() { return true; });

    54       assert.equal(document.body.className, "bar foo");

    55     },

    56     "preserves a missing class as false": function(body) {

    57       body.attr("class", "baz");

    58       body.classed("foo", false);

    59       assert.equal(document.body.className, "baz");

    60       body.attr("class", null);

    61       body.classed("bar", false);

    62       assert.equal(document.body.className, "");

    63     },

    64     "preserves a missing class as a function": function(body) {

    65       body.attr("class", "baz");

    66       body.classed("foo", function() { return false; });

    67       assert.equal(document.body.className, "baz");

    68       body.attr("class", null);

    69       body.classed("bar", function() { return false; });

    70       assert.equal(document.body.className, "");

    71     },

    72     "gets an existing class": function(body) {

    73       body.attr("class", " foo\tbar  baz");

    74       assert.isTrue(body.classed("foo"));

    75       assert.isTrue(body.classed("bar"));

    76       assert.isTrue(body.classed("baz"));

    77     },

    78     "does not get a missing class": function(body) {

    79       body.attr("class", " foo\tbar  baz");

    80       assert.isFalse(body.classed("foob"));

    81       assert.isFalse(body.classed("bare"));

    82       assert.isFalse(body.classed("rbaz"));

    83     },

    84     "returns the current selection": function(body) {

    85       assert.isTrue(body.classed("foo", true) === body);

    86     },

    87     "adds missing classes as true": function(body) {

    88       body.attr("class", null);

    89       body.classed("foo bar", true);

    90       assert.equal(document.body.className, "foo bar");

    91     },

    92     "gets existing classes": function(body) {

    93       body.attr("class", " foo\tbar  baz");

    94       assert.isTrue(body.classed("foo"));

    95       assert.isTrue(body.classed("foo bar"));

    96       assert.isTrue(body.classed("bar baz"));

    97       assert.isTrue(body.classed("foo bar baz"));

    98     },

    99     "does not get missing classes": function(body) {

   100       body.attr("class", " foo\tbar  baz");

   101       assert.isFalse(body.classed("foob"));

   102       assert.isFalse(body.classed("foob bar"));

   103       assert.isFalse(body.classed("bar baz blah"));

   104       assert.isFalse(body.classed("foo bar baz moo"));

   105     }

   106   }

   107 });

   108 

   109 suite.addBatch({

   110   "selectAll(div)": {

   111     topic: function() {

   112       return d3.select("body").html("").selectAll("div").data(d3.range(2)).enter().append("div");

   113     },

   114     "adds a missing class as true": function(div) {

   115       div.attr("class", null);

   116       div.classed("foo", true);

   117       assert.equal(div[0][0].className, "foo");

   118       assert.equal(div[0][1].className, "foo");

   119       div.classed("bar", true);

   120       assert.equal(div[0][0].className, "foo bar");

   121       assert.equal(div[0][1].className, "foo bar");

   122     },

   123     "adds a missing class as a function": function(div) {

   124       div.data([0, 1]).attr("class", null);

   125       div.classed("foo", function(d, i) { return d === 0; });

   126       assert.equal(div[0][0].className, "foo");

   127       assert.equal(div[0][1].className, "");

   128       div.classed("bar", function(d, i) { return i === 1; });

   129       assert.equal(div[0][0].className, "foo");

   130       assert.equal(div[0][1].className, "bar");

   131     },

   132     "removes an existing class as false": function(div) {

   133       div.attr("class", "bar foo");

   134       div.classed("foo", false);

   135       assert.equal(div[0][0].className, "bar");

   136       assert.equal(div[0][1].className, "bar");

   137       div.classed("bar", false);

   138       assert.equal(div[0][0].className, "");

   139       assert.equal(div[0][1].className, "");

   140     },

   141     "removes an existing class as a function": function(div) {

   142       div.data([0, 1]).attr("class", "bar foo");

   143       div.classed("foo", function(d, i) { return d === 0; });

   144       assert.equal(div[0][0].className, "bar foo");

   145       assert.equal(div[0][1].className, "bar");

   146       div.classed("bar", function(d, i) { return i === 1; });

   147       assert.equal(div[0][0].className, "foo");

   148       assert.equal(div[0][1].className, "bar");

   149       div.classed("foo", function() { return false; });

   150       assert.equal(div[0][0].className, "");

   151       assert.equal(div[0][1].className, "bar");

   152       div.classed("bar", function() { return false; });

   153       assert.equal(div[0][0].className, "");

   154       assert.equal(div[0][1].className, "");

   155     },

   156     "preserves an existing class as true": function(div) {

   157       div.attr("class", "bar foo");

   158       div.classed("foo", true);

   159       assert.equal(div[0][0].className, "bar foo");

   160       assert.equal(div[0][1].className, "bar foo");

   161       div.classed("bar", true);

   162       assert.equal(div[0][0].className, "bar foo");

   163       assert.equal(div[0][1].className, "bar foo");

   164     },

   165     "preserves an existing class as a function": function(div) {

   166       div.attr("class", "bar foo");

   167       div.classed("foo", function() { return true; });

   168       assert.equal(div[0][0].className, "bar foo");

   169       assert.equal(div[0][1].className, "bar foo");

   170       div.classed("bar", function() { return true; });

   171       assert.equal(div[0][0].className, "bar foo");

   172       assert.equal(div[0][1].className, "bar foo");

   173     },

   174     "preserves a missing class as false": function(div) {

   175       div.attr("class", "baz");

   176       div.classed("foo", false);

   177       assert.equal(div[0][0].className, "baz");

   178       assert.equal(div[0][1].className, "baz");

   179       div.attr("class", null);

   180       div.classed("bar", false);

   181       assert.equal(div[0][0].className, "");

   182       assert.equal(div[0][1].className, "");

   183     },

   184     "preserves a missing class as a function": function(div) {

   185       div.attr("class", "baz");

   186       div.classed("foo", function() { return false; });

   187       assert.equal(div[0][0].className, "baz");

   188       assert.equal(div[0][1].className, "baz");

   189       div.attr("class", null);

   190       div.classed("bar", function() { return false; });

   191       assert.equal(div[0][0].className, "");

   192       assert.equal(div[0][1].className, "");

   193     },

   194     "gets an existing class": function(div) {

   195       div[0][0].className = " foo\tbar  baz";

   196       assert.isTrue(div.classed("foo"));

   197       assert.isTrue(div.classed("bar"));

   198       assert.isTrue(div.classed("baz"));

   199     },

   200     "does not get a missing class": function(div) {

   201       div[0][0].className = " foo\tbar  baz";

   202       assert.isFalse(div.classed("foob"));

   203       assert.isFalse(div.classed("bare"));

   204       assert.isFalse(div.classed("rbaz"));

   205     },

   206     "ignores null nodes": function(div) {

   207       var some = d3.selectAll("div");

   208       some[0][1] = null;

   209       some.attr("class", null).classed("foo", true);

   210       assert.equal(div[0][0].className, "foo");

   211       assert.equal(div[0][1].className, "");

   212     },

   213     "returns the current selection": function(div) {

   214       assert.isTrue(div.classed("foo", true) === div);

   215     }

   216   }

   217 });

   218 

   219 suite.export(module);