1 require("../env");

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

     3 

     4 var vows = require("vows"),

     5     assert = require("assert");

     6 

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

     8 

     9 suite.addBatch({

    10   "select(body)": {

    11     topic: function() {

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

    13     },

    14     "assigns data as an array": function(body) {

    15       var data = new Object();

    16       body.data([data]);

    17       assert.strictEqual(document.body.__data__, data);

    18     },

    19     "assigns data as a function": function(body) {

    20       var data = new Object();

    21       body.data(function() { return [data]; });

    22       assert.strictEqual(document.body.__data__, data);

    23     },

    24     "stores data in the DOM": function(body) {

    25       var expected = new Object(), actual;

    26       document.body.__data__ = expected;

    27       body.each(function(d) { actual = d; });

    28       assert.strictEqual(actual, expected);

    29     },

    30     "returns a new selection": function(body) {

    31       assert.isFalse(body.data([1]) === body);

    32     }

    33   }

    34 });

    35 

    36 suite.addBatch({

    37   "selectAll(div)": {

    38     topic: function() {

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

    40     },

    41     "assigns data as an array": function(div) {

    42       var a = new Object(), b = new Object();

    43       div.data([a, b]);

    44       assert.strictEqual(div[0][0].__data__, a);

    45       assert.strictEqual(div[0][1].__data__, b);

    46     },

    47     "assigns data as a function": function(div) {

    48       var a = new Object(), b = new Object();

    49       div.data(function() { return [a, b]; });

    50       assert.strictEqual(div[0][0].__data__, a);

    51       assert.strictEqual(div[0][1].__data__, b);

    52     },

    53     "stores data in the DOM": function(div) {

    54       var a = new Object(), b = new Object(), actual = [];

    55       div[0][0].__data__ = a;

    56       div[0][1].__data__ = b;

    57       div.each(function(d) { actual.push(d); });

    58       assert.deepEqual(actual, [a, b]);

    59     },

    60     "returns a new selection": function(div) {

    61       assert.isFalse(div.data([0, 1]) === div);

    62     }

    63   }

    64 });

    65 

    66 suite.addBatch({

    67   "selectAll(div).selectAll(span)": {

    68     topic: function() {

    69       return d3.select("body").html("").selectAll("div")

    70           .data(d3.range(2))

    71         .enter().append("div").selectAll("span")

    72           .data(d3.range(2))

    73         .enter().append("span");

    74     },

    75     "assigns data as an array": function(span) {

    76       var a = new Object(), b = new Object();

    77       span.data([a, b]);

    78       assert.strictEqual(span[0][0].__data__, a);

    79       assert.strictEqual(span[0][1].__data__, b);

    80       assert.strictEqual(span[1][0].__data__, a);

    81       assert.strictEqual(span[1][1].__data__, b);

    82     },

    83     "assigns data as a function": function(span) {

    84       var a = new Object(), b = new Object(), c = new Object(), d = new Object();

    85       span.data(function(z, i) { return i ? [c, d] : [a, b]; });

    86       assert.strictEqual(span[0][0].__data__, a);

    87       assert.strictEqual(span[0][1].__data__, b);

    88       assert.strictEqual(span[1][0].__data__, c);

    89       assert.strictEqual(span[1][1].__data__, d);

    90     },

    91     "evaluates the function once per group": function(span) {

    92       var count = 0;

    93       span.data(function() { ++count; return [0, 1]; });

    94       assert.equal(count, 2);

    95     },

    96     "defines an update selection for updating data": function(span) {

    97       var update = span.data(d3.range(4));

    98       assert.equal(update.length, 2);

    99       assert.equal(update[0].length, 4);

   100       assert.equal(update[1].length, 4);

   101       assert.domEqual(update[0][0], span[0][0]);

   102       assert.domEqual(update[0][1], span[0][1]);

   103       assert.domNull(update[0][2]);

   104       assert.domNull(update[0][3]);

   105       assert.domEqual(update[1][0], span[1][0]);

   106       assert.domEqual(update[1][1], span[1][1]);

   107       assert.domNull(update[1][2]);

   108       assert.domNull(update[1][3]);

   109     },

   110     "defines an enter selection for entering data": function(span) {

   111       var enter = span.data(d3.range(4)).enter();

   112       assert.isFalse(enter.empty());

   113       assert.equal(enter.length, 2);

   114       assert.equal(enter[0].length, 4);

   115       assert.equal(enter[1].length, 4);

   116       assert.domNull(enter[0][0]);

   117       assert.domNull(enter[0][1]);

   118       assert.deepEqual(enter[0][2], {__data__: 2});

   119       assert.deepEqual(enter[0][3], {__data__: 3});

   120       assert.domNull(enter[1][0]);

   121       assert.domNull(enter[1][1]);

   122       assert.deepEqual(enter[1][2], {__data__: 2});

   123       assert.deepEqual(enter[1][3], {__data__: 3});

   124     },

   125     "defines an exit selection for exiting data": function(span) {

   126       var exit = span.data(d3.range(1)).exit();

   127       assert.isFalse(exit.empty());

   128       assert.equal(exit.length, 2);

   129       assert.equal(exit[0].length, 2);

   130       assert.equal(exit[1].length, 2);

   131       assert.domNull(exit[0][0]);

   132       assert.domEqual(exit[0][1], span[0][1]);

   133       assert.domNull(exit[1][0]);

   134       assert.domEqual(exit[1][1], span[1][1]);

   135     },

   136     "observes the specified key function": function(span) {

   137       var update = span.data([1, 2], Number);

   138       assert.isFalse(update.empty());

   139       assert.equal(update.length, 2);

   140       assert.equal(update[0].length, 2);

   141       assert.equal(update[1].length, 2);

   142       assert.domEqual(update[0][0], span[0][1]);

   143       assert.domNull(update[0][1]);

   144       assert.domEqual(update[1][0], span[1][1]);

   145       assert.domNull(update[1][1]);

   146 

   147       var enter = update.enter();

   148       assert.equal(enter.length, 2);

   149       assert.equal(enter[0].length, 2);

   150       assert.equal(enter[1].length, 2);

   151       assert.domNull(enter[0][0]);

   152       assert.deepEqual(enter[0][1], {__data__: 2});

   153       assert.domNull(enter[1][0]);

   154       assert.deepEqual(enter[1][1], {__data__: 2});

   155 

   156       var exit = update.exit();

   157       assert.equal(exit.length, 2);

   158       assert.equal(exit[0].length, 2);

   159       assert.equal(exit[1].length, 2);

   160       assert.domEqual(exit[0][0], span[0][0]);

   161       assert.domNull(exit[0][1]);

   162       assert.domEqual(exit[1][0], span[1][0]);

   163       assert.domNull(exit[1][1]);

   164     }

   165   }

   166 });

   167 

   168 suite.export(module);