@adobe/acc-js-sdk 1.0.6 → 1.0.9

package/test/escape.test.js

@@ -18,65 +18,97 @@ governing permissions and limitations under the License.
  *********************************************************************************/
 const sdk = require('../src/index.js');
 
-describe('escapeXtk', function() {
-    
-    describe('Escaping strings', function() {
-        it("Should escape null strings", () => {
-            expect(sdk.escapeXtk(null)).toBe("''");
-        });
-
-        it("Should escape undefined strings", () => {
-            expect(sdk.escapeXtk(undefined)).toBe("''");
-        });
-
-        it("Should escape empty strings", () => {
-            expect(sdk.escapeXtk("")).toBe("''");
-        });
+describe('escaping', function() {
 
-        it("Should escape empty simple strings", () => {
-            expect(sdk.escapeXtk("Hello")).toBe("'Hello'");
-            expect(sdk.escapeXtk("Hello world")).toBe("'Hello world'");
-            expect(sdk.escapeXtk(" ")).toBe("' '");
-        });
+    describe('escapeXtk', function() {
+        
+        describe('Escaping strings', function() {
+            it("Should escape null strings", () => {
+                expect(sdk.escapeXtk(null)).toBe("''");
+            });
+
+            it("Should escape undefined strings", () => {
+                expect(sdk.escapeXtk(undefined)).toBe("''");
+            });
+
+            it("Should escape empty strings", () => {
+                expect(sdk.escapeXtk("")).toBe("''");
+            });
+
+            it("Should escape empty simple strings", () => {
+                expect(sdk.escapeXtk("Hello")).toBe("'Hello'");
+                expect(sdk.escapeXtk("Hello world")).toBe("'Hello world'");
+                expect(sdk.escapeXtk(" ")).toBe("' '");
+            });
+
+            it("Should escape simple quotes", () => {
+                expect(sdk.escapeXtk("Hello 'world'")).toBe("'Hello \\'world\\''");
+            });
+        })
 
-        it("Should escape simple quotes", () => {
-            expect(sdk.escapeXtk("Hello 'world'")).toBe("'Hello \\'world\\''");
-        });
-    })
+        describe('Tagged template litteral', function() {
 
-    describe('Tagged template litteral', function() {
+            it("Should escape in template litteral", () => {
+                expect(sdk.escapeXtk`Hello world`).toBe("Hello world");
+                expect(sdk.escapeXtk`Hello 'world'`).toBe("Hello 'world'");     // only variables are escaped
 
-        it("Should escape in template litteral", () => {
-            expect(sdk.escapeXtk`Hello world`).toBe("Hello world");
-            expect(sdk.escapeXtk`Hello 'world'`).toBe("Hello 'world'");     // only variables are escaped
+                const empty = "";
+                expect(sdk.escapeXtk``).toBe("");
+                expect(sdk.escapeXtk`${empty}`).toBe("''");
 
-            const empty = "";
-            expect(sdk.escapeXtk``).toBe("");
-            expect(sdk.escapeXtk`${empty}`).toBe("''");
+                const name = "Joe's";
+                expect(sdk.escapeXtk`Hello ${name}`).toBe("Hello 'Joe\\'s'");    // variable value is quoted and escaped
 
-            const name = "Joe's";
-            expect(sdk.escapeXtk`Hello ${name}`).toBe("Hello 'Joe\\'s'");    // variable value is quoted and escaped
+                // A more relevant test
+                const userName = 'Alex';
+                expect({ expr: sdk.escapeXtk`@name = ${userName}` }).toEqual({ expr: "@name = 'Alex'" });
 
-            // A more relevant test
-            const userName = 'Alex';
-            expect({ expr: sdk.escapeXtk`@name = ${userName}` }).toEqual({ expr: "@name = 'Alex'" });
+                // Should support multiple variables
+                expect({ expr: sdk.escapeXtk`@name = ${userName} or @name = ${name}` }).toEqual({ expr: "@name = 'Alex' or @name = 'Joe\\'s'" });
+            })
 
-            // Should support multiple variables
-            expect({ expr: sdk.escapeXtk`@name = ${userName} or @name = ${name}` }).toEqual({ expr: "@name = 'Alex' or @name = 'Joe\\'s'" });
+            it("Should support constants", () => {
+                expect(sdk.escapeXtk([],[])).toBe("''");
+            })
         })
 
-        it("Should support constants", () => {
-            expect(sdk.escapeXtk([],[])).toBe("''");
+        it("examples in jsdoc", () => {
+            expect(sdk.escapeXtk("Rock 'n' Roll")).toBe("'Rock \\'n\\' Roll'");
+            expect(sdk.escapeXtk`@name=${"Rock 'n' Roll"}`).toBe("@name='Rock \\'n\\' Roll'");
+        });
+
+        describe('QueryDef & template litteral', () => {
+            
         })
-    })
 
-    it("examples in jsdoc", () => {
-        expect(sdk.escapeXtk("Rock 'n' Roll")).toBe("'Rock \\'n\\' Roll'");
-        expect(sdk.escapeXtk`@name=${"Rock 'n' Roll"}`).toBe("@name='Rock \\'n\\' Roll'");
     });
 
-    describe('QueryDef & template litteral', () => {
-        
-    })
+    describe('escapeForLike', function() {
+        it('Should support null and undefined', () => {
+            expect(sdk.escapeForLike(null)).toBe('');
+            expect(sdk.escapeForLike(undefined)).toBe('');
+            expect(sdk.escapeForLike('')).toBe('');
+        });
+
+        it('Should escape simple strings', () => {
+            expect(sdk.escapeForLike('Hello')).toBe('Hello');
+            expect(sdk.escapeForLike('Hello world')).toBe('Hello world');
+            expect(sdk.escapeForLike('1234')).toBe('1234');
+        });
+
+        it('Should escape special chars', () => {
+            expect(sdk.escapeForLike('99.9%')).toBe('99.9\\%');
+            expect(sdk.escapeForLike("John 'Rusty' Toe")).toBe("John \\'Rusty\\' Toe");
+            expect(sdk.escapeForLike("Hello_Cruel_World")).toBe("Hello\\_Cruel\\_World");
+            expect(sdk.escapeForLike("John \\Rusty\\ Toe")).toBe("John \\\\Rusty\\\\ Toe");
+            // $ is not a special char
+            expect(sdk.escapeForLike('$99.9')).toBe('$99.9');
+        });
+
+        it('Should escape Xtk Variables', () => {
+            expect(sdk.escapeForLike('$99.9', false)).toBe('$99.9');
+            expect(sdk.escapeForLike('1+$id', true)).toBe("1+' + Char('36') + 'id");
+        });
+    });
 
-});
+});

package/test/index.test.js

@@ -73,6 +73,74 @@ describe('ACC SDK', function() {
                 sdk._transport(old);
             }
         });
-    })
+    });
+
+    describe("expandXPath", () => {
+        it("Should support empty paths", () => {
+            expect(sdk.expandXPath(null)).toBe(null);
+            expect(sdk.expandXPath(undefined)).toBe(undefined);
+            expect(sdk.expandXPath("")).toBe("");
+        });
+
+        it("Should preserve already expanded xpath", () => {
+            expect(sdk.expandXPath("[@email]")).toBe("[@email]");
+            expect(sdk.expandXPath("[@recipient-id]")).toBe("[@recipient-id]");
+            expect(sdk.expandXPath("[recipient/@id]")).toBe("[recipient/@id]");
+        });
+
+        it("Should not add brackets if not necessary", () => {
+            expect(sdk.expandXPath("@email")).toBe("@email");
+            expect(sdk.expandXPath("@email_address")).toBe("@email_address");
+        });
+
+        it("Should add brackets if necessary", () => {
+            expect(sdk.expandXPath("@recipient-id")).toBe("[@recipient-id]");
+            expect(sdk.expandXPath("email/@address")).toBe("[email/@address]");
+            expect(sdk.expandXPath("nms:recipient")).toBe("[nms:recipient]");
+        });
+    });
+
+    describe("unexpandXPath", () => {
+        it("Should support empty paths", () => {
+            expect(sdk.unexpandXPath(null)).toBe(null);
+            expect(sdk.unexpandXPath(undefined)).toBe(undefined);
+            expect(sdk.unexpandXPath("")).toBe("");
+        });
+
+        it("Should remove brackets", () => {
+            expect(sdk.unexpandXPath("[@email]")).toBe("@email");
+            expect(sdk.unexpandXPath("[@recipient-id]")).toBe("@recipient-id");
+            expect(sdk.unexpandXPath("[recipient/@id]")).toBe("recipient/@id");
+        });
+
+        it("Should preseve already unexpanded pathx", () => {
+            expect(sdk.unexpandXPath("@email")).toBe("@email");
+            expect(sdk.unexpandXPath("@email_address")).toBe("@email_address");
+        });
+
+        it("Should support array-paths", () => {
+            expect(sdk.unexpandXPath("coll[0]")).toBe("coll[0]");
+            expect(sdk.unexpandXPath("[coll[0]]")).toBe("coll[0]");
+        });
+    });
+    
+    describe("xtkConstText", () => {
+        it("Should handle various types", () => {
+            // Strings are quoted and escaped
+            expect(sdk.xtkConstText("Hello", "string")).toBe("'Hello'");
+            expect(sdk.xtkConstText("", "string")).toBe("''");
+            expect(sdk.xtkConstText(123, "string")).toBe("'123'");
+            expect(sdk.xtkConstText("Hello'World", "memo")).toBe("'Hello\\'World'");
+            // Numbers are unchanged
+            expect(sdk.xtkConstText(123, "long")).toBe("123");
+            expect(sdk.xtkConstText(-42.3, "double")).toBe("-42.3");
+            expect(sdk.xtkConstText("", "long")).toBe("0");
+            expect(sdk.xtkConstText(undefined, "short")).toBe("0");
+            // Timestamps are surrounded by ##
+            expect(sdk.xtkConstText("2022-02-15T09:49:04.000Z", "datetime")).toBe("#2022-02-15T09:49:04.000Z#");
+            expect(sdk.xtkConstText("", "datetime")).toBe("##");
+            expect(sdk.xtkConstText(undefined, "date")).toBe("##");
+        });
+    });
 
 });

