@adobe/ccweb-add-on-core 0.1.0

package/src/test/models/PackageJson.spec.ts

@@ -0,0 +1,198 @@
+/********************************************************************************
+ * MIT License
+
+ * © Copyright 2023 Adobe. All rights reserved.
+
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ ********************************************************************************/
+
+import { assert } from "chai";
+import "mocha";
+import { PackageJson } from "../../models/PackageJson.js";
+import { removeSymbols } from "../../utilities/Extensions.js";
+
+describe("PackageJson", () => {
+    describe("constructor ...", () => {
+        it(`should not set any properties when the constructor argument is empty.`, () => {
+            const packageJson = new PackageJson({});
+            assert.isDefined(packageJson);
+            assert.isUndefined(packageJson.name);
+            assert.isUndefined(packageJson.version);
+            assert.isUndefined(packageJson.description);
+            assert.isUndefined(packageJson.keywords);
+            assert.isUndefined(packageJson.devDependencies);
+            assert.isUndefined(packageJson.dependencies);
+            assert.isUndefined(packageJson.scripts);
+        });
+
+        it(`should only set name when the constructor argument only contains name.`, () => {
+            const content = {
+                name: "simple-app"
+            };
+
+            const packageJson = new PackageJson(content);
+            assert.isDefined(packageJson);
+            assert.equal(packageJson.name, content.name);
+
+            assert.isUndefined(packageJson.version);
+            assert.isUndefined(packageJson.description);
+            assert.isUndefined(packageJson.keywords);
+
+            assert.isUndefined(packageJson.devDependencies);
+            assert.isUndefined(packageJson.dependencies);
+            assert.isUndefined(packageJson.scripts);
+        });
+
+        it(`should only set version when the constructor argument only contains version.`, () => {
+            const content = {
+                version: "1.0.0"
+            };
+
+            const packageJson = new PackageJson(content);
+            assert.isDefined(packageJson);
+            assert.equal(packageJson.version, content.version);
+
+            assert.isUndefined(packageJson.name);
+            assert.isUndefined(packageJson.description);
+            assert.isUndefined(packageJson.keywords);
+
+            assert.isUndefined(packageJson.devDependencies);
+            assert.isUndefined(packageJson.dependencies);
+            assert.isUndefined(packageJson.scripts);
+        });
+
+        it(`should only set description when the constructor argument only contains description.`, () => {
+            const content = {
+                description: "simple app"
+            };
+
+            const packageJson = new PackageJson(content);
+            assert.isDefined(packageJson);
+            assert.equal(packageJson.description, content.description);
+
+            assert.isUndefined(packageJson.name);
+            assert.isUndefined(packageJson.version);
+            assert.isUndefined(packageJson.keywords);
+
+            assert.isUndefined(packageJson.devDependencies);
+            assert.isUndefined(packageJson.dependencies);
+            assert.isUndefined(packageJson.scripts);
+        });
+
+        it(`should only set keywords when the constructor argument only contains keywords.`, () => {
+            const content = {
+                keywords: ["simple", "app"]
+            };
+
+            const packageJson = new PackageJson(content);
+            assert.isDefined(packageJson);
+            assert.equal(packageJson.keywords, content.keywords);
+
+            assert.isUndefined(packageJson.name);
+            assert.isUndefined(packageJson.description);
+            assert.isUndefined(packageJson.version);
+
+            assert.isUndefined(packageJson.devDependencies);
+            assert.isUndefined(packageJson.dependencies);
+            assert.isUndefined(packageJson.scripts);
+        });
+
+        it(`should set all properties when the constructor argument contains them.`, () => {
+            const content = {
+                name: "simple-app",
+                version: "1.0.0",
+                description: "simple app",
+                keywords: ["simple", "app"],
+                devDependencies: {
+                    a: "1.0.0",
+                    b: "2.0.0"
+                },
+                dependencies: {
+                    c: "3.0.0",
+                    d: "4.0.0"
+                },
+                scripts: {
+                    e: "clean",
+                    f: "build"
+                }
+            };
+
+            const packageJson = new PackageJson(content);
+            assert.isDefined(packageJson);
+            assert.equal(packageJson.name, content.name);
+            assert.equal(packageJson.version, content.version);
+            assert.equal(packageJson.description, content.description);
+            assert.equal(packageJson.keywords, content.keywords);
+
+            assert.isDefined(packageJson.devDependencies);
+            assert.equal(packageJson.devDependencies?.get("a"), content.devDependencies.a);
+            assert.equal(packageJson.devDependencies?.get("b"), content.devDependencies.b);
+
+            assert.isDefined(packageJson.dependencies);
+            assert.equal(packageJson.dependencies?.get("c"), content.dependencies.c);
+            assert.equal(packageJson.dependencies?.get("d"), content.dependencies.d);
+
+            assert.isDefined(packageJson.scripts);
+            assert.equal(packageJson.scripts?.get("e"), content.scripts.e);
+            assert.equal(packageJson.scripts?.get("f"), content.scripts.f);
+        });
+    });
+
+    describe("toJSON ...", () => {
+        it(`should return stringify-ed PackageJson with properties except for the undefined ones.`, () => {
+            const content = {
+                name: "simple-app",
+                version: "1.0.0",
+                description: "simple app",
+                keywords: ["simple", "app"]
+            };
+
+            const packageJson = new PackageJson(content);
+            const packageJsonString = packageJson.toJSON();
+
+            assert.equal(removeSymbols(packageJsonString), removeSymbols(JSON.stringify(content, undefined, 4)));
+        });
+
+        it(`should return stringify-ed PackageJson with all properties when all are defined.`, () => {
+            const content = {
+                name: "simple-app",
+                version: "1.0.0",
+                description: "simple app",
+                scripts: {
+                    e: "clean",
+                    f: "build"
+                },
+                keywords: ["simple", "app"],
+                dependencies: {
+                    c: "3.0.0",
+                    d: "4.0.0"
+                },
+                devDependencies: {
+                    a: "1.0.0",
+                    b: "2.0.0"
+                }
+            };
+
+            const packageJson = new PackageJson(content);
+            const packageJsonString = packageJson.toJSON();
+
+            assert.equal(removeSymbols(packageJsonString), removeSymbols(JSON.stringify(content, undefined, 4)));
+        });
+    });
+});

