← Back to branch summary

~ubuntu-branches/ubuntu/raring/maas/raring-updates

« back to all changes in this revision

Viewing changes to src/maasserver/static/jslibs/yui/3.4.1/tests/datasource/tests/src/datasource-function.js

  • Committer: Package Import Robot
  • Author(s): Andres Rodriguez
  • Date: 2012-07-03 17:42:37 UTC
  • mfrom: (1.1.13)
  • Revision ID: package-import@ubuntu.com-20120703174237-p8l0keuuznfg721k
Tags: 0.1+bzr709+dfsg-0ubuntu1
* New Upstream release
* debian/control:
  - Depends on python-celery, python-tempita, libjs-yui3-{full,min},
    libjs-raphael
* debian/maas.install:
  - Install apiclient, celeryconfig.py, maas-import-pxe-files, preseeds_v2.
  - Update to install various files from chroot, rather tha manually copy
    them from the source.
* debian/maas.links: symlink celeryconfig.py
* debian/maas.maas-celery.upstart: Add job.
* debian/rules:
  - Install celery upstart job.
  - Do not install jslibs as packages are now used.
  - Drop copying of maas_local_settings_sample.py as source now ships
    a maas_local_settings.py
* debian/patches:
  - 04-maas-http-fix.patch: Drop. Merged upstream.
  - 01-fix-database-settings.patch: Refreshed.
  - 99_enums_js.patch: Added until creation of enum.js / build process
    is fixed.
* debian/maas.postinst: Update bzr version to correctly handle upgrades.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/maasserver/static/jslibs/yui/3.4.1/tests/datasource/tests/src/datasource-function.js
1
 
var Assert = Y.Assert,
2
 
 
3
 
    suite = new Y.Test.Suite("DataSource.Function Test Suite");
4
 
 
5
 
function testFn() {
6
 
    return [
7
 
        { type: "a", age:  0, name: "c" },
8
 
        { type: "d", age:  1, name: "f" },
9
 
        { type: "g", age: -1, name: "i" }
10
 
    ];
11
 
}
12
 
 
13
 
