mirror of
https://github.com/Mibew/mibew.git
synced 2025-06-08 01:56:16 +03:00
763 lines
20 KiB
JavaScript
763 lines
20 KiB
JavaScript
// Testing MibewAPIInteraction class
|
|
module('MibewAPIInteraction');
|
|
|
|
/**
|
|
* Represents test interaction type
|
|
*
|
|
* @constructor
|
|
*/
|
|
function MibewAPITestInteraction() {
|
|
|
|
this.mandatoryArguments = function() {
|
|
return {
|
|
'*': {
|
|
'return': {},
|
|
'references': {}
|
|
},
|
|
'foo': {
|
|
'bar': 127
|
|
}
|
|
};
|
|
}
|
|
|
|
this.getReservedFunctionsNames = function() {
|
|
return [
|
|
'result'
|
|
];
|
|
}
|
|
|
|
}
|
|
MibewAPITestInteraction.prototype = new MibewAPIInteraction();
|
|
|
|
// Tests for the getMandatoryArguments method
|
|
test('getMandatoryArguments', function(){
|
|
var interaction = new MibewAPITestInteraction();
|
|
// Arguments for all function
|
|
deepEqual(
|
|
interaction.getMandatoryArguments('some_function'),
|
|
['return', 'references'],
|
|
'Test with arguments for all functions'
|
|
);
|
|
|
|
// Arguments for specific function
|
|
deepEqual(
|
|
interaction.getMandatoryArguments('foo'),
|
|
['return', 'references', 'bar'],
|
|
'Test with arguments for specific function'
|
|
);
|
|
});
|
|
|
|
// Tests for the getMandatoryArgumentsDefaults method
|
|
test('getMandatoryArgumentsDefaults', function(){
|
|
var interaction = new MibewAPITestInteraction();
|
|
// Default values for arguments for all function
|
|
deepEqual(
|
|
interaction.getMandatoryArgumentsDefaults('some_function'),
|
|
{
|
|
'return': {},
|
|
'references': {}
|
|
},
|
|
'Test with default values for arguments for all functions'
|
|
);
|
|
|
|
// Default values for arguments for specific function
|
|
deepEqual(
|
|
interaction.getMandatoryArgumentsDefaults('foo'),
|
|
{
|
|
'return': {},
|
|
'references': {},
|
|
'bar': 127
|
|
},
|
|
'Test with default values for arguments for specific function'
|
|
);
|
|
});
|
|
|
|
// Testing MibewAPI class
|
|
module("MibewAPI");
|
|
|
|
// Tests for the class constructor
|
|
test("constructor", function(){
|
|
// Incorrect initialization
|
|
try {
|
|
new MibewAPI({});
|
|
} catch (e) {
|
|
equal(
|
|
e.message,
|
|
"Wrong interaction type",
|
|
"Test with wrong constructor argument"
|
|
);
|
|
}
|
|
|
|
// Correct Initialization
|
|
new MibewAPI(new MibewAPITestInteraction());
|
|
ok(true, "Correct initialization");
|
|
});
|
|
|
|
// Tests for the checkFunction method
|
|
test("checkFunction", function(){
|
|
var mibewAPI = new MibewAPI(new MibewAPITestInteraction());
|
|
|
|
// Try to check empty function object
|
|
try {
|
|
mibewAPI.checkFunction({});
|
|
} catch (e) {
|
|
equal(
|
|
e.message,
|
|
"Cannot call for function with no name",
|
|
"Test with empty function object"
|
|
);
|
|
}
|
|
|
|
// Try to check function with no name
|
|
try {
|
|
mibewAPI.checkFunction({"function": ""});
|
|
} catch (e) {
|
|
equal(
|
|
e.message,
|
|
"Cannot call for function with no name",
|
|
"Test with a function with no name"
|
|
);
|
|
}
|
|
|
|
// Try to check function with reserved name and filterReservedFunctions
|
|
// argument equals to true
|
|
try {
|
|
mibewAPI.checkFunction({"function" : "result"}, true);
|
|
} catch (e) {
|
|
equal(
|
|
e.message,
|
|
"'result' is reserved function name",
|
|
"Test with reserved function's name and filterReservedFunctions " +
|
|
"arguments set to true"
|
|
);
|
|
}
|
|
|
|
// Try to check function with reserved name and filterReservedFunctions
|
|
// argument equals to false. Arguments list is undefined
|
|
try {
|
|
mibewAPI.checkFunction({"function": "result"}, false);
|
|
} catch (e) {
|
|
equal(
|
|
e.message,
|
|
"There are no arguments in 'result' function",
|
|
"Test with reserved function's name and filterReservedFunctions " +
|
|
"arguments set to false. Arguments list is undefined"
|
|
);
|
|
}
|
|
|
|
// Try to check function with not all obligatory arguments
|
|
try {
|
|
mibewAPI.checkFunction({
|
|
"function" : "test",
|
|
"arguments" : {"return" : []}
|
|
});
|
|
} catch (e) {
|
|
equal(
|
|
e.message,
|
|
"Not all mandatory arguments are set in 'test' function",
|
|
"Test with not all mandatory arguments"
|
|
);
|
|
}
|
|
|
|
// Try to check correct function
|
|
mibewAPI.checkFunction({
|
|
"function" : "test",
|
|
"arguments" : {
|
|
"return" : [],
|
|
"references" : [],
|
|
"testArgument" : "testValue"
|
|
}
|
|
});
|
|
ok(true, "Test correct function");
|
|
});
|
|
|
|
// Test for the checkRequest method
|
|
test("checkRequest", function() {
|
|
var mibewAPI = new MibewAPI(new MibewAPITestInteraction());
|
|
var correctFunction = {
|
|
"function" : "test",
|
|
"arguments" : {
|
|
"return" : [],
|
|
"references" : [],
|
|
"testArgument" : "testValue"
|
|
}
|
|
}
|
|
|
|
// Try to check request without token
|
|
try {
|
|
mibewAPI.checkRequest({});
|
|
} catch (e) {
|
|
equal(
|
|
e.message,
|
|
"Empty token",
|
|
"Test with empty token"
|
|
);
|
|
}
|
|
|
|
// Try to check request with wrong token type
|
|
try {
|
|
mibewAPI.checkRequest({"token" : false});
|
|
} catch (e) {
|
|
equal(
|
|
e.message,
|
|
"Wrong token type",
|
|
"Test with wrong token type"
|
|
);
|
|
}
|
|
|
|
// Try to check request with empty token string
|
|
try {
|
|
mibewAPI.checkRequest({"token" : ""});
|
|
} catch (e) {
|
|
equal(
|
|
e.message,
|
|
"Empty token",
|
|
"Test with empty token string"
|
|
);
|
|
}
|
|
|
|
// Try to check request with no functions list
|
|
try {
|
|
mibewAPI.checkRequest({"token" : "123"});
|
|
} catch (e) {
|
|
equal(
|
|
e.message,
|
|
"Empty functions set",
|
|
"Test with no functions list"
|
|
);
|
|
}
|
|
|
|
// Try to check request with functions list of the wrong type
|
|
try {
|
|
mibewAPI.checkRequest({"token" : "123", "functions" : {}});
|
|
} catch (e) {
|
|
equal(
|
|
e.message,
|
|
"Empty functions set",
|
|
"Test with wrong type of the functions list"
|
|
);
|
|
}
|
|
|
|
// Try to check request with empty functions list
|
|
try {
|
|
mibewAPI.checkRequest({"token" : "123", "functions" : []});
|
|
} catch (e) {
|
|
equal(
|
|
e.message,
|
|
"Empty functions set",
|
|
"Test with empty functions list"
|
|
);
|
|
}
|
|
|
|
// Try to check correct request
|
|
mibewAPI.checkRequest({
|
|
"token" : "123",
|
|
"functions" : [
|
|
correctFunction,
|
|
correctFunction
|
|
]
|
|
});
|
|
ok(true, "Test with correct request");
|
|
});
|
|
|
|
// Test for the checkPackage method
|
|
test("checkPackage", function() {
|
|
var mibewAPI = new MibewAPI(new MibewAPITestInteraction());
|
|
var correctRequest = {
|
|
"token" : "123",
|
|
"functions" : [
|
|
{
|
|
"function" : "test",
|
|
"arguments" : {
|
|
"return" : [],
|
|
"references" : []
|
|
}
|
|
}
|
|
]
|
|
}
|
|
|
|
// Try to check package with no signature
|
|
try {
|
|
mibewAPI.checkPackage({});
|
|
} catch (e) {
|
|
equal(
|
|
e.message,
|
|
"Missed package signature",
|
|
"Test package with no signature"
|
|
);
|
|
}
|
|
|
|
// Try to check package with no protocol version
|
|
try {
|
|
mibewAPI.checkPackage({"signature" : "test_signature"});
|
|
} catch (e) {
|
|
equal(
|
|
e.message,
|
|
"Missed protocol version",
|
|
"Test package with no protocol"
|
|
);
|
|
}
|
|
|
|
// Try to check package with wrong protocol version
|
|
try {
|
|
mibewAPI.checkPackage({
|
|
"signature" : "test_signature",
|
|
"proto" : -12
|
|
});
|
|
} catch (e) {
|
|
equal(
|
|
e.message,
|
|
"Wrong protocol version",
|
|
"Test pacakge with wrong protocol version"
|
|
);
|
|
}
|
|
|
|
// Try to check package with no 'async' flag value
|
|
try {
|
|
mibewAPI.checkPackage({
|
|
"signature" : "test_signature",
|
|
"proto" : mibewAPI.protocolVersion
|
|
});
|
|
} catch (e) {
|
|
equal(
|
|
e.message,
|
|
"'async' flag is missed",
|
|
"Test with no 'async' flag"
|
|
);
|
|
}
|
|
|
|
// Try to check package with wrong 'async' flag value
|
|
try {
|
|
mibewAPI.checkPackage({
|
|
"signature" : "test_signature",
|
|
"proto" : mibewAPI.protocolVersion,
|
|
"async" : "wrong_async_flag"
|
|
});
|
|
} catch (e) {
|
|
equal(
|
|
e.message,
|
|
"Wrong 'async' flag value",
|
|
"Test with wrong 'async' flag value"
|
|
);
|
|
}
|
|
|
|
// Try to check package with no requests list
|
|
try {
|
|
mibewAPI.checkPackage({
|
|
"signature" : "test_signature",
|
|
"proto" : mibewAPI.protocolVersion,
|
|
"async" : true
|
|
});
|
|
} catch (e) {
|
|
equal(
|
|
e.message,
|
|
"Empty requests set",
|
|
"Test with no requests list"
|
|
);
|
|
}
|
|
|
|
// Try to check package with wrong requests list type
|
|
try {
|
|
mibewAPI.checkPackage({
|
|
"signature" : "test_signature",
|
|
"proto" : mibewAPI.protocolVersion,
|
|
"async" : true,
|
|
"requests" : {}
|
|
});
|
|
} catch (e) {
|
|
equal(
|
|
e.message,
|
|
"Empty requests set",
|
|
"Test with wrong requests list type"
|
|
);
|
|
}
|
|
|
|
// Try to check package with empty requests list
|
|
try {
|
|
mibewAPI.checkPackage({
|
|
"signature" : "test_signature",
|
|
"proto" : mibewAPI.protocolVersion,
|
|
"async" : true,
|
|
"requests" : []
|
|
});
|
|
} catch (e) {
|
|
equal(
|
|
e.message,
|
|
"Empty requests set",
|
|
"Test with empty requests list"
|
|
);
|
|
}
|
|
|
|
// Try to check correct package
|
|
mibewAPI.checkPackage({
|
|
"signature" : "test_signature",
|
|
"proto" : mibewAPI.protocolVersion,
|
|
"async" : true,
|
|
'requests' : [
|
|
correctRequest,
|
|
correctRequest
|
|
]
|
|
});
|
|
ok(true, "Test with correct package");
|
|
});
|
|
|
|
// Test for the getResultFunction method
|
|
test("getResult", function() {
|
|
var mibewAPI = new MibewAPI(new MibewAPITestInteraction);
|
|
var resultFunction = {
|
|
"function" : "result",
|
|
"test_field" : "test_value"
|
|
}
|
|
|
|
// Try to get result function from function list, but it contains more than
|
|
// one 'result' function
|
|
try {
|
|
mibewAPI.getResultFunction([
|
|
{"function" : "result"},
|
|
{"function" : "result"},
|
|
]);
|
|
} catch (e) {
|
|
equal(
|
|
e.message,
|
|
"Function 'result' already exists in functions list",
|
|
"Test more than one 'result' functions in functions list"
|
|
)
|
|
}
|
|
|
|
// Try to get 'result' function from functions list that have no 'result'
|
|
// function. 'existance' argument set to true
|
|
try {
|
|
mibewAPI.getResultFunction({}, true);
|
|
} catch (e) {
|
|
equal(
|
|
e.message,
|
|
"There is no 'result' function in functions list",
|
|
"Test with no 'result' function in functions list"
|
|
);
|
|
}
|
|
|
|
// Try to get 'result' function from functions list that have no 'result'
|
|
// function. 'existance' argument set to false
|
|
equal(
|
|
mibewAPI.getResultFunction({}, false),
|
|
null,
|
|
"Test with no 'result' function in functions list, 'existance' " +
|
|
"argument equals to false and null as the result functionon returned"
|
|
);
|
|
|
|
// Try to get 'result' function from functions list that have no 'result'
|
|
// function. 'existance' argument set to null
|
|
equal(
|
|
mibewAPI.getResultFunction({}, null),
|
|
null,
|
|
"Test with no 'result' function in functions list, 'existance' " +
|
|
"argument equals to null and null as the result functionon returned"
|
|
);
|
|
|
|
// Try to get 'result' function from functions list that have 'result'
|
|
// function. 'existance' argument set to false
|
|
try {
|
|
mibewAPI.getResultFunction([
|
|
{"function" : "result"}
|
|
], false);
|
|
} catch (e) {
|
|
equal(
|
|
e.message,
|
|
"There is 'result' function in functions list",
|
|
"Test with 'result' function in functions list"
|
|
);
|
|
}
|
|
|
|
// Try to get result function
|
|
deepEqual(
|
|
mibewAPI.getResultFunction([resultFunction]),
|
|
resultFunction,
|
|
"Test of get 'result' function"
|
|
);
|
|
});
|
|
|
|
// Test for the builResult method
|
|
test("buildResult", function() {
|
|
var mibewAPIInteraction = new MibewAPITestInteraction;
|
|
var mibewAPI = new MibewAPI(mibewAPIInteraction);
|
|
var testArguments = {
|
|
"first" : "test_value",
|
|
"second" : "test_value"
|
|
}
|
|
var token = "some token";
|
|
var testPackage = {
|
|
"token" : token,
|
|
"functions" : [
|
|
{
|
|
"function" : "result",
|
|
"arguments" : {
|
|
"first" : "test_value",
|
|
"second" : "test_value",
|
|
"return" : {},
|
|
"references" : {}
|
|
}
|
|
}
|
|
]
|
|
}
|
|
|
|
// Compare result package
|
|
deepEqual(
|
|
mibewAPI.buildResult(testArguments, token),
|
|
testPackage,
|
|
"Test returned package"
|
|
);
|
|
});
|
|
|
|
// Test for the encodePackage Method
|
|
test("encodePackage", function() {
|
|
var mibewAPI = new MibewAPI(new MibewAPITestInteraction);
|
|
var testRequest = mibewAPI.buildResult({}, "some_token");
|
|
var testPackage = {
|
|
"signature" : "",
|
|
"proto" : mibewAPI.protocolVersion,
|
|
"async" : true,
|
|
"requests" : [testRequest]
|
|
}
|
|
|
|
// Compare encoded packages
|
|
equal(
|
|
mibewAPI.encodePackage([testRequest]),
|
|
encodeURIComponent(JSON.stringify(testPackage)),
|
|
"Test encoded package"
|
|
);
|
|
});
|
|
|
|
// Test for the decodePackage method
|
|
test("decodePackage", function() {
|
|
var mibewAPI = new MibewAPI(new MibewAPITestInteraction);
|
|
var testRequest = mibewAPI.buildResult({}, "some_token");
|
|
var testPackage = {
|
|
"signature" : "",
|
|
"proto" : mibewAPI.protocolVersion,
|
|
"async" : true,
|
|
"requests" : [testRequest]
|
|
}
|
|
var encodedPackage = mibewAPI.encodePackage([testRequest]);
|
|
|
|
// Try to decode broken package
|
|
try {
|
|
mibewAPI.decodePackage(encodedPackage.substr(
|
|
Math.floor(encodedPackage.length / 2)
|
|
));
|
|
} catch(e) {
|
|
ok(e.name = "SyntaxError","Test broken package");
|
|
}
|
|
|
|
// Compare decoded packages
|
|
deepEqual(
|
|
mibewAPI.decodePackage(encodedPackage),
|
|
testPackage,
|
|
"Test decoded package"
|
|
)
|
|
});
|
|
|
|
// Testing MibewAPIExecutionContext class
|
|
module("MibewAPIExecutionContext");
|
|
|
|
// Test for the storeFunctionResults method
|
|
test("storeFunctionResults", function() {
|
|
var context = new MibewAPIExecutionContext();
|
|
|
|
// Try to store result for function with inconsistent 'return' argument and
|
|
// function's result
|
|
try {
|
|
context.storeFunctionResults(
|
|
{
|
|
"function" : "test",
|
|
"arguments" : {
|
|
"return" : {"test_field" : "alias_for_test_field"}
|
|
}
|
|
},
|
|
{"another_test_field" : "another_test_value"}
|
|
);
|
|
} catch (e) {
|
|
equal(
|
|
e.message,
|
|
"Variable with name 'test_field' is undefined in " +
|
|
"the results of the 'test' function",
|
|
"Test with inconsistent 'return' argument and function results"
|
|
);
|
|
}
|
|
|
|
// Try to store correct results
|
|
context.storeFunctionResults(
|
|
{
|
|
"function" : "test",
|
|
"arguments" : {
|
|
"return" : {
|
|
"test_field" : "alias_for_test_field",
|
|
"another_test_field" : "another_alias"
|
|
}
|
|
}
|
|
},
|
|
{
|
|
"test_field" : "test_value",
|
|
"another_test_field" : "another_test_value"
|
|
}
|
|
);
|
|
deepEqual(
|
|
context.returnValues,
|
|
{
|
|
"alias_for_test_field" : "test_value",
|
|
"another_alias" : "another_test_value"
|
|
},
|
|
"Test returnValues after storing correct results"
|
|
);
|
|
deepEqual(
|
|
context.functionsResults,
|
|
[{
|
|
"test_field" : "test_value",
|
|
"another_test_field" : "another_test_value"
|
|
}],
|
|
"Test functionsResults after storing correct results"
|
|
);
|
|
});
|
|
|
|
// Test for the getArgumentsList method
|
|
test("getArgumentsList", function(){
|
|
var context = new MibewAPIExecutionContext();
|
|
|
|
// Try to reference to undefined function number in execution context
|
|
try {
|
|
context.getArgumentsList({
|
|
"function" : "test",
|
|
"arguments" : {
|
|
"return" : {},
|
|
"references" : {"test" : 1},
|
|
"test" : "test_value"
|
|
}
|
|
});
|
|
} catch (e) {
|
|
equal(
|
|
e.message,
|
|
"Wrong reference in 'test' function. Function #1 does not call yet.",
|
|
"Test with reference to function that does not called function"
|
|
);
|
|
}
|
|
|
|
// Store some test results in context
|
|
context.storeFunctionResults(
|
|
{
|
|
"function" : "test",
|
|
"arguments" : {
|
|
"return" : {
|
|
"test_field" : "alias_for_test_field",
|
|
"another_test_field" : "another_alias"
|
|
}
|
|
}
|
|
},
|
|
{
|
|
"test_field" : "test_value",
|
|
"another_test_field" : "another_test_value"
|
|
}
|
|
);
|
|
|
|
// Check undefined target name
|
|
try {
|
|
context.getArgumentsList({
|
|
"function" : "test",
|
|
"arguments" : {
|
|
"return" : {},
|
|
"references" : {"test" : 1}
|
|
}
|
|
});
|
|
} catch (e) {
|
|
equal(
|
|
e.message,
|
|
"Wrong reference in 'test' function. Empty 'test' argument.",
|
|
"Test with undefined reference argument"
|
|
);
|
|
}
|
|
|
|
// Check empty target name
|
|
try {
|
|
context.getArgumentsList({
|
|
"function" : "test",
|
|
"arguments" : {
|
|
"return" : {},
|
|
"references" : {"test" : 1},
|
|
"test" : ""
|
|
}
|
|
});
|
|
} catch (e) {
|
|
equal(
|
|
e.message,
|
|
"Wrong reference in 'test' function. Empty 'test' argument.",
|
|
"Test with empty reference argument"
|
|
);
|
|
}
|
|
|
|
// Check undefined target value
|
|
try {
|
|
context.getArgumentsList({
|
|
"function" : "test",
|
|
"arguments" : {
|
|
"return" : {},
|
|
"references" : {"test" : 1},
|
|
"test" : "undefined_target_value"
|
|
}
|
|
});
|
|
} catch (e) {
|
|
equal(
|
|
e.message,
|
|
"Wrong reference in 'test' function. There is no " +
|
|
"'undefined_target_value' argument in #1 function results",
|
|
"Test with undefined target value"
|
|
);
|
|
}
|
|
|
|
// Check correct references
|
|
deepEqual(
|
|
context.getArgumentsList({
|
|
"function" : "test",
|
|
"arguments" : {
|
|
"return" : {},
|
|
"references" : {"test" : 1},
|
|
"test" : "test_field"
|
|
}
|
|
}),
|
|
{
|
|
"return" : {},
|
|
"references" : {"test" : 1},
|
|
"test" : "test_value"
|
|
},
|
|
"Test returned arguments list"
|
|
);
|
|
});
|
|
|
|
// Test for the getResults method
|
|
test("getResults", function() {
|
|
var context = new MibewAPIExecutionContext();
|
|
|
|
// Store some test results in context
|
|
context.storeFunctionResults(
|
|
{
|
|
"function" : "test",
|
|
"arguments" : {
|
|
"return" : {
|
|
"test_field" : "alias_for_test_field",
|
|
"another_test_field" : "another_alias"
|
|
}
|
|
}
|
|
},
|
|
{
|
|
"test_field" : "test_value",
|
|
"another_test_field" : "another_test_value"
|
|
}
|
|
);
|
|
|
|
// Check returned values
|
|
deepEqual(
|
|
context.getResults(),
|
|
{
|
|
"alias_for_test_field" : "test_value",
|
|
"another_alias" : "another_test_value"
|
|
},
|
|
"Test returned values"
|
|
);
|
|
}); |