@pubtech-ai/testing 1.6.0

package/lib/mjs/GVLFactory.cjs

@@ -0,0 +1,9 @@
+import { GVL } from '@pubtech-ai/core';
+export class GVLFactory {
+    static getVersion(version, schema = "v2") {
+        return new GVL(require(`./vendorlist/${schema}/vendor-list-v${version}.json`));
+    }
+    static getLatest(schema = "v2") {
+        return new GVL(require(`./vendorlist/${schema}/vendor-list.json`));
+    }
+}

package/lib/mjs/GVLFactory.d.cts

@@ -0,0 +1,5 @@
+import { GVL } from '@pubtech-ai/core';
+export declare class GVLFactory {
+    static getVersion(version: number, schema?: string): GVL;
+    static getLatest(schema?: string): GVL;
+}

package/lib/mjs/GVLFactory.d.ts

@@ -0,0 +1,5 @@
+import { GVL } from '@pubtech-ai/core';
+export declare class GVLFactory {
+    static getVersion(version: number, schema?: string): GVL;
+    static getLatest(schema?: string): GVL;
+}

package/lib/mjs/GVLFactory.js

@@ -0,0 +1,18 @@
+import { GVL } from '@pubtech-ai/core';
+import * as fs from 'fs';
+import * as path from 'path';
+import { fileURLToPath } from 'url';
+// eslint-disable-next-line @typescript-eslint/ban-ts-ignore
+// @ts-ignore
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+export class GVLFactory {
+    static getVersion(version, schema = 'v2') {
+        const json = JSON.parse(fs.readFileSync(__dirname + `/vendorlist/${schema}/vendor-list-v${version}.json`).toString());
+        return new GVL(json);
+    }
+    static getLatest(schema = 'v2') {
+        const json = JSON.parse(fs.readFileSync(__dirname + `/vendorlist/${schema}/vendor-list.json`).toString());
+        return new GVL(json);
+    }
+}

package/lib/mjs/PowerSet.d.ts

@@ -0,0 +1,3 @@
+export declare class PowerSet {
+    static generate(numValues: number): boolean[][];
+}

package/lib/mjs/PowerSet.js

@@ -0,0 +1,14 @@
+export class PowerSet {
+    static generate(numValues) {
+        const total = 1 << numValues;
+        const powSet = [];
+        for (let i = 0; i < total; i++) {
+            const group = [];
+            for (let j = 0; j < numValues; j++) {
+                group.push(!!((i >> j) & 1));
+            }
+            powSet.push(group);
+        }
+        return powSet;
+    }
+}

package/lib/mjs/TCModelFactory.d.ts

@@ -0,0 +1,6 @@
+import { TCModel } from '@pubtech-ai/core';
+export declare class TCModelFactory {
+    static noGVL(tcModel?: TCModel): TCModel;
+    static addPublisherRestrictions(tcModel: TCModel): TCModel;
+    static withGVL(): TCModel;
+}

package/lib/mjs/TCModelFactory.js

