← Back to branch summary

~launchpad-pqm/launchpad/devel

« back to all changes in this revision

Viewing changes to lib/lp/app/javascript/testing/mockio.js

[r=jtv,
 wallyworld][bug=824435][incr] Add tests for the request builds code
 in requestbuilds_overlay.js.

Show diffs side-by-side

added added

removed removed

Lines of Context:
lib/lp/app/javascript/testing/mockio.js
1
 
/* Copyright (c) 2009, Canonical Ltd. All rights reserved. */
2
 
 
3
 
YUI.add('lazr.testing.mockio', function(Y) {
4
 
/**
5
 
 * A utility module for use in YUI unit-tests with a helper for mocking Y.io.
6
 
 *
7
 
 * @module lazr.testing
8
 
 */
9
 
var MockIo = function() {
10
 
    this.uri = null;
11
 
    this.cfg = null;
12
 
};
13
 
 
14
 
/* Save the Y.io() arguments. */
15
 
MockIo.prototype.io = function(uri, cfg) {
16
 
    this.uri = uri;
17
 
    this.cfg = cfg;
18
 
    return this;  // Usually this isn't used, except for logging.
19
 
};
20
 
 
21
 
/* Simulate the Xhr request/response cycle. */
22
 
MockIo.prototype.simulateXhr = function(response, is_failure) {
23
 
    var cfg = this.cfg;
24
 
    var context = cfg.context || this;
25
 
    var args = cfg.arguments;
26
 
    var tId = 'mockTId';
27
 
    if (!response) {
28
 
        response = {};
29
 
    }
30
 
 
31
 
    // See the Y.io utility documentation for the signatures.
32
 
    if (cfg.on.start) {
33
 
        cfg.on.start.call(context, tId, args);
34
 
    }
35
 
    if (cfg.on.complete) {
36
 
        cfg.on.complete.call(context, tId, response, args);
37
 
    }
38
 
    if (cfg.on.success && !is_failure) {
39
 
        cfg.on.success.call(context, tId, response, args);
40
 
    }
41
 
    if (cfg.on.failure && is_failure) {
42
 
        cfg.on.failure.call(context, tId, response, args);
43
 
    }
44
 
};
45
 
 
46
 
/* Make a successful XHR response object. */
47
 
MockIo.makeXhrSuccessResponse = function(responseText) {
48
 
    var text = responseText || "";
49
 
    return {
50
 
        status: 200,
51
 
        statusText: "OK",
52
 
        responseText: text
53
 
    };
54
 
};
55
 
 
56
 
/* Make a failed XHR response object. */
57
 
MockIo.makeXhrFailureResponse = function(responseText) {
58
 
    var text = responseText || "";
59
 
    return {
60
 
        status: 500,
61
 
        statusText: "Internal Server Error",
62
 
        responseText: text
63
 
    };
64
 
};
65
 
 
66
 
Y.namespace("lazr.testing");
67
 
Y.lazr.testing.MockIo = MockIo;
 
1
/* Copyright (c) 2009-2011, Canonical Ltd. All rights reserved. */
 
2
 
 
3
YUI.add('lp.testing.mockio', function(Y) {
 
4
    /**
 
5
     * A utility module for use in YUI unit-tests with a helper for
 
6
     * mocking Y.io.
 
7
     *
 
8
     * @module lp.testing.mockio
 
9
     */
 
10
    var namespace =  Y.namespace("lp.testing.mockio");
 
11
 
 
12
    var MockHttpResponse = function(config) {
 
13
        if (config === undefined) {
 
14
            config = {};
 
15
        }
 
16
        if (config.status !== undefined) {
 
17
            this.status = config.status;
 
18
        } else {
 
19
            this.status = 200;
 
20
        }
 
21
        if (config.statusText !== undefined) {
 
22
            this.statusText = config.statusText;
 
23
        } else {
 
24
            if (this.isFailure()) {
 
25
                this.statusText = "Internal Server Error";
 
26
            } else {
 
27
                this.statusText = "OK";
 
28
            }
 
29
        }
 
30
        if (config.responseText !== undefined) {
 
31
            this.responseText = config.responseText;
 
32
        } else {
 
33
            this.responseText = '[]';
 
34
        }
 
35
        if (config.responseHeaders !== undefined) {
 
36
            this.responseHeaders = config.responseHeaders;
 
37
        } else {
 
38
            this.responseHeaders = {};
 
39
        }
 
40
    };
 
41
 
 
42
    MockHttpResponse.prototype = {
 
43
        isFailure: function () {
 
44
            return this.status >= 400;
 
45
        },
 
46
 
 
47
        setResponseHeader: function (header, value) {
 
48
            this.responseHeaders[header] = value;
 
49
        },
 
50
 
 
51
        getResponseHeader: function(header) {
 
52
            return this.responseHeaders[header];
 
53
        }
 
54
    };
 
55
    namespace.MockHttpResponse = MockHttpResponse;
 
56
 
 
57
    function MockHttpRequest(url, config){
 
58
        this.url = url;
 
59
        this.config = config;
 
60
        this.response = null;
 
61
    }
 
62
 
 
63
    /* Simulate the Xhr request/response cycle. */
 
64
    MockHttpRequest.prototype.respond = function(response_config) {
 
65
        var context = this.config.context || Y,
 
66
            args = this.config['arguments'] || [],
 
67
            tId = 'mockTId',
 
68
            response = this.response = new MockHttpResponse(response_config);
 
69
 
 
70
        // See the Y.io utility documentation for the signatures.
 
71
        if (this.config.on.start !== undefined) {
 
72
            this.config.on.start.call(context, tId, args);
 
73
        }
 
74
        if (this.config.on.complete !== undefined) {
 
75
            this.config.on.complete.call(context, tId, response, args);
 
76
        }
 
77
        if (this.config.on.success !== undefined && !response.isFailure()) {
 
78
            this.config.on.success.call(context, tId, response, args);
 
79
        }
 
80
        if (this.config.on.failure !== undefined && response.isFailure()) {
 
81
            this.config.on.failure.call(context, tId, response, args);
 
82
        }
 
83
    };
 
84
 
 
85
    namespace.MockHttpRequest = MockHttpRequest;
 
86
 
 
87
    var MockIo = function() {
 
88
        this.requests = [];
 
89
        this.last_request = null;
 
90
    };
 
91
 
 
92
    /* Save the Y.io() arguments. */
 
93
    MockIo.prototype.io = function(url, config) {
 
94
        this.last_request = new MockHttpRequest(url, config);
 
95
        this.requests.push(this.last_request);
 
96
        return this;  // Usually this isn't used, except for logging.
 
97
    };
 
98
 
 
99
    /* Call respond method on last_request. */
 
100
    MockIo.prototype.respond = function(response_config) {
 
101
        this.last_request.respond(response_config);
 
102
    };
 
103
 
 
104
    /* Call respond method with successful values. */
 
105
    MockIo.prototype.success = function(config) {
 
106
        if (config === undefined) {
 
107
            config = {};
 
108
        }
 
109
        if (config.status === undefined || config.status >= 400) {
 
110
            config.status = 200;
 
111
        }
 
112
        config.statusText = 'OK';
 
113
        this.respond(config);
 
114
    };
 
115
 
 
116
    /* Call respond method with failed values. */
 
117
    MockIo.prototype.failure = function(config) {
 
118
        if (config === undefined) {
 
119
            config = {};
 
120
        }
 
121
        if (config.status === undefined || config.status < 400) {
 
122
            config.status = 500;
 
123
        }
 
124
        config.statusText = 'Internal Server Error';
 
125
        this.respond(config);
 
126
    };
 
127
 
 
128
    namespace.MockIo = MockIo;
68
129
 
69
130
}, '0.1', {});