package/src/test/models/PreferenceJson.spec.ts

@@ -0,0 +1,184 @@
+/********************************************************************************
+ * MIT License
+
+ * © Copyright 2023 Adobe. All rights reserved.
+
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ ********************************************************************************/
+
+import { assert } from "chai";
+import "mocha";
+import { DEFAULT_HOST_NAME } from "../../constants.js";
+import { PreferenceJson } from "../../models/PreferenceJson.js";
+import { removeSymbols } from "../../utilities/Extensions.js";
+
+describe("PreferenceJson", () => {
+    describe("constructor", () => {
+        it("should set required properties to default value when the constructor argument is empty.", () => {
+            const preferenceJson = new PreferenceJson({});
+
+            assert.isDefined(preferenceJson);
+            assert.isUndefined(preferenceJson.hasTelemetryConsent);
+            assert.isUndefined(preferenceJson.ims);
+            assert.isUndefined(preferenceJson.clientId);
+            assert.isUndefined(preferenceJson.ssl);
+        });
+
+        it("should set the properties from the 'content' constructor argument.", () => {
+            const content = {
+                hasTelemetryConsent: false,
+                ims: {
+                    contexts: {
+                        cli: {
+                            "cli.bare-output": true
+                        }
+                    }
+                },
+                clientId: 1096361282655,
+                ssl: {
+                    localhost: {
+                        certificatePath: "/some-directory/localhost/ssl/certificate.cert",
+                        keyPath: "/some-directory/localhost/ssl/private-key.key"
+                    },
+                    "localhost.adobe.com": {
+                        certificatePath: "/some-directory/localhost.adobe.com/ssl/certificate.cert",
+                        keyPath: "/some-directory/localhost.adobe.com/ssl/private-key.key"
+                    }
+                }
+            };
+
+            const preferenceJson = new PreferenceJson(content);
+
+            assert.isDefined(preferenceJson);
+            assert.equal(preferenceJson.hasTelemetryConsent, content.hasTelemetryConsent);
+            assert.deepEqual(preferenceJson.ims, content.ims);
+            assert.equal(preferenceJson.clientId, content.clientId);
+            assert.deepEqual(Object.fromEntries(preferenceJson.ssl!), content.ssl);
+        });
+
+        it("should set the backward compatible SSL properties from the 'content' constructor argument.", () => {
+            const content = {
+                hasTelemetryConsent: false,
+                ims: {
+                    contexts: {
+                        cli: {
+                            "cli.bare-output": true
+                        }
+                    }
+                },
+                clientId: 1096361282655,
+                sslCertPath: "/some-directory/localhost/ssl/certificate.cert",
+                sslKeyPath: "/some-directory/localhost/ssl/private-key.key"
+            };
+
+            const preferenceJson = new PreferenceJson(content);
+
+            assert.isDefined(preferenceJson);
+            assert.equal(preferenceJson.hasTelemetryConsent, content.hasTelemetryConsent);
+            assert.deepEqual(preferenceJson.ims, content.ims);
+            assert.equal(preferenceJson.clientId, content.clientId);
+            assert.deepEqual(Object.fromEntries(preferenceJson.ssl!), {
+                [DEFAULT_HOST_NAME]: {
+                    certificatePath: content.sslCertPath,
+                    keyPath: content.sslKeyPath
+                }
+            });
+        });
+
+        it("should set the latest SSL version when both versions are present in the 'content' constructor argument.", () => {
+            const content = {
+                hasTelemetryConsent: false,
+                ims: {
+                    contexts: {
+                        cli: {
+                            "cli.bare-output": true
+                        }
+                    }
+                },
+                clientId: 1096361282655,
+                ssl: {
+                    localhost: {
+                        certificatePath: "/some-directory/localhost/ssl/certificate.cert",
+                        keyPath: "/some-directory/localhost/ssl/private-key.key"
+                    },
+                    "localhost.adobe.com": {
+                        certificatePath: "/some-directory/localhost.adobe.com/ssl/certificate.cert",
+                        keyPath: "/some-directory/localhost.adobe.com/ssl/private-key.key"
+                    }
+                },
+                sslCertPath: "/some-directory/localhost/ssl/certificate.cert",
+                sslKeyPath: "/some-directory/localhost/ssl/private-key.key"
+            };
+
+            const preferenceJson = new PreferenceJson(content);
+
+            assert.isDefined(preferenceJson);
+            assert.equal(preferenceJson.hasTelemetryConsent, content.hasTelemetryConsent);
+            assert.deepEqual(preferenceJson.ims, content.ims);
+            assert.equal(preferenceJson.clientId, content.clientId);
+            assert.deepEqual(Object.fromEntries(preferenceJson.ssl!), content.ssl);
+        });
+    });
+
+    describe("toJSON", () => {
+        const runs = [
+            {
+                content: {
+                    hasTelemetryConsent: true,
+                    clientId: 1096361282655
+                }
+            },
+            {
+                content: {
+                    hasTelemetryConsent: false,
+                    ims: {
+                        contexts: {
+                            cli: {
+                                "cli.bare-output": true
+                            }
+                        }
+                    },
+                    clientId: 1096361282655,
+                    ssl: {
+                        localhost: {
+                            certificatePath: "/some-directory/localhost/ssl/certificate.cert",
+                            keyPath: "/some-directory/localhost/ssl/private-key.key"
+                        },
+                        "localhost.adobe.com": {
+                            certificatePath: "/some-directory/localhost.adobe.com/ssl/certificate.cert",
+                            keyPath: "/some-directory/localhost.adobe.com/ssl/private-key.key"
+                        }
+                    }
+                }
+            }
+        ];
+
+        runs.forEach(run => {
+            it("should return stringify-ed PreferenceJson with properties except for the undefined ones.", () => {
+                const preferenceJson = new PreferenceJson(run.content);
+                const preferenceJsonString = preferenceJson.toJSON();
+
+                assert.equal(
+                    removeSymbols(preferenceJsonString),
+                    removeSymbols(JSON.stringify(run.content, undefined, 4))
+                );
+            });
+        });
+    });
+});

