IntenseWebs/freeipa
3
0
Fork 0
mirror of https://salsa.debian.org/freeipa-team/freeipa.git synced 2025-02-25 18:55:28 -06:00
Code Issues Packages Projects Releases Wiki Activity

Update tests

Browse Source 
With newer QUnit the API has changed, therefor there are necesary changes
in tests. QUnit methods does not pollute global workspace they use global
QUnit object or assert object passed as argument to test method.

Related: https://pagure.io/freeipa/issue/7278
Reviewed-By: Christian Heimes <cheimes@redhat.com>
This commit is contained in:
Pavel Vomacka 2017-11-21 08:56:11 +01:00 committed by Christian Heimes
parent c47784dc9f
commit 2dd7741075
15 changed files with 459 additions and 716 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

44
install/ui/test/aci_tests.js
View File

@ -39,8 +39,8 @@ var target_facet;
var entity = IPA.entity({ name: 'bogus', redirect_facet: 'details' }); var entity = IPA.entity({ name: 'bogus', redirect_facet: 'details' });
var group_entity = IPA.entity({ name: 'group' }); var group_entity = IPA.entity({ name: 'group' });
module('aci', { QUnit.module('aci', {
setup: function() { beforeEach: function(assert) {
fields.register(); fields.register();
widgets.register(); widgets.register();
@ -52,7 +52,7 @@ module('aci', {
IPA.init({ IPA.init({
url: 'data', url: 'data',
on_error: function(xhr, text_status, error_thrown) { on_error: function(xhr, text_status, error_thrown) {
ok(false, "ipa_init() failed: "+error_thrown); assert.ok(false, "ipa_init() failed: "+error_thrown);
} }
}); });
@ -130,13 +130,13 @@ module('aci', {
target_facet.create(); target_facet.create();
target_widget = target_facet.widgets.get_widget('target'); target_widget = target_facet.widgets.get_widget('target');
}, },
teardown: function() { afterEach: function() {
target_container.remove(); target_container.remove();
}} }}
); );
test("aci.attributes_widget", function() { QUnit.test("aci.attributes_widget", function(assert) {
var aciattrs = md.source.objects.user.aciattrs; var aciattrs = md.source.objects.user.aciattrs;
@ -154,7 +154,7 @@ test("aci.attributes_widget", function() {
var list = $('ul', container); var list = $('ul', container);
ok( assert.ok(
list, list,
'Widget contains list'); 'Widget contains list');
@ -163,7 +163,7 @@ test("aci.attributes_widget", function() {
list = $('ul', container); // reload the DOM node which contains options list = $('ul', container); // reload the DOM node which contains options
var li = $('li', list); var li = $('li', list);
same( assert.deepEqual(
li.length, aciattrs.length, li.length, aciattrs.length,
'Widget contains all user ACI attributes'); 'Widget contains all user ACI attributes');
@ -175,7 +175,7 @@ test("aci.attributes_widget", function() {
] ]
}; };
same( assert.deepEqual(
widget.save(), [], widget.save(), [],
'Widget has no initialy checked values'); 'Widget has no initialy checked values');
@ -184,16 +184,16 @@ test("aci.attributes_widget", function() {
list = $('ul', container); // reload the DOM node which contains options list = $('ul', container); // reload the DOM node which contains options
li = $('li', list); li = $('li', list);
same( assert.deepEqual(
li.length, aciattrs.length+1, li.length, aciattrs.length+1,
'Widget contains all user ACI attributes plus 1 unmatched attribute'); 'Widget contains all user ACI attributes plus 1 unmatched attribute');
same( assert.deepEqual(
widget.save(), record.attrs.sort(), widget.save(), record.attrs.sort(),
'All loaded values are saved and sorted'); 'All loaded values are saved and sorted');
}); });
test("aci.rights_widget.", function() { QUnit.test("aci.rights_widget.", function(assert) {
var container = $('<span/>', { var container = $('<span/>', {
name: 'permissions' name: 'permissions'
@ -208,7 +208,7 @@ test("aci.rights_widget.", function() {
var inputs = $('input', container); var inputs = $('input', container);
same( assert.deepEqual(
inputs.length, widget.rights.length, inputs.length, widget.rights.length,
'Widget displays all permissions'); 'Widget displays all permissions');
}); });
@ -231,7 +231,7 @@ var get_visible_rows = function(section) {
}; };
test("Testing type target.", function() { QUnit.test("Testing type target.", function(assert) {
var data = { var data = {
id: null, id: null,
error: null, error: null,
@ -240,11 +240,11 @@ test("Testing type target.", function() {
target_facet.load(data); target_facet.load(data);
same(target_widget.target, 'type', 'type selected'); assert.deepEqual(target_widget.target, 'type', 'type selected');
var attrs_w = target_widget.widgets.get_widget('attrs'); var attrs_w = target_widget.widgets.get_widget('attrs');
var options = attrs_w.options; var options = attrs_w.options;
ok(options.length > 0, "Attrs has some options"); assert.ok(options.length > 0, "Attrs has some options");
// check them all // check them all
var values = []; var values = [];
for (var i=0,l=options.length; i<l; i++) { for (var i=0,l=options.length; i<l; i++) {
@ -256,18 +256,18 @@ test("Testing type target.", function() {
var record = {}; var record = {};
target_facet.save(record); target_facet.save(record);
same(record.type[0], data.result.result.type, assert.deepEqual(record.type[0], data.result.result.type,
"saved type matches sample data"); "saved type matches sample data");
same(get_visible_rows(target_widget), ['type', 'extratargetfilter', assert.deepEqual(get_visible_rows(target_widget), ['type', 'extratargetfilter',
'ipapermtarget', 'memberof', 'attrs'], 'ipapermtarget', 'memberof', 'attrs'],
'type and attrs rows visible'); 'type and attrs rows visible');
same(record.attrs.length, options.length, "response contains all checked attrs"); assert.deepEqual(record.attrs.length, options.length, "response contains all checked attrs");
}); });
test("Testing general target.", function() { QUnit.test("Testing general target.", function(assert) {
var data = { var data = {
id: null, id: null,
@ -280,13 +280,13 @@ test("Testing general target.", function() {
var record = {}; var record = {};
target_facet.save(record); target_facet.save(record);
same(target_widget.target, 'general', 'general selected'); assert.deepEqual(target_widget.target, 'general', 'general selected');
same(get_visible_rows(target_widget), ['type', 'ipapermlocation', assert.deepEqual(get_visible_rows(target_widget), ['type', 'ipapermlocation',
'extratargetfilter', 'ipapermtarget', 'memberof', 'extratargetfilter', 'ipapermtarget', 'memberof',
'attrs_multi'], 'general target fields visible'); 'attrs_multi'], 'general target fields visible');
same(record.extratargetfilter[0], data.result.result.extratargetfilter, 'filter set correctly'); assert.deepEqual(record.extratargetfilter[0], data.result.result.extratargetfilter, 'filter set correctly');
}); });
};}); };});

19
install/ui/test/all_tests.html
View File

@ -3,13 +3,23 @@
<head> <head>
<title>Complete Test Suite</title> <title>Complete Test Suite</title>
<link rel="stylesheet" href="qunit.css" type="text/css" media="screen"> <link rel="stylesheet" href="qunit.css" type="text/css" media="screen">
<script type="text/javascript" src="qunit.js"></script>
<script type="text/javascript" src="../js/libs/loader.js"></script> <script type="text/javascript" src="../js/libs/loader.js"></script>
<script type="text/javascript" src="../js/libs/jquery.js"></script> <script type="text/javascript" src="../js/libs/jquery.js"></script>
<script>
// import qunit.js only in situations it is not imported by grunt-contrib-qunit
// allows to run tests using grunt and using Firefox (FF needs explicit import)
if (window.QUnit === undefined) {
var s = document.createElement("script");
s.type = "text/javascript";
s.src = "qunit.js";
$("head script:last-of-type").before(s); // insert qunit.js import before dojo import
}
</script>
<script type="text/javascript" src="../js/libs/jquery.ordered-map.js"></script> <script type="text/javascript" src="../js/libs/jquery.ordered-map.js"></script>
<script type="text/javascript" src="../js/libs/bootstrap.js"></script> <script type="text/javascript" src="../js/libs/bootstrap.js"></script>
<script type="text/javascript" src="config.js"></script> <script type="text/javascript" src="config.js"></script>
<script type="text/javascript" src="../js/dojo/dojo.js"></script> <script class='insertBefore' type="text/javascript" src="../js/dojo/dojo.js"></script>
<script type="text/javascript"> <script type="text/javascript">
require([ require([
@ -18,7 +28,6 @@
'test/details_tests', 'test/details_tests',
'test/entity_tests', 'test/entity_tests',
'test/association_tests', 'test/association_tests',
'test/navigation_tests',
'test/certificate_tests', 'test/certificate_tests',
'test/aci_tests', 'test/aci_tests',
'test/widget_tests', 'test/widget_tests',
@ -26,13 +35,13 @@
'test/utils_tests', 'test/utils_tests',
'test/build_tests', 'test/build_tests',
'test/binding_tests', 'test/binding_tests',
], function(om, ipa, details, entity, as, nav, cert, aci, wid, ip, ut, bt, bi){ ], function(om, ipa, details, entity, as, cert, aci, wid, ip, ut, bt, bi){
QUnit.start();
om(); om();
ipa(); ipa();
details(); details();
entity(); entity();
as(); as();
nav();
cert(); cert();
aci(); aci();
wid(); wid();

30
install/ui/test/association_tests.js
View File

@ -28,12 +28,12 @@ define([
], function(IPA, $, rpc) ], function(IPA, $, rpc)
{ return function() { { return function() {
module('association'); QUnit.module('association');
test("Testing serial_associator().", function() { QUnit.test("Testing serial_associator().", function(assert) {
expect(11); assert.expect(11);
var orig_ipa_batch_command = rpc.batch_command; var orig_ipa_batch_command = rpc.batch_command;
@ -54,7 +54,7 @@ test("Testing serial_associator().", function() {
var that = orig_ipa_batch_command(spec); var that = orig_ipa_batch_command(spec);
that.execute = function() { that.execute = function() {
equals(that.commands.length, params.values.length, assert.equal(that.commands.length, params.values.length,
'Checking rpc.batch_command command count'); 'Checking rpc.batch_command command count');
var i, command; var i, command;
@ -62,15 +62,15 @@ test("Testing serial_associator().", function() {
for(i=0; i < params.values.length; i++) { for(i=0; i < params.values.length; i++) {
command = that.commands[i]; command = that.commands[i];
equals( assert.equal(
command.entity, params.other_entity.name, command.entity, params.other_entity.name,
'Checking rpc.command() parameter: entity'); 'Checking rpc.command() parameter: entity');
equals( assert.equal(
command.method, params.method, command.method, params.method,
'Checking rpc.command() parameter: method'); 'Checking rpc.command() parameter: method');
equals( assert.equal(
command.args[0], 'user'+(i+1), command.args[0], 'user'+(i+1),
'Checking rpc.command() parameter: primary key'); 'Checking rpc.command() parameter: primary key');
} }
@ -82,7 +82,7 @@ test("Testing serial_associator().", function() {
}; };
params.on_success = function() { params.on_success = function() {
ok(true, "on_success() is invoked."); assert.ok(true, "on_success() is invoked.");
}; };
var associator = IPA.serial_associator(params); var associator = IPA.serial_associator(params);
@ -91,9 +91,9 @@ test("Testing serial_associator().", function() {
rpc.batch_command = orig_ipa_batch_command; rpc.batch_command = orig_ipa_batch_command;
}); });
test("Testing bulk_associator().", function() { QUnit.test("Testing bulk_associator().", function(assert) {
expect(4); assert.expect(4);
var orig_ipa_command = rpc.command; var orig_ipa_command = rpc.command;
@ -118,15 +118,15 @@ test("Testing bulk_associator().", function() {
that.execute = function() { that.execute = function() {
counter++; counter++;
equals( assert.equal(
that.method, params.method, that.method, params.method,
'Checking rpc.command() parameter: method'); 'Checking rpc.command() parameter: method');
equals( assert.equal(
that.args[0], params.pkey, that.args[0], params.pkey,
'Checking rpc.command() parameter: primary key'); 'Checking rpc.command() parameter: primary key');
equals( assert.equal(
that.options[params.other_entity.name], 'user1,user2,user3', that.options[params.other_entity.name], 'user1,user2,user3',
'Checking rpc.command() parameter: options[\""+params.other_entity+"\"]'); 'Checking rpc.command() parameter: options[\""+params.other_entity+"\"]');
@ -137,7 +137,7 @@ test("Testing bulk_associator().", function() {
}; };
params.on_success = function() { params.on_success = function() {
ok(true, "on_success() is invoked."); assert.ok(true, "on_success() is invoked.");
}; };
var associator = IPA.bulk_associator(params); var associator = IPA.bulk_associator(params);
@ -146,4 +146,4 @@ test("Testing bulk_associator().", function() {
rpc.command = orig_ipa_command; rpc.command = orig_ipa_command;
}); });
};}); };});

26
install/ui/test/binding_tests.js
View File

@ -28,13 +28,7 @@ define([
function(builder, FieldBinder, mod_widget, mod_field) { return function() { function(builder, FieldBinder, mod_widget, mod_field) { return function() {
module('build',{ QUnit.module('binding');
setup: function() {
},
teardown: function() {
}
});
/** /**
@ -42,17 +36,17 @@ module('build',{
* *
* All three have to have the same value. * All three have to have the same value.
*/ */
test('Testing two way bindings', function() { QUnit.test('Testing two way bindings', function(assert) {
function test_same_value(value, dirty) { function test_same_value(value, dirty) {
if (dirty) { if (dirty) {
ok(field.dirty, "Field is dirty") assert.ok(field.dirty, "Field is dirty")
} else { } else {
ok(!field.dirty, "Field is not dirty") assert.ok(!field.dirty, "Field is not dirty")
} }
same(widget1.get_value(), value, 'Testing Widget 1 value'); assert.deepEqual(widget1.get_value(), value, 'Testing Widget 1 value');
same(widget2.get_value(), value, 'Testing Widget 2 value'); assert.deepEqual(widget2.get_value(), value, 'Testing Widget 2 value');
same(field.get_value(), value, 'Testing Field value'); assert.deepEqual(field.get_value(), value, 'Testing Field value');
} }
mod_widget.register(); mod_widget.register();
@ -110,9 +104,9 @@ test('Testing two way bindings', function() {
b2.unbind(); b2.unbind();
field.reset(); field.reset();
widget2.set_value(value3); widget2.set_value(value3);
same(widget1.get_value(), value2, 'Testing Widget 1 value'); assert.deepEqual(widget1.get_value(), value2, 'Testing Widget 1 value');
same(widget2.get_value(), value3, 'Testing Widget 2 value'); assert.deepEqual(widget2.get_value(), value3, 'Testing Widget 2 value');
same(field.get_value(), value, 'Testing Field value'); assert.deepEqual(field.get_value(), value, 'Testing Field value');
// bind again // bind again
b1.bind(); b1.bind();

92
install/ui/test/build_tests.js
View File

@ -29,15 +29,9 @@ define([
function(declare, Builder, C_reg, Spec_mod, IPA, su) { return function() { function(declare, Builder, C_reg, Spec_mod, IPA, su) { return function() {
module('build',{ QUnit.module('build');
setup: function() { QUnit.test('Testing builder', function(assert) {
},
teardown: function() {
}
});
test('Testing builder', function() {
var simple_factory = function(spec) { var simple_factory = function(spec) {
@ -69,18 +63,18 @@ test('Testing builder', function() {
var r2 = new Simple_class({}); var r2 = new Simple_class({});
var r21 = new Simple_class({ foo:'baz'}); var r21 = new Simple_class({ foo:'baz'});
deepEqual(o1, r1, 'Factory, default'); assert.deepEqual(o1, r1, 'Factory, default');
deepEqual(o11, r11, 'Factory, spec use'); assert.deepEqual(o11, r11, 'Factory, spec use');
deepEqual(o2, r2, 'Constructor, default'); assert.deepEqual(o2, r2, 'Constructor, default');
deepEqual(o21, r21, 'Constructor, spec use'); assert.deepEqual(o21, r21, 'Constructor, spec use');
strictEqual(o11, o12, 'Don\'t build built object - factory'); assert.strictEqual(o11, o12, 'Don\'t build built object - factory');
strictEqual(o21, o22, 'Don\'t build built object - constructor'); assert.strictEqual(o21, o22, 'Don\'t build built object - constructor');
}); });
test('Testing Spec_mod', function() { QUnit.test('Testing Spec_mod', function(assert) {
var sm = new Spec_mod(); var sm = new Spec_mod();
@ -149,7 +143,7 @@ test('Testing Spec_mod', function() {
sm.mod(spec, diff); sm.mod(spec, diff);
deepEqual(spec, ref, 'Complex Modification'); assert.deepEqual(spec, ref, 'Complex Modification');
spec = { spec = {
a: [ 'a1', 'a2', 'a3' ] a: [ 'a1', 'a2', 'a3' ]
@ -157,10 +151,10 @@ test('Testing Spec_mod', function() {
var rules = [[ 'a', 'new', 1]]; var rules = [[ 'a', 'new', 1]];
sm.add(spec, rules); sm.add(spec, rules);
deepEqual(spec, { a: ['a1', 'new', 'a2', 'a3'] }, 'Add on position'); assert.deepEqual(spec, { a: ['a1', 'new', 'a2', 'a3'] }, 'Add on position');
}); });
test('Testing Construct registry', function() { QUnit.test('Testing Construct registry', function(assert) {
var undefined; var undefined;
@ -171,22 +165,22 @@ test('Testing Construct registry', function() {
cr.register('ctor', ctor); cr.register('ctor', ctor);
var ctor_cs = cr.get('ctor'); var ctor_cs = cr.get('ctor');
equals(ctor_cs.type, 'ctor', 'Ctor: Match type'); assert.equal(ctor_cs.type, 'ctor', 'Ctor: Match type');
equals(ctor_cs.ctor, ctor, 'Ctor: Match ctor'); assert.equal(ctor_cs.ctor, ctor, 'Ctor: Match ctor');
equals(ctor_cs.factory, undefined, 'Ctor: Match factory'); assert.equal(ctor_cs.factory, undefined, 'Ctor: Match factory');
equals(ctor_cs.pre_ops.length, 0, 'Ctor: No pre_ops'); assert.equal(ctor_cs.pre_ops.length, 0, 'Ctor: No pre_ops');
equals(ctor_cs.post_ops.length, 0, 'Ctor: No post_ops'); assert.equal(ctor_cs.post_ops.length, 0, 'Ctor: No post_ops');
// test simple factory registration // test simple factory registration
var fac = function(){}; var fac = function(){};
cr.register('fac', fac); cr.register('fac', fac);
var fac_cs = cr.get('fac'); var fac_cs = cr.get('fac');
equals(fac_cs.type, 'fac', 'Factory: Match type'); assert.equal(fac_cs.type, 'fac', 'Factory: Match type');
equals(fac_cs.ctor, undefined, 'Factory: Match ctor'); assert.equal(fac_cs.ctor, undefined, 'Factory: Match ctor');
equals(fac_cs.factory, fac, 'Factory: Match factory'); assert.equal(fac_cs.factory, fac, 'Factory: Match factory');
equals(fac_cs.pre_ops.length, 0, 'Factory: No pre_ops'); assert.equal(fac_cs.pre_ops.length, 0, 'Factory: No pre_ops');
equals(fac_cs.post_ops.length, 0, 'Factory: No post_ops'); assert.equal(fac_cs.post_ops.length, 0, 'Factory: No post_ops');
// test complex registration // test complex registration
@ -201,22 +195,22 @@ test('Testing Construct registry', function() {
}; };
cr.register(cs); cr.register(cs);
var complex_cs = cr.get('complex'); var complex_cs = cr.get('complex');
equals(complex_cs.type, 'complex', 'Complex: Match type'); assert.equal(complex_cs.type, 'complex', 'Complex: Match type');
equals(complex_cs.ctor, ctor, 'Complex: Match ctor'); assert.equal(complex_cs.ctor, ctor, 'Complex: Match ctor');
equals(complex_cs.factory, fac, 'Complex: Match factory'); assert.equal(complex_cs.factory, fac, 'Complex: Match factory');
equals(complex_cs.pre_ops.length, 0, 'Complex: No pre_ops'); assert.equal(complex_cs.pre_ops.length, 0, 'Complex: No pre_ops');
equals(complex_cs.post_ops.length, 0, 'Complex: No post_ops'); assert.equal(complex_cs.post_ops.length, 0, 'Complex: No post_ops');
deepEqual(complex_cs.spec, spec, 'Complex: Match spec'); assert.deepEqual(complex_cs.spec, spec, 'Complex: Match spec');
// copy: new cs based on existing // copy: new cs based on existing
cr.copy('complex', 'copy', {}); // pure copy cr.copy('complex', 'copy', {}); // pure copy
var copy_cs = cr.get('copy'); var copy_cs = cr.get('copy');
equals(copy_cs.type, 'copy', 'Copy: Match type'); assert.equal(copy_cs.type, 'copy', 'Copy: Match type');
equals(copy_cs.ctor, ctor, 'Copy: Match ctor'); assert.equal(copy_cs.ctor, ctor, 'Copy: Match ctor');
equals(copy_cs.factory, fac, 'Copy: Match factory'); assert.equal(copy_cs.factory, fac, 'Copy: Match factory');
equals(copy_cs.pre_ops.length, 0, 'Copy: No pre_ops'); assert.equal(copy_cs.pre_ops.length, 0, 'Copy: No pre_ops');
equals(copy_cs.post_ops.length, 0, 'Copy: No post_ops'); assert.equal(copy_cs.post_ops.length, 0, 'Copy: No post_ops');
deepEqual(copy_cs.spec, spec, 'Copy: Match spec'); assert.deepEqual(copy_cs.spec, spec, 'Copy: Match spec');
// add post op and pre op to complex // add post op and pre op to complex
var op1 = function() {}; var op1 = function() {};
@ -226,11 +220,11 @@ test('Testing Construct registry', function() {
cr.register_pre_op('complex', op1); cr.register_pre_op('complex', op1);
cr.register_pre_op('complex', op2, true /* first*/); cr.register_pre_op('complex', op2, true /* first*/);
deepEqual(complex_cs.pre_ops, [op2, op1], 'Adding pre_ops'); assert.deepEqual(complex_cs.pre_ops, [op2, op1], 'Adding pre_ops');
cr.register_post_op('complex', op3); cr.register_post_op('complex', op3);
cr.register_post_op('complex', op4, true); cr.register_post_op('complex', op4, true);
deepEqual(complex_cs.post_ops, [op4, op3], 'Adding post_ops'); assert.deepEqual(complex_cs.post_ops, [op4, op3], 'Adding post_ops');
// copy: altered // copy: altered
@ -249,16 +243,16 @@ test('Testing Construct registry', function() {
}); });
var a_copy_cs = cr.get('copy2'); var a_copy_cs = cr.get('copy2');
equals(a_copy_cs.type, 'copy2', 'Altered copy: Match type'); assert.equal(a_copy_cs.type, 'copy2', 'Altered copy: Match type');
equals(a_copy_cs.ctor, ctor2, 'Altered copy: Match ctor'); assert.equal(a_copy_cs.ctor, ctor2, 'Altered copy: Match ctor');
equals(a_copy_cs.factory, fac2, 'Altered copy: Match factory'); assert.equal(a_copy_cs.factory, fac2, 'Altered copy: Match factory');
deepEqual(a_copy_cs.spec, { assert.deepEqual(a_copy_cs.spec, {
name: 'spec', name: 'spec',
foo: 'bar' foo: 'bar'
}, 'Altered copy: Match spec'); }, 'Altered copy: Match spec');
deepEqual(a_copy_cs.pre_ops, [op2, op1, op5], 'Altered copy: Match pre_ops'); assert.deepEqual(a_copy_cs.pre_ops, [op2, op1, op5], 'Altered copy: Match pre_ops');
deepEqual(a_copy_cs.post_ops, [op4, op3, op6], 'Altered copy: Match post_ops'); assert.deepEqual(a_copy_cs.post_ops, [op4, op3, op6], 'Altered copy: Match post_ops');
}); });
};}); };});

31
install/ui/test/certificate_tests.js
View File

@ -18,42 +18,45 @@
* along with this program. If not, see <http://www.gnu.org/licenses/>. * along with this program. If not, see <http://www.gnu.org/licenses/>.
*/ */
define(['freeipa/ipa', 'freeipa/jquery', 'freeipa/certificate'], function(IPA, $) { define(['freeipa/ipa',
return function() { 'freeipa/jquery',
'freeipa/certificate'],
function(IPA, $) {
return function() {
module('certificate'); QUnit.module('certificate');
test("Testing certificate_parse_dn().", function() { QUnit.test("Testing certificate_parse_dn().", function(assert) {
same( assert.deepEqual(
IPA.cert.parse_dn(), {}, IPA.cert.parse_dn(), {},
"Checking IPA.cert.parse_dn()"); "Checking IPA.cert.parse_dn()");
same( assert.deepEqual(
IPA.cert.parse_dn(''), {}, IPA.cert.parse_dn(''), {},
"Checking IPA.cert.parse_dn('')"); "Checking IPA.cert.parse_dn('')");
same( assert.deepEqual(
IPA.cert.parse_dn('c=US'), {'c': 'US'}, IPA.cert.parse_dn('c=US'), {'c': 'US'},
"Checking IPA.cert.parse_dn('c=US')"); "Checking IPA.cert.parse_dn('c=US')");
same( assert.deepEqual(
IPA.cert.parse_dn('st=TX,c=US'), {'st': 'TX','c': 'US'}, IPA.cert.parse_dn('st=TX,c=US'), {'st': 'TX','c': 'US'},
"Checking IPA.cert.parse_dn('st=TX,c=US')"); "Checking IPA.cert.parse_dn('st=TX,c=US')");
same( assert.deepEqual(
IPA.cert.parse_dn('c=US,st=TX'), {'st': 'TX','c': 'US'}, IPA.cert.parse_dn('c=US,st=TX'), {'st': 'TX','c': 'US'},
"Checking IPA.cert.parse_dn('c=US,st=TX')"); "Checking IPA.cert.parse_dn('c=US,st=TX')");
same( assert.deepEqual(
IPA.cert.parse_dn(' st = New Mexico , c = US '), {'st': 'New Mexico','c': 'US'}, IPA.cert.parse_dn(' st = New Mexico , c = US '), {'st': 'New Mexico','c': 'US'},
"Checking IPA.cert.parse_dn(' st = New Mexico , c = US ')"); "Checking IPA.cert.parse_dn(' st = New Mexico , c = US ')");
same( assert.deepEqual(
IPA.cert.parse_dn('ST=TX,C=US'), {'st': 'TX','c': 'US'}, IPA.cert.parse_dn('ST=TX,C=US'), {'st': 'TX','c': 'US'},
"Checking IPA.cert.parse_dn('ST=TX,C=US')"); "Checking IPA.cert.parse_dn('ST=TX,C=US')");
same( assert.deepEqual(
IPA.cert.parse_dn('cn=dev.example.com,ou=Engineering,o=Example,l=Austin,ST=TX,C=US'), IPA.cert.parse_dn('cn=dev.example.com,ou=Engineering,o=Example,l=Austin,ST=TX,C=US'),
{ 'cn': 'dev.example.com', { 'cn': 'dev.example.com',
'ou': 'Engineering', 'ou': 'Engineering',
@ -64,7 +67,7 @@ test("Testing certificate_parse_dn().", function() {
}, },
"Checking IPA.cert.parse_dn('cn=dev.example.com,ou=Engineering,o=Example,l=Austin,ST=TX,C=US')"); "Checking IPA.cert.parse_dn('cn=dev.example.com,ou=Engineering,o=Example,l=Austin,ST=TX,C=US')");
same( assert.deepEqual(
IPA.cert.parse_dn('cn=John Smith,ou=Developers,ou=Users,dc=example,dc=com'), IPA.cert.parse_dn('cn=John Smith,ou=Developers,ou=Users,dc=example,dc=com'),
{ {
'cn': 'John Smith', 'cn': 'John Smith',
@ -74,4 +77,4 @@ test("Testing certificate_parse_dn().", function() {
"Checking IPA.cert.parse_dn('cn=John Smith,ou=Developers,ou=Users,dc=example,dc=com')"); "Checking IPA.cert.parse_dn('cn=John Smith,ou=Developers,ou=Users,dc=example,dc=com')");
}); });
};}); };});

56
install/ui/test/details_tests.js
View File

@ -35,8 +35,8 @@ define([
var details_container; var details_container;
module('details', { QUnit.module('details', {
setup: function() { beforeEach: function(assert) {
IPA.ajax_options.async = false; IPA.ajax_options.async = false;
mod_facet.register(); mod_facet.register();
@ -46,7 +46,7 @@ module('details', {
IPA.init({ IPA.init({
url: 'data', url: 'data',
on_error: function(xhr, text_status, error_thrown) { on_error: function(xhr, text_status, error_thrown) {
ok(false, "ipa_init() failed: "+error_thrown); assert.ok(false, "ipa_init() failed: "+error_thrown);
} }
}); });
@ -60,14 +60,14 @@ module('details', {
}); });
}); });
}, },
teardown: function() { afterEach: function() {
details_container.remove(); details_container.remove();
reg.facet.remove('details'); reg.facet.remove('details');
} }
}); });
test("Testing IPA.details_section.create().", function() { QUnit.test("Testing IPA.details_section.create().", function(assert) {
var facet = IPA.details_facet({ var facet = IPA.details_facet({
entity: IPA.get_entity('user'), entity: IPA.get_entity('user'),
@ -84,7 +84,7 @@ test("Testing IPA.details_section.create().", function() {
var section = facet.widgets.get_widget('IDIDID'); var section = facet.widgets.get_widget('IDIDID');
ok(section !== null, 'Verifying section existence.'); assert.ok(section !== null, 'Verifying section existence.');
var fields = section.widgets.get_widgets(); var fields = section.widgets.get_widgets();
var container = $("<div/>"); var container = $("<div/>");
@ -92,12 +92,12 @@ test("Testing IPA.details_section.create().", function() {
var section_el = $('.details-section-content', container); var section_el = $('.details-section-content', container);
same( assert.deepEqual(
section_el.length, 1, section_el.length, 1,
'Verifying section element'); 'Verifying section element');
var controls = $('.form-group', section_el); var controls = $('.form-group', section_el);
same( assert.deepEqual(
controls.length, fields.length, controls.length, fields.length,
'Verifying number of controls'); 'Verifying number of controls');
@ -105,17 +105,17 @@ test("Testing IPA.details_section.create().", function() {
var field = fields[i]; var field = fields[i];
var field_label = $('.control-label label[name='+field.name+']', container); var field_label = $('.control-label label[name='+field.name+']', container);
same( assert.deepEqual(
field_label.text(), field.label, field_label.text(), field.label,
'Verifying label for field '+field.name); 'Verifying label for field '+field.name);
var field_container = $('.controls div[name='+field.name+']', container); var field_container = $('.controls div[name='+field.name+']', container);
ok( assert.ok(
field_container.length, field_container.length,
'Verifying container for field '+field.name); 'Verifying container for field '+field.name);
ok( assert.ok(
field_container.hasClass('widget'), field_container.hasClass('widget'),
'Verifying field '+field.name+' was created'); 'Verifying field '+field.name+' was created');
} }
@ -123,7 +123,7 @@ test("Testing IPA.details_section.create().", function() {
test("Testing details lifecycle: create, load.", function(){ QUnit.test("Testing details lifecycle: create, load.", function(assert){
var data = {}; var data = {};
data.result = {}; data.result = {};
@ -134,10 +134,10 @@ test("Testing details lifecycle: create, load.", function(){
method: 'show', method: 'show',
args: ['kfrog'], args: ['kfrog'],
on_success: function(data, text_status, xhr) { on_success: function(data, text_status, xhr) {
ok(true, "rpc.command() succeeded."); assert.ok(true, "rpc.command() succeeded.");
}, },
on_error: function(xhr, text_status, error_thrown) { on_error: function(xhr, text_status, error_thrown) {
ok(false, "rpc.command() failed: "+error_thrown); assert.ok(false, "rpc.command() failed: "+error_thrown);
} }
}).execute(); }).execute();
@ -237,23 +237,23 @@ test("Testing details lifecycle: create, load.", function(){
var contact = $('.details-section[name=contact]', facet.dom_node); var contact = $('.details-section[name=contact]', facet.dom_node);
ok( assert.ok(
contact.length, contact.length,
'Verifying section for contact is created'); 'Verifying section for contact is created');
var identity = $('.details-section[name=identity]', facet.dom_node); var identity = $('.details-section[name=identity]', facet.dom_node);
ok( assert.ok(
identity.length, identity.length,
'Verifying section for identity is created'); 'Verifying section for identity is created');
var rows = $('.form-group', identity); var rows = $('.form-group', identity);
same( assert.deepEqual(
rows.length, 6, rows.length, 6,
'Verifying rows for identity'); 'Verifying rows for identity');
ok (load_called, 'load manager called'); assert.ok(load_called, 'load manager called');
var field = facet.fields.get_field('test'); var field = facet.fields.get_field('test');
field.set_value("foo"); field.set_value("foo");
@ -265,14 +265,14 @@ test("Testing details lifecycle: create, load.", function(){
function(){update_success_called = true;}, function(){update_success_called = true;},
function(){update_failure_called = true;}); function(){update_failure_called = true;});
ok (update_success_called,'update success called'); assert.ok(update_success_called,'update success called');
ok (!update_failure_called,'update failure not called'); assert.ok(!update_failure_called,'update failure not called');
ok (save_called, 'save called'); assert.ok(save_called, 'save called');
}); });
test("Testing IPA.details_section_create again()",function() { QUnit.test("Testing IPA.details_section_create again()",function(assert) {
var facet = IPA.details_facet({ var facet = IPA.details_facet({
entity: IPA.get_entity('user'), entity: IPA.get_entity('user'),
@ -301,7 +301,7 @@ test("Testing IPA.details_section_create again()",function() {
}); });
var section = facet.widgets.get_widget('IDIDID'); var section = facet.widgets.get_widget('IDIDID');
ok(section !== null, 'Verifying section existence.'); assert.ok(section !== null, 'Verifying section existence.');
var fields = section.widgets.get_widgets(); var fields = section.widgets.get_widgets();
var container = $("<div title='entity'/>"); var container = $("<div title='entity'/>");
@ -317,12 +317,12 @@ test("Testing IPA.details_section_create again()",function() {
var section_el = $('.details-section-content', container); var section_el = $('.details-section-content', container);
same( assert.deepEqual(
section_el.length, 1, section_el.length, 1,
'Verifying section element'); 'Verifying section element');
var controls = $('.form-group', section_el); var controls = $('.form-group', section_el);
same( assert.deepEqual(
controls.length, fields.length, controls.length, fields.length,
'Verifying number of controls'); 'Verifying number of controls');
@ -330,17 +330,17 @@ test("Testing IPA.details_section_create again()",function() {
var field = fields[i]; var field = fields[i];
var field_label = $('.control-label label[name='+field.name+']', container); var field_label = $('.control-label label[name='+field.name+']', container);
same( assert.deepEqual(
field_label.text(), field.label, field_label.text(), field.label,
'Verifying label for field '+field.name); 'Verifying label for field '+field.name);
var field_container = $('.controls div[name='+field.name+']', container); var field_container = $('.controls div[name='+field.name+']', container);
ok( assert.ok(
field_container.length, field_container.length,
'Verifying container for field '+field.name); 'Verifying container for field '+field.name);
ok( assert.ok(
field_container.hasClass('widget'), field_container.hasClass('widget'),
'Verifying field '+field.name+' was created'); 'Verifying field '+field.name+' was created');
} }

16
install/ui/test/entity_tests.js
View File

@ -32,8 +32,8 @@ define([
var container; var container;
module('entity',{ QUnit.module('entity',{
setup: function() { beforeEach: function(assert) {
IPA.ajax_options.async = false; IPA.ajax_options.async = false;
@ -60,20 +60,20 @@ module('entity',{
}); });
}, },
on_error: function(xhr, text_status, error_thrown) { on_error: function(xhr, text_status, error_thrown) {
ok(false, "ipa_init() failed: "+error_thrown); assert.ok(false, "ipa_init() failed: "+error_thrown);
} }
}); });
container = $('<div id="content"/>').appendTo(document.body); container = $('<div id="content"/>').appendTo(document.body);
}, },
teardown: function() { afterEach: function() {
container.remove(); container.remove();
reg.facet.remove('search'); reg.facet.remove('search');
} }
}); });
test('Testing IPA.entity_set_search_definition().', function() { QUnit.test('Testing IPA.entity_set_search_definition().', function(assert) {
var uid_callback = function() { var uid_callback = function() {
return true; return true;
@ -85,15 +85,15 @@ test('Testing IPA.entity_set_search_definition().', function() {
facet.create(); facet.create();
var column = facet.get_columns()[0]; var column = facet.get_columns()[0];
ok( assert.ok(
column, column,
'column is not null'); 'column is not null');
equals( assert.equal(
column.name, 'uid', column.name, 'uid',
'column.name'); 'column.name');
equals( assert.equal(
column.label, 'User login', column.label, 'User login',
'column.label'); 'column.label');

217
install/ui/test/ip_tests.js
View File

@ -21,288 +21,283 @@
define(['freeipa/ipa', 'freeipa/net'], function(IPA, NET) { define(['freeipa/ipa', 'freeipa/net'], function(IPA, NET) {
return function() { return function() {
module('ip-addresses',{ QUnit.module('ip-addresses');
setup: function() {
},
teardown: function() {
}
});
var get_reverse = function(str) { var get_reverse = function(str) {
var address = NET.ip_address(str); var address = NET.ip_address(str);
return address.get_reverse(); return address.get_reverse();
}; };
test('Testing correct IPv4 addresses', function() { QUnit.test('Testing correct IPv4 addresses', function(assert) {
var address = NET.ip_address('255.0.173.1'); var address = NET.ip_address('255.0.173.1');
ok(address.valid, 'Dotted decimal - 255.0.173.1'); assert.ok(address.valid, 'Dotted decimal - 255.0.173.1');
same(address.parts, ['255', '0', '173', '1'], 'Checking parts'); assert.deepEqual(address.parts, ['255', '0', '173', '1'], 'Checking parts');
address = NET.ip_address('0377.0.0255.01'); address = NET.ip_address('0377.0.0255.01');
ok(address.valid, 'Dotted octal - 0377.0.0255.01'); assert.ok(address.valid, 'Dotted octal - 0377.0.0255.01');
same(address.parts, ['255', '0', '173', '1'], 'Checking parts'); assert.deepEqual(address.parts, ['255', '0', '173', '1'], 'Checking parts');
address = NET.ip_address('0xFF.0x0.0xAD.0x1'); address = NET.ip_address('0xFF.0x0.0xAD.0x1');
ok(address.valid, 'Dotted hexadecimal - 0xFF.0x.0xAD.0x1'); assert.ok(address.valid, 'Dotted hexadecimal - 0xFF.0x.0xAD.0x1');
same(address.parts, ['255', '0', '173', '1'], 'Checking parts'); assert.deepEqual(address.parts, ['255', '0', '173', '1'], 'Checking parts');
address = NET.ip_address('4294967295'); address = NET.ip_address('4294967295');
ok(address.valid, 'Max decimal - 4294967295'); assert.ok(address.valid, 'Max decimal - 4294967295');
same(address.parts, ['255', '255', '255', '255'], 'Checking parts'); assert.deepEqual(address.parts, ['255', '255', '255', '255'], 'Checking parts');
address = NET.ip_address('037777777777'); address = NET.ip_address('037777777777');
ok(address.valid, 'Max octal - 037777777777'); assert.ok(address.valid, 'Max octal - 037777777777');
same(address.parts, ['255', '255', '255', '255'], 'Checking parts'); assert.deepEqual(address.parts, ['255', '255', '255', '255'], 'Checking parts');
address = NET.ip_address('0xFFFFFFFF'); address = NET.ip_address('0xFFFFFFFF');
ok(address.valid, 'Max hexadecimal - 0xFFFFFFFF'); assert.ok(address.valid, 'Max hexadecimal - 0xFFFFFFFF');
same(address.parts, ['255', '255', '255', '255'], 'Checking parts'); assert.deepEqual(address.parts, ['255', '255', '255', '255'], 'Checking parts');
address = NET.ip_address('255.0.0xAD.01'); address = NET.ip_address('255.0.0xAD.01');
ok(address.valid, 'Dotted mixed - 255.0.0xAD.01'); assert.ok(address.valid, 'Dotted mixed - 255.0.0xAD.01');
same(address.parts, ['255', '0', '173', '1'], 'Checking parts'); assert.deepEqual(address.parts, ['255', '0', '173', '1'], 'Checking parts');
address = NET.ip_address('0'); address = NET.ip_address('0');
ok(address.valid, 'Zero decimal - 0'); assert.ok(address.valid, 'Zero decimal - 0');
same(address.parts, ['0', '0', '0', '0'], 'Checking parts'); assert.deepEqual(address.parts, ['0', '0', '0', '0'], 'Checking parts');
address = NET.ip_address('00'); address = NET.ip_address('00');
ok(address.valid, 'Zero octal - 00'); assert.ok(address.valid, 'Zero octal - 00');
same(address.parts, ['0', '0', '0', '0'], 'Checking parts'); assert.deepEqual(address.parts, ['0', '0', '0', '0'], 'Checking parts');
address = NET.ip_address('0X0'); address = NET.ip_address('0X0');
ok(address.valid, 'Zero hexa - 0X0'); assert.ok(address.valid, 'Zero hexa - 0X0');
same(address.parts, ['0', '0', '0', '0'], 'Checking parts'); assert.deepEqual(address.parts, ['0', '0', '0', '0'], 'Checking parts');
}); });
test('Testing incorrect IPv4 addresses', function() { QUnit.test('Testing incorrect IPv4 addresses', function(assert) {
var address = NET.ip_address('256.0.0.1'); var address = NET.ip_address('256.0.0.1');
ok(!address.valid, 'Out of range - 256.0.0.1'); assert.ok(!address.valid, 'Out of range - 256.0.0.1');
address = NET.ip_address('0x100.0.0.1'); address = NET.ip_address('0x100.0.0.1');
ok(!address.valid, 'Out of range - 0x100.0.0.1'); assert.ok(!address.valid, 'Out of range - 0x100.0.0.1');
address = NET.ip_address('0400.0.0.1'); address = NET.ip_address('0400.0.0.1');
ok(!address.valid, 'Out of range - 0400.0.0.1'); assert.ok(!address.valid, 'Out of range - 0400.0.0.1');
address = NET.ip_address('0x100000000'); address = NET.ip_address('0x100000000');
ok(!address.valid, 'Out of range - 0x100000000'); assert.ok(!address.valid, 'Out of range - 0x100000000');
address = NET.ip_address('040000000000'); address = NET.ip_address('040000000000');
ok(!address.valid, 'Out of range - 040000000000'); assert.ok(!address.valid, 'Out of range - 040000000000');
address = NET.ip_address('4294967296'); address = NET.ip_address('4294967296');
ok(!address.valid, 'Out of range - 4294967296'); assert.ok(!address.valid, 'Out of range - 4294967296');
address = NET.ip_address('250.0.173'); address = NET.ip_address('250.0.173');
ok(!address.valid, '3 parts - 250.0.173'); assert.ok(!address.valid, '3 parts - 250.0.173');
address = NET.ip_address('250.0.173.21.21'); address = NET.ip_address('250.0.173.21.21');
ok(!address.valid, '5 parts - 250.0.173.21.21'); assert.ok(!address.valid, '5 parts - 250.0.173.21.21');
address = NET.ip_address('250.001.173.21'); address = NET.ip_address('250.001.173.21');
ok(!address.valid, 'Trailing zeros - 250.001.173.21'); assert.ok(!address.valid, 'Trailing zeros - 250.001.173.21');
address = NET.ip_address('250.001.173.FF'); address = NET.ip_address('250.001.173.FF');
ok(!address.valid, 'Bad hexapart - 250.01.173.FF'); assert.ok(!address.valid, 'Bad hexapart - 250.01.173.FF');
address = NET.ip_address('abcd'); address = NET.ip_address('abcd');
ok(!address.valid, 'Word - abcd'); assert.ok(!address.valid, 'Word - abcd');
address = NET.ip_address('192.168 .0.21'); address = NET.ip_address('192.168 .0.21');
ok(!address.valid, 'With space - 192.168 .0.21'); assert.ok(!address.valid, 'With space - 192.168 .0.21');
address = NET.ip_address(' 192.168.0.21'); address = NET.ip_address(' 192.168.0.21');
ok(!address.valid, 'With space - " 192.168.0.21"'); assert.ok(!address.valid, 'With space - " 192.168.0.21"');
}); });
test('Testing correct IPv6 addresses', function() { QUnit.test('Testing correct IPv6 addresses', function(assert) {
var address = NET.ip_address('2001:0db8:85a3:0000:0000:8a2e:0370:7334'); var address = NET.ip_address('2001:0db8:85a3:0000:0000:8a2e:0370:7334');
ok(address.valid, 'Address - 2001:0db8:85a3:0000:0000:8a2e:0370:7334'); assert.ok(address.valid, 'Address - 2001:0db8:85a3:0000:0000:8a2e:0370:7334');
same(address.parts, ['2001', '0db8', '85a3', '0000','0000','8a2e','0370','7334'], 'Checking parts'); assert.deepEqual(address.parts, ['2001', '0db8', '85a3', '0000','0000','8a2e','0370','7334'], 'Checking parts');
address = NET.ip_address('2001:db8:85a3:0:0:8a2e:370:7334'); address = NET.ip_address('2001:db8:85a3:0:0:8a2e:370:7334');
ok(address.valid, 'Without trailing zeros - 2001:db8:85a3:0:0:8a2e:370:7334'); assert.ok(address.valid, 'Without trailing zeros - 2001:db8:85a3:0:0:8a2e:370:7334');
same(address.parts, ['2001', '0db8', '85a3', '0000','0000','8a2e','0370','7334'], 'Checking parts'); assert.deepEqual(address.parts, ['2001', '0db8', '85a3', '0000','0000','8a2e','0370','7334'], 'Checking parts');
address = NET.ip_address('2001:db8::1:0:0:1'); address = NET.ip_address('2001:db8::1:0:0:1');
ok(address.valid, 'With :: - 2001:db8::1:0:0:1'); assert.ok(address.valid, 'With :: - 2001:db8::1:0:0:1');
same(address.parts, ['2001', '0db8', '0000', '0000','0001','0000','0000','0001'], 'Checking parts'); assert.deepEqual(address.parts, ['2001', '0db8', '0000', '0000','0001','0000','0000','0001'], 'Checking parts');
address = NET.ip_address('::1'); address = NET.ip_address('::1');
ok(address.valid, 'Address - ::1'); assert.ok(address.valid, 'Address - ::1');
same(address.parts, ['0000', '0000', '0000', '0000','0000','0000','0000','0001'], 'Checking parts'); assert.deepEqual(address.parts, ['0000', '0000', '0000', '0000','0000','0000','0000','0001'], 'Checking parts');
address = NET.ip_address('::'); address = NET.ip_address('::');
ok(address.valid, 'Address - ::'); assert.ok(address.valid, 'Address - ::');
same(address.parts, ['0000', '0000', '0000', '0000','0000','0000','0000','0000'], 'Checking parts'); assert.deepEqual(address.parts, ['0000', '0000', '0000', '0000','0000','0000','0000','0000'], 'Checking parts');
address = NET.ip_address('1::'); address = NET.ip_address('1::');
ok(address.valid, 'Address - 1::'); assert.ok(address.valid, 'Address - 1::');
same(address.parts, ['0001', '0000', '0000', '0000','0000','0000','0000','0000'], 'Checking parts'); assert.deepEqual(address.parts, ['0001', '0000', '0000', '0000','0000','0000','0000','0000'], 'Checking parts');
address = NET.ip_address('::ffff:192.0.2.128'); address = NET.ip_address('::ffff:192.0.2.128');
ok(address.valid, 'With IPv4 part - ::ffff:192.0.2.128'); assert.ok(address.valid, 'With IPv4 part - ::ffff:192.0.2.128');
same(address.parts, ['0000', '0000', '0000', '0000','0000','ffff','c000','0280'], 'Checking parts'); assert.deepEqual(address.parts, ['0000', '0000', '0000', '0000','0000','ffff','c000','0280'], 'Checking parts');
}); });
test('Testing incorrect IPv6 addresses', function() { QUnit.test('Testing incorrect IPv6 addresses', function(assert) {
var address = NET.ip_address('02001:0db8:85a3:0000:0000:8a2e:0370:7334'); var address = NET.ip_address('02001:0db8:85a3:0000:0000:8a2e:0370:7334');
ok(!address.valid, 'Too long part- 02001:0db8:85a3:0000:0000:8a2e:0370:7334'); assert.ok(!address.valid, 'Too long part- 02001:0db8:85a3:0000:0000:8a2e:0370:7334');
address = NET.ip_address('2001:db8:85a3:0:0:8a2e:370'); address = NET.ip_address('2001:db8:85a3:0:0:8a2e:370');
ok(!address.valid, 'Missing part - 2001:db8:85a3:0:0:8a2e:370'); assert.ok(!address.valid, 'Missing part - 2001:db8:85a3:0:0:8a2e:370');
address = NET.ip_address(':'); address = NET.ip_address(':');
ok(!address.valid, 'Address - :'); assert.ok(!address.valid, 'Address - :');
address = NET.ip_address('::1::'); address = NET.ip_address('::1::');
ok(!address.valid, 'Address - ::1::'); assert.ok(!address.valid, 'Address - ::1::');
address = NET.ip_address(':::'); address = NET.ip_address(':::');
ok(!address.valid, 'Address - :::'); assert.ok(!address.valid, 'Address - :::');
address = NET.ip_address('1::1::1'); address = NET.ip_address('1::1::1');
ok(!address.valid, 'Address - 1::1::1'); assert.ok(!address.valid, 'Address - 1::1::1');
address = NET.ip_address('::ffff:192.0.0x2.128'); address = NET.ip_address('::ffff:192.0.0x2.128');
ok(!address.valid, 'With IPv4 hex part - ::ffff:192.0.0x2.128'); assert.ok(!address.valid, 'With IPv4 hex part - ::ffff:192.0.0x2.128');
address = NET.ip_address('::ffff:192.0.02.128'); address = NET.ip_address('::ffff:192.0.02.128');
ok(!address.valid, 'With IPv4 oct part - ::ffff:192.0.02.128'); assert.ok(!address.valid, 'With IPv4 oct part - ::ffff:192.0.02.128');
address = NET.ip_address('aa:rt::'); address = NET.ip_address('aa:rt::');
ok(!address.valid, 'Invalid chars - aa:rt::'); assert.ok(!address.valid, 'Invalid chars - aa:rt::');
}); });
test('Testing reverse addresses', function() { QUnit.test('Testing reverse addresses', function(assert) {
var reverse_valid = '4.3.3.7.0.7.3.0.e.2.a.8.0.0.0.0.0.0.0.0.3.a.5.8.8.b.d.0.1.0.0.2.ip6.arpa'; var reverse_valid = '4.3.3.7.0.7.3.0.e.2.a.8.0.0.0.0.0.0.0.0.3.a.5.8.8.b.d.0.1.0.0.2.ip6.arpa';
var reverse = get_reverse('2001:0db8:85a3:0000:0000:8a2e:0370:7334'); var reverse = get_reverse('2001:0db8:85a3:0000:0000:8a2e:0370:7334');
same(reverse, reverse_valid, '2001:0db8:85a3:0000:0000:8a2e:0370:7334'); assert.deepEqual(reverse, reverse_valid, '2001:0db8:85a3:0000:0000:8a2e:0370:7334');
reverse = get_reverse('2001:db8:85a3::8a2e:370:7334'); reverse = get_reverse('2001:db8:85a3::8a2e:370:7334');
same(reverse, reverse_valid, '2001:db8:85a3::8a2e:370:7334'); assert.deepEqual(reverse, reverse_valid, '2001:db8:85a3::8a2e:370:7334');
reverse_valid = '1.0.168.192.in-addr.arpa'; reverse_valid = '1.0.168.192.in-addr.arpa';
reverse = get_reverse('192.168.0.1'); reverse = get_reverse('192.168.0.1');
same(reverse, reverse_valid, '192.168.0.1'); assert.deepEqual(reverse, reverse_valid, '192.168.0.1');
reverse_valid = '0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.ip6.arpa'; reverse_valid = '0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.ip6.arpa';
reverse = get_reverse('::'); reverse = get_reverse('::');
same(reverse, reverse_valid, '::'); assert.deepEqual(reverse, reverse_valid, '::');
reverse_valid = '1.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.ip6.arpa'; reverse_valid = '1.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.ip6.arpa';
reverse = get_reverse('::1'); reverse = get_reverse('::1');
same(reverse, reverse_valid, '::1'); assert.deepEqual(reverse, reverse_valid, '::1');
reverse_valid = '0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.1.0.0.0.ip6.arpa'; reverse_valid = '0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.1.0.0.0.ip6.arpa';
reverse = get_reverse('1::'); reverse = get_reverse('1::');
same(reverse, reverse_valid, '1::'); assert.deepEqual(reverse, reverse_valid, '1::');
reverse_valid = '5.1.0.0.8.a.0.c.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.ip6.arpa'; reverse_valid = '5.1.0.0.8.a.0.c.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.ip6.arpa';
reverse = get_reverse('::192.168.0.21'); reverse = get_reverse('::192.168.0.21');
same(reverse, reverse_valid, '::192.168.0.21'); assert.deepEqual(reverse, reverse_valid, '::192.168.0.21');
reverse_valid = '255.254.253.252.in-addr.arpa'; reverse_valid = '255.254.253.252.in-addr.arpa';
reverse = get_reverse('0xFCFDFEFF'); reverse = get_reverse('0xFCFDFEFF');
same(reverse, reverse_valid, '0xFCFDFEFF'); assert.deepEqual(reverse, reverse_valid, '0xFCFDFEFF');
reverse = get_reverse('4244504319'); reverse = get_reverse('4244504319');
same(reverse, reverse_valid, '4244504319'); assert.deepEqual(reverse, reverse_valid, '4244504319');
reverse = get_reverse('037477377377'); reverse = get_reverse('037477377377');
same(reverse, reverse_valid, '037477377377'); assert.deepEqual(reverse, reverse_valid, '037477377377');
reverse_valid = '0.0.0.0.in-addr.arpa'; reverse_valid = '0.0.0.0.in-addr.arpa';
reverse = get_reverse('0'); reverse = get_reverse('0');
same(reverse, reverse_valid, '0'); assert.deepEqual(reverse, reverse_valid, '0');
reverse = get_reverse('00'); reverse = get_reverse('00');
same(reverse, reverse_valid, '00'); assert.deepEqual(reverse, reverse_valid, '00');
reverse = get_reverse('0x0'); reverse = get_reverse('0x0');
same(reverse, reverse_valid, '0x0'); assert.deepEqual(reverse, reverse_valid, '0x0');
}); });
test('Usage - constructor direct input', function() { QUnit.test('Usage - constructor direct input', function(assert) {
var address = NET.ip_address('0xC0A80001'); var address = NET.ip_address('0xC0A80001');
ok(address.valid, 'Valid'); assert.ok(address.valid, 'Valid');
same(address.type, 'v4-int', 'Checking type'); assert.deepEqual(address.type, 'v4-int', 'Checking type');
same(address.parts, ['192', '168', '0', '1'], 'Checking parts'); assert.deepEqual(address.parts, ['192', '168', '0', '1'], 'Checking parts');
var reverse_valid = '1.0.168.192.in-addr.arpa'; var reverse_valid = '1.0.168.192.in-addr.arpa';
same(address.get_reverse(), reverse_valid, 'Checking reverse address'); assert.deepEqual(address.get_reverse(), reverse_valid, 'Checking reverse address');
}); });
test('Usage - constructor spec object', function() { QUnit.test('Usage - constructor spec object', function(assert) {
var address = NET.ip_address({ address: '0xC0A80001' }); var address = NET.ip_address({ address: '0xC0A80001' });
ok(address.valid, 'Valid'); assert.ok(address.valid, 'Valid');
same(address.type, 'v4-int', 'Checking type'); assert.deepEqual(address.type, 'v4-int', 'Checking type');
same(address.parts, ['192', '168', '0', '1'], 'Checking parts'); assert.deepEqual(address.parts, ['192', '168', '0', '1'], 'Checking parts');
var reverse_valid = '1.0.168.192.in-addr.arpa'; var reverse_valid = '1.0.168.192.in-addr.arpa';
same(address.get_reverse(), reverse_valid, 'Checking reverse address'); assert.deepEqual(address.get_reverse(), reverse_valid, 'Checking reverse address');
}); });
test('Usage - constructor spec object - by parts', function() { QUnit.test('Usage - constructor spec object - by parts', function(assert) {
var address = NET.ip_address({ var address = NET.ip_address({
parts: ['0xC0', '168', '00', '1'], parts: ['0xC0', '168', '00', '1'],
type: 'v4-quads' type: 'v4-quads'
}); });
ok(address.valid, 'Valid'); assert.ok(address.valid, 'Valid');
same(address.type, 'v4-quads', 'Checking type'); assert.deepEqual(address.type, 'v4-quads', 'Checking type');
same(address.parts, ['192', '168', '0', '1'], 'Checking parts'); assert.deepEqual(address.parts, ['192', '168', '0', '1'], 'Checking parts');
var reverse_valid = '1.0.168.192.in-addr.arpa'; var reverse_valid = '1.0.168.192.in-addr.arpa';
same(address.get_reverse(), reverse_valid, 'Checking reverse address'); assert.deepEqual(address.get_reverse(), reverse_valid, 'Checking reverse address');
}); });
test('Usage - constructor spec object - by parts - IPv6', function() { QUnit.test('Usage - constructor spec object - by parts - IPv6', function(assert) {
var address = NET.ip_address({ var address = NET.ip_address({
parts: ['2001','db8','85a3','0','0','8a2e','370','7334'], parts: ['2001','db8','85a3','0','0','8a2e','370','7334'],
type: 'v6' type: 'v6'
}); });
ok(address.valid, 'Valid'); assert.ok(address.valid, 'Valid');
same(address.type, 'v6', 'Checking type'); assert.deepEqual(address.type, 'v6', 'Checking type');
same(address.parts, ['2001','0db8','85a3','0000','0000','8a2e','0370','7334'], 'Checking parts'); assert.deepEqual(address.parts, ['2001','0db8','85a3','0000','0000','8a2e','0370','7334'], 'Checking parts');
var reverse_valid = '4.3.3.7.0.7.3.0.e.2.a.8.0.0.0.0.0.0.0.0.3.a.5.8.8.b.d.0.1.0.0.2.ip6.arpa'; var reverse_valid = '4.3.3.7.0.7.3.0.e.2.a.8.0.0.0.0.0.0.0.0.3.a.5.8.8.b.d.0.1.0.0.2.ip6.arpa';
same(address.get_reverse(), reverse_valid, 'Checking reverse address'); assert.deepEqual(address.get_reverse(), reverse_valid, 'Checking reverse address');
}); });
test('Usage - set address.input', function() { QUnit.test('Usage - set address.input', function(assert) {
var address = NET.ip_address(); var address = NET.ip_address();
ok(!address.valid, 'No input - invalid'); assert.ok(!address.valid, 'No input - invalid');
address.input = '192.168.0.1'; address.input = '192.168.0.1';
address.parse(); address.parse();
ok(address.valid, 'Valid'); assert.ok(address.valid, 'Valid');
same(address.type, 'v4-quads', 'Checking type'); assert.deepEqual(address.type, 'v4-quads', 'Checking type');
same(address.parts, ['192', '168', '0', '1'], 'Checking parts'); assert.deepEqual(address.parts, ['192', '168', '0', '1'], 'Checking parts');
var reverse_valid = '1.0.168.192.in-addr.arpa'; var reverse_valid = '1.0.168.192.in-addr.arpa';
same(address.get_reverse(), reverse_valid, 'Checking reverse address'); assert.deepEqual(address.get_reverse(), reverse_valid, 'Checking reverse address');
}); });
test('Usage - set address.parts, no type', function() { QUnit.test('Usage - set address.parts, no type', function(assert) {
var address = NET.ip_address(); var address = NET.ip_address();
ok(!address.valid, 'No input - invalid'); assert.ok(!address.valid, 'No input - invalid');
address.parts = ['192', '168', '0', '1']; address.parts = ['192', '168', '0', '1'];
address.parse(); address.parse();
ok(!address.valid, 'Still invalid'); assert.ok(!address.valid, 'Still invalid');
same(address.type, null, 'Checking type'); assert.deepEqual(address.type, null, 'Checking type');
}); });
};}); };});

111
install/ui/test/ipa_tests.js
View File

@ -29,73 +29,72 @@ define([
function(IPA, $, rpc) { function(IPA, $, rpc) {
return function() { return function() {
module('ipa'); QUnit.module('ipa', {
beforeEach: function(assert) {
var done = assert.async();
test("Testing ipa_init().", function() { IPA.init({
url: 'data',
expect(1); on_success: function(data, text_status, xhr) {
assert.ok(true, "ipa_init() succeeded.");
IPA.ajax_options.async = false; done();
},
IPA.init({ on_error: function(xhr, text_status, error_thrown) {
url: 'data', assert.ok(false, "ipa_init() failed: "+error_thrown);
on_success: function(data, text_status, xhr) { done();
ok(true, "ipa_init() succeeded."); }
}, });
on_error: function(xhr, text_status, error_thrown) { }
ok(false, "ipa_init() failed: "+error_thrown);
}
});
}); });
test("Testing IPA.get_entity_param().", function() { QUnit.test("Testing IPA.get_entity_param().", function(assert) {
var metadata = IPA.get_entity_param("user", "uid"); var metadata = IPA.get_entity_param("user", "uid");
ok( assert.ok(
metadata, metadata,
"IPA.get_entity_param(\"user\", \"uid\") not null"); "IPA.get_entity_param(\"user\", \"uid\") not null");
equals( assert.equal(
metadata["label"], "User login", metadata["label"], "User login",
"IPA.get_entity_param(\"user\", \"uid\")[\"label\"]"); "IPA.get_entity_param(\"user\", \"uid\")[\"label\"]");
equals( assert.equal(
IPA.get_entity_param("user", "wrong_attribute"), null, IPA.get_entity_param("user", "wrong_attribute"), null,
"IPA.get_entity_param(\"user\", \"wrong_attribute\")"); "IPA.get_entity_param(\"user\", \"wrong_attribute\")");
equals( assert.equal(
IPA.get_entity_param("user", null), null, IPA.get_entity_param("user", null), null,
"IPA.get_entity_param(\"user\", null)"); "IPA.get_entity_param(\"user\", null)");
equals( assert.equal(
IPA.get_entity_param("wrong_entity", "uid"), null, IPA.get_entity_param("wrong_entity", "uid"), null,
"IPA.get_entity_param(\"wrong_entity\", \"uid\")"); "IPA.get_entity_param(\"wrong_entity\", \"uid\")");
equals( assert.equal(
IPA.get_entity_param(null, "uid"), null, IPA.get_entity_param(null, "uid"), null,
"IPA.get_entity_param(null, \"uid\")"); "IPA.get_entity_param(null, \"uid\")");
}); });
test("Testing IPA.get_member_attribute().", function() { QUnit.test("Testing IPA.get_member_attribute().", function(assert) {
equals( assert.equal(
IPA.get_member_attribute("user", "group"), "memberofindirect", IPA.get_member_attribute("user", "group"), "memberofindirect",
"IPA.get_member_attribute(\"user\", \"group\")"); "IPA.get_member_attribute(\"user\", \"group\")");
equals( assert.equal(
IPA.get_member_attribute("user", "host"), null, IPA.get_member_attribute("user", "host"), null,
"IPA.get_member_attribute(\"user\", \"host\")"); "IPA.get_member_attribute(\"user\", \"host\")");
equals( assert.equal(
IPA.get_member_attribute("user", null), null, IPA.get_member_attribute("user", null), null,
"IPA.get_member_attribute(\"user\", null)"); "IPA.get_member_attribute(\"user\", null)");
equals( assert.equal(
IPA.get_member_attribute(null, "group"), null, IPA.get_member_attribute(null, "group"), null,
"IPA.get_member_attribute(null, \"group\")"); "IPA.get_member_attribute(null, \"group\")");
}); });
test("Testing successful rpc.command().", function() { QUnit.test("Testing successful rpc.command().", function(assert) {
var method = 'method'; var method = 'method';
var args = ['arg1', 'arg2', 'arg3']; var args = ['arg1', 'arg2', 'arg3'];
@ -130,20 +129,20 @@ test("Testing successful rpc.command().", function() {
$.ajax = function(request) { $.ajax = function(request) {
ajax_counter++; ajax_counter++;
equals( assert.equal(
request.url, "data/"+object+"_"+method+".json", request.url, "data/"+object+"_"+method+".json",
"Checking request.url"); "Checking request.url");
var data = JSON.parse(request.data); var data = JSON.parse(request.data);
equals( assert.equal(
data.method, object+'_'+method, data.method, object+'_'+method,
"Checking method"); "Checking method");
// By default all rpc calls contain version of API // By default all rpc calls contain version of API
$.extend(options, {'version': window.ipa_loader.api_version}); $.extend(options, {'version': window.ipa_loader.api_version});
same( assert.deepEqual(
data.params, [args, options], data.params, [args, options],
"Checking parameters"); "Checking parameters");
@ -159,24 +158,24 @@ test("Testing successful rpc.command().", function() {
on_error: error_handler on_error: error_handler
}).execute(); }).execute();
equals( assert.equal(
ajax_counter, 1, ajax_counter, 1,
"Checking ajax invocation counter"); "Checking ajax invocation counter");
var dialog = $('[data-name=error_dialog]'); var dialog = $('[data-name=error_dialog]');
ok( assert.ok(
dialog.length === 0, dialog.length === 0,
"The dialog box is not created."); "The dialog box is not created.");
ok( assert.ok(
success_handler_counter === 1 && error_handler_counter === 0, success_handler_counter === 1 && error_handler_counter === 0,
"Only the success handler is called."); "Only the success handler is called.");
$.ajax = orig; $.ajax = orig;
}); });
test("Testing unsuccessful rpc.command().", function() { QUnit.test("Testing unsuccessful rpc.command().", function(assert) {
var method = 'method'; var method = 'method';
var args = ['arg1', 'arg2', 'arg3']; var args = ['arg1', 'arg2', 'arg3'];
@ -210,17 +209,17 @@ test("Testing unsuccessful rpc.command().", function() {
$.ajax = function(request) { $.ajax = function(request) {
ajax_counter++; ajax_counter++;
equals(request.url, "data/"+object+"_"+method+".json", assert.equal(request.url, "data/"+object+"_"+method+".json",
"Checking request.url"); "Checking request.url");
var data = JSON.parse(request.data); var data = JSON.parse(request.data);
equals(data.method, object+'_'+method, "Checking method"); assert.equal(data.method, object+'_'+method, "Checking method");
// By default all rpc calls contain version of API // By default all rpc calls contain version of API
$.extend(options, { 'version': window.ipa_loader.api_version}); $.extend(options, { 'version': window.ipa_loader.api_version});
same(data.params, [args, options], "Checking parameters"); assert.deepEqual(data.params, [args, options], "Checking parameters");
// remove api version from options object // remove api version from options object
delete options.version; delete options.version;
@ -245,42 +244,42 @@ test("Testing unsuccessful rpc.command().", function() {
var dialog = $(dialog_selector); var dialog = $(dialog_selector);
equals( assert.equal(
ajax_counter, 1, ajax_counter, 1,
"Checking ajax invocation counter"); "Checking ajax invocation counter");
ok( assert.ok(
dialog.length === 1, dialog.length === 1,
"The dialog box is created and open."); "The dialog box is created and open.");
ok( assert.ok(
success_handler_counter === 0 && error_handler_counter === 0, success_handler_counter === 0 && error_handler_counter === 0,
"Initially none of the handlers are called."); "Initially none of the handlers are called.");
click_button('retry'); click_button('retry');
equals( assert.equal(
ajax_counter, 2, ajax_counter, 2,
"Checking ajax invocation counter"); "Checking ajax invocation counter");
ok( assert.ok(
success_handler_counter === 0 && error_handler_counter === 0, success_handler_counter === 0 && error_handler_counter === 0,
"After 1st retry, none of the handlers are called."); "After 1st retry, none of the handlers are called.");
click_button('retry'); click_button('retry');
equals(ajax_counter, 3, assert.equal(ajax_counter, 3,
"Checking ajax invocation counter"); "Checking ajax invocation counter");
ok(success_handler_counter === 0 && error_handler_counter === 0, assert.ok(success_handler_counter === 0 && error_handler_counter === 0,
"After 2nd retry, none of the handlers are called."); "After 2nd retry, none of the handlers are called.");
click_button('cancel'); click_button('cancel');
equals(ajax_counter, 3, assert.equal(ajax_counter, 3,
"Checking ajax invocation counter"); "Checking ajax invocation counter");
ok(success_handler_counter === 0 && error_handler_counter === 1, assert.ok(success_handler_counter === 0 && error_handler_counter === 1,
"Only the error handler is called."); "Only the error handler is called.");
// cleanup - qunit doesn't really play well with asynchronous opening and // cleanup - qunit doesn't really play well with asynchronous opening and
@ -292,8 +291,8 @@ test("Testing unsuccessful rpc.command().", function() {
$.ajax = orig; $.ajax = orig;
}); });
test("Testing observer.", function() { QUnit.test("Testing observer.", function(assert) {
expect(6); assert.expect(7);
var obj = {}; var obj = {};
var param1_value = 'p1'; var param1_value = 'p1';
var param2_value = 'p2'; var param2_value = 'p2';
@ -301,20 +300,20 @@ test("Testing observer.", function() {
obj.event = IPA.observer(); obj.event = IPA.observer();
obj.event.attach(function(param1, param2) { obj.event.attach(function(param1, param2) {
ok(true, "Proper function 1 callback"); assert.ok(true, "Proper function 1 callback");
}); });
var first = true; var first = true;
var func = function(param1, param2) { var func = function(param1, param2) {
if(first) { if(first) {
ok(true, "Proper function 2 callback"); assert.ok(true, "Proper function 2 callback");
equals(param1, param1_value, "Testing Parameter 1"); assert.equal(param1, param1_value, "Testing Parameter 1");
equals(param2, param2_value, "Testing Parameter 2"); assert.equal(param2, param2_value, "Testing Parameter 2");
equals(this, obj, "Testing Context"); assert.equal(this, obj, "Testing Context");
first = false; first = false;
} else { } else {
ok(false, "Fail function 2 callback"); assert.ok(false, "Fail function 2 callback");
} }
}; };

25
install/ui/test/navigation_tests.html
View File

@ -1,25 +0,0 @@
<!DOCTYPE html>
<html>
<head>
<title>Navigation Test Suite</title>
<link rel="stylesheet" href="qunit.css" type="text/css" media="screen">
<script type="text/javascript" src="qunit.js"></script>
<script type="text/javascript" src="../js/libs/loader.js"></script>
<script type="text/javascript" src="../js/libs/jquery.js"></script>
<script type="text/javascript" src="../js/libs/jquery.ordered-map.js"></script>
<script type="text/javascript" src="config.js"></script>
<script type="text/javascript" src="../js/dojo/dojo.js"></script>
<script type="text/javascript">
require(['test/navigation_tests'], function(tests){ tests() });
</script>
</head>
<body>
<h1 id="qunit-header">Navigation Test Suite</h1>
<h2 id="qunit-banner"></h2>
<div id="qunit-testrunner-toolbar"></div>
<h2 id="qunit-userAgent"></h2>
<ol id="qunit-tests"></ol>
<div id="qunit-fixture"></div>
</body>
</html>

225
install/ui/test/navigation_tests.js
View File

@ -1,225 +0,0 @@
/* Authors:
* Adam Young <ayoung@redhat.com>
*
* Copyright (C) 2010 Red Hat
* see file 'COPYING' for use and warranty information
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
define(['freeipa/ipa', 'freeipa/jquery', 'freeipa/navigation', 'freeipa/entity'],
function(IPA, $) {
return function() {
module('navigation', {
// setup: function() {
// IPA.ajax_options.async = false;
// IPA.init({
// url: 'data',
// on_error: function(xhr, text_status, error_thrown) {
// ok(false, 'ipa_init() failed: '+error_thrown);
// }
// });
// }
});
test("Testing IPA.navigation.create().", function() {
// var entity;
// var user_mock_called = false;
// var group_mock_called = false;
// //Force reset of entities
// IPA.entities = $.ordered_map();
//
// IPA.register('user', function(spec) {
//
// var that = IPA.entity({
// name: 'user',
// metadata: IPA.metadata.objects.user,
// facets: [
// {
// type: 'search'
// }
// ]
// });
//
// that.display = function(container){
// user_mock_called = true;
// same(container.attr('name'), 'user', 'user container name');
// same(container[0].nodeName, 'DIV', 'user container element');
// };
//
// return that;
// });
//
// IPA.register('group', function(spec) {
//
// var that = IPA.entity({
// name: 'group',
// metadata: IPA.metadata.objects.group
// });
//
// that.display = function(container){
// group_mock_called = true;
// same(container.attr('name'), 'group','user container name');
// same(container[0].nodeName, 'DIV', 'user container element');
// };
//
// return that;
// });
//
// var navigation_container = $('<div id="navigation"/>').appendTo(document.body);
// var entity_container = $('<div id="content"/>').appendTo(document.body);
//
// var navigation = IPA.navigation({
// container: navigation_container,
// content: entity_container,
// tabs: [
// { name:'identity', label:'IDENTITY', children: [
// {name:'user', entity:'user'},
// {name:'group', entity:'group'}
// ]}
// ]
// });
//
// navigation.create();
// navigation.update();
//
// ok(user_mock_called, "mock user setup was called");
// ok(!group_mock_called, "mock group setup was not called because the tab is inactive");
//
// var tabs_container = navigation_container.children('div');
//
// var level1_tabs = tabs_container.children('div');
// same(level1_tabs.length, 1, "One level 1 tab");
//
// var identity_tab = level1_tabs.first();
// same(identity_tab.attr('name'), 'identity', "Identity Tab");
//
// var level2_tabs = identity_tab.children('div');
// same(level2_tabs.length, 2, "Two level 2 tabs");
//
// var user_tab = level2_tabs.first();
// same(user_tab.attr('name'), 'user', "User Tab");
//
// var group_tab = user_tab.next();
// same(group_tab.attr('name'), 'group', "Group Tab");
//
// entity_container.remove();
// navigation_container.remove();
});
test("Testing IPA.navigation.update() with valid index.", function() {
// var navigation_container = $('<div id="navigation"/>').appendTo(document.body);
// var entity_container = $('<div id="content"/>').appendTo(document.body);
//
// var navigation = IPA.navigation({
// container: navigation_container,
// content: entity_container,
// tabs: [
// { name:'identity', label:'IDENTITY', children: [
// {name:'one', label:'One'},
// {name:'two', label:'Two'}
// ]}
// ]
// });
//
// var state = {};
//
// navigation.push_state = function(params) {
// $.extend(state, params);
// };
//
// navigation.get_state = function(key) {
// return key ? state[key] : {};
// };
//
// navigation.remove_state = function(key) {
// delete state[key];
// };
//
// navigation.create();
// navigation.push_state({'identity': 'two'});
// navigation.update();
//
// var tabs_container = navigation_container.children('div');
//
// same(
// tabs_container.tabs('option', 'selected'), 0,
// "Active tab at level 1");
//
// same(
// $('.tabs[name=identity]', tabs_container).tabs('option', 'selected'), 1,
// "Active tab at level 2");
//
// navigation.remove_state("identity");
//
// entity_container.remove();
// navigation_container.remove();
// });
//
// test("Testing IPA.navigation.update() with out-of-range index.", function() {
//
// var navigation_container = $('<div id="navigation"/>').appendTo(document.body);
// var entity_container = $('<div id="content"/>').appendTo(document.body);
//
// var navigation = IPA.navigation({
// container: navigation_container,
// content: entity_container,
// tabs: [
// { name:'identity', label:'IDENTITY', children: [
// {name:'one', label:'One', setup: function (){}},
// {name:'two', label:'Two', setup: function (){}}
// ]}
// ]
// });
//
// var state = {};
//
// navigation.push_state = function(params) {
// $.extend(state, params);
// };
//
// navigation.get_state = function(key) {
// return key ? state[key] : {};
// };
//
// navigation.remove_state = function(key) {
// delete state[key];
// };
//
// navigation.create();
// navigation.push_state({'identity': 'three'});
// navigation.update();
//
// var tabs_container = navigation_container.children('div');
//
// same(
// tabs_container.tabs('option', 'selected'), 0,
// "Active tab at level 1");
//
// same(
// $('.tabs[name=identity]', tabs_container).tabs('option', 'selected'), 0,
// "Active tab at level 2");
//
// navigation.remove_state("identity");
//
// entity_container.remove();
// navigation_container.remove();
});
};});

53
install/ui/test/ordered_map_tests.js
View File

@ -18,21 +18,20 @@
* along with this program. If not, see <http://www.gnu.org/licenses/>. * along with this program. If not, see <http://www.gnu.org/licenses/>.
*/ */
define(['freeipa/jquery'], function($) { define(['freeipa/jquery'], function($) {
return function() { return function() {
QUnit.module('ordered_map');
module('ordered_map'); QUnit.test("Testing $.ordered_map constructor.", function(assert) {
test("Testing $.ordered_map constructor.", function() {
var test = $.ordered_map(); var test = $.ordered_map();
strictEqual(test.length, 0, "Checking length."); assert.strictEqual(test.length, 0, "Checking length.");
deepEqual(test.keys, [], "Checking keys."); assert.deepEqual(test.keys, [], "Checking keys.");
deepEqual(test.values, [], "Checking values."); assert.deepEqual(test.values, [], "Checking values.");
}); });
test("Testing $.ordered_map.put().", function() { QUnit.test("Testing $.ordered_map.put().", function(assert) {
var test = $.ordered_map(); var test = $.ordered_map();
@ -80,12 +79,12 @@ test("Testing $.ordered_map.put().", function() {
test.put(key7, value7, 100); //put at end test.put(key7, value7, 100); //put at end
test.put(key8, value8, 'foobar'); //put at end test.put(key8, value8, 'foobar'); //put at end
strictEqual(test.length, 8, 'Checking length.'); assert.strictEqual(test.length, 8, 'Checking length.');
deepEqual(test.keys, [key5, key4, key1, key3, key2, key6, key7, key8], 'Checking keys.'); assert.deepEqual(test.keys, [key5, key4, key1, key3, key2, key6, key7, key8], 'Checking keys.');
deepEqual(test.values, [value5, value4, value1, value3, value2, value6, value7, value8], 'Checking values.'); assert.deepEqual(test.values, [value5, value4, value1, value3, value2, value6, value7, value8], 'Checking values.');
}); });
test("Testing $.ordered_map.get().", function() { QUnit.test("Testing $.ordered_map.get().", function(assert) {
var test = $.ordered_map(); var test = $.ordered_map();
@ -105,14 +104,14 @@ test("Testing $.ordered_map.get().", function() {
var result1 = test.get(key1); var result1 = test.get(key1);
var result2 = test.get(key2); var result2 = test.get(key2);
strictEqual(test.length, 2, 'Checking length.'); assert.strictEqual(test.length, 2, 'Checking length.');
deepEqual(test.keys, [key1, key2], 'Checking keys.'); assert.deepEqual(test.keys, [key1, key2], 'Checking keys.');
deepEqual(test.values, [value1, value2], 'Checking values.'); assert.deepEqual(test.values, [value1, value2], 'Checking values.');
strictEqual(result1, value1, 'Checking result 1.'); assert.strictEqual(result1, value1, 'Checking result 1.');
strictEqual(result2, value2, 'Checking result 2.'); assert.strictEqual(result2, value2, 'Checking result 2.');
}); });
test("Testing $.ordered_map.remove().", function() { QUnit.test("Testing $.ordered_map.remove().", function(assert) {
var test = $.ordered_map(); var test = $.ordered_map();
@ -130,13 +129,13 @@ test("Testing $.ordered_map.remove().", function() {
var result1 = test.remove(key1); var result1 = test.remove(key1);
strictEqual(test.length, 1, 'Checking length.'); assert.strictEqual(test.length, 1, 'Checking length.');
deepEqual(test.keys, [key2], 'Checking keys.'); assert.deepEqual(test.keys, [key2], 'Checking keys.');
deepEqual(test.values, [value2], 'Checking values.'); assert.deepEqual(test.values, [value2], 'Checking values.');
strictEqual(result1, value1, 'Checking result.'); assert.strictEqual(result1, value1, 'Checking result.');
}); });
test("Testing $.ordered_map.empty().", function() { QUnit.test("Testing $.ordered_map.empty().", function(assert) {
var test = $.ordered_map(); var test = $.ordered_map();
@ -151,9 +150,9 @@ test("Testing $.ordered_map.empty().", function() {
test.empty(); test.empty();
strictEqual(test.length, 0, 'Checking length.'); assert.strictEqual(test.length, 0, 'Checking length.');
deepEqual(test.keys, [], 'Checking keys.'); assert.deepEqual(test.keys, [], 'Checking keys.');
deepEqual(test.values, [], 'Checking values.'); assert.deepEqual(test.values, [], 'Checking values.');
}); });
};}); };});

96
install/ui/test/utils_tests.js
View File

@ -29,9 +29,9 @@ define([
var old; var old;
module('utils',{ QUnit.module('utils',{
setup: function() { beforeEach: function() {
old = IPA.messages; old = IPA.messages;
IPA.messages = { IPA.messages = {
widget: { widget: {
@ -45,12 +45,12 @@ module('utils',{
} }
}; };
}, },
teardown: function() { afterEach: function() {
IPA.messages = old; IPA.messages = old;
} }
}); });
test('Testing metadata validator', function() { QUnit.test('Testing metadata validator', function(assert) {
// using strings as values because it is an output of inputs // using strings as values because it is an output of inputs
@ -69,24 +69,24 @@ test('Testing metadata validator', function() {
var value; var value;
value = "50"; value = "50";
ok(validator.validate(value, context).valid, 'Checking lower maximun, alphabetically higher'); assert.ok(validator.validate(value, context).valid, 'Checking lower maximun, alphabetically higher');
value = "200"; value = "200";
ok(validator.validate(value, context).valid, 'Checking higher minimum, alphabetically lower'); assert.ok(validator.validate(value, context).valid, 'Checking higher minimum, alphabetically lower');
value = "29"; value = "29";
ok(!validator.validate(value, context).valid, 'Checking below minimum'); assert.ok(!validator.validate(value, context).valid, 'Checking below minimum');
value = "301"; value = "301";
ok(!validator.validate(value, context).valid, 'Checking above maximum'); assert.ok(!validator.validate(value, context).valid, 'Checking above maximum');
context.metadata.minvalue = 0; context.metadata.minvalue = 0;
value = "-1"; value = "-1";
ok(!validator.validate(value, context).valid, 'Checking zero minimum - below'); assert.ok(!validator.validate(value, context).valid, 'Checking zero minimum - below');
value = "0"; value = "0";
ok(validator.validate(value, context).valid, 'Checking zero minimum - above'); assert.ok(validator.validate(value, context).valid, 'Checking zero minimum - above');
value = "1"; value = "1";
ok(validator.validate(value, context).valid, 'Checking zero minimum - same'); assert.ok(validator.validate(value, context).valid, 'Checking zero minimum - same');
context.metadata = { context.metadata = {
type: 'int', type: 'int',
@ -94,21 +94,21 @@ test('Testing metadata validator', function() {
minvalue: "" minvalue: ""
}; };
ok(validator.validate(value, context).valid, 'Checking empty strings as boundaries'); assert.ok(validator.validate(value, context).valid, 'Checking empty strings as boundaries');
context.metadata = { context.metadata = {
type: 'int', type: 'int',
maxvalue: null, maxvalue: null,
minvalue: null minvalue: null
}; };
ok(validator.validate(value, context).valid, 'Checking null as boundaries'); assert.ok(validator.validate(value, context).valid, 'Checking null as boundaries');
context.metadata = { context.metadata = {
type: 'int', type: 'int',
maxvalue: undefined, maxvalue: undefined,
minvalue: undefined minvalue: undefined
}; };
ok(validator.validate(value, context).valid, 'Checking undefined as boundaries'); assert.ok(validator.validate(value, context).valid, 'Checking undefined as boundaries');
context.metadata = { context.metadata = {
type: 'Decimal', type: 'Decimal',
@ -117,51 +117,51 @@ test('Testing metadata validator', function() {
}; };
value = "10.333"; value = "10.333";
ok(validator.validate(value, context).valid, 'Decimal: checking maximum'); assert.ok(validator.validate(value, context).valid, 'Decimal: checking maximum');
value = "10.3331"; value = "10.3331";
ok(!validator.validate(value, context).valid, 'Decimal: checking maximum - invalid'); assert.ok(!validator.validate(value, context).valid, 'Decimal: checking maximum - invalid');
value = "-10.333"; value = "-10.333";
ok(validator.validate(value, context).valid, 'Decimal: checking minimum'); assert.ok(validator.validate(value, context).valid, 'Decimal: checking minimum');
value = "-10.3331"; value = "-10.3331";
ok(!validator.validate(value, context).valid, 'Decimal: checking minimum - invalid'); assert.ok(!validator.validate(value, context).valid, 'Decimal: checking minimum - invalid');
}); });
test('Testing IPA.defined', function() { QUnit.test('Testing IPA.defined', function(assert) {
// positive // positive
same(IPA.defined({}), true, 'Object'); assert.deepEqual(IPA.defined({}), true, 'Object');
same(IPA.defined(0), true, 'Zero number'); assert.deepEqual(IPA.defined(0), true, 'Zero number');
same(IPA.defined(1), true, 'Some number'); assert.deepEqual(IPA.defined(1), true, 'Some number');
same(IPA.defined(false), true, 'false'); assert.deepEqual(IPA.defined(false), true, 'false');
same(IPA.defined(true), true, 'true'); assert.deepEqual(IPA.defined(true), true, 'true');
same(IPA.defined(function(){}), true, 'function'); assert.deepEqual(IPA.defined(function(){}), true, 'function');
same(IPA.defined(''), true, 'Empty string - not checking'); assert.deepEqual(IPA.defined(''), true, 'Empty string - not checking');
// negative // negative
same(IPA.defined('', true), false, 'Empty string - checking'); assert.deepEqual(IPA.defined('', true), false, 'Empty string - checking');
same(IPA.defined(undefined), false, 'undefined'); assert.deepEqual(IPA.defined(undefined), false, 'undefined');
same(IPA.defined(null), false, 'null'); assert.deepEqual(IPA.defined(null), false, 'null');
}); });
test('Testing util.equals', function() { QUnit.test('Testing util.equals', function(assert) {
ok(util.equals([], []), 'Empty Arrays'); assert.ok(util.equals([], []), 'Empty Arrays');
ok(util.equals([1, "a", false, true], [1, "a", false, true]), 'Arrays'); assert.ok(util.equals([1, "a", false, true], [1, "a", false, true]), 'Arrays');
ok(util.equals(true, true), 'Boolean: true'); assert.ok(util.equals(true, true), 'Boolean: true');
ok(util.equals(false, false), 'Boolean: false'); assert.ok(util.equals(false, false), 'Boolean: false');
ok(!util.equals(true, false), 'Negative: boolean'); assert.ok(!util.equals(true, false), 'Negative: boolean');
ok(!util.equals(false, true), 'Negative: boolean'); assert.ok(!util.equals(false, true), 'Negative: boolean');
ok(util.equals("abc", "abc"), 'Positive: strings'); assert.ok(util.equals("abc", "abc"), 'Positive: strings');
ok(!util.equals("abc", "aBC"), 'Negative: string casing'); assert.ok(!util.equals("abc", "aBC"), 'Negative: string casing');
ok(util.equals(1, 1), 'Positive: number'); assert.ok(util.equals(1, 1), 'Positive: number');
ok(util.equals(1.0, 1), 'Positive: number'); assert.ok(util.equals(1.0, 1), 'Positive: number');
ok(util.equals(2.2, 2.2), 'Positive: number'); assert.ok(util.equals(2.2, 2.2), 'Positive: number');
ok(!util.equals([], [""]), 'Negative: empty array'); assert.ok(!util.equals([], [""]), 'Negative: empty array');
}); });
test('Testing datetime', function() { QUnit.test('Testing datetime', function(assert) {
var valid = [ var valid = [
// [format, str, data, utc, output] // [format, str, data, utc, output]
@ -219,19 +219,19 @@ test('Testing datetime', function() {
var parsed = datetime.parse(str); var parsed = datetime.parse(str);
ok(parsed, "Parse successful: "+str); assert.ok(parsed, "Parse successful: "+str);
if (!parsed) return; // don't die for other tests if (!parsed) return; // don't die for other tests
strictEqual(parsed.getTime(), expected.getTime(), "Valid date: "+str); assert.strictEqual(parsed.getTime(), expected.getTime(), "Valid date: "+str);
var formatted = datetime.format(parsed, format, !utc); var formatted = datetime.format(parsed, format, !utc);
expected = output || str; expected = output || str;
strictEqual(formatted, expected, "Format: "+format); assert.strictEqual(formatted, expected, "Format: "+format);
} }
function test_invalid(str, utc) { function test_invalid(str, utc) {
datetime.allow_local = !utc; datetime.allow_local = !utc;
var parsed = datetime.parse(str); var parsed = datetime.parse(str);
strictEqual(parsed, null, "Parse invalid date: "+str); assert.strictEqual(parsed, null, "Parse invalid date: "+str);
} }
for (i=0, l=valid.length; i < l; i++) { for (i=0, l=valid.length; i < l; i++) {
@ -243,4 +243,4 @@ test('Testing datetime', function() {
} }
}); });
};}); };});

134
install/ui/test/widget_tests.js
View File

@ -34,13 +34,13 @@ var factory;
var spec; var spec;
module('widget',{ QUnit.module('widget',{
setup: function() { beforeEach: function(assert) {
IPA.ajax_options.async = false; IPA.ajax_options.async = false;
IPA.init({ IPA.init({
url: 'data', url: 'data',
on_error: function(xhr, text_status, error_thrown) { on_error: function(xhr, text_status, error_thrown) {
ok(false, "ipa_init() failed: "+error_thrown); assert.ok(false, "ipa_init() failed: "+error_thrown);
} }
}); });
widget_container = $('<div id="widget"/>').appendTo(document.body); widget_container = $('<div id="widget"/>').appendTo(document.body);
@ -52,13 +52,13 @@ module('widget',{
group.register(); group.register();
}, },
teardown: function() { afterEach: function() {
widget_container.remove(); widget_container.remove();
}} }}
); );
function base_widget_test(value){ function base_widget_test(assert, value){
spec.entity = { spec.entity = {
name:'user' name:'user'
}; };
@ -66,7 +66,7 @@ function base_widget_test(value){
widget = factory(spec); widget = factory(spec);
var field_name = widget.name; var field_name = widget.name;
ok(widget, "Created Widget"); assert.ok(widget, "Created Widget");
//init reads param info for an entity. We'll use the user entity //init reads param info for an entity. We'll use the user entity
widget.name = field_name; widget.name = field_name;
@ -75,32 +75,32 @@ function base_widget_test(value){
// ok(widget.tooltip,'widget with entity and name has tooltip'); // ok(widget.tooltip,'widget with entity and name has tooltip');
ok(!widget.container,'widget has no container before create'); assert.ok(!widget.container,'widget has no container before create');
widget.create(widget_container); widget.create(widget_container);
ok(widget.container,'widget has container after create'); assert.ok(widget.container,'widget has container after create');
} }
function widget_string_test() { function widget_string_test(assert) {
var value = 'test_title'; var value = 'test_title';
var mock_record = {'title': value}; var mock_record = {'title': value};
widget.update(mock_record.title); widget.update(mock_record.title);
ok(widget.save() instanceof Array,'save returns array'); assert.ok(widget.save() instanceof Array,'save returns array');
mock_record = {'title':[value]}; mock_record = {'title':[value]};
widget.update(mock_record.title); widget.update(mock_record.title);
ok(widget.save() instanceof Array,'save returns array'); assert.ok(widget.save() instanceof Array,'save returns array');
} }
function text_tests(widget,input){ function text_tests(assert, widget, input){
var value_changed = false; var value_changed = false;
var undo_clicked = false; var undo_clicked = false;
@ -115,15 +115,15 @@ function text_tests(widget,input){
input.val('changed'); input.val('changed');
input.keyup(); input.keyup();
same(widget.save(),['changed'], "Setting Value"); assert.deepEqual(widget.save(),['changed'], "Setting Value");
same(value_changed, true, "Click triggers value_changed"); assert.deepEqual(value_changed, true, "Click triggers value_changed");
var undo = widget.get_undo(); var undo = widget.get_undo();
undo.click(); undo.click();
same(undo_clicked, true, "Click on 'undo' triggers undo_clicked"); assert.deepEqual(undo_clicked, true, "Click on 'undo' triggers undo_clicked");
} }
function multivalued_text_tests(widget) { function multivalued_text_tests(assert, widget) {
var values = ['val1', 'val2', 'val3']; var values = ['val1', 'val2', 'val3'];
var changed = false; var changed = false;
@ -134,23 +134,23 @@ function multivalued_text_tests(widget) {
widget.update(values); widget.update(values);
same(widget.save(), values, "All values loaded"); assert.deepEqual(widget.save(), values, "All values loaded");
values = ['val1', 'val2', 'val3', 'val4']; values = ['val1', 'val2', 'val3', 'val4'];
widget.add_row(['val4']); widget.add_row(['val4']);
same(widget.save(), values, "Value added"); assert.deepEqual(widget.save(), values, "Value added");
ok(changed, "Value changed"); assert.ok(changed, "Value changed");
changed = false; changed = false;
values = ['val1', 'val3', 'val4']; values = ['val1', 'val3', 'val4'];
widget.remove_row(widget.rows[1]); widget.remove_row(widget.rows[1]);
same(widget.save(), values, "Value removed"); assert.deepEqual(widget.save(), values, "Value removed");
ok(changed, "Value changed"); assert.ok(changed, "Value changed");
changed = false; changed = false;
} }
test("IPA.table_widget" ,function(){ QUnit.test("IPA.table_widget" , function(assert) {
factory = IPA.table_widget; factory = IPA.table_widget;
spec = { spec = {
undo:true, undo:true,
@ -175,9 +175,9 @@ test("IPA.table_widget" ,function(){
width:'20em' width:'20em'
})); }));
ok(!widget.container,'widget has no container before create'); assert.ok(!widget.container,'widget has no container before create');
widget.create(widget_container); widget.create(widget_container);
ok(widget.container,'widget has container after create'); assert.ok(widget.container,'widget has container after create');
var mock_results = { var mock_results = {
@ -187,72 +187,72 @@ test("IPA.table_widget" ,function(){
widget.load(mock_results); widget.load(mock_results);
same ($('tr' ,widget_container).length, 4, 'four rows after load'); assert.deepEqual($('tr' ,widget_container).length, 4, 'four rows after load');
}); });
test("Testing base widget.", function() { QUnit.test("Testing base widget.", function(assert) {
var update_called = false; var update_called = false;
spec = { spec = {
name:'title' name:'title'
}; };
factory = IPA.input_widget; factory = IPA.input_widget;
base_widget_test('test_value'); base_widget_test(assert, 'test_value');
widget_string_test(); widget_string_test(assert);
}); });
test("IPA.textarea_widget" ,function(){ QUnit.test("IPA.textarea_widget" , function(assert) {
spec = {undo:true,name:'title'}; spec = {undo:true,name:'title'};
factory = IPA.textarea_widget; factory = IPA.textarea_widget;
base_widget_test('test_value'); base_widget_test(assert, 'test_value');
widget_string_test(); widget_string_test(assert);
text_tests(widget, $('textarea',widget_container)); text_tests(assert, widget, $('textarea',widget_container));
}); });
test("Testing text widget.", function() { QUnit.test("Testing text widget.", function(assert) {
factory = IPA.text_widget; factory = IPA.text_widget;
spec = {undo:true,name:'title'}; spec = {undo:true,name:'title'};
base_widget_test('test_value'); base_widget_test(assert, 'test_value');
widget_string_test(); widget_string_test(assert);
text_tests(widget, $('input[type=text]',widget_container)); text_tests(assert, widget, $('input[type=text]',widget_container));
}); });
test("Testing multi-valued text widget.", function() { QUnit.test("Testing multi-valued text widget.", function(assert) {
factory = IPA.multivalued_widget; factory = IPA.multivalued_widget;
spec = {undo:true,name:'title'}; spec = {undo:true,name:'title'};
base_widget_test('test_value'); base_widget_test(assert, 'test_value');
widget_string_test(); widget_string_test(assert);
multivalued_text_tests(widget); multivalued_text_tests(assert, widget);
}); });
test("Testing checkbox widget.", function() { QUnit.test("Testing checkbox widget.", function(assert) {
factory = IPA.checkbox_widget; factory = IPA.checkbox_widget;
spec = {name:'title'}; spec = {name:'title'};
base_widget_test('test_value'); base_widget_test(assert, 'test_value');
//Changing mock record from 'TRUE' to true. Value normalization is field's //Changing mock record from 'TRUE' to true. Value normalization is field's
//job. Checkbox should work with booleans values. //job. Checkbox should work with booleans values.
var mock_record = { 'title': [true] }; var mock_record = { 'title': [true] };
widget.update(mock_record.title); widget.update(mock_record.title);
same(widget.save(),[true], "Checkbox is set"); assert.deepEqual(widget.save(),[true], "Checkbox is set");
mock_record = {'title':null}; mock_record = {'title':null};
widget.update(mock_record.title); widget.update(mock_record.title);
same(widget.save(), [false], "Checkbox is not set"); assert.deepEqual(widget.save(), [false], "Checkbox is not set");
var input = $('input[type=checkbox]',widget_container); var input = $('input[type=checkbox]',widget_container);
same(input.length,1,'One control in the container'); assert.deepEqual(input.length,1,'One control in the container');
var value_changed = false; var value_changed = false;
widget.value_changed.attach(function() { widget.value_changed.attach(function() {
@ -261,29 +261,29 @@ test("Testing checkbox widget.", function() {
input.click(); input.click();
same(widget.save(),[true], "Click sets checkbox"); assert.deepEqual(widget.save(),[true], "Click sets checkbox");
same(value_changed, true, "Click triggers value_changed"); assert.deepEqual(value_changed, true, "Click triggers value_changed");
}); });
test("IPA.checkboxes_widget" ,function(){ QUnit.test("IPA.checkboxes_widget" ,function(assert){
factory = IPA.checkboxes_widget; factory = IPA.checkboxes_widget;
spec = {undo:true, name:'title' }; spec = {undo:true, name:'title' };
base_widget_test('test_value'); base_widget_test(assert, 'test_value');
}); });
test("IPA.select_widget" ,function(){ QUnit.test("IPA.select_widget" ,function(assert){
factory = IPA.select_widget; factory = IPA.select_widget;
spec = {undo:true,name:'title'}; spec = {undo:true,name:'title'};
base_widget_test('test_value'); base_widget_test(assert, 'test_value');
}); });
test("IPA.entity_select_widget" ,function() { QUnit.test("IPA.entity_select_widget" ,function(assert) {
var user = IPA.entity({ name: 'user' }); var user = IPA.entity({ name: 'user' });
factory = IPA.entity_select_widget; factory = IPA.entity_select_widget;
spec = { spec = {
@ -292,17 +292,17 @@ test("IPA.entity_select_widget" ,function() {
other_field: 'uid' other_field: 'uid'
}; };
base_widget_test('test_value'); base_widget_test(assert, 'test_value');
var mock_record = { uid: ['kfrog']}; var mock_record = { uid: ['kfrog']};
widget.update(mock_record.uid); widget.update(mock_record.uid);
ok($('option', widget.list).length > 1,"options come from AJAX"); assert.ok($('option', widget.list).length > 1,"options come from AJAX");
var value = widget.save(); var value = widget.save();
same(value, ['kfrog'],'select set from values'); assert.deepEqual(value, ['kfrog'],'select set from values');
}); });
test("IPA.entity_link_widget" ,function(){ QUnit.test("IPA.entity_link_widget" , function(assert){
factory = IPA.link_widget; factory = IPA.link_widget;
spec = { spec = {
name: 'gidnumber', name: 'gidnumber',
@ -311,7 +311,7 @@ test("IPA.entity_link_widget" ,function(){
return ['kfrog']; return ['kfrog'];
} }
}; };
base_widget_test(widget,'user','test_value'); base_widget_test(assert, widget,'user','test_value');
var mock_entity = { var mock_entity = {
get_primary_key: function(){ get_primary_key: function(){
@ -324,42 +324,42 @@ test("IPA.entity_link_widget" ,function(){
var nonlink = widget_container.find('label'); var nonlink = widget_container.find('label');
var link = widget_container.find('a'); var link = widget_container.find('a');
ok(nonlink.length === 1, "Only one <label> element exists"); assert.ok(nonlink.length === 1, "Only one <label> element exists");
ok(link.length === 1, "Only one <a> element exists"); assert.ok(link.length === 1, "Only one <a> element exists");
var mock_record = { gidnumber: ['123456']}; var mock_record = { gidnumber: ['123456']};
widget.update(mock_record.gidnumber); widget.update(mock_record.gidnumber);
link = widget_container.find('a:contains("123456")'); link = widget_container.find('a:contains("123456")');
same(link.length, 1,'link is populated'); assert.deepEqual(link.length, 1,'link is populated');
same(link.css('display'), 'inline','link is displayed'); assert.deepEqual(link.css('display'), 'inline','link is displayed');
same(widget.nonlink.css('display'), 'none','text is not displayed'); assert.deepEqual(widget.nonlink.css('display'), 'none','text is not displayed');
}); });
test("IPA.radio_widget" ,function(){ QUnit.test("IPA.radio_widget" , function(assert){
var options = [{label:"Engineer",value:"engineer"}, var options = [{label:"Engineer",value:"engineer"},
{label:"Manager", value:"manager"}, {label:"Manager", value:"manager"},
{label:"Director",value:"director"}, {label:"Director",value:"director"},
{label:"Vice President",value:"VP"}]; {label:"Vice President",value:"VP"}];
factory = IPA.radio_widget; factory = IPA.radio_widget;
spec = {undo:true, name: 'title',options:options}; spec = {undo:true, name: 'title',options:options};
base_widget_test('test_value'); base_widget_test(assert, 'test_value');
var mock_record = {'title':["director"]}; var mock_record = {'title':["director"]};
widget.update(mock_record.title); widget.update(mock_record.title);
var values = widget.save(); var values = widget.save();
same(values[0],'director','Options set correctly'); assert.deepEqual(values[0],'director','Options set correctly');
mock_record = { title: ["VP"]}; mock_record = { title: ["VP"]};
widget.update(mock_record.title); widget.update(mock_record.title);
values = widget.save(); values = widget.save();
same(values[0],'VP','Options set correctly'); assert.deepEqual(values[0],'VP','Options set correctly');
var i =0; var i =0;
$('label', widget_container).each( function(){ $('label', widget_container).each( function(){
same( $(this).text(),options[i].label, 'labels match'); assert.deepEqual($(this).text(),options[i].label, 'labels match');
i += 1; i += 1;
}); });