package/test/mock.js

@@ -17,6 +17,17 @@ governing permissions and limitations under the License.
  * 
  *********************************************************************************/
  const sdk = require('../src/index.js');
+ const crypto = require("crypto");
+
+ const makeKey = () => {
+    const a = [];
+    for (let i=0; i<32; i++) {
+        a.push(Math.floor(crypto.randomInt(0, 256))); 
+    }
+    const buffer = Buffer.from(a);
+    const s = buffer.toString('base64');
+    return s;
+ }
 
  async function makeAnonymousClient(options) {
     const connectionParameters = sdk.ConnectionParameters.ofAnonymousUser("http://acc-sdk:8080", options);
@@ -219,7 +230,17 @@ const GET_XTK_SESSION_SCHEMA_RESPONSE = Promise.resolve(`<?xml version='1.0'?>
                     </method>
                     <method name="NonStatic"></method>
                     <method name="TestCnx" static="true"></method>
-                    </methods>
+                    <method name="NonStaticP1">
+                        <parameters>
+                            <param name="name" type="string"/>
+                        </parameters>
+                    </method>
+                    <method name="StaticP1" static="true">
+                        <parameters>
+                            <param name="name" type="string"/>
+                        </parameters>
+                    </method>
+                </methods>
             </schema>
             </pdomDoc>
         </GetEntityIfMoreRecentResponse>
@@ -280,37 +301,43 @@ const GET_XTK_QUERY_SCHEMA_RESPONSE = Promise.resolve(`<?xml version='1.0'?>
     </SOAP-ENV:Body>
     </SOAP-ENV:Envelope>`);
 
-const GET_MID_EXT_ACCOUNT_RESPONSE = Promise.resolve(`<?xml version='1.0'?>
+const GET_MID_EXT_ACCOUNT_RESPONSE = (encryptedPassword) => {
+    return  Promise.resolve(`<?xml version='1.0'?>
     <SOAP-ENV:Envelope xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' xmlns:ns='urn:xtk:queryDef' xmlns:SOAP-ENV='http://schemas.xmlsoap.org/soap/envelope/'>
     <SOAP-ENV:Body>
         <ExecuteQueryResponse xmlns='urn:xtk:queryDef' SOAP-ENV:encodingStyle='http://schemas.xmlsoap.org/soap/encoding/'>
             <pdomOutput xsi:type='ns:Element' SOAP-ENV:encodingStyle='http://xml.apache.org/xml-soap/literalxml'>
-                <extAccount account="mid" id="2088" name="defaultEmailMid" password="@57QS5VHMb9BCsojLVrKI/Q==" server="http://ffdamid:8080" type="3"/>
+                <extAccount account="mid" id="2088" name="defaultEmailMid" password="${encryptedPassword}" server="http://ffdamid:8080" type="3"/>
             </pdomOutput>
         </ExecuteQueryResponse>
     </SOAP-ENV:Body>
     </SOAP-ENV:Envelope>`);
+}
 
-const GET_BAD_EXT_ACCOUNT_RESPONSE = Promise.resolve(`<?xml version='1.0'?>
+const GET_BAD_EXT_ACCOUNT_RESPONSE = (encryptedPassword) => {
+    return Promise.resolve(`<?xml version='1.0'?>
     <SOAP-ENV:Envelope xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' xmlns:ns='urn:xtk:queryDef' xmlns:SOAP-ENV='http://schemas.xmlsoap.org/soap/envelope/'>
     <SOAP-ENV:Body>
         <ExecuteQueryResponse xmlns='urn:xtk:queryDef' SOAP-ENV:encodingStyle='http://schemas.xmlsoap.org/soap/encoding/'>
             <pdomOutput xsi:type='ns:Element' SOAP-ENV:encodingStyle='http://xml.apache.org/xml-soap/literalxml'>
-                <extAccount account="bad" id="2088" name="bad" password="@57QS5VHMb9BCsojLVrKI/Q==" server="http://zz:8080" type="999"/>
+                <extAccount account="bad" id="2088" name="bad" password="${encryptedPassword}" server="http://zz:8080" type="999"/>
             </pdomOutput>
         </ExecuteQueryResponse>
     </SOAP-ENV:Body>
     </SOAP-ENV:Envelope>`);
+}
 
-const GET_SECRET_KEY_OPTION_RESPONSE = Promise.resolve(`<?xml version='1.0'?>
+const GET_SECRET_KEY_OPTION_RESPONSE = (key) => {
+    return Promise.resolve(`<?xml version='1.0'?>
     <SOAP-ENV:Envelope xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' xmlns:ns='urn:xtk:session' xmlns:SOAP-ENV='http://schemas.xmlsoap.org/soap/envelope/'>
     <SOAP-ENV:Body>
         <GetOptionResponse xmlns='urn:xtk:session' SOAP-ENV:encodingStyle='http://schemas.xmlsoap.org/soap/encoding/'>
-            <pstrValue xsi:type='xsd:string'>HMLmn6uvWr8wu1Akt8UORr07YbC64u1FVW7ENAxNjpo=</pstrValue>
+            <pstrValue xsi:type='xsd:string'>${key}</pstrValue>
             <pbtType xsi:type='xsd:byte'>6</pbtType>
         </GetOptionResponse>
     </SOAP-ENV:Body>
     </SOAP-ENV:Envelope>`);
+}
 
 const GET_LOGON_MID_RESPONSE = Promise.resolve(`<?xml version='1.0'?>
     <SOAP-ENV:Envelope xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' xmlns:ns='urn:xtk:session' xmlns:SOAP-ENV='http://schemas.xmlsoap.org/soap/envelope/'>
@@ -594,6 +621,7 @@ exports.Mock = {
   makeClient: makeClient,
   makeAnonymousClient: makeAnonymousClient,
   withMockConsole: withMockConsole,
+  makeKey: makeKey,
   R_TEST: R_TEST,
   PING: PING,
   MC_PING: MC_PING,

package/test/soap.test.js

@@ -154,11 +154,8 @@ describe('SOAP', function() {
             const env = DomUtil.parse(request.data).documentElement;
             const header = hasChildElement(env, "SOAP-ENV:Header");
             expect(DomUtil.findElement(header, "Cookie")).toBeFalsy();
-            hasChildElement(header, "X-Security-Token");
             const body = hasChildElement(env, "SOAP-ENV:Body");
             const method = hasChildElement(body, "m:Empty", undefined, "xmlns:m", "urn:xtk:session", "SOAP-ENV:encodingStyle", "http://schemas.xmlsoap.org/soap/encoding/");
-            // sessiontoken is always required as first parameter, even if not set
-            expect(DomUtil.findElement(method, "sessiontoken")).toBeTruthy();
         });
 
         it('Should have set authentication tokens', function() {
@@ -168,11 +165,8 @@ describe('SOAP', function() {
             assert.equal(request.headers["Cookie"], "__sessiontoken=$session$", "Session token matches");
             const env = DomUtil.parse(request.data).documentElement;
             const header = hasChildElement(env, "SOAP-ENV:Header");
-            hasChildElement(header, "Cookie", "__sessiontoken=$session$");
-            hasChildElement(header, "X-Security-Token", "$security$");
             const body = hasChildElement(env, "SOAP-ENV:Body");
             const method = hasChildElement(body, "m:Empty");
-            hasChildElement(method, "sessiontoken", "$session$", "xsi:type", "xsd:string");
         });
 
         it('Should set boolean parameters', function() {

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/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);
+    });
 });