package/src/test/models/TemplateJson.spec.ts

@@ -0,0 +1,179 @@
+/********************************************************************************
+ * MIT License
+
+ * © Copyright 2023 Adobe. All rights reserved.
+
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ ********************************************************************************/
+
+import { assert } from "chai";
+import "mocha";
+import { TemplateJson } from "../../models/index.js";
+
+describe("TemplateJson", () => {
+    describe("constructor ...", () => {
+        it(`should not set any properties when the constructor argument is undefined.`, () => {
+            const templateJson = new TemplateJson({});
+            assert.isDefined(templateJson);
+            assert.isUndefined(templateJson.devDependencies);
+            assert.isUndefined(templateJson.dependencies);
+            assert.isUndefined(templateJson.scripts);
+        });
+
+        it(`should only set devDependencies when the constructor argument only contains devDependencies.`, () => {
+            const content = {
+                devDependencies: {
+                    a: "1.0.0",
+                    b: "2.0.0"
+                }
+            };
+
+            let templateJson = new TemplateJson(content);
+            assert.isDefined(templateJson);
+
+            assert.isDefined(templateJson.devDependencies);
+            assert.equal(templateJson.devDependencies?.get("a"), content.devDependencies.a);
+            assert.equal(templateJson.devDependencies?.get("b"), content.devDependencies.b);
+
+            assert.isUndefined(templateJson.dependencies);
+            assert.isUndefined(templateJson.scripts);
+
+            const contentMap = {
+                devDependencies: new Map([
+                    ["a", "1.0.0"],
+                    ["b", "2.0.0"]
+                ])
+            };
+
+            templateJson = new TemplateJson(contentMap);
+            assert.isDefined(templateJson);
+
+            assert.isDefined(templateJson.devDependencies);
+            assert.equal(templateJson.devDependencies?.get("a"), content.devDependencies.a);
+            assert.equal(templateJson.devDependencies?.get("b"), content.devDependencies.b);
+
+            assert.isUndefined(templateJson.dependencies);
+            assert.isUndefined(templateJson.scripts);
+        });
+
+        it(`should only set dependencies when the constructor argument only contains dependencies.`, () => {
+            const content = {
+                dependencies: {
+                    c: "3.0.0",
+                    d: "4.0.0"
+                }
+            };
+
+            let templateJson = new TemplateJson(content);
+            assert.isDefined(templateJson);
+
+            assert.isDefined(templateJson.dependencies);
+            assert.equal(templateJson.dependencies?.get("c"), content.dependencies.c);
+            assert.equal(templateJson.dependencies?.get("d"), content.dependencies.d);
+
+            assert.isUndefined(templateJson.devDependencies);
+            assert.isUndefined(templateJson.scripts);
+
+            const contentMap = {
+                dependencies: new Map([
+                    ["c", "3.0.0"],
+                    ["d", "4.0.0"]
+                ])
+            };
+
+            templateJson = new TemplateJson(contentMap);
+            assert.isDefined(templateJson);
+
+            assert.isDefined(templateJson.dependencies);
+            assert.equal(templateJson.dependencies?.get("c"), content.dependencies.c);
+            assert.equal(templateJson.dependencies?.get("d"), content.dependencies.d);
+
+            assert.isUndefined(templateJson.devDependencies);
+            assert.isUndefined(templateJson.scripts);
+        });
+
+        it(`should only set scripts when the constructor argument only contains scripts.`, () => {
+            const content = {
+                scripts: {
+                    e: "clean",
+                    f: "build"
+                }
+            };
+
+            let templateJson = new TemplateJson(content);
+            assert.isDefined(templateJson);
+
+            assert.isDefined(templateJson.scripts);
+            assert.equal(templateJson.scripts?.get("e"), content.scripts.e);
+            assert.equal(templateJson.scripts?.get("f"), content.scripts.f);
+
+            assert.isUndefined(templateJson.devDependencies);
+            assert.isUndefined(templateJson.dependencies);
+
+            const contentMap = {
+                scripts: new Map([
+                    ["e", "clean"],
+                    ["f", "build"]
+                ])
+            };
+
+            templateJson = new TemplateJson(contentMap);
+            assert.isDefined(templateJson);
+
+            assert.isDefined(templateJson.scripts);
+            assert.equal(templateJson.scripts?.get("e"), content.scripts.e);
+            assert.equal(templateJson.scripts?.get("f"), content.scripts.f);
+
+            assert.isUndefined(templateJson.devDependencies);
+            assert.isUndefined(templateJson.dependencies);
+        });
+
+        it(`should set all properties when the constructor argument contains them.`, () => {
+            const content = {
+                devDependencies: {
+                    a: "1.0.0",
+                    b: "2.0.0"
+                },
+                dependencies: {
+                    c: "3.0.0",
+                    d: "4.0.0"
+                },
+                scripts: {
+                    e: "clean",
+                    f: "build"
+                }
+            };
+
+            const templateJson = new TemplateJson(content);
+            assert.isDefined(templateJson);
+
+            assert.isDefined(templateJson.devDependencies);
+            assert.equal(templateJson.devDependencies?.get("a"), content.devDependencies.a);
+            assert.equal(templateJson.devDependencies?.get("b"), content.devDependencies.b);
+
+            assert.isDefined(templateJson.dependencies);
+            assert.equal(templateJson.dependencies?.get("c"), content.dependencies.c);
+            assert.equal(templateJson.dependencies?.get("d"), content.dependencies.d);
+
+            assert.isDefined(templateJson.scripts);
+            assert.equal(templateJson.scripts?.get("e"), content.scripts.e);
+            assert.equal(templateJson.scripts?.get("f"), content.scripts.f);
+        });
+    });
+});