@adobe/acc-js-sdk 1.0.7 → 1.1.0

package/test/util.test.js

@@ -17,7 +17,7 @@ governing permissions and limitations under the License.
  * 
  *********************************************************************************/
 
- const { Util } = require('../src/util.js');
+ const { Util, ArrayMap } = require('../src/util.js');
  const { SafeStorage, Cache } = require('../src/cache.js');
 
 
@@ -232,4 +232,170 @@ describe('Util', function() {
         expect(cache._cache["Hello"].value).toBe("World");
     })
 
+    describe("ArrayMap", () => {
+
+        it("Should support access by keys", () => {
+            const am = new ArrayMap();
+            am._push("hello", "Hello");
+            am._push("world", "World");
+            expect(am["hello"]).toBe("Hello");
+            expect(am["world"]).toBe("World");
+            expect(am.get("hello")).toBe("Hello");
+            expect(am.get("world")).toBe("World");
+        });
+
+        it("Should support access by index", () => {
+            const am = new ArrayMap();
+            am._push("hello", "Hello");
+            am._push("world", "World");
+            expect(am[0]).toBe("Hello");
+            expect(am[1]).toBe("World");
+            expect(am.get(0)).toBe("Hello");
+            expect(am.get(1)).toBe("World");
+        });
+
+        it("Should support length attribute", () => {
+            const am = new ArrayMap();
+            am._push("hello", "Hello");
+            am._push("world", "World");
+            expect(am.length).toBe(2);
+        });
+
+        it("Should support iterators (for...of)", () => {
+            const am = new ArrayMap();
+            am._push("hello", "Hello");
+            am._push("world", "World");
+            let cat = "";
+            for (const s of am) cat = cat + s;
+            expect(cat).toBe("HelloWorld");
+        });
+
+        it("Should support map()", () => {
+            const am = new ArrayMap();
+            am._push("hello", "Hello");
+            am._push("world", "World");
+            const cat = am.map(s => s).join(',');
+            expect(cat).toBe("Hello,World");
+        });
+
+        it("Should support flatMap()", () => {
+            const am = new ArrayMap();
+            am._push("hello", "Hello");
+            am._push("world", ["Adobe", "World"]);
+            const cat = am.flatMap(s => s).join(',');
+            expect(cat).toBe("Hello,Adobe,World");
+        });
+
+        it("Should support find()", () => {
+            const am = new ArrayMap();
+            am._push("hello", "Hello");
+            am._push("world", "World");
+            const world = am.find(s => s === 'World');
+            expect(world).toBe("World");
+            const notFound = am.find(s => s === 'NotFound');
+            expect(notFound).toBe(undefined);
+        });
+
+        it("Should support filter()", () => {
+            const am = new ArrayMap();
+            am._push("hello", "Hello");
+            am._push("world", "World");
+            const all = am.filter(s => true);
+            expect(all).toMatchObject([ "Hello", "World" ]);
+            const none = am.filter(s => false);
+            expect(none).toMatchObject([ ]);
+            const world = am.filter(s => s === 'World');
+            expect(world).toMatchObject([ "World" ]);
+        });
+
+        it("Should support forEach", () => {
+            const am = new ArrayMap();
+            am._push("hello", "Hello");
+            am._push("world", "World");
+            let cat = "";
+            am.forEach(s => cat = cat + s);
+            expect(cat).toBe("HelloWorld");
+        });
+
+        it("Should support forEach as a key", () => {
+            const am = new ArrayMap();
+            am._push("forEach", "Hello");
+            const cat = am.map(s => s).join(',');
+            expect(cat).toBe("Hello");
+            expect(typeof am.forEach).toBe('function');
+            expect(am["forEach"]).not.toBe("Hello"); // forEach is a function
+            expect(am.get("forEach")).toBe("Hello");
+        });
+
+        it("Should support for...in", () => {
+            const am = new ArrayMap();
+            am._push("hello", "Hello");
+            am._push("world", "World");
+            let cat = "";
+            for (const s in am) cat = cat + s;
+            expect(cat).toBe("helloworld");
+        });
+
+        it("Should not support for...in when there's a property named 'forEach'", () => {
+            const am = new ArrayMap();
+            am._push("hello", "Hello");
+            am._push("forEach", "World");
+            let cat = "";
+            for (const s in am) cat = cat + s;
+            expect(cat).toBe("hello");
+        });
+
+        it("Should support enumerations whose key is a number", () => {
+            // For instance the "addressQuality" enumeration
+            const am = new ArrayMap();
+            am._push("0", { name:"0", value:0 });
+            am._push("1", { name:"1", value:1 });
+            am._push("2", { name:"2", value:2 });
+            let cat = "";
+            for (const k in am) cat = cat + am.get(k).name;
+            expect(cat).toBe("012");
+        });
+
+        it("Should not support adding the same key twice", () => {
+            const am = new ArrayMap();
+            am._push("hello", "Hello");
+            expect(() => { am._push("hello", "World"); }).toThrow("Failed to add element 'hello' to ArrayMap. There's already an item with the same name");
+        });
+
+        it("Should support missing names", () => {
+            const am = new ArrayMap();
+            am._push("", { name:"0", value:0 });
+            am._push(undefined, { name:"1", value:1 });
+            am._push(null, { name:"2", value:2 });
+            expect(am.length).toBe(3);
+            expect(am[0].name).toBe("0");
+            expect(am[1].name).toBe("1");
+            expect(am[2].name).toBe("2");
+        });
+
+        it("Should handle compatibility", () => {
+            const am = new ArrayMap();
+            am._push("perfect", { name:"perfect", value:0 });
+            am._push("notPerfect", { name:"notPerfect", value:1 });
+            am._push("error", { name:"error", value:2 });
+            // length
+            expect(am.length).toBe(3);
+            // Access by name
+            expect(am.perfect).toMatchObject({ name:"perfect", value:0 });
+            expect(am.notPerfect).toMatchObject({ name:"notPerfect", value:1 });
+            expect(am.error).toMatchObject({ name:"error", value:2 });
+            expect(am.notFound).toBeUndefined();
+            // for .. in loop
+            const list = [];
+            for (const p in am) list.push(p);
+            expect(list).toMatchObject([ "perfect", "notPerfect", "error" ]);
+        });
+    });
+
+    describe("Is Browser", () => {
+        it("Should not be a browser", () => {
+            expect(Util.isBrowser()).toBe(false);
+        });
+    });
 });
+

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() {
@@ -813,4 +815,123 @@ describe('XtkCaster', function() {
         });
     })
 
+    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);
+    });
 });