suite.add(new Y.Test.Case({
14
 
    name: "DataSource.Function Tests",
15
 
 
16
 
    testFunctionDefaults: function() {
17
 
        var ds = new Y.DataSource.Function({ source: testFn }),
18
 
            request = null, response, tId, data, callback;
19
 
 
20
 
        ds.sendRequest({
21
 
            request: "foo",
22
 
            callback: {
23
 
                success: function (e) {
24
 
                    request  = e.request;
25
 
                    response = e.response;
26
 
                    tId      = e.tId;
27
 
                    data     = e.data;
28
 
                    callback = e.callback;
29
 
                }
30
 
            }
31
 
        });
32
 
 
33
 
        Assert.areSame("foo", request, "Expected same request.");
34
 
        Assert.isObject(response, "Expected response object.");
35
 
        Assert.isNotUndefined(tId);
36
 
        Assert.isNotUndefined(data);
37
 
        Assert.isNotUndefined(callback);
38
 
    },
39
 
 
40
 
    testFunctionEvents: function() {
41
 
        var ds = new Y.DataSource.Function({ source: testFn }),
42
 
            requestCallback, dataCallback, responseCallback;
43
 
 
44
 
        ds.plug(Y.Plugin.DataSourceArraySchema, {
45
 
            schema: {
46
 
                resultFields: ["type", "name"]
47
 
            }
48
 
        });
49
 
 
50
 
        ds.on("request", function (e) {
51
 
            Assert.areSame("dataSourceFunction:request", e.type);
52
 
            Assert.isNumber(e.tId, "request: Expected transaction ID.");
53
 
            Assert.areSame("foo", e.request, "Expected same request.");
54
 
            Assert.areSame("callback", e.callback, "request: Expected callback.");
55
 
            requestCallback = true;
56
 
        });
57
 
 
58
 
        ds.on("data", function (e) {
59
 
            Assert.areSame("dataSourceFunction:data", e.type);
60
 
            Assert.isNumber(e.tId, "data: Expected transaction ID.");
61
 
            Assert.areSame("foo", e.request, "Expected same request.");
62
 
            Assert.areSame("callback", e.callback, "data: Expected callback.");
63
 
            Assert.isObject(e.data, "data: Expected raw data.");
64
 
            dataCallback = true;
65
 
        });
66
 
 
67
 
        ds.on("response", function (e) {
68
 
            Assert.areSame("dataSourceFunction:response", e.type);
69
 
            Assert.isNumber(e.tId, "response: Expected transaction ID.");
70
 
            Assert.areSame("foo", e.request, "Expected same request.");
71
 
            Assert.areSame("callback", e.callback, "response: Expected callback.");
72
 
            Assert.isObject(e.data, "response: Expected raw data.");
73
 
            Assert.isObject(e.response, "response: Expected normalized response object.");
74
 
            Assert.isArray(e.response.results, "response: Expected parsed results.");
75
 
            Assert.isObject(e.response.meta, "response: Expected parsed meta data.");
76
 
            responseCallback = true;
77
 
        });
78
 
 
79
 
        ds.sendRequest({
80
 
            request: "foo",
81
 
            callback: "callback" // ???
82
 
        });
83
 
 
84
 
        Assert.isTrue(requestCallback);
85
 
        Assert.isTrue(dataCallback);
86
 
        Assert.isTrue(responseCallback);
87
 
    },
88
 
 
89
 
    testFunctionError: function() {
90
 
        var ds = new Y.DataSource.Function({ source: "foo" }),
91
 
            errorCallback;
92
 
 
93
 
        ds.plug(Y.Plugin.DataSourceArraySchema, {
94
 
            schema: {
95
 
                resultFields: ["type", "name"]
96
 
            }
97
 
        });
98
 
 
99
 
        ds.on("error", function (e) {
100
 
            Assert.areSame("dataSourceFunction:error", e.type);
101
 
            Assert.isNumber(e.tId, "error: Expected transaction ID.");
102
 
            Assert.areSame("a", e.request, "error: Expected request.");
103
 
            Assert.areSame("callback", e.callback, "error: Expected callback.");
104
 
            Assert.isUndefined(e.data, "error: Expected undefined data.");
105
 
            Assert.isObject(e.response, "error: Expected normalized response object.");
106
 
            Assert.isObject(e.error, "error: Expected error.");
107
 
            errorCallback = true;
108
 
        });
109
 
 
110
 
        ds.sendRequest({
111
 
            request: "a",
112
 
            callback: "callback"
113
 
        });
114
 
 
115
 
        Assert.isTrue(errorCallback);
116
 
    },
117
 
    
118
 
    testFunctionException: function() {
119
 
        var ds = new Y.DataSource.Function({
120
 
                source: function() {
121
 
                    throw new Error("myException");
122
 
                }
123
 
            }),
124
 
            errorCallback;
125
 
 
126
 
        ds.plug(Y.Plugin.DataSourceArraySchema, {
127
 
            schema: {
128
 
                resultFields: ["type", "name"]
129
 
            }
130
 
        });
131
 
 
132
 
        ds.on("error", function (e) {
133
 
            Assert.isNumber(e.tId, "error: Expected transaction ID.");
134
 
            Assert.areSame("a", e.request, "error: Expected request.");
135
 
            Assert.areSame("callback", e.callback, "error: Expected callback.");
136
 
            Assert.isUndefined(e.data, "error: Expected undefined data.");
137
 
            Assert.isObject(e.response, "error: Expected normalized response object.");
138
 
            Assert.isObject(e.error, "error: Expected error.");
139
 
            Assert.areSame("myException", e.error.message, "error: Expected message.");
140
 
            errorCallback = true;
141
 
        });
142
 
 
143
 
        ds.sendRequest({
144
 
            request: "a",
145
 
            callback: "callback"
146
 
        });
147
 
 
148
 
        Assert.isTrue(errorCallback);
149
 
    },
150
 
 
151
 
    "success or failure callback should not cause data event to fire again":
152
 
    function () {
153
 
        var ds = new Y.DataSource.Function({
154
 
                source: function () { return ['a','b']; }
155
 
            }),
156
 
            count = 0;
157
 
 
158
 
        ds.on("data", function () {
159
 
            count++;
160
 
        });
161
 
 
162
 
        ds.sendRequest({
163
 
            request: 'a',
164
 
            callbacks: {
165
 
                success: function () {
166
 
                    throw new Error("boom");
167
 
                }
168
 
            }
169
 
        });
170
 
 
171
 
 
172
 
        Y.Assert.areSame(1, count);
173
 
 
174
 
    }
175
 
}));
176
 
 
177
 
Y.Test.Runner.add(suite);