@@ -0,0 +1,91 @@
+import { TCModel, PurposeRestriction, RestrictionType } from '@pubtech-ai/core';
+import { makeRandomInt } from './makeRandomInt.js';
+import { GVLFactory } from './GVLFactory.js';
+export class TCModelFactory {
+    static noGVL(tcModel) {
+        const latestGVL = GVLFactory.getLatest();
+        if (!tcModel) {
+            tcModel = new TCModel();
+        }
+        tcModel.cmpId = makeRandomInt(2, 100);
+        tcModel.cmpVersion = makeRandomInt(1, 10);
+        tcModel.consentScreen = makeRandomInt(1, 5);
+        tcModel.isServiceSpecific = !!makeRandomInt(0, 1);
+        tcModel.vendorListVersion = makeRandomInt(1, latestGVL.vendorListVersion);
+        let counter = 0;
+        const rand = makeRandomInt(1, TCModel.consentLanguages.size);
+        TCModel.consentLanguages.forEach((lang) => {
+            counter++;
+            if (counter === rand) {
+                tcModel.consentLanguage = lang;
+            }
+        });
+        tcModel.publisherCountryCode = String.fromCharCode(makeRandomInt(65, 90)) +
+            String.fromCharCode(makeRandomInt(65, 90));
+        const date = new Date();
+        const utcDate = new Date(Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate()));
+        const now = utcDate.getTime();
+        const GDPRMageddon = 1576883249;
+        tcModel.created = new Date(makeRandomInt(GDPRMageddon, now));
+        tcModel.lastUpdated = new Date(makeRandomInt(GDPRMageddon, now));
+        const mapping = {
+            'purposes': [
+                'publisherConsents',
+                'publisherLegitimateInterests',
+                'purposeConsents',
+                'purposeLegitimateInterests',
+            ],
+            'specialFeatures': [
+                'specialFeatureOptins',
+            ],
+            'vendors': [
+                'vendorConsents',
+                'vendorLegitimateInterests',
+                'vendorsAllowed',
+                'vendorsDisclosed',
+            ],
+        };
+        Object.keys(mapping).forEach((gvlIntMap) => {
+            const ids = Object.keys(latestGVL[gvlIntMap]).map((strId) => +strId);
+            ids.forEach((id) => {
+                mapping[gvlIntMap].forEach((vectorName) => {
+                    // 75% chance of being set
+                    if (makeRandomInt(1, 4) !== 3) {
+                        tcModel[vectorName].set(id);
+                    }
+                });
+            });
+        });
+        return tcModel;
+    }
+    static addPublisherRestrictions(tcModel) {
+        if (!tcModel.gvl) {
+            tcModel.gvl = GVLFactory.getLatest();
+        }
+        Object.keys(tcModel.gvl.vendors).forEach((vendorId) => {
+            const vendor = tcModel.gvl.vendors[vendorId];
+            if (vendor.flexiblePurposes.length) {
+                const purposeId = vendor.flexiblePurposes[makeRandomInt(0, vendor.flexiblePurposes.length - 1)];
+                const isInConsent = vendor.purposes.includes(purposeId);
+                const notAllowed = makeRandomInt(0, 1) === 1;
+                let purpRestriction;
+                if (notAllowed) {
+                    purpRestriction = new PurposeRestriction(purposeId, RestrictionType.NOT_ALLOWED);
+                }
+                else if (isInConsent) {
+                    purpRestriction = new PurposeRestriction(purposeId, RestrictionType.REQUIRE_LI);
+                }
+                else {
+                    purpRestriction = new PurposeRestriction(purposeId, RestrictionType.REQUIRE_CONSENT);
+                }
+                tcModel.publisherRestrictions.add(+vendorId, purpRestriction);
+            }
+        });
+        return tcModel;
+    }
+    static withGVL() {
+        const tcModel = this.noGVL();
+        tcModel.gvl = GVLFactory.getLatest();
+        return tcModel;
+    }
+}

package/lib/mjs/TCStringFactory.d.ts

@@ -0,0 +1,4 @@
+export declare class TCStringFactory {
+    static base(isForSaving?: boolean): string;
+    static withPubRestrictions(isForSaving?: boolean): string;
+}

package/lib/mjs/TCStringFactory.js

@@ -0,0 +1,15 @@
+import { TCModelFactory } from './TCModelFactory.js';
+import { TCString } from '@pubtech-ai/core';
+export class TCStringFactory {
+    static base(isForSaving = false) {
+        const encodingOptions = { isForVendors: !isForSaving };
+        const tcModel = TCModelFactory.withGVL();
+        return TCString.encode(tcModel, encodingOptions);
+    }
+    static withPubRestrictions(isForSaving = false) {
+        const encodingOptions = { isForVendors: !isForSaving };
+        let tcModel = TCModelFactory.withGVL();
+        tcModel = TCModelFactory.addPublisherRestrictions(tcModel);
+        return TCString.encode(tcModel, encodingOptions);
+    }
+}

package/lib/mjs/TestCollector.d.ts

@@ -0,0 +1,4 @@
+export declare class TestCollector {
+    static requireTests(filePath: string): Promise<void>;
+    static eslintTests(directories?: string[], fileExtensions?: string[]): void;
+}

package/lib/mjs/TestCollector.js

