1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
|
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
"use strict";
var BaseAssert = require("sdk/test/assert").Assert;
const getOwnIdentifiers = x => [...Object.getOwnPropertyNames(x),
...Object.getOwnPropertySymbols(x)];
/**
* Whether or not given property descriptors are equivalent. They are
* equivalent either if both are marked as "conflict" or "required" property
* or if all the properties of descriptors are equal.
* @param {Object} actual
* @param {Object} expected
*/
function equivalentDescriptors(actual, expected) {
return (actual.conflict && expected.conflict) ||
(actual.required && expected.required) ||
equalDescriptors(actual, expected);
}
function equalDescriptors(actual, expected) {
return actual.get === expected.get &&
actual.set === expected.set &&
actual.value === expected.value &&
!!actual.enumerable === !!expected.enumerable &&
!!actual.configurable === !!expected.configurable &&
!!actual.writable === !!expected.writable;
}
/**
* Whether or not given `target` array contains all the element
* from a given `source` array.
*/
function containsSet(source, target) {
return source.some(function(element) {
return 0 > target.indexOf(element);
});
}
/**
* Whether or not given two arrays contain all elements from another.
*/
function equivalentSets(source, target) {
return containsSet(source, target) && containsSet(target, source);
}
/**
* Finds name of the property from `source` property descriptor map, that
* is not equivalent of the name named property in the `target` property
* descriptor map. If not found `null` is returned instead.
*/
function findNonEquivalentPropertyName(source, target) {
var value = null;
getOwnIdentifiers(source).some(function(key) {
var areEquivalent = false;
if (!equivalentDescriptors(source[key], target[key])) {
value = key;
areEquivalent = true;
}
return areEquivalent;
});
return value;
}
var AssertDescriptor = {
equalTraits: {
value: function equivalentTraits(actual, expected, message) {
var difference;
var actualKeys = getOwnIdentifiers(actual);
var expectedKeys = getOwnIdentifiers(expected);
if (equivalentSets(actualKeys, expectedKeys)) {
this.fail({
operator: "equalTraits",
message: "Traits define different properties",
actual: actualKeys.sort().join(","),
expected: expectedKeys.sort().join(","),
});
}
else if ((difference = findNonEquivalentPropertyName(actual, expected))) {
this.fail({
operator: "equalTraits",
message: "Traits define non-equivalent property `" + difference + "`",
actual: actual[difference],
expected: expected[difference]
});
}
else {
this.pass(message || "Traits are equivalent.");
}
}
}
};
exports.Assert = function Assert() {
return Object.create(BaseAssert.apply(null, arguments), AssertDescriptor);
};
|
