← Back to branch summary

~ubuntu-branches/ubuntu/quantal/maas/quantal-updates

« back to all changes in this revision

Viewing changes to src/maasserver/static/jslibs/yui/3.4.1/tests/datasource/tests/datasource-io-tests.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/datasource-io-tests.js
1
 
YUI.add('datasource-io-tests', function(Y) {
2
 
 
3
 
var Assert = Y.Assert,
4
 
    ObjectAssert = Y.ObjectAssert,
5
 
 
6
 
    suite = new Y.Test.Suite("DataSource.IO Test Suite"),
7
 
 
8
 
    jsonData = '{"ResultSet":{"Result":[{"Title":"Madonna"}]}}';
9
 
 
10
 
 
11
 
suite.add(new Y.Test.Case({
12
 
    name: "DataSource.IO Tests",
13
 
 
14
 
    testConstructorIO: function() {
15
 
        var ds = new Y.DataSource.IO();
16
 
        Assert.isInstanceOf(Y.Base, ds, "Expected Base instance.");
17
 
        Assert.isInstanceOf(Y.DataSource.Local, ds, "Expected DataSource.Local instance.");
18
 
        Assert.isInstanceOf(Y.DataSource.IO, ds, "Expected DataSource.IO instance.");
19
 
    },
20
 
 
21
 
    testIODefaults: function() {
22
 
        var ds = new Y.DataSource.IO({
23
 
                source: "./php/ysearch_json_madonna.php",
24
 
                io: function (uri, config) {
25
 
                    var id = Y.guid();
26
 
                    config.on.success.call(ds, id, {
27
 
                        responseText: jsonData
28
 
                    }, config["arguments"]);
29
 
 
30
 
                    return id;
31
 
                }
32
 
            }),
33
 
            request, response, tId, data, callback;
34
 
 
35
 
        ds.sendRequest({
36
 
            request: null,
37
 
            callback: {
38
 
                success: function (e) {
39
 
                    request  = e.request;
40
 
                    response = e.response;
41
 
                    tId      = e.tId;
42
 
                    data     = e.data;
43
 
                    callback = e.callback;
44
 
                }
45
 
            }
46
 
        });
47
 
 
48
 
        Assert.isNull(request, "Expected null request.");
49
 
        Assert.isObject(response, "Expected response object.");
50
 
        Assert.isNotUndefined(tId);
51
 
        Assert.isNotUndefined(data);
52
 
        Assert.isNotUndefined(callback);
53
 
    },
54
 
 
55
 
    testIOConfig: function() {
56
 
        var ioCallback, failureCallback,
57
 
            ds = new Y.DataSource.IO({
58
 
                source: "x",
59
 
                ioConfig: {
60
 
                    method: "POST",
61
 
                    data: "foo=bar",
62
 
                    timeout: 1
63
 
                },
64
 
                io: function (uri, config) {
65
 
                    var id = Y.guid();
66
 
                    Assert.areSame(1, config.timeout);
67
 
                    Assert.areSame(ds, config.context);
68
 
                    Assert.areSame("foo=bar", config.data);
69
 
                    Assert.areSame("POST", config.method);
70
 
 
71
 
                    ioCallback = true;
72
 
 
73
 
                    config.on.failure.call(config.context, id, {
74
 
                        responseText: jsonData
75
 
                    }, config["arguments"]);
76
 
                }
77
 
            });
78
 
 
79
 
        ds.sendRequest({
80
 
            request: null,
81
 
            callback: {
82
 
                failure: function (e) {
83
 
                    Assert.isObject(e.error, "Expected error from timeout.");
84
 
                    Assert.isNull(e.request, "Expected null request.");
85
 
                    Assert.isObject(e.response, "Expected response object.");
86
 
                    ObjectAssert.ownsKeys({
87
 
                        tId: null,
88
 
                        request: null,
89
 
                        data: null,
90
 
                        response: null,
91
 
                        callback: null
92
 
                    }, e, "Expected all properties.");
93
 
                    failureCallback = true;
94
 
                }
95
 
            }
96
 
        });
97
 
 
98
 
        Assert.isTrue(ioCallback);
99
 
        Assert.isTrue(failureCallback);
100
 
    },
101
 
 
102
 
    testIOPost: function() {
103
 
        var ioCallback, successCallback,
104
 
            ds = new Y.DataSource.IO({
105
 
                source: "./php/ysearch_json_madonna.php",
106
 
                io: function (uri, config) {
107
 
                    var id = Y.guid();
108
 
                    Assert.areSame(ds, config.context);
109
 
                    Assert.areSame("foo=bar", config.data);
110
 
                    Assert.areSame("POST", config.method);
111
 
 
112
 
                    ioCallback = true;
113
 
 
114
 
                    config.on.success.call(config.context, id, {
115
 
                        responseText: jsonData
116
 
                    }, config["arguments"]);
117
 
                }
118
 
            });
119
 
 
120
 
        ds.sendRequest({
121
 
            callback: {
122
 
                success: function (e) {
123
 
                    Assert.isUndefined(e.request, "Expected undefined request.");
124
 
                    Assert.isObject(e.response, "Expected response object.");
125
 
                    ObjectAssert.ownsKeys({
126
 
                        tId: null,
127
 
                        request: null,
128
 
                        data: null,
129
 
                        response: null,
130
 
                        callback: null
131
 
                    }, e, "Expected all properties.");
132
 
 
133
 
                    successCallback = true;
134
 
                }
135
 
            },
136
 
            cfg: {
137
 
                method: "POST",
138
 
                data: "foo=bar"
139
 
            }
140
 
        });
141
 
 
142
 
        Assert.isTrue(ioCallback);
143
 
        Assert.isTrue(successCallback);
144
 
    },
145
 
 
146
 
    testIOEvents: function() {
147
 
        var ioCallback, requestCallback, dataCallback, responseCallback,
148
 
            ds = new Y.DataSource.IO({
149
 
                source: "./php/ysearch_json_madonna.php",
150
 
                io: function (uri, config) {
151
 
                    var id = Y.guid();
152
 
 
153
 
                    ioCallback = true;
154
 
 
155
 
                    config.on.success.call(config.context, id, {
156
 
                        responseText: jsonData
157
 
                    }, config["arguments"]);
158
 
                }
159
 
            });
160
 
 
161
 
        ds.plug(Y.Plugin.DataSourceJSONSchema, {
162
 
            schema: {
163
 
                resultListLocator: "ResultSet.Result",
164
 
                resultFields: ["Title"]
165
 
            }
166
 
        });
167
 
 
168
 
        ds.on("request", function (e) {
169
 
            Assert.areSame("dataSourceIO:request", e.type);
170
 
            Assert.isNumber(e.tId, "request: Expected transaction ID.");
171
 
            Assert.isUndefined(e.request, "request: Expected undefined request.");
172
 
            Assert.areSame("callback", e.callback, "request: Expected callback.");
173
 
            requestCallback = true;
174
 
        });
175
 
 
176
 
        ds.on("data", function (e) {
177
 
            Assert.areSame("dataSourceIO:data", e.type);
178
 
            Assert.isNumber(e.tId, "data: Expected transaction ID.");
179
 
            Assert.isUndefined(e.request, "data: Expected undefined request.");
180
 
            Assert.areSame("callback", e.callback, "data: Expected callback.");
181
 
            Assert.isObject(e.data, "data: Expected raw data.");
182
 
            dataCallback = true;
183
 
        });
184
 
 
185
 
        ds.on("response", function (e) {
186
 
            Assert.areSame("dataSourceIO:response", e.type);
187
 
            Assert.isNumber(e.tId, "response: Expected transaction ID.");
188
 
            Assert.isUndefined(e.request, "response: Expected undefined request.");
189
 
            Assert.areSame("callback", e.callback, "response: Expected callback.");
190
 
            Assert.isObject(e.data, "response: Expected raw data.");
191
 
            Assert.isObject(e.response, "response: Expected normalized response object.");
192
 
            Assert.isArray(e.response.results, "response: Expected parsed results.");
193
 
            Assert.isObject(e.response.meta, "response: Expected parsed meta data.");
194
 
            responseCallback = true;
195
 
        });
196
 
 
197
 
        ds.sendRequest({
198
 
            callback: "callback"
199
 
        });
200
 
 
201
 
        Assert.isTrue(ioCallback);
202
 
        Assert.isTrue(requestCallback);
203
 
        Assert.isTrue(dataCallback);
204
 
        Assert.isTrue(responseCallback);
205
 
    },
206
 
 
207
 
    testIOError: function() {
208
 
        var ds = new Y.DataSource.IO({
209
 
                source: "./php/ysearch_json_madonna.php",
210
 
                io: function (uri, config) {
211
 
                    var id = Y.guid();
212
 
                    config.on.failure.call(config.context, id, {
213
 
                        responseText: jsonData
214
 
                    }, config["arguments"]);
215
 
                }
216
 
            }),
217
 
            errorCallback;
218
 
 
219
 
        ds.plug(Y.Plugin.DataSourceJSONSchema, {
220
 
            schema: {
221
 
                resultListLocator: "ResultSet.Result",
222
 
                resultFields: ["Title"]
223
 
            }
224
 
        });
225
 
 
226
 
        ds.on("error", function (e) {
227
 
            Assert.areSame("dataSourceIO:error", e.type);
228
 
            Assert.isNumber(e.tId, "error: Expected transaction ID.");
229
 
            Assert.areSame("a", e.request, "error: Expected request.");
230
 
            Assert.areSame("callback", e.callback, "error: Expected callback.");
231
 
            Assert.isObject(e.data, "error: Expected raw data.");
232
 
            Assert.isObject(e.response, "error: Expected normalized response object.");
233
 
            Assert.isObject(e.error, "error: Expected error.");
234
 
            errorCallback = true;
235
 
        });
236
 
 
237
 
        ds.set("source", "foo");
238
 
        ds.sendRequest({
239
 
            request: "a",
240
 
            callback: "callback"
241
 
        });
242
 
 
243
 
        Assert.isTrue(errorCallback);
244
 
    }
245
 
}));
246
 
 
247
 
Y.Test.Runner.add(suite);
248
 
 
249
 
 
250
 
}, '@VERSION@' ,{requires:['datasource-io', 'test']});