a34c8c8233
This basically commits the transpiled CoffeeScript JS (with minor cleanup) and removes coffee build support. A tiny amount of support for xblocks exists, because external users may have xblocks with coffee. But no coffee in our tree anyway.
115 lines
4.0 KiB
JavaScript
115 lines
4.0 KiB
JavaScript
/*
|
|
* decaffeinate suggestions:
|
|
* DS102: Remove unnecessary code created because of implicit returns
|
|
* Full docs: https://github.com/decaffeinate/decaffeinate/blob/master/docs/suggestions.md
|
|
*/
|
|
describe("RequireJS namespacing", function() {
|
|
beforeEach(() =>
|
|
|
|
// Jasmine does not provide a way to use the typeof operator. We need
|
|
// to create our own custom matchers so that a TypeError is not thrown.
|
|
jasmine.addMatchers({
|
|
requirejsTobeUndefined() {
|
|
return {
|
|
compare() {
|
|
return {
|
|
pass: typeof requirejs === "undefined"
|
|
};
|
|
}
|
|
};
|
|
},
|
|
|
|
requireTobeUndefined() {
|
|
return {
|
|
compare() {
|
|
return {
|
|
pass: typeof require === "undefined"
|
|
};
|
|
}
|
|
};
|
|
},
|
|
|
|
defineTobeUndefined() {
|
|
return {
|
|
compare() {
|
|
return {
|
|
pass: typeof define === "undefined"
|
|
};
|
|
}
|
|
};
|
|
}}));
|
|
|
|
|
|
it("check that the RequireJS object is present in the global namespace", function() {
|
|
expect(RequireJS).toEqual(jasmine.any(Object));
|
|
expect(window.RequireJS).toEqual(jasmine.any(Object));
|
|
});
|
|
|
|
it("check that requirejs(), require(), and define() are not in the global namespace", function() {
|
|
|
|
// The custom matchers that we defined in the beforeEach() function do
|
|
// not operate on an object. We pass a dummy empty object {} not to
|
|
// confuse Jasmine.
|
|
expect({}).requirejsTobeUndefined();
|
|
expect({}).requireTobeUndefined();
|
|
expect({}).defineTobeUndefined();
|
|
expect(window.requirejs).not.toBeDefined();
|
|
expect(window.require).not.toBeDefined();
|
|
expect(window.define).not.toBeDefined();
|
|
});
|
|
});
|
|
|
|
|
|
describe("RequireJS module creation", function() {
|
|
let inDefineCallback = undefined;
|
|
let inRequireCallback = undefined;
|
|
it("check that we can use RequireJS to define() and require() a module", function(done) {
|
|
const d1 = $.Deferred();
|
|
const d2 = $.Deferred();
|
|
// Because Require JS works asynchronously when defining and requiring
|
|
// modules, we need to use the special Jasmine functions runs(), and
|
|
// waitsFor() to set up this test.
|
|
const func = function() {
|
|
|
|
// Initialize the variable that we will test for. They will be set
|
|
// to true in the appropriate callback functions called by Require
|
|
// JS. If their values do not change, this will mean that something
|
|
// is not working as is intended.
|
|
inDefineCallback = false;
|
|
inRequireCallback = false;
|
|
|
|
// Define our test module.
|
|
RequireJS.define("test_module", [], function() {
|
|
inDefineCallback = true;
|
|
|
|
d1.resolve();
|
|
|
|
// This module returns an object. It can be accessed via the
|
|
// Require JS require() function.
|
|
return {module_status: "OK"};
|
|
});
|
|
|
|
|
|
// Require our defined test module.
|
|
return RequireJS.require(["test_module"], function(test_module) {
|
|
inRequireCallback = true;
|
|
|
|
// If our test module was defined properly, then we should
|
|
// be able to get the object it returned, and query some
|
|
// property.
|
|
expect(test_module.module_status).toBe("OK");
|
|
|
|
return d2.resolve();
|
|
});
|
|
};
|
|
|
|
func();
|
|
// We will wait before checking if our module was defined and that we were able to require() the module.
|
|
$.when(d1, d2).done(function() {
|
|
// The final test behavior
|
|
expect(inDefineCallback).toBeTruthy();
|
|
expect(inRequireCallback).toBeTruthy();
|
|
}).always(done);
|
|
});
|
|
});
|