pax_global_header 0000666 0000000 0000000 00000000064 13463035407 0014517 g ustar 00root root 0000000 0000000 52 comment=0524b5387fd7b2843b2e7604f3367940984bd7dd
rjs_json_form-master-test/ 0000775 0000000 0000000 00000000000 13463035407 0016203 5 ustar 00root root 0000000 0000000 rjs_json_form-master-test/test/ 0000775 0000000 0000000 00000000000 13463035407 0017162 5 ustar 00root root 0000000 0000000 rjs_json_form-master-test/test/index.html 0000664 0000000 0000000 00000002044 13463035407 0021157 0 ustar 00root root 0000000 0000000
Test JSON form
test markup, will be hidden
rjs_json_form-master-test/test/jsonform_test.js 0000664 0000000 0000000 00000022040 13463035407 0022412 0 ustar 00root root 0000000 0000000 /*jslint nomen: true, regexp: true*/
/*global console, RSVP, renderJS, QUnit, window, document,
__RenderJSGadget, URL, jIO*/
(function (document, renderJS, QUnit, jIO) {
"use strict";
var test = QUnit.test,
module = QUnit.module,
RenderJSGadget = __RenderJSGadget,
jsonform_url = '../jsonform.gadget.html',
url_list = [],
test_settings,
skip_files,
skip_modules,
todo_tests;
QUnit.config.autostart = false;
QUnit.dump.maxDepth = 10;
function replaceAll(str, searchStr, replaceStr) {
searchStr = searchStr.replace(/[\-\/\\\^$*+?.()|\[\]{}]/g, '\\$&');
return str.replace(new RegExp(searchStr, 'gi'), replaceStr);
}
function downloadJSON(url) {
return RSVP.Queue()
.push(function () {
return jIO.util.ajax({
url: url,
dataType: "json"
});
})
.push(undefined, function (error) {
console.log(error);
throw error;
})
.push(function (evt) {
return evt.target.response;
});
}
function create_gadget(__aq_parent) {
var gadget = new RenderJSGadget();
gadget.__sub_gadget_dict = {};
gadget.__aq_parent = __aq_parent;
// return gadget.declareGadget(jsonform_url, {
return gadget.declareGadget((new URL(jsonform_url, window.location)), {
// sandbox: "iframe",
element: document.querySelector('#qunit-fixture'),
scope: 'foobar'
});
}
/////////////////////////////////////////////////////////////////
// render
/////////////////////////////////////////////////////////////////
module("jsonform.general");
test('JSON Form render', function (assert) {
var done = assert.async(),
gadget;
create_gadget(function (method_name, argument_list) {
if (method_name === "notifyValid") {
assert.ok(argument_list, "form correctly filled");
return "result correctly fetched from parent";
}
throw new renderJS.AcquisitionError("Can not handle " + method_name);
})
.push(function (g) {
gadget = g;
return gadget.render({
key: "foo"
});
})
.push(function (element) {
assert.ok(element, "gadget rendered");
})
.push(undefined, function (error) {
assert.notOk(error, "issue in gadget");
})
.push(function () {
done();
});
});
test('JSON Form getContent', function (assert) {
var done = assert.async(),
gadget,
key = "foo_key",
schema = {
"properties": {
"foo": {"type": "integer"},
"bar": {"type": "string"}
},
required: ["foo"]
},
value = {foo: 1, bar: "fsdfs"},
schema_orig = JSON.parse(JSON.stringify(schema));
create_gadget(function (method_name, argument_list) {
if (method_name === "notifyValid") {
assert.ok(argument_list, "form correctly filled");
return "result correctly fetched from parent";
}
throw new renderJS.AcquisitionError("Can not handle " + method_name);
})
.push(function (g) {
gadget = g;
return gadget.render({
key: key,
schema: schema,
value: value
});
})
.push(function (element) {
assert.ok(element, "gadget rendered");
return gadget.getContent();
})
.push(function (json_document) {
assert.deepEqual(schema, schema_orig,
"schema not change (side effect absent)");
assert.deepEqual(JSON.parse(json_document[key]), value,
"returned value equal");
})
.push(undefined, function (error) {
assert.notOk(error, "issue in gadget");
})
.push(function () {
done();
});
});
// Json schema test suite written for validator check i use it for form generator check,
// so i need change some tests.
test_settings = {
// `null` type field used so json_document changed on render and invert validation
"allOf with base schema: mismatch second allOf": {
invert_valid: true,
changed: true
}
};
skip_files = [
// XXX not realized
"if-then-else.json",
"dependencies.json"
];
skip_modules = [
];
todo_tests = [
];
// XXX base URI change based on $id property not realised
todo_tests.push("base URI change: base URI change ref valid");
todo_tests.push("base URI change - change folder: number is valid");
todo_tests.push("base URI change - change folder in subschema:" +
" number is valid");
todo_tests.push("maxLength validation: two supplementary Unicode " +
"code points is long enough");
todo_tests.push("minLength validation: one supplementary Unicode " +
"code point is not long enough");
function create_callback(schema, schema_url, value, valid) {
return function (assert) {
var done = assert.async(),
gadget,
test_id = assert.test.module.name + ': ' + assert.test.testName,
settings = test_settings[test_id] || {},
key = "foo_key",
changed = false,
schema_orig;
if (schema !== undefined) {
schema_orig = JSON.parse(JSON.stringify(schema));
}
if (settings.invert_valid) {
valid = !valid;
}
create_gadget(function (method_name) {
if (method_name === "notifyValid") {
assert.ok(valid, "form correctly filled");
} else if (method_name === "notifyInvalid") {
assert.notOk(valid, "form incorrectly filled");
} else if (method_name === "notifyChange") {
changed = true;
} else {
throw new renderJS.AcquisitionError("Can not handle " + method_name);
}
})
.push(function (g) {
var opt = {
key: key,
value: value,
saveOrigValue: true
};
gadget = g;
if (schema !== undefined) {
opt.schema = schema;
} else {
opt.schema_url = schema_url;
}
return gadget.render(opt);
})
.push(function (element) {
assert.ok(element, "gadget rendered");
return gadget.getContent();
})
.push(function (json_document) {
var returned_value;
if (schema_orig !== undefined) {
// if schema used check side error
// if schema_url used we can not check schema_side_error
// because gadget himself download schema
assert.ok(json_document.hasOwnProperty(key),
"getContent does not content property");
assert.deepEqual(schema, schema_orig,
"schema changed (side effect on schema)");
}
try {
returned_value = JSON.parse(json_document[key]);
} catch (error) {
assert.notOk("value not parsable:'" +
returned_value + "'\n" + error);
}
if (!(changed || settings.changed)) {
assert.deepEqual(returned_value, value,
"document does not changed while rendered");
} else {
assert.notDeepEqual(returned_value, value,
"document changed while rendered");
}
})
.push(undefined, function (error) {
console.log(test_id);
console.error(error);
assert.notOk(error, "issue in gadget");
})
.push(function () {
done();
});
};
}
RSVP.Queue()
.push(function () {
return downloadJSON("../test_index.json");
})
.push(function (list) {
var i,
url,
tasks = [];
for (i = 0; i < list.length; i += 1) {
url = '../' + list[i];
tasks.push(downloadJSON(url));
url_list.push(url);
}
return RSVP.all(tasks);
})
.push(function (list) {
var i,
k,
z,
m,
t,
schema,
skip_file,
skip_module,
create_test;
for (i = 0; i < list.length; i += 1) {
skip_file = skip_files.indexOf(url_list[i].replace(/.*\//, '')) >= 0;
for (k = 0; k < list[i].length; k += 1) {
m = list[i][k];
skip_module = skip_modules.indexOf(m.description) >= 0;
module(m.description);
schema = JSON.parse(replaceAll(JSON.stringify(m.schema),
"http://localhost:1234/",
"http://127.0.0.1:9000/node_modules/" +
"json-schema-test-suite/remotes/"));
for (z = 0; z < m.tests.length; z += 1) {
t = m.tests[z];
if (todo_tests.indexOf(m.description + ': ' +
t.description) >= 0) {
create_test = QUnit.todo;
} else if (skip_module || skip_file) {
create_test = QUnit.skip;
} else {
create_test = test;
}
create_test(t.description, create_callback(
schema,
url_list[i] + '#/' + k + '/schema',
t.data,
t.valid
));
}
}
}
})
.push(function () {
QUnit.start();
});
}(document, renderJS, QUnit, jIO)); rjs_json_form-master-test/test/jsonform_test_view.html 0000664 0000000 0000000 00000004045 13463035407 0024001 0 ustar 00root root 0000000 0000000
JSON Schema form generator tests