← Back to branch summary

~divmod-dev/divmod.org/trunk

« back to all changes in this revision

Viewing changes to Nevow/nevow/js/Nevow/Test/TestTabbedPane.js

  • Committer: Jean-Paul Calderone
  • Date: 2014-06-29 20:33:04 UTC
  • mfrom: (2749.1.1 remove-epsilon-1325289)
  • Revision ID: exarkun@twistedmatrix.com-20140629203304-gdkmbwl1suei4m97
merge lp:~exarkun/divmod.org/remove-epsilon-1325289

Show diffs side-by-side

added added

removed removed

Lines of Context:
Nevow/nevow/js/Nevow/Test/TestTabbedPane.js
1
 
// -*- test-case-name: nevow.test.test_javascript.JSUnitTests.test_tabbedPane -*-
2
 
 
3
 
// import Divmod.UnitTest
4
 
// import Nevow.Test.WidgetUtil
5
 
// import Nevow.TagLibrary.TabbedPane
6
 
 
7
 
Nevow.Test.TestTabbedPane.TabbedPaneViewTests = Divmod.UnitTest.TestCase.subclass(
8
 
    'Nevow.Test.TestTabbedPane.TabbedPaneViewTests');
9
 
/**
10
 
 * Tests for L{Nevow.TagLibrary.TabbedPane.TabbedPaneView}.
11
 
 */
12
 
Nevow.Test.TestTabbedPane.TabbedPaneViewTests.methods(
13
 
    /**
14
 
     * L{Nevow.TagLibrary.TabbedPane.TabbedPaneView.tabNameFromTabNode} should
15
 
     * get the right value.
16
 
     */
17
 
    function test_tabNameFromTabNode(self) {
18
 
        var view = Nevow.TagLibrary.TabbedPane.TabbedPaneView(null, null);
19
 
        var name = 'test_tabNameFromTabNode';
20
 
        var tabNode = document.createElement('li');
21
 
        tabNode.appendChild(document.createTextNode(name));
22
 
        self.assertIdentical(
23
 
            view.tabNameFromTabNode(tabNode), name);
24
 
    },
25
 
 
26
 
    /**
27
 
     * Make a tab container node containing tabs with the given names.
28
 
     */
29
 
    function _makeTabContainerNode(self, tabNames, selected) {
30
 
        var tabContainerNode = document.createElement('ul');
31
 
        var tabNode = document.createElement('li');
32
 
        for(var i = 0; i < tabNames.length; i++) {
33
 
            var tabNode = document.createElement('li');
34
 
            var className;
35
 
            if(i === selected) {
36
 
                className = 'nevow-tabbedpane-selected-tab';
37
 
            } else {
38
 
                className = 'nevow-tabbedpane-tab';
39
 
            }
40
 
            tabNode.setAttribute('class', className);
41
 
            tabNode.appendChild(document.createTextNode(tabNames[i]));
42
 
            tabContainerNode.appendChild(tabNode);
43
 
        }
44
 
        return tabContainerNode;
45
 
    },
46
 
 
47
 
    /**
48
 
     * Make a pane container node containing the given number of panes.
49
 
     */
50
 
    function _makePaneContainerNode(self, paneCount, selected) {
51
 
        var paneContainerNode = document.createElement('div');
52
 
        for(var i = 0; i < paneCount; i++) {
53
 
            var paneNode = document.createElement('div');
54
 
            var className;
55
 
            if(i === selected) {
56
 
                className = 'nevow-tabbedpane-selected-pane';
57
 
            } else {
58
 
                className = 'nevow-tabbedpane-pane';
59
 
            }
60
 
            paneNode.setAttribute('class', className);
61
 
            paneContainerNode.appendChild(paneNode);
62
 
        }
63
 
        return paneContainerNode;
64
 
    },
65
 
 
66
 
    /**
67
 
     * L{Nevow.TagLibrary.TabbedPane.TabbedPaneView.getNamedPaneNode} should
68
 
     * return the right node.
69
 
     */
70
 
    function test_getNamedPaneNode(self) {
71
 
        var tabContainerNode = self._makeTabContainerNode(
72
 
            ['foo', 'bar'], 0);
73
 
        var paneContainerNode = self._makePaneContainerNode(2, 0);
74
 
        var secondPaneNode = paneContainerNode.childNodes[1];
75
 
        var view = Nevow.TagLibrary.TabbedPane.TabbedPaneView(
76
 
            function nodeById(id) {
77
 
                return {
78
 
                    'pane-container': paneContainerNode,
79
 
                    'tab-container': tabContainerNode
80
 
                }[id];
81
 
            }, 'foo');
82
 
        self.assertIdentical(
83
 
            view.getNamedPaneNode('bar'), secondPaneNode);
84
 
    },
85
 
 
86
 
    /**
87
 
     * L{Nevow.TagLibrary.TabbedPane.TabbedPaneView.replaceNamedPaneContent}
88
 
     * should append the given node and remove any existing ones.
89
 
     */
90
 
    function test_replaceNamedPaneContent(self) {
91
 
        var tabContainerNode = self._makeTabContainerNode(
92
 
            ['foo', 'bar'], 0);
93
 
        var paneContainerNode = self._makePaneContainerNode(2, 0);
94
 
        var secondPaneNode = paneContainerNode.childNodes[1];
95
 
        secondPaneNode.appendChild(document.createTextNode('HI'));
96
 
        secondPaneNode.appendChild(document.createElement('div'));
97
 
        var view = Nevow.TagLibrary.TabbedPane.TabbedPaneView(
98
 
            function nodeById(id) {
99
 
                return {
100
 
                    'pane-container': paneContainerNode,
101
 
                    'tab-container': tabContainerNode
102
 
                }[id];
103
 
            }, 'foo');
104
 
        var replacementNode = document.createElement('div');
105
 
        view.replaceNamedPaneContent('bar', replacementNode);
106
 
        self.assertIdentical(secondPaneNode.childNodes.length, 1);
107
 
        self.assertIdentical(
108
 
            secondPaneNode.childNodes[0], replacementNode);
109
 
    },
110
 
 
111
 
    /**
112
 
     * L{Nevow.TagLibrary.TabbedPane.TabbedPaneView.selectNamedTab} should
113
 
     * select the right tab node.
114
 
     */
115
 
    function test_selectNamedTab(self) {
116
 
        var tabContainerNode = self._makeTabContainerNode(
117
 
            ['first tab node', 'second tab node'], 0);
118
 
        var firstTabNode = tabContainerNode.childNodes[0];
119
 
        var secondTabNode = tabContainerNode.childNodes[1];
120
 
        var paneContainerNode = self._makePaneContainerNode(2, 0);
121
 
        var firstPaneNode = paneContainerNode.childNodes[0];
122
 
        var secondPaneNode = paneContainerNode.childNodes[1];
123
 
 
124
 
        var view = Nevow.TagLibrary.TabbedPane.TabbedPaneView(
125
 
            function nodeById(id) {
126
 
                return {
127
 
                    'pane-container': paneContainerNode,
128
 
                    'tab-container': tabContainerNode
129
 
                }[id];
130
 
            }, 'first tab node');
131
 
        view.selectNamedTab('second tab node');
132
 
        self.assertIdentical(
133
 
            firstTabNode.getAttribute('class'), 'nevow-tabbedpane-tab');
134
 
        self.assertIdentical(
135
 
            firstPaneNode.getAttribute('class'), 'nevow-tabbedpane-pane');
136
 
        self.assertIdentical(
137
 
            secondTabNode.getAttribute('class'),
138
 
            'nevow-tabbedpane-selected-tab');
139
 
        self.assertIdentical(
140
 
            secondPaneNode.getAttribute('class'),
141
 
            'nevow-tabbedpane-selected-pane');
142
 
    });
