@adobe/acc-js-sdk 1.0.5 → 1.0.8

package/test/testUtil.test.js

@@ -0,0 +1,64 @@
+/*
+Copyright 2020 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+const sdk = require("../src");
+const { DomUtil } = require("../src/domUtil");
+ 
+describe('TestUtil', function() {
+
+    describe('Creating test schema', () => {
+        it ('Should create schema from string', () => {
+            const schema = sdk.TestUtil.newSchema(`
+                <schema namespace="nms" name="recipient">
+                    <enumeration name="gender" basetype="byte">
+                    <value name="unknown" label="None specified" value="0"/>
+                    <value name="male" label="Male" value="1"/>
+                    <value name="female" label="Female" value="2"/>
+                    </enumeration>
+                    <element name="recipient">
+                    <attribute name="id" type="long"/>
+                    <attribute name="email" type="string"/>
+                    <attribute name="age" type="long"/>
+                    <attribute name="gender" type="long" enum="nms:recipient:gender"/>
+                    </element>
+                </schema>
+            `);
+            expect(schema.id).toBe("nms:recipient");
+        });
+
+        it ('Should create schema from XML', () => {
+            const xml = DomUtil.parse(`
+                <schema namespace="nms" name="recipient">
+                    <enumeration name="gender" basetype="byte">
+                    <value name="unknown" label="None specified" value="0"/>
+                    <value name="male" label="Male" value="1"/>
+                    <value name="female" label="Female" value="2"/>
+                    </enumeration>
+                    <element name="recipient">
+                    <attribute name="id" type="long"/>
+                    <attribute name="email" type="string"/>
+                    <attribute name="age" type="long"/>
+                    <attribute name="gender" type="long" enum="nms:recipient:gender"/>
+                    </element>
+                </schema>
+            `);
+            // From DOM document
+            let schema = sdk.TestUtil.newSchema(xml);
+            expect(schema.id).toBe("nms:recipient");
+            // From DOM element
+            schema = sdk.TestUtil.newSchema(xml.documentElement);
+            expect(schema.id).toBe("nms:recipient");
+        });
+    });
+
+});
+

package/test/util.test.js

@@ -17,7 +17,8 @@ governing permissions and limitations under the License.
  * 
  *********************************************************************************/
 