@@ -0,0 +1,22 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import lint from 'mocha-eslint';
+export class TestCollector {
+    static async requireTests(filePath) {
+        if (fs.statSync(filePath).isDirectory()) {
+            describe(filePath.split('/').pop() + '/', () => {
+                fs.readdirSync(filePath).forEach((item) => {
+                    this.requireTests(path.join(filePath, item));
+                });
+            });
+        }
+        else if (filePath.indexOf('.test.ts') === filePath.length - '.test.ts'.length) {
+            await import(filePath);
+        }
+    }
+    static eslintTests(directories = ['.'], fileExtensions = ['ts', 'js', 'json']) {
+        lint([`{${directories}}/**/*.{${fileExtensions}}`], {
+            alwaysWarn: false,
+        });
+    }
+}

package/lib/mjs/XMLHttpTestTools.d.ts

@@ -0,0 +1,7 @@
+import * as sinon from 'sinon';
+export declare class XMLHttpTestTools {
+    static JSON_HEADER: object;
+    private static xhr;
+    static requests: sinon.SinonFakeXMLHttpRequest[];
+    static beforeEach(): void;
+}

package/lib/mjs/XMLHttpTestTools.js

@@ -0,0 +1,13 @@
+import * as sinon from 'sinon';
+export class XMLHttpTestTools {
+    static JSON_HEADER = { 'Content-Type': 'application/json' };
+    static xhr;
+    static requests;
+    static beforeEach() {
+        this.xhr = sinon.useFakeXMLHttpRequest();
+        this.requests = [];
+        this.xhr.onCreate = (xhr) => {
+            this.requests.push(xhr);
+        };
+    }
+}

package/lib/mjs/index.d.ts

@@ -0,0 +1,12 @@
+export * from './GVLFactory.js';
+export * from './PowerSet.js';
+export * from './TCModelFactory.js';
+export * from './TCStringFactory.js';
+export * from './TestCollector.js';
+export * from './XMLHttpTestTools.js';
+export * from './isPrimitive.js';
+export * from './makeRandomInt.js';
+export * from './makeRandomIntArray.js';
+export * from './makeRandomString.js';
+export * from './sameDataDiffRef.js';
+export * from './smellsLikeGVL.js';

package/lib/mjs/index.js

@@ -0,0 +1,12 @@
+export * from './GVLFactory.js';
+export * from './PowerSet.js';
+export * from './TCModelFactory.js';
+export * from './TCStringFactory.js';
+export * from './TestCollector.js';
+export * from './XMLHttpTestTools.js';
+export * from './isPrimitive.js';
+export * from './makeRandomInt.js';
+export * from './makeRandomIntArray.js';
+export * from './makeRandomString.js';
+export * from './sameDataDiffRef.js';
+export * from './smellsLikeGVL.js';

package/lib/mjs/isPrimitive.d.ts

@@ -0,0 +1 @@
+export declare const isPrimitive: (value: unknown) => boolean;

package/lib/mjs/isPrimitive.js

@@ -0,0 +1,4 @@
+export const isPrimitive = (value) => {
+    const itsType = typeof value;
+    return (itsType === 'number' || itsType === 'string' || itsType === 'boolean');
+};

package/lib/mjs/makeRandomInt.d.ts

@@ -0,0 +1 @@
+export declare function makeRandomInt(betweenStart: number, betweenEnd: number): number;

package/lib/mjs/makeRandomInt.js

@@ -0,0 +1,3 @@
+export function makeRandomInt(betweenStart, betweenEnd) {
+    return Math.round(Math.random() * (betweenEnd - betweenStart)) + betweenStart;
+}

package/lib/mjs/makeRandomIntArray.d.ts

@@ -0,0 +1 @@
+export declare function makeRandomIntArray(intsBetweenStart: number, intsBetweenEnd: number, length?: number): number[];

package/lib/mjs/makeRandomIntArray.js