143
 
 
144
 
 
145
 
Nevow.Test.TestTabbedPane.StubTabbedPaneView = Divmod.Class.subclass(
146
 
    'Nevow.Test.TestTabbedPane.StubTabbedPaneView');
147
 
/**
148
 
 * Stub L{Nevow.TagLibrary.TabbedPane.TabbedPaneView}.
149
 
 *
150
 
 * @ivar tabName: Value to return from L{tabNameFromTabNode}.
151
 
 * @type tabName: C{String}
152
 
 *
153
 
 * @ivar selectedTabName: The name of the currently selected tab.
154
 
 * @type selectedTabName: C{String}
155
 
 *
156
 
 * @ivar tabNodes: Sequence of nodes passed to L{tabNameFromTabNode}.
157
 
 * @type tabNodes: C{Array}
158
 
 */
159
 
Nevow.Test.TestTabbedPane.StubTabbedPaneView.methods(
160
 
    function __init__(self, tabName, selectedTabName) {
161
 
        self.tabName = tabName;
162
 
        self.selectedTabName = selectedTabName;
163
 
        self.tabNodes = [];
164
 
    },
165
 
 
166
 
    /**
167
 
     * Store C{tabNode} and return L{tabName}.
168
 
     */
169
 
    function tabNameFromTabNode(self, tabNode) {
170
 
        self.tabNodes.push(tabNode);
171
 
        return self.tabName;
172
 
    },
173
 
 
174
 
    /**
175
 
     * Set L{selectedTabName} to C{tabName}.
176
 
     */
177
 
    function selectNamedTab(self, tabName) {
178
 
        self.selectedTabName = tabName;
179
 
    });
180
 
 
181
 
 
182
 