-const { Util, SafeStorage, Cache } = require('../src/util.js');
+ const { Util } = require('../src/util.js');
+ const { SafeStorage, Cache } = require('../src/cache.js');
 
 
 describe('Util', function() {

package/test/xtkCaster.test.js

@@ -428,7 +428,9 @@ describe('XtkCaster', function() {
             const value = expected[0];
             const expectedResult = expected[1];
             it('Should return the value casted as a timestamp ("' + value + '")', function() {
-                const actual = XtkCaster.asTimestamp(value);
+                let actual = XtkCaster.asTimestamp(value);
+                assert.myEquals(actual, expectedResult);
+                actual = XtkCaster.asDatetime(value);
                 assert.myEquals(actual, expectedResult);
             });
             it('Should return the value casted as type datetime', function() {
@@ -696,14 +698,22 @@ describe('XtkCaster', function() {
         expect(XtkCaster._variantStorageAttribute(6)).toBe("stringValue");
         expect(XtkCaster._variantStorageAttribute("string")).toBe("stringValue");
         expect(XtkCaster._variantStorageAttribute("int64")).toBe("stringValue");
+        expect(XtkCaster._variantStorageAttribute("uuid")).toBe("stringValue");
         expect(XtkCaster._variantStorageAttribute(12)).toBe("memoValue");
         expect(XtkCaster._variantStorageAttribute(13)).toBe("memoValue");
         expect(XtkCaster._variantStorageAttribute("memo")).toBe("memoValue");
         expect(XtkCaster._variantStorageAttribute("CDATA")).toBe("memoValue");
+        expect(XtkCaster._variantStorageAttribute("blob")).toBe("memoValue");
+        expect(XtkCaster._variantStorageAttribute("html")).toBe("memoValue");
         expect(XtkCaster._variantStorageAttribute(1)).toBe("longValue");
         expect(XtkCaster._variantStorageAttribute(2)).toBe("longValue");
         expect(XtkCaster._variantStorageAttribute(3)).toBe("longValue");
         expect(XtkCaster._variantStorageAttribute(15)).toBe("longValue");
+        expect(XtkCaster._variantStorageAttribute("byte")).toBe("longValue");
+        expect(XtkCaster._variantStorageAttribute("short")).toBe("longValue");
+        expect(XtkCaster._variantStorageAttribute("long")).toBe("longValue");
+        expect(XtkCaster._variantStorageAttribute("int")).toBe("longValue");
+        expect(XtkCaster._variantStorageAttribute("boolean")).toBe("longValue");
         expect(XtkCaster._variantStorageAttribute(4)).toBe("doubleValue");
         expect(XtkCaster._variantStorageAttribute(5)).toBe("doubleValue");
         expect(XtkCaster._variantStorageAttribute("float")).toBe("doubleValue");
@@ -716,4 +726,212 @@ describe('XtkCaster', function() {
         expect(XtkCaster._variantStorageAttribute("date")).toBe("timeStampValue");
         expect(() => { XtkCaster._variantStorageAttribute(777); }).toThrow("Cannot get variant storage");
     });
+
+    describe("Array tests", () => {
+            it("Should return array", () => {
+            expect(XtkCaster.asArray(null)).toStrictEqual([]);
+            expect(XtkCaster.asArray(undefined)).toStrictEqual([]);
+            expect(XtkCaster.asArray(false)).toStrictEqual([false]);
+            expect(XtkCaster.asArray("Hello")).toStrictEqual(["Hello"]);
+            expect(XtkCaster.asArray([])).toStrictEqual([]);
+            expect(XtkCaster.asArray([null])).toStrictEqual([null]);
+        })
+    
+        it("Should support arrays", () => {
+            expect(XtkCaster.as(null, "array")).toStrictEqual([]);
+            expect(XtkCaster.as(undefined, "array")).toStrictEqual([]);
+            expect(XtkCaster.as(false, "array")).toStrictEqual([false]);
+            expect(XtkCaster.as("Hello", "array")).toStrictEqual(["Hello"]);
+            expect(XtkCaster.as([], "array")).toStrictEqual([]);
+            expect(XtkCaster.as([null], "array")).toStrictEqual([null]);
+        });
+    });
+
+    describe("Timespan test", () => {
+        it("Should return timespan", () => {
+            expect(XtkCaster.asTimespan(null)).toStrictEqual(0);
+            expect(XtkCaster.asTimespan(undefined)).toStrictEqual(0);
+            expect(XtkCaster.asTimespan(false)).toStrictEqual(0);
+            expect(XtkCaster.asTimespan("Hello")).toStrictEqual(0);
+            expect(XtkCaster.asTimespan([])).toStrictEqual(0);
+            expect(XtkCaster.asTimespan([null])).toStrictEqual(0);
+            expect(XtkCaster.asTimespan(NaN)).toStrictEqual(0);
+            expect(XtkCaster.asTimespan(Number.POSITIVE_INFINITY)).toStrictEqual(0);
+            expect(XtkCaster.asTimespan(Number.NEGATIVE_INFINITY)).toStrictEqual(0);
+            expect(XtkCaster.asTimespan("86400")).toStrictEqual(86400);
+            expect(XtkCaster.asTimespan(86400)).toStrictEqual(86400);
+        })
+
+        it("As should support 'timspan'", () => {
+            expect(XtkCaster.as(null, "timespan")).toStrictEqual(0);
+            expect(XtkCaster.as(undefined, "timespan")).toStrictEqual(0);
+            expect(XtkCaster.as(false, "timespan")).toStrictEqual(0);
+            expect(XtkCaster.as("Hello", "timespan")).toStrictEqual(0);
+            expect(XtkCaster.as([], "timespan")).toStrictEqual(0);
+            expect(XtkCaster.as([null], "timespan")).toStrictEqual(0);
+            expect(XtkCaster.as("86400", "timespan")).toStrictEqual(86400);
+            expect(XtkCaster.as(86400, "timespan")).toStrictEqual(86400);
+        });
+
+        it("As should support type 14", () => {
+            expect(XtkCaster.as(null, 14)).toStrictEqual(0);
+            expect(XtkCaster.as(undefined, 14)).toStrictEqual(0);
+            expect(XtkCaster.as(false, 14)).toStrictEqual(0);
+            expect(XtkCaster.as("Hello", 14)).toStrictEqual(0);
+            expect(XtkCaster.as([], 14)).toStrictEqual(0);
+            expect(XtkCaster.as([null], 14)).toStrictEqual(0);
+            expect(XtkCaster.as("86400", 14)).toStrictEqual(86400);
+            expect(XtkCaster.as(86400, 14)).toStrictEqual(86400);
+        });
+    })
+
+    describe("Other string types", () => {
+        it("Type 'html'", () => {
+            expect(XtkCaster.as(null, "html")).toStrictEqual("");
+            expect(XtkCaster.as(undefined, "html")).toStrictEqual("");
+            expect(XtkCaster.as("Hello", "html")).toStrictEqual("Hello");
+            expect(XtkCaster.as("0", "html")).toStrictEqual("0");
+        });
+
+        it("Type 'uuid'", () => {
+            expect(XtkCaster.as(null, "uuid")).toStrictEqual("");
+            expect(XtkCaster.as(undefined, "uuid")).toStrictEqual("");
+            expect(XtkCaster.as("Hello", "uuid")).toStrictEqual("Hello");
+            expect(XtkCaster.as("0", "uuid")).toStrictEqual("0");
+        });
+
+        it("Type 'blob'", () => {
+            expect(XtkCaster.as(null, "blob")).toStrictEqual("");
+            expect(XtkCaster.as(undefined, "blob")).toStrictEqual("");
+            expect(XtkCaster.as("Hello", "blob")).toStrictEqual("Hello");
+            expect(XtkCaster.as("0", "blob")).toStrictEqual("0");
+        });
+
+        it("Type 'int'", () => {
+            expect(XtkCaster.as(null, "int")).toStrictEqual(0);
+            expect(XtkCaster.as(undefined, "int")).toStrictEqual(0);
+            expect(XtkCaster.as("42", "int")).toStrictEqual(42);
+            expect(XtkCaster.as("0", "int")).toStrictEqual(0);
+        });
+    })
+
+    it("Should check time type", () => {
+        expect(XtkCaster.isTimeType(null)).toBe(false);
+        expect(XtkCaster.isTimeType(undefined)).toBe(false);
+        expect(XtkCaster.isTimeType(0)).toBe(false);
+        expect(XtkCaster.isTimeType("")).toBe(false);
+        expect(XtkCaster.isTimeType(6)).toBe(false);
+        expect(XtkCaster.isTimeType("string")).toBe(false);
+        expect(XtkCaster.isTimeType("int64")).toBe(false);
+        expect(XtkCaster.isTimeType("uuid")).toBe(false);
+        expect(XtkCaster.isTimeType(12)).toBe(false);
+        expect(XtkCaster.isTimeType(13)).toBe(false);
+        expect(XtkCaster.isTimeType("memo")).toBe(false);
+        expect(XtkCaster.isTimeType("CDATA")).toBe(false);
+        expect(XtkCaster.isTimeType("blob")).toBe(false);
+        expect(XtkCaster.isTimeType("html")).toBe(false);
+        expect(XtkCaster.isTimeType(1)).toBe(false);
+        expect(XtkCaster.isTimeType(2)).toBe(false);
+        expect(XtkCaster.isTimeType(3)).toBe(false);
+        expect(XtkCaster.isTimeType(15)).toBe(false);
+        expect(XtkCaster.isTimeType("byte")).toBe(false);
+        expect(XtkCaster.isTimeType("short")).toBe(false);
+        expect(XtkCaster.isTimeType("long")).toBe(false);
+        expect(XtkCaster.isTimeType("int")).toBe(false);
+        expect(XtkCaster.isTimeType("boolean")).toBe(false);
+        expect(XtkCaster.isTimeType(4)).toBe(false);
+        expect(XtkCaster.isTimeType(5)).toBe(false);
+        expect(XtkCaster.isTimeType("float")).toBe(false);
+        expect(XtkCaster.isTimeType("double")).toBe(false);
+        expect(XtkCaster.isTimeType(7)).toBe(true);
+        expect(XtkCaster.isTimeType(10)).toBe(true);
+        expect(XtkCaster.isTimeType("datetime")).toBe(true);
+        expect(XtkCaster.isTimeType("timestamp")).toBe(true);
+        expect(XtkCaster.isTimeType("datetimetz")).toBe(true);
+        expect(XtkCaster.isTimeType("datetimenotz")).toBe(true);
+        expect(XtkCaster.isTimeType("date")).toBe(true);
+        expect(XtkCaster.isTimeType(14)).toBe(true);
+        expect(XtkCaster.isTimeType("time")).toBe(true);
+        expect(XtkCaster.isTimeType("timespan")).toBe(true);
+    });
+
+    it("Should check string type", () => {
+        expect(XtkCaster.isStringType(null)).toBe(false);
+        expect(XtkCaster.isStringType(undefined)).toBe(false);
+        expect(XtkCaster.isStringType(0)).toBe(false);
+        expect(XtkCaster.isStringType("")).toBe(false);
+        expect(XtkCaster.isStringType(6)).toBe(true);
+        expect(XtkCaster.isStringType("string")).toBe(true);
+        expect(XtkCaster.isStringType("int64")).toBe(false);
+        expect(XtkCaster.isStringType("uuid")).toBe(false);
+        expect(XtkCaster.isStringType(12)).toBe(true);
+        expect(XtkCaster.isStringType(13)).toBe(true);
+        expect(XtkCaster.isStringType("memo")).toBe(true);
+        expect(XtkCaster.isStringType("CDATA")).toBe(true);
+        expect(XtkCaster.isStringType("blob")).toBe(true);
+        expect(XtkCaster.isStringType("html")).toBe(true);
+        expect(XtkCaster.isStringType(1)).toBe(false);
+        expect(XtkCaster.isStringType(2)).toBe(false);
+        expect(XtkCaster.isStringType(3)).toBe(false);
+        expect(XtkCaster.isStringType(15)).toBe(false);
+        expect(XtkCaster.isStringType("byte")).toBe(false);
+        expect(XtkCaster.isStringType("short")).toBe(false);
+        expect(XtkCaster.isStringType("long")).toBe(false);
+        expect(XtkCaster.isStringType("int")).toBe(false);
+        expect(XtkCaster.isStringType("boolean")).toBe(false);
+        expect(XtkCaster.isStringType(4)).toBe(false);
+        expect(XtkCaster.isStringType(5)).toBe(false);
+        expect(XtkCaster.isStringType("float")).toBe(false);
+        expect(XtkCaster.isStringType("double")).toBe(false);
+        expect(XtkCaster.isStringType(7)).toBe(false);
+        expect(XtkCaster.isStringType(10)).toBe(false);
+        expect(XtkCaster.isStringType("datetime")).toBe(false);
+        expect(XtkCaster.isStringType("timestamp")).toBe(false);
+        expect(XtkCaster.isStringType("datetimetz")).toBe(false);
+        expect(XtkCaster.isStringType("datetimenotz")).toBe(false);
+        expect(XtkCaster.isStringType("date")).toBe(false);
+        expect(XtkCaster.isStringType(14)).toBe(false);
+        expect(XtkCaster.isStringType("time")).toBe(false);
+        expect(XtkCaster.isStringType("timespan")).toBe(false);
+    });
+
+    it("Should check number type", () => {
+        expect(XtkCaster.isNumericType(null)).toBe(false);
+        expect(XtkCaster.isNumericType(undefined)).toBe(false);
+        expect(XtkCaster.isNumericType(0)).toBe(false);
+        expect(XtkCaster.isNumericType("")).toBe(false);
+        expect(XtkCaster.isNumericType(6)).toBe(false);
+        expect(XtkCaster.isNumericType("string")).toBe(false);
+        expect(XtkCaster.isNumericType("int64")).toBe(false);
+        expect(XtkCaster.isNumericType("uuid")).toBe(false);
+        expect(XtkCaster.isNumericType(12)).toBe(false);
+        expect(XtkCaster.isNumericType(13)).toBe(false);
+        expect(XtkCaster.isNumericType("memo")).toBe(false);
+        expect(XtkCaster.isNumericType("CDATA")).toBe(false);
+        expect(XtkCaster.isNumericType("blob")).toBe(false);
+        expect(XtkCaster.isNumericType("html")).toBe(false);
+        expect(XtkCaster.isNumericType(1)).toBe(true);
+        expect(XtkCaster.isNumericType(2)).toBe(true);
+        expect(XtkCaster.isNumericType(3)).toBe(true);
+        expect(XtkCaster.isNumericType(15)).toBe(false);
+        expect(XtkCaster.isNumericType("byte")).toBe(true);
+        expect(XtkCaster.isNumericType("short")).toBe(true);
+        expect(XtkCaster.isNumericType("long")).toBe(true);
+        expect(XtkCaster.isNumericType("int")).toBe(true);
+        expect(XtkCaster.isNumericType("boolean")).toBe(false);
+        expect(XtkCaster.isNumericType(4)).toBe(true);
+        expect(XtkCaster.isNumericType(5)).toBe(true);
+        expect(XtkCaster.isNumericType("float")).toBe(true);
+        expect(XtkCaster.isNumericType("double")).toBe(true);
+        expect(XtkCaster.isNumericType(7)).toBe(false);
+        expect(XtkCaster.isNumericType(10)).toBe(false);
+        expect(XtkCaster.isNumericType("datetime")).toBe(false);
+        expect(XtkCaster.isNumericType("timestamp")).toBe(false);
+        expect(XtkCaster.isNumericType("datetimetz")).toBe(false);
+        expect(XtkCaster.isNumericType("datetimenotz")).toBe(false);
+        expect(XtkCaster.isNumericType("date")).toBe(false);
+        expect(XtkCaster.isNumericType(14)).toBe(true);
+        expect(XtkCaster.isNumericType("time")).toBe(false);
+        expect(XtkCaster.isNumericType("timespan")).toBe(true);
+    });
 });