@@ -0,0 +1,19 @@
+import { makeRandomInt } from './makeRandomInt.js';
+export function makeRandomIntArray(intsBetweenStart, intsBetweenEnd, length) {
+    const intSet = new Set();
+    let retr = [];
+    if (length !== undefined && intsBetweenEnd - intsBetweenStart <= length) {
+        while (intSet.size != length) {
+            intSet.add(makeRandomInt(intsBetweenStart, intsBetweenEnd));
+        }
+        retr = Array.from(intSet);
+    }
+    else {
+        length = makeRandomInt(intsBetweenStart, intsBetweenEnd);
+        while (intSet.size != length) {
+            intSet.add(makeRandomInt(intsBetweenStart, intsBetweenEnd));
+        }
+        retr = Array.from(intSet);
+    }
+    return retr;
+}

package/lib/mjs/makeRandomString.d.ts

@@ -0,0 +1 @@
+export declare function makeRandomString(length: number, asciiStart?: number, asciiEnd?: number): string;

package/lib/mjs/makeRandomString.js

@@ -0,0 +1,8 @@
+import { makeRandomInt } from './makeRandomInt.js';
+export function makeRandomString(length, asciiStart = 0, asciiEnd = 127) {
+    let retr = '';
+    for (let i = 0; i < length; i++) {
+        retr += String.fromCharCode(makeRandomInt(asciiStart, asciiEnd));
+    }
+    return retr;
+}

package/lib/mjs/package.json

@@ -0,0 +1,3 @@
+{
+    "type": "module"
+}

package/lib/mjs/sameDataDiffRef.d.ts

@@ -0,0 +1 @@
+export declare const sameDataDiffRef: (obj1: object, obj2: object, objName: string, ignoreKeys?: string[]) => void;

package/lib/mjs/sameDataDiffRef.js

@@ -0,0 +1,48 @@
+import { expect } from 'chai';
+import { isPrimitive } from './isPrimitive.js';
+export const sameDataDiffRef = (obj1, obj2, objName, ignoreKeys) => {
+    if (obj1 === undefined && obj2 === undefined) {
+        return;
+    }
+    expect(typeof obj1, `typeof ${objName}`).to.equal(typeof obj2);
+    expect(obj1, objName).not.to.equal(obj2);
+    const keySet = new Set(Object.keys(obj1)
+        .concat(Object.keys(obj2))
+        /**
+         * filter out all of the keys that end with an underscore since those are
+         * private members
+         */
+        .filter((key) => (key.indexOf('_') !== key.length - 1)));
+    if (Array.isArray(ignoreKeys)) {
+        ignoreKeys.forEach((item) => {
+            if (keySet.has(item)) {
+                keySet.delete(item);
+            }
+        });
+    }
+    for (const key of keySet) {
+        if (key.indexOf('_') !== key.length - 1) {
+            const item1 = obj1[key];
+            const item2 = obj2[key];
+            const itsType = typeof item1;
+            expect(typeof item2, `typeof ${objName}->${key}`).to.equal(itsType);
+            if (item1 === undefined && item2 === undefined) {
+                continue;
+            }
+            if (isPrimitive(item1)) {
+                expect(item2, `${objName}->${key}`).to.equal(item1);
+            }
+            else {
+                if (item1 instanceof Date) {
+                    const time1 = item1.getTime();
+                    const time2 = item2.getTime();
+                    // should be within the 200 milisecond range
+                    expect(time2, `${objName}->${key}`).to.be.within(time1 - 100, time1 + 100);
+                }
+                else {
+                    sameDataDiffRef(item1, item2, key, ignoreKeys);
+                }
+            }
+        }
+    }
+};

package/lib/mjs/smellsLikeGVL.d.ts

@@ -0,0 +1 @@
+export declare const smellsLikeGVL: (possibleGVL: object) => void;

package/lib/mjs/smellsLikeGVL.js

@@ -0,0 +1,15 @@
+import { expect } from 'chai';
+export const smellsLikeGVL = (possibleGVL) => {
+    expect(possibleGVL, 'maybe gvl?').to.include([
+        'gvlSpecificationVersion',
+        'vendorListVersion',
+        'tcfPolicyVersion',
+        'lastUpdated',
+        'purposes',
+        'specialPurposes',
+        'features',
+        'specialFeatures',
+        'vendors',
+        'stacks',
+    ]);
+};