ember-cli-test-imagine-api
Version:
Create an Imaginary API in CoffeeScript with a declarative interface and neumonic for resources
670 lines (565 loc) • 19.9 kB
JavaScript
;
/* jshint ignore:start */
/* jshint ignore:end */
define('dummy/app', ['exports', 'ember', 'ember/resolver', 'ember/load-initializers', 'dummy/config/environment'], function (exports, Ember, Resolver, loadInitializers, config) {
'use strict';
var App;
Ember['default'].MODEL_FACTORY_INJECTIONS = true;
App = Ember['default'].Application.extend({
modulePrefix: config['default'].modulePrefix,
podModulePrefix: config['default'].podModulePrefix,
Resolver: Resolver['default']
});
loadInitializers['default'](App, config['default'].modulePrefix);
exports['default'] = App;
});
define('dummy/ember-cli-test-imagine-api/tests/modules/ember-cli-test-imagine-api/imagine', ['exports', 'ember'], function (exports, Ember) {
'use strict';
var Imagine;
Imagine = (function () {
function Imagine() {}
Imagine.verbose = true;
Imagine.server = null;
Imagine.api = null;
Imagine.call_history = null;
Imagine.setApi = function (api) {
return this.api = api;
};
Imagine._ensure_prentender = function () {
if (!this.server) {
this.call_history = {};
this.server = sinon.fakeServer.create();
this.server.autoRespondAfter = 2;
return this.server.autoRespond = true;
}
};
Imagine.callCount = function (verb, resource) {
var ref, ref1;
verb = verb.toUpperCase();
if ((ref = this.call_history[verb]) != null ? (ref1 = ref[resource]) != null ? ref1['count'] : void 0 : void 0) {
return this.call_history[verb][resource]['count'];
} else {
return 0;
}
};
Imagine.requestDataHistory = function (verb, resource) {
var ref, ref1;
verb = verb.toUpperCase();
if ((ref = this.call_history[verb]) != null ? (ref1 = ref[resource]) != null ? ref1['requests'] : void 0 : void 0) {
return this.call_history[verb][resource]['requests'];
} else {
return [];
}
};
Imagine.lastRequestData = function (verb, resource) {
var requests;
requests = this.requestDataHistory(verb, resource);
if (requests.length > 0) {
return requests[requests.length - 1];
} else {
return void 0;
}
};
Imagine.called = function (verb, resource) {
return this.callCount(verb, resource) > 0;
};
Imagine.json = function (opts) {
var api, headers, method, results;
this._ensure_prentender();
headers = {
"Content-Type": "application/json"
};
results = [];
for (method in opts) {
api = opts[method];
results.push((function (_this) {
return function (method, api) {
var apiKey, response, results1;
results1 = [];
for (apiKey in api) {
response = api[apiKey];
results1.push((function (apiKey, response) {
var http_verb, resource_location, response_body;
http_verb = method.toUpperCase();
if (_this.api[apiKey]) {
response_body = JSON.stringify(response.body);
resource_location = _this.api[apiKey];
if (_this.verbose) {
console.log("ImagineApi: Created Mock : method: " + http_verb + " " + resource_location + " [" + response.status + "," + JSON.stringify(headers) + "," + response_body + "]");
}
return _this.server.respondWith(http_verb, resource_location, function (xhr, id) {
var base, base1, base2, base3;
if (_this.verbose) {
console.log("--- ImagineApi: Responding with : method: " + http_verb + " " + resource_location + " [" + response.status + "," + JSON.stringify(headers) + "," + response_body + "]");
}
(base = _this.call_history)[http_verb] || (base[http_verb] = {});
(base1 = _this.call_history[http_verb])[apiKey] || (base1[apiKey] = {});
(base2 = _this.call_history[http_verb][apiKey])['count'] || (base2['count'] = 0);
_this.call_history[http_verb][apiKey]['count']++;
(base3 = _this.call_history[http_verb][apiKey])['requests'] || (base3['requests'] = []);
return Ember['default'].run(function () {
var content_type, obj;
content_type = xhr.requestHeaders["Content-Type"];
if ((content_type != null ? content_type.indexOf("json") : void 0) > -1) {
obj = JSON.parse(xhr.requestBody);
_this.call_history[http_verb][apiKey]['requests'].push(obj);
} else {
if (_this.verbose) {
console.log("- WARN - ImagineApi.json Request Expected Content-Type JSON not found; Found " + content_type);
}
_this.call_history[http_verb][apiKey]['requests'].push(xhr.requestBody);
}
return xhr.respond(response.status, headers, response_body);
});
});
} else {
return console.log(apiKey + " is not specified in " + _this.api);
}
})(apiKey, response));
}
return results1;
};
})(this)(method, api));
}
return results;
};
Imagine.stop = function () {
if (this.server) {
this.server.restore();
return this.server = null;
}
};
return Imagine;
})();
exports['default'] = Imagine;
});
define('dummy/initializers/app-version', ['exports', 'dummy/config/environment', 'ember'], function (exports, config, Ember) {
'use strict';
var classify = Ember['default'].String.classify;
var registered = false;
exports['default'] = {
name: 'App Version',
initialize: function initialize(container, application) {
if (!registered) {
var appName = classify(application.toString());
Ember['default'].libraries.register(appName, config['default'].APP.version);
registered = true;
}
}
};
});
define('dummy/initializers/export-application-global', ['exports', 'ember', 'dummy/config/environment'], function (exports, Ember, config) {
'use strict';
exports.initialize = initialize;
function initialize(container, application) {
if (config['default'].exportApplicationGlobal !== false) {
var value = config['default'].exportApplicationGlobal;
var globalName;
if (typeof value === 'string') {
globalName = value;
} else {
globalName = Ember['default'].String.classify(config['default'].modulePrefix);
}
if (!window[globalName]) {
window[globalName] = application;
application.reopen({
willDestroy: function willDestroy() {
this._super.apply(this, arguments);
delete window[globalName];
}
});
}
}
}
;
exports['default'] = {
name: 'export-application-global',
initialize: initialize
};
});
define('dummy/router', ['exports', 'ember', 'dummy/config/environment'], function (exports, Ember, config) {
'use strict';
var Router = Ember['default'].Router.extend({
location: config['default'].locationType
});
exports['default'] = Router.map(function () {});
});
define('dummy/templates/application', ['exports'], function (exports) {
'use strict';
exports['default'] = Ember.HTMLBars.template((function() {
return {
isHTMLBars: true,
revision: "Ember@1.11.1",
blockParams: 0,
cachedFragment: null,
hasRendered: false,
build: function build(dom) {
var el0 = dom.createDocumentFragment();
var el1 = dom.createElement("h2");
dom.setAttribute(el1,"id","title");
var el2 = dom.createTextNode("Welcome to Ember.js");
dom.appendChild(el1, el2);
dom.appendChild(el0, el1);
var el1 = dom.createTextNode("\n\n");
dom.appendChild(el0, el1);
var el1 = dom.createComment("");
dom.appendChild(el0, el1);
var el1 = dom.createTextNode("\n");
dom.appendChild(el0, el1);
return el0;
},
render: function render(context, env, contextualElement) {
var dom = env.dom;
var hooks = env.hooks, content = hooks.content;
dom.detectNamespace(contextualElement);
var fragment;
if (env.useFragmentCache && dom.canClone) {
if (this.cachedFragment === null) {
fragment = this.build(dom);
if (this.hasRendered) {
this.cachedFragment = fragment;
} else {
this.hasRendered = true;
}
}
if (this.cachedFragment) {
fragment = dom.cloneNode(this.cachedFragment, true);
}
} else {
fragment = this.build(dom);
}
var morph0 = dom.createMorphAt(fragment,2,2,contextualElement);
content(env, morph0, context, "outlet");
return fragment;
}
};
}()));
});
define('dummy/tests/app.jshint', function () {
'use strict';
QUnit.module('JSHint - .');
QUnit.test('app.js should pass jshint', function(assert) {
assert.ok(true, 'app.js should pass jshint.');
});
});
define('dummy/tests/helpers/imagine-api', ['exports', 'ember-cli-test-imagine-api/imagine', 'dummy/config/environment'], function (exports, Imagine, config) {
'use strict';
Imagine['default'].setApi({
resource: 'http://host:3333/resource'
});
exports['default'] = Imagine['default'];
});
define('dummy/tests/helpers/resolver', ['exports', 'ember/resolver', 'dummy/config/environment'], function (exports, Resolver, config) {
'use strict';
var resolver = Resolver['default'].create();
resolver.namespace = {
modulePrefix: config['default'].modulePrefix,
podModulePrefix: config['default'].podModulePrefix
};
exports['default'] = resolver;
});
define('dummy/tests/helpers/resolver.jshint', function () {
'use strict';
QUnit.module('JSHint - helpers');
QUnit.test('helpers/resolver.js should pass jshint', function(assert) {
assert.ok(true, 'helpers/resolver.js should pass jshint.');
});
});
define('dummy/tests/helpers/start-app', ['exports', 'ember', 'dummy/app', 'dummy/router', 'dummy/config/environment'], function (exports, Ember, Application, Router, config) {
'use strict';
exports['default'] = startApp;
function startApp(attrs) {
var application;
var attributes = Ember['default'].merge({}, config['default'].APP);
attributes = Ember['default'].merge(attributes, attrs); // use defaults, but you can override;
Ember['default'].run(function () {
application = Application['default'].create(attributes);
application.setupForTesting();
application.injectTestHelpers();
});
return application;
}
});
define('dummy/tests/helpers/start-app.jshint', function () {
'use strict';
QUnit.module('JSHint - helpers');
QUnit.test('helpers/start-app.js should pass jshint', function(assert) {
assert.ok(true, 'helpers/start-app.js should pass jshint.');
});
});
define('dummy/tests/router.jshint', function () {
'use strict';
QUnit.module('JSHint - .');
QUnit.test('router.js should pass jshint', function(assert) {
assert.ok(true, 'router.js should pass jshint.');
});
});
define('dummy/tests/test-helper', ['dummy/tests/helpers/resolver', 'ember-qunit'], function (resolver, ember_qunit) {
'use strict';
ember_qunit.setResolver(resolver['default']);
});
define('dummy/tests/test-helper.jshint', function () {
'use strict';
QUnit.module('JSHint - .');
QUnit.test('test-helper.js should pass jshint', function(assert) {
assert.ok(true, 'test-helper.js should pass jshint.');
});
});
define('dummy/tests/unit/imagine_test', ['ember', 'qunit', 'dummy/tests/helpers/start-app', 'dummy/tests/helpers/imagine-api'], function (Ember, qunit, startApp, imagine) {
'use strict';
var application;
application = null;
qunit.module("Unit: Test Helper : imagine", {
beforeEach: function beforeEach() {
application = startApp['default']();
/*
Don't return as Ember.Application.then is deprecated.
Newer version of QUnit uses the return value's .then
function to wait for promises if it exists.
*/
},
afterEach: function afterEach() {
imagine['default'].stop();
return Ember['default'].run(application, 'destroy');
}
});
qunit.test("default resource from config is avalible", function (assert) {
imagine['default'].json({
get: {
resource: {
status: 200,
body: "get resource"
}
}
});
return $.ajax({
type: 'GET',
contentType: 'application/json',
url: imagine['default'].api.resource
}).done(function (actual_response) {
return Ember['default'].run(function () {
return assert.equal(actual_response, "get resource");
});
});
});
qunit.test("can assert on the number of times a resource was called", function (assert) {
imagine['default'].json({
get: {
resource: {
status: 200,
body: "get resource"
}
}
});
assert.equal(0, imagine['default'].callCount('get', 'resource'), "pre-condition is that call count 0");
return $.ajax({
type: 'GET',
contentType: 'application/json',
url: imagine['default'].api.resource
}).done(function (actual_response) {
return Ember['default'].run(function () {
return assert.equal(1, imagine['default'].callCount('get', 'resource'), "post-condition is that call count is 1");
});
});
});
qunit.test("can assert on if the resource was called or not", function (assert) {
imagine['default'].json({
get: {
resource: {
status: 200,
body: "get resource"
}
}
});
return $.ajax({
type: 'GET',
contentType: 'application/json',
url: imagine['default'].api.resource
}).done(function (actual_response) {
return Ember['default'].run(function () {
return assert.ok(imagine['default'].called('get', 'resource'), "called get resource");
});
});
});
qunit.test("imagine get and post at same url", function (assert) {
imagine['default'].api.dancing = "http://dancing-api.local:123123/dance/v1/disco";
imagine['default'].json({
get: {
dancing: {
status: 200,
body: "get"
}
},
post: {
dancing: {
status: 200,
body: "post"
}
}
});
return $.ajax({
type: 'POST',
contentType: 'application/json',
url: imagine['default'].api.dancing
}).done(function (actual_response) {
return Ember['default'].run(function () {
assert.equal(actual_response, "post");
return $.ajax({
type: 'GET',
contentType: 'application/json',
url: imagine['default'].api.dancing
}).done(function (actual_response) {
return Ember['default'].run(function () {
return assert.equal(actual_response, "get");
});
});
});
});
});
qunit.test("#requestDataHistory contains previous requests to resource ", function (assert) {
var expected_request_object;
expected_request_object = {
cake: {
gluten: false,
eggs: false,
dairy: false,
tasty: true,
name: "Yummy Vegan Gluten Free Birthday Cake"
}
};
imagine['default'].api.cake = "http://dancing-api.local:123123/cake";
imagine['default'].json({
post: {
cake: {
status: 200,
body: {
cake: "New Yummy Vegan Gluten Free Birthday Cake Success"
}
}
}
});
return $.ajax({
type: "POST",
contentType: 'application/json',
url: imagine['default'].api.cake,
data: JSON.stringify(expected_request_object)
}).done(function (actual_response) {
var count;
count = imagine['default'].requestDataHistory('post', 'cake').length;
assert.equal(count, 1, "expected 1 request");
return $.ajax({
type: "POST",
contentType: 'application/json',
url: imagine['default'].api.cake,
data: JSON.stringify(expected_request_object)
}).done(function (actual_response) {
count = imagine['default'].requestDataHistory('post', 'cake').length;
return assert.equal(count, 2, "expected multiple requests");
});
});
});
qunit.test("#lastRequestData contains previous request to resource ", function (assert) {
var expected_request_object;
expected_request_object = {
cake: {
gluten: false,
eggs: false,
dairy: false,
tasty: true,
name: "Yummy Vegan Gluten Free Birthday Cake"
}
};
imagine['default'].api.cake = "http://dancing-api.local:123123/cake";
imagine['default'].json({
post: {
cake: {
status: 200,
body: {
cake: "New Yummy Vegan Gluten Free Birthday Cake Success"
}
}
}
});
return $.ajax({
type: "POST",
contentType: 'application/json',
url: imagine['default'].api.cake,
data: JSON.stringify(expected_request_object)
}).done(function (actual_response) {
var lastRequest;
lastRequest = imagine['default'].lastRequestData('post', 'cake');
return assert.deepEqual(lastRequest, expected_request_object);
});
});
qunit.test("imagine with large hash structure", function (assert) {
var expected_response_object;
expected_response_object = {
sub_total: {
currency: "USD",
amount: 608,
display_amount: "USD 6.08",
display_currency: "USD",
amount_str: "6.08"
},
fee_items: [{
type_note: "USD1->LLD0",
amount: 30,
currency: "USD",
display_amount: "USD 0.30",
display_currency: "USD",
amount_str: "0.30"
}],
total: {
currency: "USD",
amount: 638,
display_amount: "USD 6.38",
display_currency: "USD",
amount_str: "6.38"
},
order_item_id: 1,
status: 200
};
imagine['default'].api.dancing = "http://dancing-api.local:123123/dance/v1/disco";
imagine['default'].json({
post: {
dancing: {
status: 200,
body: expected_response_object
}
}
});
return $.ajax({
type: 'POST',
contentType: 'application/json',
url: imagine['default'].api.dancing
}).done(function (actual_response) {
return Ember['default'].run(function () {
return assert.deepEqual(actual_response, expected_response_object);
});
});
});
});
/* jshint ignore:start */
/* jshint ignore:end */
/* jshint ignore:start */
define('dummy/config/environment', ['ember'], function(Ember) {
var prefix = 'dummy';
/* jshint ignore:start */
try {
var metaName = prefix + '/config/environment';
var rawConfig = Ember['default'].$('meta[name="' + metaName + '"]').attr('content');
var config = JSON.parse(unescape(rawConfig));
return { 'default': config };
}
catch(err) {
throw new Error('Could not read config from meta tag with name "' + metaName + '".');
}
/* jshint ignore:end */
});
if (runningTests) {
require("dummy/tests/test-helper");
} else {
require("dummy/app")["default"].create({"name":"ember-cli-test-imagine-api","version":"1.13.0.14246ac7"});
}
/* jshint ignore:end */
//# sourceMappingURL=dummy.map