mirror of
https://salsa.debian.org/freeipa-team/freeipa.git
synced 2024-12-25 08:21:05 -06:00
4b2af2570a
IPA doesn't provide "messages" anymore. But actually ones are no needed for these tests. Fixes: https://pagure.io/freeipa/issue/7559 Reviewed-By: Alexander Bokovoy <abokovoy@redhat.com> Reviewed-By: Christian Heimes <cheimes@redhat.com> Reviewed-By: Petr Vobornik <pvoborni@redhat.com>
228 lines
8.1 KiB
JavaScript
228 lines
8.1 KiB
JavaScript
/* Authors:
|
|
* Petr Vobornik <pvoborni@redhat.com>
|
|
*
|
|
* Copyright (C) 2012 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/datetime',
|
|
'freeipa/util',
|
|
'freeipa/field',
|
|
'freeipa/widget'],
|
|
function(IPA, $, datetime, util) { return function() {
|
|
|
|
var old;
|
|
|
|
QUnit.module('utils');
|
|
|
|
QUnit.test('Testing metadata validator', function(assert) {
|
|
|
|
// using strings as values because it is an output of inputs
|
|
|
|
var validator = IPA.build({
|
|
$factory: IPA.metadata_validator
|
|
});
|
|
|
|
var metadata = {
|
|
type: 'int',
|
|
maxvalue: 300,
|
|
minvalue: 30
|
|
};
|
|
|
|
var context = { metadata: metadata };
|
|
|
|
var value;
|
|
|
|
value = "50";
|
|
assert.ok(validator.validate(value, context).valid, 'Checking lower maximun, alphabetically higher');
|
|
|
|
value = "200";
|
|
assert.ok(validator.validate(value, context).valid, 'Checking higher minimum, alphabetically lower');
|
|
|
|
value = "29";
|
|
assert.ok(!validator.validate(value, context).valid, 'Checking below minimum');
|
|
|
|
value = "301";
|
|
assert.ok(!validator.validate(value, context).valid, 'Checking above maximum');
|
|
|
|
context.metadata.minvalue = 0;
|
|
value = "-1";
|
|
assert.ok(!validator.validate(value, context).valid, 'Checking zero minimum - below');
|
|
value = "0";
|
|
assert.ok(validator.validate(value, context).valid, 'Checking zero minimum - above');
|
|
value = "1";
|
|
assert.ok(validator.validate(value, context).valid, 'Checking zero minimum - same');
|
|
|
|
context.metadata = {
|
|
type: 'int',
|
|
maxvalue: "",
|
|
minvalue: ""
|
|
};
|
|
|
|
assert.ok(validator.validate(value, context).valid, 'Checking empty strings as boundaries');
|
|
|
|
context.metadata = {
|
|
type: 'int',
|
|
maxvalue: null,
|
|
minvalue: null
|
|
};
|
|
assert.ok(validator.validate(value, context).valid, 'Checking null as boundaries');
|
|
|
|
context.metadata = {
|
|
type: 'int',
|
|
maxvalue: undefined,
|
|
minvalue: undefined
|
|
};
|
|
assert.ok(validator.validate(value, context).valid, 'Checking undefined as boundaries');
|
|
|
|
context.metadata = {
|
|
type: 'Decimal',
|
|
maxvalue: "10.333",
|
|
minvalue: "-10.333"
|
|
};
|
|
|
|
value = "10.333";
|
|
assert.ok(validator.validate(value, context).valid, 'Decimal: checking maximum');
|
|
value = "10.3331";
|
|
assert.ok(!validator.validate(value, context).valid, 'Decimal: checking maximum - invalid');
|
|
|
|
value = "-10.333";
|
|
assert.ok(validator.validate(value, context).valid, 'Decimal: checking minimum');
|
|
value = "-10.3331";
|
|
assert.ok(!validator.validate(value, context).valid, 'Decimal: checking minimum - invalid');
|
|
});
|
|
|
|
QUnit.test('Testing IPA.defined', function(assert) {
|
|
|
|
// positive
|
|
assert.deepEqual(IPA.defined({}), true, 'Object');
|
|
assert.deepEqual(IPA.defined(0), true, 'Zero number');
|
|
assert.deepEqual(IPA.defined(1), true, 'Some number');
|
|
assert.deepEqual(IPA.defined(false), true, 'false');
|
|
assert.deepEqual(IPA.defined(true), true, 'true');
|
|
assert.deepEqual(IPA.defined(function(){}), true, 'function');
|
|
assert.deepEqual(IPA.defined(''), true, 'Empty string - not checking');
|
|
|
|
// negative
|
|
assert.deepEqual(IPA.defined('', true), false, 'Empty string - checking');
|
|
assert.deepEqual(IPA.defined(undefined), false, 'undefined');
|
|
assert.deepEqual(IPA.defined(null), false, 'null');
|
|
});
|
|
|
|
QUnit.test('Testing util.equals', function(assert) {
|
|
|
|
assert.ok(util.equals([], []), 'Empty Arrays');
|
|
assert.ok(util.equals([1, "a", false, true], [1, "a", false, true]), 'Arrays');
|
|
assert.ok(util.equals(true, true), 'Boolean: true');
|
|
assert.ok(util.equals(false, false), 'Boolean: false');
|
|
assert.ok(!util.equals(true, false), 'Negative: boolean');
|
|
assert.ok(!util.equals(false, true), 'Negative: boolean');
|
|
assert.ok(util.equals("abc", "abc"), 'Positive: strings');
|
|
assert.ok(!util.equals("abc", "aBC"), 'Negative: string casing');
|
|
assert.ok(util.equals(1, 1), 'Positive: number');
|
|
assert.ok(util.equals(1.0, 1), 'Positive: number');
|
|
assert.ok(util.equals(2.2, 2.2), 'Positive: number');
|
|
|
|
assert.ok(!util.equals([], [""]), 'Negative: empty array');
|
|
});
|
|
|
|
QUnit.test('Testing datetime', function(assert) {
|
|
|
|
var valid = [
|
|
// [format, str, data, utc, output]
|
|
[ '${YYYY}${MM}${DD}${HH}${mm}${ss}Z', '20140114175402Z', [ 2014, 1, 14, 17, 54, 2], true ],
|
|
[ '${YYYY}-${MM}-${DD}T${HH}:${mm}:${ss}Z', '2014-01-14T17:54:02Z', [ 2014, 1, 14, 17, 54, 2], true ],
|
|
[ '${YYYY}-${MM}-${DD} ${HH}:${mm}:${ss}Z', '2014-01-14 17:54:02Z', [ 2014, 1, 14, 17, 54, 2], true ],
|
|
[ '${YYYY}-${MM}-${DD}T${HH}:${mm}Z', '2014-01-14T17:54Z', [ 2014, 1, 14, 17, 54, 0], true ],
|
|
[ '${YYYY}-${MM}-${DD} ${HH}:${mm}Z', '2014-01-14 17:54Z', [ 2014, 1, 14, 17, 54, 0], true ],
|
|
[ '${YYYY}-${MM}-${DD}', '2014-01-14', [ 2014, 1, 14, 0, 0, 0], true ],
|
|
|
|
// allow overflows?
|
|
// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/setUTCFullYear
|
|
[ '${YYYY}-${MM}-${DD}', '2014-01-32', [ 2014, 2, 1, 0, 0, 0], true, '2014-02-01' ],
|
|
[ '${YYYY}-${MM}-${DD}', '2014-02-30', [ 2014, 3, 2, 0, 0, 0], true, '2014-03-02' ],
|
|
[ '${YYYY}-${MM}-${DD}', '2014-15-10', [ 2015, 3, 10, 0, 0, 0], true, '2015-03-10' ],
|
|
|
|
// local time
|
|
[ '${YYYY}-${MM}-${DD}T${HH}:${mm}:${ss}', '2014-01-14T17:54:13', [ 2014, 1, 14, 17, 54, 13], false ],
|
|
[ '${YYYY}-${MM}-${DD} ${HH}:${mm}:${ss}', '2014-01-14 17:54:13', [ 2014, 1, 14, 17, 54, 13], false ],
|
|
[ '${YYYY}-${MM}-${DD}T${HH}:${mm}', '2014-01-14T17:54', [ 2014, 1, 14, 17, 54, 0], false ],
|
|
[ '${YYYY}-${MM}-${DD} ${HH}:${mm}', '2014-01-14 17:54', [ 2014, 1, 14, 17, 54, 0], false ]
|
|
];
|
|
var invalid = [
|
|
// [str, utc]
|
|
['2014-01-14T12:01:00', true],
|
|
['2014-01-14T12:01', true],
|
|
['2014-01-14T12', true],
|
|
['2014-01-14T12Z', true],
|
|
['2014-01-14TZ', true],
|
|
|
|
|
|
['2014-01-14 17:54:00', true],
|
|
['2014-01-14 17:54', true],
|
|
['2014-01-14 17', true],
|
|
['2014-01-14 17Z', true],
|
|
['2014-01-14Z', true],
|
|
|
|
['2014-01-14X17:54:00Z', true],
|
|
['20140114175400', false]
|
|
];
|
|
var i, l;
|
|
|
|
function test_valid(format, str, data, utc, output) {
|
|
datetime.allow_local = !utc;
|
|
var d = data;
|
|
|
|
var expected = new Date();
|
|
if (utc) {
|
|
expected.setUTCFullYear(d[0], d[1]-1, d[2]);
|
|
expected.setUTCHours(d[3], d[4], d[5], 0); // set ms to 0
|
|
} else {
|
|
expected.setFullYear(d[0], d[1]-1, d[2]);
|
|
expected.setHours(d[3], d[4], d[5], 0); // set ms to 0
|
|
}
|
|
|
|
var parsed = datetime.parse(str);
|
|
|
|
assert.ok(parsed, "Parse successful: "+str);
|
|
if (!parsed) return; // don't die for other tests
|
|
assert.strictEqual(parsed.getTime(), expected.getTime(), "Valid date: "+str);
|
|
|
|
var formatted = datetime.format(parsed, format, !utc);
|
|
expected = output || str;
|
|
assert.strictEqual(formatted, expected, "Format: "+format);
|
|
}
|
|
|
|
function test_invalid(str, utc) {
|
|
datetime.allow_local = !utc;
|
|
var parsed = datetime.parse(str);
|
|
assert.strictEqual(parsed, null, "Parse invalid date: "+str);
|
|
}
|
|
|
|
for (i=0, l=valid.length; i < l; i++) {
|
|
test_valid(valid[i][0], valid[i][1], valid[i][2], valid[i][3], valid[i][4]);
|
|
}
|
|
|
|
for (i=0, l=invalid.length; i < l; i++) {
|
|
test_invalid(invalid[i][0], invalid[i][1]);
|
|
}
|
|
});
|
|
|
|
};});
|