Nevow.Test.TestTabbedPane.TabbedPaneTests = Divmod.UnitTest.TestCase.subclass(
183
 
    'Nevow.Test.TestTabbedPane.TabbedPaneTests');
184
 
/**
185
 
 * Tests for L{Nevow.TagLibrary.TabbedPane.TabbedPane}.
186
 
 */
187
 
Nevow.Test.TestTabbedPane.TabbedPaneTests.methods(
188
 
    /**
189
 
     * L{Nevow.TagLibrary.TabbedPane.TabbedPane.dom_tabClicked} should call
190
 
     * C{tabClicked}.
191
 
     */
192
 
    function test_dom_tabClicked(self) {
193
 
        var controller = Nevow.TagLibrary.TabbedPane.TabbedPane(
194
 
            Nevow.Test.WidgetUtil.makeWidgetNode());
195
 
        var theTabNode;
196
 
        controller.tabClicked = function tabClicked(node) {
197
 
            theTabNode = node;
198
 
        }
199
 
        var tabNode = {};
200
 
        self.assertIdentical(controller.dom_tabClicked(tabNode), false);
201
 
        self.assertIdentical(theTabNode, tabNode);
202
 
    },
203
 
 
204
 
    /**
205
 
     * L{Nevow.TagLibrary.TabbedPane.TabbedPane.tabClicked} should call the
206
 
     * appropriate view methods.
207
 
     */
208
 
    function test_tabClicked(self) {
209
 
        var selectedTabName = 'some boring thing';
210
 
        var controller = Nevow.TagLibrary.TabbedPane.TabbedPane(
211
 
            Nevow.Test.WidgetUtil.makeWidgetNode(), selectedTabName);
212
 
        controller.loaded();
213
 
        var theSelectedTab;
214
 
        controller.namedTabSelected = function(selectedTab) {
215
 
            theSelectedTab = selectedTab;
216
 
        }
217
 
        var tabNode = {};
218
 
        var tabName = 'test_tabClicked';
219
 
        var view = Nevow.Test.TestTabbedPane.StubTabbedPaneView(
220
 
            tabName, selectedTabName);
221
 
        controller.view = view;
222
 
        controller.tabClicked(tabNode);
223
 
        self.assertIdentical(view.tabNodes.length, 1);
224
 
        self.assertIdentical(view.tabNodes[0], tabNode);
225
 
        self.assertIdentical(view.selectedTabName, tabName);
226
 
        self.assertIdentical(theSelectedTab, tabName);
227
 
    },
228
 
 
229
 
    /**
230
 
     * L{Nevow.TagLibrary.TabbedPane.TabbedPane.dom_tabClicked} should defer
231
 
     * any tab change until C{loaded} has been called.
232
 
     */
233
 
    function test_dom_tabClickedLoaded(self) {
234
 
        var selectedTabName = 'some boring thing';
235
 
        var tabNode = {};
236
 
        var tabName = 'test_dom_tabClickedLoaded';
237
 
        var controller = Nevow.TagLibrary.TabbedPane.TabbedPane(
238
 
            Nevow.Test.WidgetUtil.makeWidgetNode(), selectedTabName);
239
 
        var view = Nevow.Test.TestTabbedPane.StubTabbedPaneView(
240
 
            tabName, selectedTabName);
241
 
        controller.view = view;
242
 
        self.assertIdentical(controller.dom_tabClicked(tabNode), false);
243
 
        self.assertIdentical(view.tabNodes.length, 1);
244
 
        self.assertIdentical(view.tabNodes[0], tabNode);
245
 
        self.assertIdentical(view.selectedTabName, selectedTabName);
246
 
        controller.loaded();
247
 
        self.assertIdentical(view.selectedTabName, tabName);
248
 
    });
249
 
 
250
 
 
251
 
Nevow.Test.TestTabbedPane.TabbedPaneFetcher = Nevow.Athena.Widget.subclass(
252
 
    'Nevow.Test.TestTabbedPane.TabbedPaneFetcher');
253
 
/**
254
 
 * Trivial L{Nevow.Athena.Widget} subclass which fetches a tabbed pane widget
255
 
 * remotely.
256
 
 */
257
 
Nevow.Test.TestTabbedPane.TabbedPaneFetcher.methods(
258
 
    /**
259
 
     * Fetch a tabbed pane widget and add it as a child.
260
 
     */
261
 
    function dom_getTabbedPane(self) {
262
 
        var result = self.callRemote('getTabbedPane');
263
 
        result.addCallback(
264
 
            function(widgetInfo) {
265
 
                return self.addChildWidgetFromWidgetInfo(widgetInfo);
266
 
            });
267
 
        result.addCallback(
268
 
            function(widget) {
269
 
                self.node.appendChild(widget.node);
270
 
            });
271
 
        return false;
272
 
    });