ts-simple-ast/dist/tests/compiler/base/initializer/initializerExpressionedNodeTests.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("InitializerExpressionableNode", () => {
    function getEnumMemberFromText(text) {
        const result = testHelpers_1.getInfoFromText(text);
        return Object.assign({ member: result.firstChild.getMembers()[0] }, result);
    }
    describe("hasInitializer", () => {
        function doTest(code, expectedResult) {
            const { member } = getEnumMemberFromText(code);
            chai_1.expect(member.hasInitializer()).to.equal(expectedResult);
        }
        it("should have an initializer when it does", () => {
            doTest("enum MyEnum { myMember = 4 }", true);
        });
        it("should not have an initializer when it doesn't", () => {
            doTest("enum MyEnum { myMember }", false);
        });
    });
    describe("getInitializer", () => {
        describe("having initializer", () => {
            const { member } = getEnumMemberFromText("enum MyEnum { myMember = 4 }");
            const initializer = member.getInitializer();
            it("should have correct text", () => {
                chai_1.expect(initializer.getText()).to.equal("4");
            });
            it("should be of correct instance", () => {
                chai_1.expect(initializer).to.be.instanceOf(compiler_1.Expression);
            });
        });
        describe("not having initializer", () => {
            it("should be undefined", () => {
                const { member } = getEnumMemberFromText("enum MyEnum { myMember }");
                chai_1.expect(member.getInitializer()).to.be.undefined;
            });
        });
    });
    describe("getInitializerOrThrow", () => {
        it("should get when the initializer exists", () => {
            const { member } = getEnumMemberFromText("enum MyEnum { myMember = 4 }");
            chai_1.expect(member.getInitializerOrThrow().getText()).to.equal("4");
        });
        it("should throw when the initializer doesn't exist", () => {
            const { member } = getEnumMemberFromText("enum MyEnum { myMember }");
            chai_1.expect(() => member.getInitializerOrThrow()).to.throw();
        });
    });
    describe("removeInitializer", () => {
        function doTest(startCode, expectedCode) {
            const { member, sourceFile } = getEnumMemberFromText(startCode);
            member.removeInitializer();
            chai_1.expect(sourceFile.getFullText()).to.equal(expectedCode);
        }
        it("should remove when it has an initializer", () => {
            doTest("enum MyEnum { myMember = 5 }", "enum MyEnum { myMember }");
        });
        it("should do nothing when it doesn't have an initializer", () => {
            doTest("enum MyEnum { myMember }", "enum MyEnum { myMember }");
        });
    });
    describe("setInitializer", () => {
        describe("enum member", () => {
            function doThrowTest(initializerText) {
                const { member } = getEnumMemberFromText("enum MyEnum {\n    myMember = 4,\n}\n");
                chai_1.expect(() => member.setInitializer(initializerText)).to.throw();
            }
            function doEnumMemberTest(startCode, initializer, expectedCode) {
                const { member, sourceFile } = getEnumMemberFromText(startCode);
                member.setInitializer(initializer);
                chai_1.expect(sourceFile.getFullText()).to.equal(expectedCode);
            }
            it("should set the new initializer when it has one already", () => {
                doEnumMemberTest("enum MyEnum {\n    myMember = 4\n}\n", "5", "enum MyEnum {\n    myMember = 5\n}\n");
            });
            it("should set the new initializer when it has one and there's a comma", () => {
                doEnumMemberTest("enum MyEnum {\n    myMember = 4,\n}\n", "5", "enum MyEnum {\n    myMember = 5,\n}\n");
            });
            describe("having initializer and setting to empty string", () => {
                doThrowTest("");
            });
            describe("having initializer and setting to whitespace string", () => {
                doThrowTest("    ");
            });
            describe("having initializer and setting to null", () => {
                doThrowTest(null);
            });
            describe("having initializer and setting to a different type", () => {
                doThrowTest(1);
            });
            it("should set the initializer when it doens't have one", () => {
                doEnumMemberTest("enum MyEnum {\n    myMember\n}\n", "5", "enum MyEnum {\n    myMember = 5\n}\n");
            });
        });
        describe("class property", () => {
            function doClassPropTest(text, newInitializer, expected) {
                const { firstChild } = testHelpers_1.getInfoFromText(text);
                const prop = firstChild.getInstanceProperties()[0];
                prop.setInitializer(newInitializer);
                chai_1.expect(firstChild.getFullText()).to.equal(expected);
            }
            it("should set a new initializer", () => {
                doClassPropTest("class Identifier { prop; }", "2", "class Identifier { prop = 2; }");
            });
            it("should replace initializer", () => {
                doClassPropTest("class Identifier { prop = '2'; }", "2", "class Identifier { prop = 2; }");
            });
            it("should replace initializer that is an object", () => {
                doClassPropTest("class Identifier { prop = { something: ''; }; }", "{}", "class Identifier { prop = {}; }");
            });
            it("should set initializer when there's an inline comment", () => {
                doClassPropTest("class Identifier { prop/*comment*/; }", "2", "class Identifier { prop = 2/*comment*/; }");
            });
            it("should set initializer when there's a comment after and no semi-colon", () => {
                doClassPropTest("class Identifier { prop/*comment*/ }", "2", "class Identifier { prop = 2/*comment*/ }");
            });
        });
    });
    describe("fill", () => {
        function doTest(startingCode, structure, expectedCode) {
            const { firstChild, sourceFile } = testHelpers_1.getInfoFromText(startingCode);
            const firstProperty = firstChild.getInstanceProperties()[0];
            firstProperty.fill(structure);
            chai_1.expect(sourceFile.getText()).to.equal(expectedCode);
        }
        it("should modify when setting", () => {
            doTest("class Identifier { prop }", { initializer: "4" }, "class Identifier { prop = 4 }");
        });
        it("should not modify anything if the structure doesn't change anything", () => {
            doTest("class Identifier { prop = 4 }", {}, "class Identifier { prop = 4 }");
        });
    });
});

//# sourceMappingURL=initializerExpressionedNodeTests.js.map