← Back to branch summary

~bcsaller/juju-gui/update-reductions

« back to all changes in this revision

Viewing changes to lib/d3/test/core/selection-data-test.js

  • Committer: kapil.foss at gmail
  • Date: 2012-07-13 18:45:59 UTC
  • Revision ID: kapil.foss@gmail.com-20120713184559-2xl7be17egsrz0c9
reshape

Show diffs side-by-side

added added

removed removed

Lines of Context:
lib/d3/test/core/selection-data-test.js
1
 
require("../env");
2
 
 
3
 
var vows = require("vows"),
4
 
    assert = require("assert");
5
 
 
6
 
var suite = vows.describe("selection.data");
7
 
 
8
 
suite.addBatch({
9
 
  "select(body)": {
10
 
    topic: function() {
11
 
      return d3.select("body").html("");
12
 
    },
13
 
    "assigns data as an array": function(body) {
14
 
      var data = new Object();
15
 
      body.data([data]);
16
 
      assert.strictEqual(document.body.__data__, data);
17
 
    },
18
 
    "assigns data as a function": function(body) {
19
 
      var data = new Object();
20
 
      body.data(function() { return [data]; });
21
 
      assert.strictEqual(document.body.__data__, data);
22
 
    },
23
 
    "stores data in the DOM": function(body) {
24
 
      var expected = new Object(), actual;
25
 
      document.body.__data__ = expected;
26
 
      body.each(function(d) { actual = d; });
27
 
      assert.strictEqual(actual, expected);
28
 
    },
29
 
    "returns a new selection": function(body) {
30
 
      assert.isFalse(body.data([1]) === body);
31
 
    },
32
 
    "with no arguments, returns an array of data": function(body) {
33
 
      var data = new Object();
34
 
      body.data([data]);
35
 
      assert.deepEqual(body.data(), [data]);
36
 
      assert.strictEqual(body.data()[0], data);
37
 
    },
38
 
    "throws an error if data is null or undefined": function(body) {
39
 
      assert.throws(function() { body.data(null); }, Error);
40
 
      assert.throws(function() { body.data(function() {}); }, Error);
41
 
    }
42
 
  }
43
 
});
44
 
 
45
 
suite.addBatch({
46
 
  "selectAll(div)": {
47
 
    topic: function() {
48
 
      return d3.select("body").html("").selectAll("div").data(d3.range(2)).enter().append("div");
49
 
    },
50
 
    "assigns data as an array": function(div) {
51
 
      var a = new Object(), b = new Object();
52
 
      div.data([a, b]);
53
 
      assert.strictEqual(div[0][0].__data__, a);
54
 
      assert.strictEqual(div[0][1].__data__, b);
55
 
    },
56
 
    "assigns data as a function": function(div) {
57
 
      var a = new Object(), b = new Object();
58
 
      div.data(function() { return [a, b]; });
59
 
      assert.strictEqual(div[0][0].__data__, a);
60
 
      assert.strictEqual(div[0][1].__data__, b);
61
 
    },
62
 
    "stores data in the DOM": function(div) {
63
 
      var a = new Object(), b = new Object(), actual = [];
64
 
      div[0][0].__data__ = a;
65
 
      div[0][1].__data__ = b;
66
 
      div.each(function(d) { actual.push(d); });
67
 
      assert.deepEqual(actual, [a, b]);
68
 
    },
69
 
    "returns a new selection": function(div) {
70
 
      assert.isFalse(div.data([0, 1]) === div);
71
 
    },
72
 
    "throws an error if data is null or undefined": function(div) {
73
 
      assert.throws(function() { div.data(null); }, Error);
74
 
      assert.throws(function() { div.data(function() {}); }, Error);
75
 
    },
76
 
    "with no arguments, returns an array of data": function(div) {
77
 
      var a = new Object(), b = new Object(), actual = [];
78
 
      div[0][0].__data__ = a;
79
 
      div[0][1].__data__ = b;
80
 
      assert.deepEqual(div.data(), [a, b]);
81
 
    },
82
 
    "with no arguments, returned array has undefined for null nodes": function(div) {
83
 
      var b = new Object(), actual = [];
84
 
      div[0][0] = null;
85
 
      div[0][1].__data__ = b;
86
 
      var data = div.data();
87
 
      assert.isUndefined(data[0]);
88
 
      assert.strictEqual(data[1], b);
89
 
      assert.equal(data.length, 2);
90
 
    }
91
 
  }
92
 
});
93
 
 
94
 
