Added test for parsing Mixed specs.

Author: danielduarte

test/unit/types/parsing/MixedParsingTest.js

@@ -0,0 +1,145 @@
+import assert from 'assert';
+
+import SpecBuilder from "../../../../src/OpenSpec/SpecBuilder";
+import MixedSpec from "../../../../src/OpenSpec/Spec/Type/MixedSpec";
+import TypeSpec from "../../../../src/OpenSpec/Spec/Type/TypeSpec";
+import ParseSpecException from "../../../../src/OpenSpec/ParseSpecException";
+import SpecLibrary from "../../../../src/OpenSpec/SpecLibrary";
+import ArraySpec from "../../../../src/OpenSpec/Spec/Type/ArraySpec";
+
+
+function getSpecInstance()
+{
+    let specData = { type: 'mixed', options: [] };
+    let spec = SpecBuilder.getInstance().build(specData, new SpecLibrary());
+
+    return spec;
+}
+
+// @todo find a better way to compare arrays
+const equal_arrays = function(array1, array2) {
+    if (array1.length !== array2.length) {
+        return false;
+    }
+
+    for (let i = 0; i < array1.length; i++) {
+        if (array1[i] instanceof Array && array2[i] instanceof Array) {
+            if (!equal_arrays(array1[i], array2[i])) {
+                return false;
+            }
+        } else if (array1[i] !== array2[i]) {
+            return false;
+        }
+    }
+
+    return true;
+};
+
+function array_unique(array) {
+    return array.filter((elem, index, array) => { return array.indexOf(elem) === index; });
+}
+
+
+describe('MixedParsingTest', function() {
+
+    it('testParseSpecResult', function() {
+        let spec = getSpecInstance();
+
+        assert(spec instanceof MixedSpec);
+    });
+
+    it('testSpecCorrectTypeName', function() {
+        let spec = getSpecInstance();
+
+        assert(spec.getTypeName() === 'mixed');
+    });
+
+    it('testSpecRequiredFields', function() {
+        let spec = getSpecInstance();
+
+        let fields = spec.getRequiredFields();
+        fields.sort();
+        assert(equal_arrays(fields, ['options', 'type']));
+    });
+
+    it('testSpecOptionalFields', function() {
+        let spec = getSpecInstance();
+
+        let fields = spec.getOptionalFields();
+        fields.sort();
+        assert(equal_arrays(fields, []));
+    });
+
+    it('testSpecAllFields', function() {
+        let spec = getSpecInstance();
+
+        let reqFields = spec.getRequiredFields();
+        let optFields = spec.getOptionalFields();
+        let allFieldsCalculated = array_unique([...reqFields, ...optFields]);
+        allFieldsCalculated.sort();
+
+        let allFields = spec.getAllFields();
+        allFields.sort();
+
+        assert(equal_arrays(allFieldsCalculated, allFields));
+    });
+
+    it('testMissingRequiredFields', function() {
+        let specData = { type: 'mixed' };
+
+        let exception = null;
+        try {
+            SpecBuilder.getInstance().build(specData, new SpecLibrary());
+        } catch (ex) {
+
+            if (!(ex instanceof ParseSpecException)) {
+                throw new Error('Unexpected exception.');
+            }
+
+            exception = ex;
+        }
+
+        assert(exception.containsError(ParseSpecException.CODE_MISSING_REQUIRED_FIELD));
+    });
+
+    it('testUnexpectedFields', function() {
+        let specData = {
+            type:                        'mixed',
+            this_is_an_unexpected_field: 1234,
+            and_this_is_other:           ['a', 'b']
+        };
+
+        let exception = null;
+        try {
+            SpecBuilder.getInstance().build(specData, new SpecLibrary());
+        } catch (ex) {
+
+            if (!(ex instanceof ParseSpecException)) {
+                throw new Error('Unexpected exception.');
+            }
+
+            exception = ex;
+        }
+
+        assert(exception.containsError(ParseSpecException.CODE_UNEXPECTED_FIELDS));
+    });
+
+    it('testFieldItemsOfInvalidType', function() {
+        let specData = { type: 'mixed', options: 'this is a string' };
+
+        let exception = null;
+        try {
+            SpecBuilder.getInstance().build(specData, new SpecLibrary());
+        } catch (ex) {
+
+            if (!(ex instanceof ParseSpecException)) {
+                throw new Error('Unexpected exception.');
+            }
+
+            exception = ex;
+        }
+
+        assert(exception.containsError(ParseSpecException.CODE_ARRAY_EXPECTED));
+    });
+
+});