ts-simple-ast/dist/tests/compiler/statement/statementedNode/enumTests.js

TypeScript compiler wrapper for AST navigation and code generation.

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const chai_1 = require("chai");
const compiler_1 = require("./../../../../compiler");
const testHelpers_1 = require("./../../testHelpers");
describe("StatementedNode", () => {
    describe("insertEnums", () => {
        function doTest(startCode, index, structures, expectedText) {
            const { sourceFile } = testHelpers_1.getInfoFromText(startCode);
            const result = sourceFile.insertEnums(index, structures);
            chai_1.expect(sourceFile.getFullText()).to.equal(expectedText);
            chai_1.expect(result.length).to.equal(structures.length);
        }
        it("should insert to an empty file", () => {
            doTest("", 0, [{
                    name: "MyEnum",
                    members: [{ name: "member" }],
                    isConst: true
                }], "const enum MyEnum {\n    member\n}\n");
        });
        it("should insert at the start of a file", () => {
            doTest("class MyClass {\n}\n", 0, [{ name: "MyEnum" }], "enum MyEnum {\n}\n\nclass MyClass {\n}\n");
        });
        it("should insert at the end of a file", () => {
            doTest("class MyClass {\n}\n", 1, [{ name: "MyEnum" }], "class MyClass {\n}\n\nenum MyEnum {\n}\n");
        });
        it("should insert in the middle of children", () => {
            doTest("class MyClass {\n}\n\nclass MyOther {\n}\n", 1, [{ name: "MyEnum" }], "class MyClass {\n}\n\nenum MyEnum {\n}\n\nclass MyOther {\n}\n");
        });
        it("should insert multiple enums", () => {
            doTest("class MyClass {\n}\n", 1, [{ name: "MyEnum" }, { name: "Enum2" }], "class MyClass {\n}\n\nenum MyEnum {\n}\n\nenum Enum2 {\n}\n");
        });
        it("should have the expected text adding to non-source file", () => {
            const { sourceFile } = testHelpers_1.getInfoFromText("namespace MyNamespace {\n}\n");
            const namespaceDec = sourceFile.getNamespaces()[0];
            namespaceDec.insertEnums(0, [{
                    name: "MyEnum",
                    members: [{ name: "member" }]
                }]);
            chai_1.expect(sourceFile.getFullText()).to.equal("namespace MyNamespace {\n    enum MyEnum {\n        member\n    }\n}\n");
        });
    });
    describe("insertEnum", () => {
        function doTest(startCode, index, structure, expectedText) {
            const { sourceFile } = testHelpers_1.getInfoFromText(startCode);
            const result = sourceFile.insertEnum(index, structure);
            chai_1.expect(sourceFile.getFullText()).to.equal(expectedText);
            chai_1.expect(result).to.be.instanceOf(compiler_1.EnumDeclaration);
        }
        it("should insert an enum", () => {
            doTest("class MyClass {\n}\n", 0, { name: "MyEnum" }, "enum MyEnum {\n}\n\nclass MyClass {\n}\n");
        });
    });
    describe("addEnums", () => {
        function doTest(startCode, structures, expectedText) {
            const { sourceFile } = testHelpers_1.getInfoFromText(startCode);
            const result = sourceFile.addEnums(structures);
            chai_1.expect(sourceFile.getFullText()).to.equal(expectedText);
            chai_1.expect(result.length).to.equal(structures.length);
        }
        it("should add enums", () => {
            doTest("class MyClass {\n}\n", [{ name: "MyEnum" }, { name: "Enum2" }], "class MyClass {\n}\n\nenum MyEnum {\n}\n\nenum Enum2 {\n}\n");
        });
    });
    describe("addEnum", () => {
        function doTest(startCode, structure, expectedText) {
            const { sourceFile } = testHelpers_1.getInfoFromText(startCode);
            const result = sourceFile.addEnum(structure);
            chai_1.expect(sourceFile.getFullText()).to.equal(expectedText);
            chai_1.expect(result).to.be.instanceOf(compiler_1.EnumDeclaration);
        }
        it("should add an enum", () => {
            doTest("class MyClass {\n}\n", { name: "MyEnum" }, "class MyClass {\n}\n\nenum MyEnum {\n}\n");
        });
    });
    describe("getEnums", () => {
        const { sourceFile } = testHelpers_1.getInfoFromText("enum Identifier1 {}\nenum Identifier2 { member }");
        const enums = sourceFile.getEnums();
        it("should have the expected number of enums", () => {
            chai_1.expect(enums.length).to.equal(2);
        });
        it("should have correct type", () => {
            chai_1.expect(enums[0]).to.be.instanceOf(compiler_1.EnumDeclaration);
        });
    });
    describe("getEnum", () => {
        const { sourceFile } = testHelpers_1.getInfoFromText("enum Identifier1 {}\nenum Identifier2 { member }");
        it("should get an enum by a name", () => {
            chai_1.expect(sourceFile.getEnum("Identifier2").getName()).to.equal("Identifier2");
        });
        it("should get a enum by a search function", () => {
            chai_1.expect(sourceFile.getEnum(c => c.getName() === "Identifier1").getName()).to.equal("Identifier1");
        });
        it("should return undefined when the enum doesn't exist", () => {
            chai_1.expect(sourceFile.getEnum("asdf")).to.be.undefined;
        });
    });
    describe("getEnumOrThrow", () => {
        const { sourceFile } = testHelpers_1.getInfoFromText("enum Identifier1 {}\nenum Identifier2 { member }");
        it("should get an enum by a name", () => {
            chai_1.expect(sourceFile.getEnumOrThrow("Identifier2").getName()).to.equal("Identifier2");
        });
        it("should get a enum by a search function", () => {
            chai_1.expect(sourceFile.getEnumOrThrow(c => c.getName() === "Identifier1").getName()).to.equal("Identifier1");
        });
        it("should throw when the enum doesn't exist", () => {
            chai_1.expect(() => sourceFile.getEnumOrThrow("asdf")).to.throw();
        });
    });
});

//# sourceMappingURL=enumTests.js.map