suite.addBatch({
95
 
  "selectAll(div).selectAll(span)": {
96
 
    topic: function() {
97
 
      return d3.select("body").html("").selectAll("div")
98
 
          .data(d3.range(2))
99
 
        .enter().append("div").selectAll("span")
100
 
          .data(d3.range(2))
101
 
        .enter().append("span");
102
 
    },
103
 
    "assigns data as an array": function(span) {
104
 
      var a = new Object(), b = new Object();
105
 
      span.data([a, b]);
106
 
      assert.strictEqual(span[0][0].__data__, a);
107
 
      assert.strictEqual(span[0][1].__data__, b);
108
 
      assert.strictEqual(span[1][0].__data__, a);
109
 
      assert.strictEqual(span[1][1].__data__, b);
110
 
    },
111
 
    "assigns data as a function": function(span) {
112
 
      var a = new Object(), b = new Object(), c = new Object(), d = new Object();
113
 
      span.data(function(z, i) { return i ? [c, d] : [a, b]; });
114
 
      assert.strictEqual(span[0][0].__data__, a);
115
 
      assert.strictEqual(span[0][1].__data__, b);
116
 
      assert.strictEqual(span[1][0].__data__, c);
117
 
      assert.strictEqual(span[1][1].__data__, d);
118
 
    },
119
 
    "evaluates the function once per group": function(span) {
120
 
      var count = 0;
121
 
      span.data(function() { ++count; return [0, 1]; });
122
 
      assert.equal(count, 2);
123
 
    },
124
 
    "defines an update selection for updating data": function(span) {
125
 
      var update = span.data(d3.range(4));
126
 
      assert.equal(update.length, 2);
127
 
      assert.equal(update[0].length, 4);
128
 
      assert.equal(update[1].length, 4);
129
 
      assert.domEqual(update[0][0], span[0][0]);
130
 
      assert.domEqual(update[0][1], span[0][1]);
131
 
      assert.domNull(update[0][2]);
132
 
      assert.domNull(update[0][3]);
133
 
      assert.domEqual(update[1][0], span[1][0]);
134
 
      assert.domEqual(update[1][1], span[1][1]);
135
 
      assert.domNull(update[1][2]);
136
 
      assert.domNull(update[1][3]);
137
 
    },
138
 
    "defines an enter selection for entering data": function(span) {
139
 
      var enter = span.data(d3.range(4)).enter();
140
 
      assert.isFalse(enter.empty());
141
 
      assert.equal(enter.length, 2);
142
 
      assert.equal(enter[0].length, 4);
143
 
      assert.equal(enter[1].length, 4);
144
 
      assert.domNull(enter[0][0]);
145
 
      assert.domNull(enter[0][1]);
146
 
      assert.deepEqual(enter[0][2], {__data__: 2});
147
 
      assert.deepEqual(enter[0][3], {__data__: 3});
148
 
      assert.domNull(enter[1][0]);
149
 
      assert.domNull(enter[1][1]);
150
 
      assert.deepEqual(enter[1][2], {__data__: 2});
151
 
      assert.deepEqual(enter[1][3], {__data__: 3});
152
 
    },
153
 
    "defines an exit selection for exiting data": function(span) {
154
 
      var exit = span.data(d3.range(1)).exit();
155
 
      assert.isFalse(exit.empty());
156
 
      assert.equal(exit.length, 2);
157
 
      assert.equal(exit[0].length, 2);
158
 
      assert.equal(exit[1].length, 2);
159
 
      assert.domNull(exit[0][0]);
160
 
      assert.domEqual(exit[0][1], span[0][1]);
161
 
      assert.domNull(exit[1][0]);
162
 
      assert.domEqual(exit[1][1], span[1][1]);
163
 
    },
164
 
    "observes the specified key function": function(span) {
165
 
      var update = span.data([1, 2], Number);
166
 
      assert.isFalse(update.empty());
167
 
      assert.equal(update.length, 2);
168
 
      assert.equal(update[0].length, 2);
169
 
      assert.equal(update[1].length, 2);
170
 
      assert.domEqual(update[0][0], span[0][1]);
171
 
      assert.domNull(update[0][1]);
172
 
      assert.domEqual(update[1][0], span[1][1]);
173
 
      assert.domNull(update[1][1]);
174
 
 
175
 
      var enter = update.enter();
176
 
      assert.equal(enter.length, 2);
177
 
      assert.equal(enter[0].length, 2);
178
 
      assert.equal(enter[1].length, 2);
179
 
      assert.domNull(enter[0][0]);
180
 
      assert.deepEqual(enter[0][1], {__data__: 2});
181
 
      assert.domNull(enter[1][0]);
182
 
      assert.deepEqual(enter[1][1], {__data__: 2});
183
 
 
184
 
      var exit = update.exit();
185
 
      assert.equal(exit.length, 2);
186
 
      assert.equal(exit[0].length, 2);
187
 
      assert.equal(exit[1].length, 2);
188
 
      assert.domEqual(exit[0][0], span[0][0]);
189
 
      assert.domNull(exit[0][1]);
190
 
      assert.domEqual(exit[1][0], span[1][0]);
191
 
      assert.domNull(exit[1][1]);
192
 
    },
193
 
    "handles keys that are in the default object's prototype chain": function(span) {
194
 
      // This also applies to the non-standard "watch" and "unwatch" in Mozilla Firefox.
195
 
      var update = span.data(["hasOwnProperty", "isPrototypeOf", "toLocaleString", "toString", "valueOf"], String);
196
 
      assert.domNull(update[0][0]);
197
 
      assert.domNull(update[0][1]);
198
 
      assert.domNull(update[0][2]);
199
 
      assert.domNull(update[0][3]);
200
 
      assert.domNull(update[0][4]);
201
 
      // This throws an error if Object.hasOwnProperty isn't used.
202
 
      span.data([0], function() { return "hasOwnProperty"; });
203
 
    }
204
 
  }
205
 
});
206
 
 
207
 
suite.export(module);