diff --git a/bsc-plugin/src/lib/rooibos/MockUtil.ts b/bsc-plugin/src/lib/rooibos/MockUtil.ts index 525251b7..d8b51081 100644 --- a/bsc-plugin/src/lib/rooibos/MockUtil.ts +++ b/bsc-plugin/src/lib/rooibos/MockUtil.ts @@ -133,7 +133,7 @@ export class MockUtil { gatherGlobalMethodMocks(testSuite: TestSuite) { // console.log('gathering global method mocks for testSuite', testSuite.name); for (let group of [...testSuite.testGroups.values()].filter((tg) => tg.isIncluded)) { - for (let testCase of [...group.testCases.values()].filter((tc) => tc.isIncluded)) { + for (let testCase of [...group.testCases].filter((tc) => tc.isIncluded)) { this.gatherMockedGlobalMethods(testSuite, testCase); } } diff --git a/bsc-plugin/src/lib/rooibos/RooibosSessionInfo.ts b/bsc-plugin/src/lib/rooibos/RooibosSessionInfo.ts index 9a3c5fd6..24cb20fc 100644 --- a/bsc-plugin/src/lib/rooibos/RooibosSessionInfo.ts +++ b/bsc-plugin/src/lib/rooibos/RooibosSessionInfo.ts @@ -91,7 +91,7 @@ export class SessionInfo { testGroup.isIncluded = true; if (testGroup.isIgnored) { this.ignoredTestNames.push(testGroup.name + ' [WHOLE GROUP]'); - this.ignoredCount += testGroup.testCases.size; + this.ignoredCount += testGroup.testCases.length; } } @@ -99,7 +99,7 @@ export class SessionInfo { if (testGroup.isIncluded) { this.groupsCount++; } - let testCases = [...testGroup.testCases.values()]; + let testCases = [...testGroup.testCases]; for (let testCase of testCases) { testCase.isIncluded = false; diff --git a/bsc-plugin/src/lib/rooibos/TestGroup.ts b/bsc-plugin/src/lib/rooibos/TestGroup.ts index da5f1dea..fb84a740 100644 --- a/bsc-plugin/src/lib/rooibos/TestGroup.ts +++ b/bsc-plugin/src/lib/rooibos/TestGroup.ts @@ -21,19 +21,15 @@ export class TestGroup extends TestBlock { } public testSuite: TestSuite; - public testCases = new Map(); + public testCases: Array = []; public addTestCase(testCase: TestCase) { - this.testCases.set(testCase.name + (testCase.isParamTest ? testCase.paramTestIndex.toString() : ''), testCase); + this.testCases.push(testCase); this.hasIgnoredTests = this.hasIgnoredTests || testCase.isIgnored; this.hasSoloTests = this.hasSoloTests || testCase.isSolo; this.hasAsyncTests = this.hasAsyncTests || testCase.isAsync; } - public getTestCases(): TestCase[] { - return [...this.testCases.values()]; - } - public modifyAssertions(testCase: TestCase, noEarlyExit: boolean, editor: AstEditor, namespaceLookup: Map, scope: Scope) { //for each method //if assertion @@ -201,7 +197,7 @@ export class TestGroup extends TestBlock { } public asText(): string { - let testCaseText = [...this.testCases.values()].filter((tc) => tc.isIncluded).map((tc) => tc.asText()); + let testCaseText = [...this.testCases].filter((tc) => tc.isIncluded).map((tc) => tc.asText()); return ` { diff --git a/bsc-plugin/src/lib/rooibos/TestSuite.ts b/bsc-plugin/src/lib/rooibos/TestSuite.ts index 473d0e7c..dda3f4f8 100644 --- a/bsc-plugin/src/lib/rooibos/TestSuite.ts +++ b/bsc-plugin/src/lib/rooibos/TestSuite.ts @@ -94,6 +94,7 @@ export class TestSuite extends TestBlock { public hasSoloGroups = false; public isNodeTest = false; public session: RooibosSession; + public registeredTestCount = 0; public addGroup(group: TestGroup) { this.testGroups.set(group.name, group); diff --git a/bsc-plugin/src/lib/rooibos/TestSuiteBuilder.spec.ts b/bsc-plugin/src/lib/rooibos/TestSuiteBuilder.spec.ts index 75c8e18f..ae2b1451 100644 --- a/bsc-plugin/src/lib/rooibos/TestSuiteBuilder.spec.ts +++ b/bsc-plugin/src/lib/rooibos/TestSuiteBuilder.spec.ts @@ -36,208 +36,216 @@ describe('TestSuiteBuilder tests ', () => { describe('No suites', () => { it('no suite', () => { let testSuite = createTestSuite('test1.bs', ` - `); + `); expect(testSuite).to.be.null; }); it('no suite - namespace', () => { - let testSuite = createTestSuite('test1.bs', `namespace empty - end namespace - `); + let testSuite = createTestSuite('test1.bs', ` + namespace empty + end namespace + `); expect(testSuite).to.be.null; }); it('no suite - namespace with funcs', () => { - let testSuite = createTestSuite('test1.bs', `namespace empty - function foo() - end function - end namespace - `); + let testSuite = createTestSuite('test1.bs', ` + namespace empty + function foo() + end function + end namespace + `); expect(testSuite).to.be.null; }); it('no suite - namespace with class', () => { - let testSuite = createTestSuite('test1.bs', `namespace empty - class fooClass - end class - end namespace - `); + let testSuite = createTestSuite('test1.bs', ` + namespace empty + class fooClass + end class + end namespace + `); expect(testSuite).to.be.null; }); it('no suite - class', () => { - let testSuite = createTestSuite('test1.bs', `class fooClass - end class - `); + let testSuite = createTestSuite('test1.bs', ` + class fooClass + end class + `); expect(testSuite).to.be.null; }); }); describe('Suite issues', () => { - it('duplicate suite name - different files', () => { - let ts = createTestSuite('test1.bs', `namespace Tests - @suite("Rooibos assertion tests") - class AssertionTests extends rooibos.BaseTestSuite - @describe("group1") - - @it("one") - function test_one() - end function - end class - end namespace - `); + let ts = createTestSuite('test1.bs', ` + namespace Tests + @suite("Rooibos assertion tests") + class AssertionTests extends rooibos.BaseTestSuite + @describe("group1") + + @it("one") + function test_one() + end function + end class + end namespace + `); assertSuite(ts, 1); - let testSuite2 = createTestSuite('test2.bs', `namespace Tests - @suite("Rooibos assertion tests") - class AssertionTests extends rooibos.BaseTestSuite - @describe("group1") - - @it("one") - function test_one() - end function - end class - end namespace - `); + let testSuite2 = createTestSuite('test2.bs', ` + namespace Tests + @suite("Rooibos assertion tests") + class AssertionTests extends rooibos.BaseTestSuite + @describe("group1") + + @it("one") + function test_one() + end function + end class + end namespace + `); assertSuiteError(testSuite2); expect(ts.isValid).to.be.false; }); it('duplicate suite name - same file', () => { - let ts = createTestSuite('test1.bs', `namespace Tests - @suite("Rooibos assertion tests") - class AssertionTests extends rooibos.BaseTestSuite - @describe("group1") - - @it("one") - function test_one() - end function - end class - @suite("Rooibos assertion tests") - class AssertionTests extends rooibos.BaseTestSuite - @describe("group1") - - @it("one") - function test_one() - end function - end class - end namespace - `); + let ts = createTestSuite('test1.bs', ` + namespace Tests + @suite("Rooibos assertion tests") + class AssertionTests extends rooibos.BaseTestSuite + @describe("group1") + + @it("one") + function test_one() + end function + end class + @suite("Rooibos assertion tests") + class AssertionTests extends rooibos.BaseTestSuite + @describe("group1") + + @it("one") + function test_one() + end function + end class + end namespace + `); assertSuiteError(ts); }); it('duplicate group', () => { - let ts = createTestSuite('test1.bs', `namespace Tests - @suite("Rooibos assertion tests") - class AssertionTests extends rooibos.BaseTestSuite - @describe("group1") - - @it("one") - function test_one() - end function - - @describe("group1") - - @it("two") - function test_Two() - end function - end class - end namespace - `); + let ts = createTestSuite('test1.bs', ` + namespace Tests + @suite("Rooibos assertion tests") + class AssertionTests extends rooibos.BaseTestSuite + @describe("group1") + + @it("one") + function test_one() + end function + + @describe("group1") + + @it("two") + function test_Two() + end function + end class + end namespace + `); assertSuiteError(ts); }); it('duplicate test', () => { - let ts = createTestSuite('test1.bs', `namespace Tests - @suite("Rooibos assertion tests") - class AssertionTests extends rooibos.BaseTestSuite - @describe("group1") - - @it("one") - function test_one() - end function - - @it("one") - function test_Two() - end function - end class - end namespace - `); - assertSuiteError(ts); + let ts = createTestSuite('test1.bs', ` + namespace Tests + @suite("Rooibos assertion tests") + class AssertionTests extends rooibos.BaseTestSuite + @describe("group1") + + @it("one") + function test_one() + end function + + @it("one") + function test_Two() + end function + end class + end namespace + `); + assertSuite(ts, 1); }); }); describe('Has valid suites', () => { it('class with 1 group, 1 test', () => { - let testSuite = createTestSuite('test1.bs', `namespace Tests - - @suite("Rooibos assertion tests") - class AssertionTests extends rooibos.BaseTestSuite - - '+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ - @describe("group1") - '+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ - - @it("one") - function test_one() - end function - end class -end namespace - `); + let testSuite = createTestSuite('test1.bs', ` + namespace Tests + @suite("Rooibos assertion tests") + class AssertionTests extends rooibos.BaseTestSuite + + '+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + @describe("group1") + '+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + + @it("one") + function test_one() + end function + end class + end namespace + `); assertSuite(testSuite, 1); assertGroupCount(testSuite, 0, 1); }); }); it('class with 1 group 2 tests', () => { - let testSuite = createTestSuite('test1.bs', `namespace Tests - - @suite("Rooibos assertion tests") - class AssertionTests extends rooibos.BaseTestSuite - - '+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ - @describe("group1") - '+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ - - @it("one") - function test_one() - end function - - @it("two") - function test_two() - end function -end class -end namespace - `); + let testSuite = createTestSuite('test1.bs', ` + namespace Tests + @suite("Rooibos assertion tests") + class AssertionTests extends rooibos.BaseTestSuite + + '+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + @describe("group1") + '+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + + @it("one") + function test_one() + end function + + @it("two") + function test_two() + end function + end class + end namespace + `); assertSuite(testSuite, 1); assertGroupCount(testSuite, 0, 2); }); it('class with 2 group, 1 test each', () => { - let testSuite = createTestSuite('test1.bs', `namespace Tests - - @suite("Rooibos assertion tests") - class AssertionTests extends rooibos.BaseTestSuite - - '+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ - @describe("group1") - '+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ - - @it("one") - function test_one() - end function - - '+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ - @describe("group2") - '+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ - - @it("two") - function test_two() - end function - end class - end namespace - `); + let testSuite = createTestSuite('test1.bs', ` + namespace Tests + @suite("Rooibos assertion tests") + class AssertionTests extends rooibos.BaseTestSuite + + '+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + @describe("group1") + '+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + + @it("one") + function test_one() + end function + + '+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + @describe("group2") + '+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + + @it("two") + function test_two() + end function + end class + end namespace + `); assertSuite(testSuite, 2); assertGroupCount(testSuite, 0, 1); assertGroupCount(testSuite, 1, 1); @@ -245,25 +253,24 @@ end namespace }); it('class with 2 group, 1 test each - concise syntax', () => { - let testSuite = createTestSuite('test1.bs', `namespace Tests - - @suite("Rooibos assertion tests") - class AssertionTests extends rooibos.BaseTestSuite - - @describe("group1") - - @it("one") - function test_one() - end function - - @describe("group2") - - @it("two") - function test_two() - end function - end class - end namespace - `); + let testSuite = createTestSuite('test1.bs', ` + namespace Tests + @suite("Rooibos assertion tests") + class AssertionTests extends rooibos.BaseTestSuite + @describe("group1") + + @it("one") + function test_one() + end function + + @describe("group2") + + @it("two") + function test_two() + end function + end class + end namespace + `); assertSuite(testSuite, 2); assertGroupCount(testSuite, 0, 1); assertGroupCount(testSuite, 1, 1); @@ -271,41 +278,39 @@ end namespace }); it('Valid params', () => { - let testSuite = createTestSuite('test1.bs', `namespace Tests - - @suite("Rooibos assertion tests") - class AssertionTests extends rooibos.BaseTestSuite - - @describe("group1") - - @it("one") - @params(true, "one") - function test_one(v1, v2) - end function - end class - end namespace - `); + let testSuite = createTestSuite('test1.bs', ` + namespace Tests + @suite("Rooibos assertion tests") + class AssertionTests extends rooibos.BaseTestSuite + @describe("group1") + + @it("one") + @params(true, "one") + function test_one(v1, v2) + end function + end class + end namespace + `); assertSuite(testSuite, 1); assertGroupCount(testSuite, 0, 1); assertParamTestCase(testSuite, 0, 0, 0); }); it('Valid params 2 params', () => { - let testSuite = createTestSuite('test1.bs', `namespace Tests - - @suite("Rooibos assertion tests") - class AssertionTests extends rooibos.BaseTestSuite - - @describe("group1") - - @it("one") - @params(true, "one") - @params(true, "one") - function test_one(v1, v2) - end function - end class - end namespace - `); + let testSuite = createTestSuite('test1.bs', ` + namespace Tests + @suite("Rooibos assertion tests") + class AssertionTests extends rooibos.BaseTestSuite + @describe("group1") + + @it("one") + @params(true, "one") + @params(true, "one") + function test_one(v1, v2) + end function + end class + end namespace + `); assertSuite(testSuite, 1); assertGroupCount(testSuite, 0, 2); assertParamTestCase(testSuite, 0, 0, 0); @@ -313,24 +318,23 @@ end namespace }); it('Valid params 5 params', () => { - let testSuite = createTestSuite('test1.bs', `namespace Tests - - @suite("Rooibos assertion tests") - class AssertionTests extends rooibos.BaseTestSuite - - @describe("group1") - - @it("one") - @params(true, "1") - @params(true, "2") - @params(true, "3") - @params(true, "4") - @params(true, "5") - function test_one(v1, v2) - end function - end class - end namespace - `); + let testSuite = createTestSuite('test1.bs', ` + namespace Tests + @suite("Rooibos assertion tests") + class AssertionTests extends rooibos.BaseTestSuite + @describe("group1") + + @it("one") + @params(true, "1") + @params(true, "2") + @params(true, "3") + @params(true, "4") + @params(true, "5") + function test_one(v1, v2) + end function + end class + end namespace + `); assertSuite(testSuite, 1); assertGroupCount(testSuite, 0, 5); assertParamTestCase(testSuite, 0, 0, 0); @@ -341,22 +345,23 @@ end namespace }); describe('only tags', () => { it('only suite', () => { - let ts = createTestSuite('test1.bs', `namespace Tests - @only - @suite("Rooibos assertion tests") - class AssertionTests extends rooibos.BaseTestSuite - @describe("group1") - - @it("one") - function test_one() - end function - - @it("two") - function test_Two() - end function - end class - end namespace - `); + let ts = createTestSuite('test1.bs', ` + namespace Tests + @only + @suite("Rooibos assertion tests") + class AssertionTests extends rooibos.BaseTestSuite + @describe("group1") + + @it("one") + function test_one() + end function + + @it("two") + function test_Two() + end function + end class + end namespace + `); assertSuite(ts, 1); assertGroupCount(ts, 0, 2); expect(ts.isSolo).to.be.true; @@ -368,22 +373,23 @@ end namespace }); it('only group', () => { - let ts = createTestSuite('test1.bs', `namespace Tests - @suite("Rooibos assertion tests") - class AssertionTests extends rooibos.BaseTestSuite - @only - @describe("group1") - - @it("one") - function test_one() - end function - - @it("two") - function test_Two() - end function - end class - end namespace - `); + let ts = createTestSuite('test1.bs', ` + namespace Tests + @suite("Rooibos assertion tests") + class AssertionTests extends rooibos.BaseTestSuite + @only + @describe("group1") + + @it("one") + function test_one() + end function + + @it("two") + function test_Two() + end function + end class + end namespace + `); assertSuite(ts, 1); assertGroupCount(ts, 0, 2); expect(ts.isSolo).to.be.false; @@ -395,22 +401,23 @@ end namespace }); it('only test', () => { - let ts = createTestSuite('test1.bs', `namespace Tests - @suite("Rooibos assertion tests") - class AssertionTests extends rooibos.BaseTestSuite - @describe("group1") - - @only - @it("one") - function test_one() - end function - - @it("two") - function test_Two() - end function - end class - end namespace - `); + let ts = createTestSuite('test1.bs', ` + namespace Tests + @suite("Rooibos assertion tests") + class AssertionTests extends rooibos.BaseTestSuite + @describe("group1") + + @only + @it("one") + function test_one() + end function + + @it("two") + function test_Two() + end function + end class + end namespace + `); assertSuite(ts, 1); assertGroupCount(ts, 0, 2); expect(ts.isSolo).to.be.false; @@ -422,23 +429,24 @@ end namespace }); it('two tests', () => { - let ts = createTestSuite('test1.bs', `namespace Tests - @suite("Rooibos assertion tests") - class AssertionTests extends rooibos.BaseTestSuite - @describe("group1") - - @only - @it("one") - function test_one() - end function - - @only - @it("two") - function test_Two() - end function - end class - end namespace - `); + let ts = createTestSuite('test1.bs', ` + namespace Tests + @suite("Rooibos assertion tests") + class AssertionTests extends rooibos.BaseTestSuite + @describe("group1") + + @only + @it("one") + function test_one() + end function + + @only + @it("two") + function test_Two() + end function + end class + end namespace + `); assertSuite(ts, 1); assertGroupCount(ts, 0, 2); expect(ts.isSolo).to.be.false; @@ -449,24 +457,25 @@ end namespace expect(ts.hasSoloGroups).to.be.false; }); it('two tests and group', () => { - let ts = createTestSuite('test1.bs', `namespace Tests - @suite("Rooibos assertion tests") - class AssertionTests extends rooibos.BaseTestSuite - @only - @describe("group1") - - @only - @it("one") - function test_one() - end function - - @only - @it("two") - function test_Two() - end function - end class - end namespace - `); + let ts = createTestSuite('test1.bs', ` + namespace Tests + @suite("Rooibos assertion tests") + class AssertionTests extends rooibos.BaseTestSuite + @only + @describe("group1") + + @only + @it("one") + function test_one() + end function + + @only + @it("two") + function test_Two() + end function + end class + end namespace + `); assertSuite(ts, 1); assertGroupCount(ts, 0, 2); expect(ts.isSolo).to.be.false; @@ -477,25 +486,26 @@ end namespace expect(ts.hasSoloGroups).to.be.true; }); it('all', () => { - let ts = createTestSuite('test1.bs', `namespace Tests - @only - @suite("Rooibos assertion tests") - class AssertionTests extends rooibos.BaseTestSuite - @only - @describe("group1") - - @only - @it("one") - function test_one() - end function - - @only - @it("two") - function test_Two() - end function - end class - end namespace - `); + let ts = createTestSuite('test1.bs', ` + namespace Tests + @only + @suite("Rooibos assertion tests") + class AssertionTests extends rooibos.BaseTestSuite + @only + @describe("group1") + + @only + @it("one") + function test_one() + end function + + @only + @it("two") + function test_Two() + end function + end class + end namespace + `); assertSuite(ts, 1); assertGroupCount(ts, 0, 2); expect(ts.isSolo).to.be.true; @@ -506,30 +516,31 @@ end namespace expect(ts.hasSoloGroups).to.be.true; }); it('two groups', () => { - let ts = createTestSuite('test1.bs', `namespace Tests - @only - @suite("Rooibos assertion tests") - class AssertionTests extends rooibos.BaseTestSuite - @only - @describe("group1") - - @only - @it("one") - function test_one() - end function - - @only - @it("two") - function test_Two() - end function - @describe("group2") - - @it("one") - function test_g2_one() - end function - end class - end namespace - `); + let ts = createTestSuite('test1.bs', ` + namespace Tests + @only + @suite("Rooibos assertion tests") + class AssertionTests extends rooibos.BaseTestSuite + @only + @describe("group1") + + @only + @it("one") + function test_one() + end function + + @only + @it("two") + function test_Two() + end function + @describe("group2") + + @it("one") + function test_g2_one() + end function + end class + end namespace + `); assertSuite(ts, 2); assertGroupCount(ts, 0, 2); expect(ts.isSolo).to.be.true; @@ -543,30 +554,31 @@ end namespace expect(ts.hasSoloGroups).to.be.true; }); it('mixup', () => { - let ts = createTestSuite('test1.bs', `namespace Tests - @only - @suite("Rooibos assertion tests") - class AssertionTests extends rooibos.BaseTestSuite - @only - @describe("group1") - - @it("one") - function test_one() - end function - - @only - @it("two") - function test_Two() - end function - @describe("group2") - - @only - @it("one") - function test_g2_one() - end function - end class - end namespace - `); + let ts = createTestSuite('test1.bs', ` + namespace Tests + @only + @suite("Rooibos assertion tests") + class AssertionTests extends rooibos.BaseTestSuite + @only + @describe("group1") + + @it("one") + function test_one() + end function + + @only + @it("two") + function test_Two() + end function + @describe("group2") + + @only + @it("one") + function test_g2_one() + end function + end class + end namespace + `); assertSuite(ts, 2); assertGroupCount(ts, 0, 2); expect(ts.isSolo).to.be.true; @@ -580,25 +592,26 @@ end namespace expect(ts.hasSoloGroups).to.be.true; }); it('only on param block', () => { - let ts = createTestSuite('test1.bs', `namespace Tests - @suite("Rooibos assertion tests") - class AssertionTests extends rooibos.BaseTestSuite - @describe("group1") - - @Only - @it("one") - @params("1") - @params("2") - @params("3") - function test_one(value) - end function - - @it("two") - function test_Two() - end function - end class - end namespace - `); + let ts = createTestSuite('test1.bs', ` + namespace Tests + @suite("Rooibos assertion tests") + class AssertionTests extends rooibos.BaseTestSuite + @describe("group1") + + @Only + @it("one") + @params("1") + @params("2") + @params("3") + function test_one(value) + end function + + @it("two") + function test_Two() + end function + end class + end namespace + `); assertSuite(ts, 1); assertGroupCount(ts, 0, 4); expect(ts.isSolo).to.be.false; @@ -613,24 +626,25 @@ end namespace }); it('onlyparams', () => { - let ts = createTestSuite('test1.bs', `namespace Tests - @suite("Rooibos assertion tests") - class AssertionTests extends rooibos.BaseTestSuite - @describe("group1") - - @it("one") - @params("1") - @onlyParams("2") - @params("3") - function test_one(value) - end function - - @it("two") - function test_Two() - end function - end class - end namespace - `); + let ts = createTestSuite('test1.bs', ` + namespace Tests + @suite("Rooibos assertion tests") + class AssertionTests extends rooibos.BaseTestSuite + @describe("group1") + + @it("one") + @params("1") + @onlyParams("2") + @params("3") + function test_one(value) + end function + + @it("two") + function test_Two() + end function + end class + end namespace + `); assertSuite(ts, 1); assertGroupCount(ts, 0, 4); expect(ts.isSolo).to.be.false; @@ -645,24 +659,25 @@ end namespace }); it('onlyparams 2', () => { - let ts = createTestSuite('test1.bs', `namespace Tests - @suite("Rooibos assertion tests") - class AssertionTests extends rooibos.BaseTestSuite - @describe("group1") - - @it("one") - @onlyParams("1") - @params("2") - @onlyParams("3") - function test_one(value) - end function - - @it("two") - function test_Two() - end function - end class - end namespace - `); + let ts = createTestSuite('test1.bs', ` + namespace Tests + @suite("Rooibos assertion tests") + class AssertionTests extends rooibos.BaseTestSuite + @describe("group1") + + @it("one") + @onlyParams("1") + @params("2") + @onlyParams("3") + function test_one(value) + end function + + @it("two") + function test_Two() + end function + end class + end namespace + `); assertSuite(ts, 1); assertGroupCount(ts, 0, 4); expect(ts.isSolo).to.be.false; @@ -680,22 +695,23 @@ end namespace describe('ignore tags', () => { it('ignore suite', () => { - let ts = createTestSuite('test1.bs', `namespace Tests - @ignore - @suite("Rooibos assertion tests") - class AssertionTests extends rooibos.BaseTestSuite - @describe("group1") - - @it("one") - function test_one() - end function - - @it("two") - function test_Two() - end function - end class - end namespace - `); + let ts = createTestSuite('test1.bs', ` + namespace Tests + @ignore + @suite("Rooibos assertion tests") + class AssertionTests extends rooibos.BaseTestSuite + @describe("group1") + + @it("one") + function test_one() + end function + + @it("two") + function test_Two() + end function + end class + end namespace + `); assertSuite(ts, 1); assertGroupCount(ts, 0, 2); expect(ts.isIgnored).to.be.true; @@ -706,22 +722,23 @@ end namespace }); it('ignore group', () => { - let ts = createTestSuite('test1.bs', `namespace Tests - @suite("Rooibos assertion tests") - class AssertionTests extends rooibos.BaseTestSuite - @ignore - @describe("group1") - - @it("one") - function test_one() - end function - - @it("two") - function test_Two() - end function - end class - end namespace - `); + let ts = createTestSuite('test1.bs', ` + namespace Tests + @suite("Rooibos assertion tests") + class AssertionTests extends rooibos.BaseTestSuite + @ignore + @describe("group1") + + @it("one") + function test_one() + end function + + @it("two") + function test_Two() + end function + end class + end namespace + `); assertSuite(ts, 1); assertGroupCount(ts, 0, 2); expect(ts.isIgnored).to.be.false; @@ -731,22 +748,23 @@ end namespace expect(ts.hasIgnoredTests).to.be.false; }); it('ignore test', () => { - let ts = createTestSuite('test1.bs', `namespace Tests - @suite("Rooibos assertion tests") - class AssertionTests extends rooibos.BaseTestSuite - @describe("group1") - - @ignore - @it("one") - function test_one() - end function - - @it("two") - function test_Two() - end function - end class - end namespace - `); + let ts = createTestSuite('test1.bs', ` + namespace Tests + @suite("Rooibos assertion tests") + class AssertionTests extends rooibos.BaseTestSuite + @describe("group1") + + @ignore + @it("one") + function test_one() + end function + + @it("two") + function test_Two() + end function + end class + end namespace + `); assertSuite(ts, 1); assertGroupCount(ts, 0, 2); expect(ts.isIgnored).to.be.false; @@ -758,23 +776,24 @@ end namespace }); it('two tests', () => { - let ts = createTestSuite('test1.bs', `namespace Tests - @suite("Rooibos assertion tests") - class AssertionTests extends rooibos.BaseTestSuite - @describe("group1") - - @ignore - @it("one") - function test_one() - end function - - @ignore - @it("two") - function test_Two() - end function - end class - end namespace - `); + let ts = createTestSuite('test1.bs', ` + namespace Tests + @suite("Rooibos assertion tests") + class AssertionTests extends rooibos.BaseTestSuite + @describe("group1") + + @ignore + @it("one") + function test_one() + end function + + @ignore + @it("two") + function test_Two() + end function + end class + end namespace + `); assertSuite(ts, 1); assertGroupCount(ts, 0, 2); expect(ts.isIgnored).to.be.false; @@ -785,24 +804,25 @@ end namespace expect(ts.hasIgnoredTests).to.be.true; }); it('two tests and group', () => { - let ts = createTestSuite('test1.bs', `namespace Tests - @suite("Rooibos assertion tests") - class AssertionTests extends rooibos.BaseTestSuite - @ignore - @describe("group1") - - @ignore - @it("one") - function test_one() - end function - - @ignore - @it("two") - function test_Two() - end function - end class - end namespace - `); + let ts = createTestSuite('test1.bs', ` + namespace Tests + @suite("Rooibos assertion tests") + class AssertionTests extends rooibos.BaseTestSuite + @ignore + @describe("group1") + + @ignore + @it("one") + function test_one() + end function + + @ignore + @it("two") + function test_Two() + end function + end class + end namespace + `); assertSuite(ts, 1); assertGroupCount(ts, 0, 2); expect(ts.isIgnored).to.be.false; @@ -813,25 +833,26 @@ end namespace expect(ts.hasIgnoredTests).to.be.true; }); it('all', () => { - let ts = createTestSuite('test1.bs', `namespace Tests - @ignore - @suite("Rooibos assertion tests") - class AssertionTests extends rooibos.BaseTestSuite - @ignore - @describe("group1") - - @ignore - @it("one") - function test_one() - end function - - @ignore - @it("two") - function test_Two() - end function - end class - end namespace - `); + let ts = createTestSuite('test1.bs', ` + namespace Tests + @ignore + @suite("Rooibos assertion tests") + class AssertionTests extends rooibos.BaseTestSuite + @ignore + @describe("group1") + + @ignore + @it("one") + function test_one() + end function + + @ignore + @it("two") + function test_Two() + end function + end class + end namespace + `); assertSuite(ts, 1); assertGroupCount(ts, 0, 2); expect(ts.isIgnored).to.be.true; @@ -843,30 +864,31 @@ end namespace expect(ts.hasIgnoredTests).to.be.true; }); it('two groups', () => { - let ts = createTestSuite('test1.bs', `namespace Tests - @ignore - @suite("Rooibos assertion tests") - class AssertionTests extends rooibos.BaseTestSuite - @ignore - @describe("group1") - - @ignore - @it("one") - function test_one() - end function - - @ignore - @it("two") - function test_Two() - end function - @describe("group2") - - @it("one") - function test_g2_one() - end function - end class - end namespace - `); + let ts = createTestSuite('test1.bs', ` + namespace Tests + @ignore + @suite("Rooibos assertion tests") + class AssertionTests extends rooibos.BaseTestSuite + @ignore + @describe("group1") + + @ignore + @it("one") + function test_one() + end function + + @ignore + @it("two") + function test_Two() + end function + @describe("group2") + + @it("one") + function test_g2_one() + end function + end class + end namespace + `); assertSuite(ts, 2); assertGroupCount(ts, 0, 2); expect(ts.isIgnored).to.be.true; @@ -882,30 +904,31 @@ end namespace expect(ts.hasIgnoredTests).to.be.true; }); it('mixup', () => { - let ts = createTestSuite('test1.bs', `namespace Tests - @ignore - @suite("Rooibos assertion tests") - class AssertionTests extends rooibos.BaseTestSuite - @ignore - @describe("group1") - - @it("one") - function test_one() - end function - - @ignore - @it("two") - function test_Two() - end function - @describe("group2") - - @ignore - @it("one") - function test_g2_one() - end function - end class - end namespace - `); + let ts = createTestSuite('test1.bs', ` + namespace Tests + @ignore + @suite("Rooibos assertion tests") + class AssertionTests extends rooibos.BaseTestSuite + @ignore + @describe("group1") + + @it("one") + function test_one() + end function + + @ignore + @it("two") + function test_Two() + end function + @describe("group2") + + @ignore + @it("one") + function test_g2_one() + end function + end class + end namespace + `); assertSuite(ts, 2); assertGroupCount(ts, 0, 2); expect(ts.isIgnored).to.be.true; @@ -921,25 +944,26 @@ end namespace expect(ts.hasIgnoredTests).to.be.true; }); it('ignore on param block', () => { - let ts = createTestSuite('test1.bs', `namespace Tests - @suite("Rooibos assertion tests") - class AssertionTests extends rooibos.BaseTestSuite - @describe("group1") - - @ignore - @it("one") - @params("1") - @params("2") - @params("3") - function test_one(value) - end function - - @it("two") - function test_Two() - end function - end class - end namespace - `); + let ts = createTestSuite('test1.bs', ` + namespace Tests + @suite("Rooibos assertion tests") + class AssertionTests extends rooibos.BaseTestSuite + @describe("group1") + + @ignore + @it("one") + @params("1") + @params("2") + @params("3") + function test_one(value) + end function + + @it("two") + function test_Two() + end function + end class + end namespace + `); assertSuite(ts, 1); assertGroupCount(ts, 0, 4); expect(ts.isIgnored).to.be.false; @@ -954,24 +978,25 @@ end namespace }); it('ignoreParams', () => { - let ts = createTestSuite('test1.bs', `namespace Tests - @suite("Rooibos assertion tests") - class AssertionTests extends rooibos.BaseTestSuite - @describe("group1") - - @it("one") - @params("1") - @ignoreParams("2") - @params("3") - function test_one(value) - end function - - @it("two") - function test_Two() - end function - end class - end namespace - `); + let ts = createTestSuite('test1.bs', ` + namespace Tests + @suite("Rooibos assertion tests") + class AssertionTests extends rooibos.BaseTestSuite + @describe("group1") + + @it("one") + @params("1") + @ignoreParams("2") + @params("3") + function test_one(value) + end function + + @it("two") + function test_Two() + end function + end class + end namespace + `); assertSuite(ts, 1); assertGroupCount(ts, 0, 4); expect(ts.isIgnored).to.be.false; @@ -986,24 +1011,25 @@ end namespace }); it('ignoreParams 2', () => { - let ts = createTestSuite('test1.bs', `namespace Tests - @suite("Rooibos assertion tests") - class AssertionTests extends rooibos.BaseTestSuite - @describe("group1") - - @it("one") - @ignoreParams("1") - @params("2") - @ignoreParams("3") - function test_one(value) - end function - - @it("two") - function test_Two() - end function - end class - end namespace - `); + let ts = createTestSuite('test1.bs', ` + namespace Tests + @suite("Rooibos assertion tests") + class AssertionTests extends rooibos.BaseTestSuite + @describe("group1") + + @it("one") + @ignoreParams("1") + @params("2") + @ignoreParams("3") + function test_one(value) + end function + + @it("two") + function test_Two() + end function + end class + end namespace + `); assertSuite(ts, 1); assertGroupCount(ts, 0, 4); expect(ts.isIgnored).to.be.false; @@ -1021,128 +1047,135 @@ end namespace describe('params', () => { it('simple params', () => { - let ts = createTestSuite('test1.bs', `namespace Tests - @suite("Rooibos assertion tests") - class AssertionTests extends rooibos.BaseTestSuite - @describe("group1") - - @it("one") - @params("1") - @params("2") - @params("3") - function test_one(value) - end function - end class - end namespace - `); + let ts = createTestSuite('test1.bs', ` + namespace Tests + @suite("Rooibos assertion tests") + class AssertionTests extends rooibos.BaseTestSuite + @describe("group1") + + @it("one") + @params("1") + @params("2") + @params("3") + function test_one(value) + end function + end class + end namespace + `); assertSuite(ts, 1); assertGroupCount(ts, 0, 3); }); it('2 params', () => { - let ts = createTestSuite('test1.bs', `namespace Tests - @suite("Rooibos assertion tests") - class AssertionTests extends rooibos.BaseTestSuite - @describe("group1") - - @it("one") - @params("1", true) - @params("2", false) - @params("3", true) - function test_one(value, arg2) - end function - end class - end namespace - `); + let ts = createTestSuite('test1.bs', ` + namespace Tests + @suite("Rooibos assertion tests") + class AssertionTests extends rooibos.BaseTestSuite + @describe("group1") + + @it("one") + @params("1", true) + @params("2", false) + @params("3", true) + function test_one(value, arg2) + end function + end class + end namespace + `); assertSuite(ts, 1); assertGroupCount(ts, 0, 3); }); }); it('2 with url and chars', () => { - let ts = createTestSuite('test1.bs', `namespace Tests - @suite("Rooibos assertion tests") - class AssertionTests extends rooibos.BaseTestSuite - @describe("group1") - - @it("one") - @params("http://google.com/thing", true) - @params("#'_!!@#%", false) - @params("3", true) - function test_one(value, arg2) - end function - end class - end namespace - `); + let ts = createTestSuite('test1.bs', ` + namespace Tests + @suite("Rooibos assertion tests") + class AssertionTests extends rooibos.BaseTestSuite + @describe("group1") + + @it("one") + @params("http://google.com/thing", true) + @params("#'_!!@#%", false) + @params("3", true) + function test_one(value, arg2) + end function + end class + end namespace + `); assertSuite(ts, 1); assertGroupCount(ts, 0, 3); }); it('param mismatch -no params', () => { - let ts = createTestSuite('test1.bs', `namespace Tests - @suite("Rooibos assertion tests") - class AssertionTests extends rooibos.BaseTestSuite - @describe("group1") - - @it("one") - function test_one(value, arg2) - end function - end class - end namespace - `); + let ts = createTestSuite('test1.bs', ` + namespace Tests + @suite("Rooibos assertion tests") + class AssertionTests extends rooibos.BaseTestSuite + @describe("group1") + + @it("one") + function test_one(value, arg2) + end function + end class + end namespace + `); assertSuiteError(ts); }); it('param mismatch -one', () => { - let ts = createTestSuite('test1.bs', `namespace Tests - @suite("Rooibos assertion tests") - class AssertionTests extends rooibos.BaseTestSuite - @describe("group1") - - @it("one") - @params("http://google.com/thing") - @params("#'_!!@#%", false) - @params("3", true) - function test_one(value, arg2) - end function - end class - end namespace - `); + let ts = createTestSuite('test1.bs', ` + namespace Tests + @suite("Rooibos assertion tests") + class AssertionTests extends rooibos.BaseTestSuite + @describe("group1") + + @it("one") + @params("http://google.com/thing") + @params("#'_!!@#%", false) + @params("3", true) + function test_one(value, arg2) + end function + end class + end namespace + `); assertSuiteError(ts); }); it('param mismatch -all', () => { - let ts = createTestSuite('test1.bs', `namespace Tests - @suite("Rooibos assertion tests") - class AssertionTests extends rooibos.BaseTestSuite - @describe("group1") - - @it("one") - @params("http://google.com/thing", true) - @params("#'_!!@#%", false) - @params("3", true) - function test_one(value) - end function - end class - end namespace - `); + let ts = createTestSuite('test1.bs', ` + namespace Tests + @suite("Rooibos assertion tests") + class AssertionTests extends rooibos.BaseTestSuite + @describe("group1") + + @it("one") + @params("http://google.com/thing", true) + @params("#'_!!@#%", false) + @params("3", true) + function test_one(value) + end function + end class + end namespace + `); assertSuiteError(ts); }); it('cannot parse', () => { - let ts = createTestSuite('test1.bs', `namespace Tests - @suite("Rooibos assertion tests") - class AssertionTests extends rooibos.BaseTestSuite - @describe("group1") - - @it("one") - @params("http://google.com/thing", true ") - @params("#'_!!@#%", false) - @params("3", true) - function test_one(value, value) - end function - end class - end namespace - `); + let ts = createTestSuite('test1.bs', ` + namespace Tests + @suite("Rooibos assertion tests") + class AssertionTests extends rooibos.BaseTestSuite + @describe("group1") + + @it("one") + @params("http://google.com/thing", true ") + @params("#'_!!@#%", false) + @params("3", true) + function test_one(value, value) + end function + end class + end namespace + `); assertSuiteError(ts); }); }); @@ -1159,12 +1192,12 @@ function assertSuiteError(testSuite: TestSuite) { } function assertGroupCount(testSuite: TestSuite, groupIndex: number, expectedTests: number) { - expect(testSuite.getTestGroups()[groupIndex].getTestCases()).to.have.lengthOf(expectedTests); + expect(testSuite.getTestGroups()[groupIndex].testCases).to.have.lengthOf(expectedTests); } function getTestCase(testSuite: TestSuite, groupIndex: number, testIndex: number): TestCase { let group = testSuite.getTestGroups()[groupIndex]; - return group.getTestCases()[testIndex]; + return group.testCases[testIndex]; } function getGroup(testSuite: TestSuite, groupIndex: number): TestGroup { diff --git a/bsc-plugin/src/lib/rooibos/TestSuiteBuilder.ts b/bsc-plugin/src/lib/rooibos/TestSuiteBuilder.ts index 846ffee2..9ed1dcf1 100644 --- a/bsc-plugin/src/lib/rooibos/TestSuiteBuilder.ts +++ b/bsc-plugin/src/lib/rooibos/TestSuiteBuilder.ts @@ -15,13 +15,13 @@ import { RooibosAnnotation, AnnotationType } from './Annotation'; import { TestCase } from './TestCase'; import { TestSuite } from './TestSuite'; +import * as crypto from 'crypto'; + import { diagnosticDuplicateSuite, diagnosticErrorProcessingFile, diagnosticGroupWithNameAlreadyDefined, - // diagnosticIncompatibleAnnotation, diagnosticNoGroup, - diagnosticTestWithNameAlreadyDefined, diagnosticWrongAnnotation, diagnosticWrongParameterCount, diagnosticWrongTestParameterCount, @@ -110,7 +110,7 @@ export class TestSuiteBuilder { } if (this.currentGroup) { this.testSuite.addGroup(this.currentGroup); - if (this.currentGroup.testCases.size === 0) { + if (this.currentGroup.testCases.length === 0) { diagnosticEmptyGroup(this.file, this.currentGroup.annotation); } } @@ -185,23 +185,18 @@ export class TestSuiteBuilder { } } - private sanitizeFunctionName(name: string) { - if (/^\d/.test(name)) { - name = '_' + name; - } - return name.replace(/[^0-9_a-z]/ig, '_'); + private createTestCaseFunctionName() { + const md5sum = crypto.createHash('md5'); + md5sum.update(this.testSuite.name + this.file.pkgPath.replace(/[\/\\]+/g, '/')); + return `rooiboos_test_case_${md5sum.digest('hex')}_${this.testSuite.registeredTestCount++}`; } + public createTestCases(statement: ClassMethodStatement, annotation: RooibosAnnotation): boolean { const lineNumber = statement.func.range.start.line; const numberOfArgs = statement.func.parameters.length; const numberOfParams = annotation.params.length; - if (this.currentGroup.testCases.has(annotation.name) || this.currentGroup.testCases.get(annotation.name + '0')?.paramLineNumber) { - diagnosticTestWithNameAlreadyDefined(annotation); - - return false; - } - let sanitizedTestName = this.sanitizeFunctionName(this.currentGroup.name) + '_' + this.sanitizeFunctionName(annotation.name); + const sanitizedTestName = this.createTestCaseFunctionName(); statement.name.text = sanitizedTestName; statement.func.functionStatement.name.text = sanitizedTestName; diff --git a/bsc-plugin/src/lib/rooibos/Utils.ts b/bsc-plugin/src/lib/rooibos/Utils.ts index 7b3d788e..5697aab8 100644 --- a/bsc-plugin/src/lib/rooibos/Utils.ts +++ b/bsc-plugin/src/lib/rooibos/Utils.ts @@ -3,6 +3,7 @@ import { TokenKind, isXmlScope } from 'brighterscript'; import * as brighterscript from 'brighterscript'; import { diagnosticCorruptTestProduced } from '../utils/Diagnostics'; import type { TestSuite } from './TestSuite'; +import * as path from 'path'; export function addOverriddenMethod(file: BrsFile, annotation: AnnotationExpression, target: ClassStatement, name: string, source: string, editor: AstEditor): boolean { let functionSource = ` diff --git a/bsc-plugin/src/lib/utils/Diagnostics.ts b/bsc-plugin/src/lib/utils/Diagnostics.ts index 4b5db9b0..9ecfd36b 100644 --- a/bsc-plugin/src/lib/utils/Diagnostics.ts +++ b/bsc-plugin/src/lib/utils/Diagnostics.ts @@ -157,14 +157,14 @@ export function diagnosticGroupWithNameAlreadyDefined(file: BrsFile, annotation: ); } -export function diagnosticTestWithNameAlreadyDefined(annotation: RooibosAnnotation) { - addDiagnosticForAnnotation( - annotation.file, - 2210, - `Test with name ${annotation.name}, is already declared in this group. Ignoring`, - annotation.annotation - ); -} +// export function diagnosticTestWithNameAlreadyDefined(annotation: RooibosAnnotation) { +// addDiagnosticForAnnotation( +// annotation.file, +// 2210, +// `Test with name ${annotation.name}, is already declared in this group. Ignoring`, +// annotation.annotation +// ); +// } export function diagnosticIncompatibleAnnotation(annotation: RooibosAnnotation) { addDiagnosticForAnnotation( diff --git a/bsc-plugin/src/plugin.spec.ts b/bsc-plugin/src/plugin.spec.ts index ba70c304..d54f2fcf 100644 --- a/bsc-plugin/src/plugin.spec.ts +++ b/bsc-plugin/src/plugin.spec.ts @@ -251,7 +251,7 @@ describe('RooibosPlugin', () => { let suiteOneGroups = [...suiteOne.testGroups.values()]; let suiteOneTests = []; for (let group of suiteOneGroups) { - suiteOneTests.push(...group.testCases.values()); + suiteOneTests.push(...group.testCases); } expect(suiteOne.name).to.equal('named1'); expect(suiteOneGroups).to.be.length(2); @@ -266,7 +266,7 @@ describe('RooibosPlugin', () => { let suiteTwoGroups = [...suiteTwo.testGroups.values()]; let suiteTwoTests = []; for (let group of suiteTwoGroups) { - suiteTwoTests.push(...group.testCases.values()); + suiteTwoTests.push(...group.testCases); } expect(suiteTwo.name).to.equal('named2'); expect(suiteTwoGroups).to.be.length(2); @@ -281,7 +281,7 @@ describe('RooibosPlugin', () => { let suiteThreeGroups = [...suiteThree.testGroups.values()]; let suiteThreeTests = []; for (let group of suiteThreeGroups) { - suiteThreeTests.push(...group.testCases.values()); + suiteThreeTests.push(...group.testCases); } expect(suiteThree.name).to.equal('named3'); expect(suiteThreeGroups).to.be.length(2); @@ -296,7 +296,7 @@ describe('RooibosPlugin', () => { let suiteFourGroups = [...suiteFour.testGroups.values()]; let suiteFourTests = []; for (let group of suiteFourGroups) { - suiteFourTests.push(...group.testCases.values()); + suiteFourTests.push(...group.testCases); } expect(suiteFour.name).to.equal('named4'); expect(suiteFourGroups).to.be.length(2); @@ -311,7 +311,7 @@ describe('RooibosPlugin', () => { let suiteFiveGroups = [...suiteFive.testGroups.values()]; let suiteFiveTests = []; for (let group of suiteFiveGroups) { - suiteFiveTests.push(...group.testCases.values()); + suiteFiveTests.push(...group.testCases); } expect(suiteFive.name).to.equal('named5'); expect(suiteFiveGroups).to.be.length(1); @@ -344,15 +344,15 @@ describe('RooibosPlugin', () => { expect(suite.name).to.equal('ATest'); expect(suite.isAsync).to.be.true; expect(suite.asyncTimeout).to.equal(60000); - let test = suite.testGroups.get('groupA').testCases.get('is test1'); + let test = suite.testGroups.get('groupA').testCases[0]; expect(test.isAsync).to.be.true; expect(test.asyncTimeout).to.equal(2000); }); it('finds a @async and applies timeout override', () => { program.setFile('source/test.spec.bs', ` - @async(1) - @suite("named") + @async(1) + @suite("named") class ATest @describe("groupA") @@ -370,7 +370,7 @@ describe('RooibosPlugin', () => { expect(suite.name).to.equal('named'); expect(suite.isAsync).to.be.true; expect(suite.asyncTimeout).to.equal(1); - let test = suite.testGroups.get('groupA').testCases.get('is test1'); + let test = suite.testGroups.get('groupA').testCases[0]; expect(test.isAsync).to.be.true; expect(test.asyncTimeout).to.equal(2); }); @@ -395,7 +395,7 @@ describe('RooibosPlugin', () => { expect(plugin.session.sessionInfo.testsCount).to.equal(1); expect([...plugin.session.sessionInfo.testSuites.entries()][0][1].isIgnored).to.equal(true); expect([...[...plugin.session.sessionInfo.testSuites.entries()][0][1].testGroups.entries()][0][1].isIgnored).to.equal(true); - expect([...[...[...plugin.session.sessionInfo.testSuites.entries()][0][1].testGroups.entries()][0][1].testCases.entries()][0][1].isIgnored).to.equal(true); + expect([...[...plugin.session.sessionInfo.testSuites.entries()][0][1].testGroups.entries()][0][1].testCases[0].isIgnored).to.equal(true); }); it('ignores a group', () => { @@ -418,7 +418,7 @@ describe('RooibosPlugin', () => { expect(plugin.session.sessionInfo.testsCount).to.equal(1); expect([...plugin.session.sessionInfo.testSuites.entries()][0][1].isIgnored).to.equal(false); expect([...[...plugin.session.sessionInfo.testSuites.entries()][0][1].testGroups.entries()][0][1].isIgnored).to.equal(true); - expect([...[...[...plugin.session.sessionInfo.testSuites.entries()][0][1].testGroups.entries()][0][1].testCases.entries()][0][1].isIgnored).to.equal(true); + expect([...[...plugin.session.sessionInfo.testSuites.entries()][0][1].testGroups.entries()][0][1].testCases[0].isIgnored).to.equal(true); }); it('ignores a test', () => { @@ -442,7 +442,7 @@ describe('RooibosPlugin', () => { expect(plugin.session.sessionInfo.testsCount).to.equal(1); expect([...plugin.session.sessionInfo.testSuites.entries()][0][1].isIgnored).to.equal(false); expect([...[...plugin.session.sessionInfo.testSuites.entries()][0][1].testGroups.entries()][0][1].isIgnored).to.equal(false); - expect([...[...[...plugin.session.sessionInfo.testSuites.entries()][0][1].testGroups.entries()][0][1].testCases.entries()][0][1].isIgnored).to.equal(true); + expect([...[...plugin.session.sessionInfo.testSuites.entries()][0][1].testGroups.entries()][0][1].testCases[0].isIgnored).to.equal(true); }); it('multiple groups', () => { @@ -497,8 +497,15 @@ describe('RooibosPlugin', () => { end class `); program.validate(); - expect(program.getDiagnostics()).to.not.be.empty; - expect(plugin.session.sessionInfo.testSuitesToRun).to.be.empty; + + expect(program.getDiagnostics()).to.be.empty; + expect([...[...plugin.session.sessionInfo.testSuites.entries()][0][1].testGroups.entries()][0][1].testCases[0].funcName).to.equal('rooiboos_test_case_0d635a9477c4624180ef87bef352afd3_0'); + expect([...[...plugin.session.sessionInfo.testSuites.entries()][0][1].testGroups.entries()][0][1].testCases[0].name).to.equal('is test1'); + expect([...[...plugin.session.sessionInfo.testSuites.entries()][0][1].testGroups.entries()][1][1].testCases[0].funcName).to.equal('rooiboos_test_case_0d635a9477c4624180ef87bef352afd3_1'); + expect([...[...plugin.session.sessionInfo.testSuites.entries()][0][1].testGroups.entries()][1][1].testCases[0].name).to.equal('is test1'); + expect([...[...plugin.session.sessionInfo.testSuites.entries()][0][1].testGroups.entries()][1][1].testCases[1].funcName).to.equal('rooiboos_test_case_0d635a9477c4624180ef87bef352afd3_2'); + expect([...[...plugin.session.sessionInfo.testSuites.entries()][0][1].testGroups.entries()][1][1].testCases[1].name).to.equal('is test1'); + expect(plugin.session.sessionInfo.testSuitesToRun).to.be.length(1); }); it('empty test group', () => { @@ -637,7 +644,7 @@ describe('RooibosPlugin', () => { instance = {} instance.new = sub() end sub - instance.groupB_is_test1 = function() + instance.rooiboos_test_case_0d635a9477c4624180ef87bef352afd3_0 = function() number = 123 m.assertEqual("123", ("alpha-" + bslib_toString(number) + "-beta")) m.assertEqual(123, 123) @@ -715,7 +722,7 @@ describe('RooibosPlugin', () => { instance.new = sub() m.super0_new() end sub - instance.groupA_is_test1 = function() + instance.rooiboos_test_case_0d635a9477c4624180ef87bef352afd3_0 = function() m.currentAssertLineNumber = 8 m.assertEqual(1, 1) if m.currentResult?.isFail = true then @@ -739,7 +746,7 @@ describe('RooibosPlugin', () => { end if end if end function - instance.groupA_is_test2 = sub() + instance.rooiboos_test_case_0d635a9477c4624180ef87bef352afd3_1 = sub() m.currentAssertLineNumber = 18 m.assertEqual(1, 1) if m.currentResult?.isFail = true then @@ -804,7 +811,7 @@ describe('RooibosPlugin', () => { { isSolo: false noCatch: false - funcName: "groupA_is_test1" + funcName: "rooiboos_test_case_0d635a9477c4624180ef87bef352afd3_0" isIgnored: false isAsync: false asyncTimeout: 2000 @@ -822,7 +829,7 @@ describe('RooibosPlugin', () => { { isSolo: false noCatch: false - funcName: "groupA_is_test2" + funcName: "rooiboos_test_case_0d635a9477c4624180ef87bef352afd3_1" isIgnored: false isAsync: false asyncTimeout: 2000 @@ -897,7 +904,7 @@ describe('RooibosPlugin', () => { instance.new = sub() m.super0_new() end sub - instance._1groupA_is_test1 = function() + instance.rooiboos_test_case_0d635a9477c4624180ef87bef352afd3_0 = function() end function instance.super0_getTestSuiteData = instance.getTestSuiteData instance.getTestSuiteData = function() @@ -940,7 +947,7 @@ describe('RooibosPlugin', () => { { isSolo: false noCatch: false - funcName: "_1groupA_is_test1" + funcName: "rooiboos_test_case_0d635a9477c4624180ef87bef352afd3_0" isIgnored: false isAsync: false asyncTimeout: 2000 @@ -1439,9 +1446,9 @@ describe('RooibosPlugin', () => { end class `); program.setFile('source/code.bs', ` - function sayHello(firstName = "" as string, lastName = "" as string) - print firstName + " " + lastName - end function + function sayHello(firstName = "" as string, lastName = "" as string) + print firstName + " " + lastName + end function `); program.validate(); expect(program.getDiagnostics()).to.be.empty; @@ -1451,65 +1458,66 @@ describe('RooibosPlugin', () => { expect( testText ).to.eql(undent` - item = { - id: "item" - } - m.currentAssertLineNumber = 8 - m._expectCalled(sayHello, "sayHello", invalid, invalid, [ - "arg1" - "arg2" - ], "return") - if m.currentResult?.isFail = true then - m.done() - return invalid - end if - m.currentAssertLineNumber = 9 - m._expectCalled(sayHello, "sayHello", invalid, invalid, []) - if m.currentResult?.isFail = true then - m.done() - return invalid - end if - m.currentAssertLineNumber = 10 - m._expectCalled(sayHello, "sayHello", invalid, invalid, [], "return") - if m.currentResult?.isFail = true then - m.done() - return invalid - end if - m.currentAssertLineNumber = 11 - m._expectCalled(sayHello, "sayHello", invalid, invalid, [ - "arg1" - "arg2" - ]) - if m.currentResult?.isFail = true then - m.done() - return invalid - end if -`); + item = { + id: "item" + } + m.currentAssertLineNumber = 8 + m._expectCalled(sayHello, "sayHello", invalid, invalid, [ + "arg1" + "arg2" + ], "return") + if m.currentResult?.isFail = true then + m.done() + return invalid + end if + m.currentAssertLineNumber = 9 + m._expectCalled(sayHello, "sayHello", invalid, invalid, []) + if m.currentResult?.isFail = true then + m.done() + return invalid + end if + m.currentAssertLineNumber = 10 + m._expectCalled(sayHello, "sayHello", invalid, invalid, [], "return") + if m.currentResult?.isFail = true then + m.done() + return invalid + end if + m.currentAssertLineNumber = 11 + m._expectCalled(sayHello, "sayHello", invalid, invalid, [ + "arg1" + "arg2" + ]) + if m.currentResult?.isFail = true then + m.done() + return invalid + end if + `); let codeText = getContents('code.brs'); expect(codeText).to.equal(undent` - function sayHello(firstName = "", lastName = "") - __stubs_globalAa = getGlobalAa() - if RBS_SM_1_getMocksByFunctionName()["sayhello"] <> invalid - __stubOrMockResult = RBS_SM_1_getMocksByFunctionName()["sayhello"].callback(firstName, lastName) - return __stubOrMockResult - else if type(__stubs_globalAa?.__globalStubs?.sayhello).endsWith("Function") - __stubFunction = __stubs_globalAa.__globalStubs.sayhello - __stubOrMockResult = __stubFunction(firstName, lastName) - return __stubOrMockResult - else if __stubs_globalAa?.__globalStubs <> invalid and __stubs_globalAa.__globalStubs.doesExist("sayhello") - value = __stubs_globalAa.__globalStubs.sayhello - return value - end if - print firstName + " " + lastName - end function + function sayHello(firstName = "", lastName = "") + __stubs_globalAa = getGlobalAa() + if RBS_SM_1_getMocksByFunctionName()["sayhello"] <> invalid + __stubOrMockResult = RBS_SM_1_getMocksByFunctionName()["sayhello"].callback(firstName, lastName) + return __stubOrMockResult + else if type(__stubs_globalAa?.__globalStubs?.sayhello).endsWith("Function") + __stubFunction = __stubs_globalAa.__globalStubs.sayhello + __stubOrMockResult = __stubFunction(firstName, lastName) + return __stubOrMockResult + else if __stubs_globalAa?.__globalStubs <> invalid and __stubs_globalAa.__globalStubs.doesExist("sayhello") + value = __stubs_globalAa.__globalStubs.sayhello + return value + end if + print firstName + " " + lastName + end function - function RBS_SM_1_getMocksByFunctionName() - if m._rMocksByFunctionName = invalid - m._rMocksByFunctionName = {} - end if - return m._rMocksByFunctionName - end function`); + function RBS_SM_1_getMocksByFunctionName() + if m._rMocksByFunctionName = invalid + m._rMocksByFunctionName = {} + end if + return m._rMocksByFunctionName + end function + `); }); it('correctly transpiles namespaced function calls', async () => { plugin.config.isGlobalMethodMockingEnabled = true; @@ -1528,11 +1536,11 @@ describe('RooibosPlugin', () => { end class `); program.setFile('source/code.bs', ` - namespace utils - function sayHello(firstName = "" as string, lastName = "" as string) - print firstName + " " + lastName - end function - end namespace + namespace utils + function sayHello(firstName = "" as string, lastName = "" as string) + print firstName + " " + lastName + end function + end namespace `); program.validate(); expect(program.getDiagnostics()).to.be.empty; @@ -1579,29 +1587,29 @@ describe('RooibosPlugin', () => { let codeText = getContents('code.brs'); expect(codeText).to.equal(undent(` - function utils_sayHello(firstName = "", lastName = "") - __stubs_globalAa = getGlobalAa() - if RBS_SM_1_getMocksByFunctionName()["utils_sayhello"] <> invalid - __stubOrMockResult = RBS_SM_1_getMocksByFunctionName()["utils_sayhello"].callback(firstName, lastName) - return __stubOrMockResult - else if type(__stubs_globalAa?.__globalStubs?.utils_sayhello).endsWith("Function") - __stubFunction = __stubs_globalAa.__globalStubs.utils_sayhello - __stubOrMockResult = __stubFunction(firstName, lastName) - return __stubOrMockResult - else if __stubs_globalAa?.__globalStubs <> invalid and __stubs_globalAa.__globalStubs.doesExist("utils_sayhello") - value = __stubs_globalAa.__globalStubs.utils_sayhello - return value - end if - print firstName + " " + lastName - end function + function utils_sayHello(firstName = "", lastName = "") + __stubs_globalAa = getGlobalAa() + if RBS_SM_1_getMocksByFunctionName()["utils_sayhello"] <> invalid + __stubOrMockResult = RBS_SM_1_getMocksByFunctionName()["utils_sayhello"].callback(firstName, lastName) + return __stubOrMockResult + else if type(__stubs_globalAa?.__globalStubs?.utils_sayhello).endsWith("Function") + __stubFunction = __stubs_globalAa.__globalStubs.utils_sayhello + __stubOrMockResult = __stubFunction(firstName, lastName) + return __stubOrMockResult + else if __stubs_globalAa?.__globalStubs <> invalid and __stubs_globalAa.__globalStubs.doesExist("utils_sayhello") + value = __stubs_globalAa.__globalStubs.utils_sayhello + return value + end if + print firstName + " " + lastName + end function - function RBS_SM_1_getMocksByFunctionName() - if m._rMocksByFunctionName = invalid - m._rMocksByFunctionName = {} - end if - return m._rMocksByFunctionName - end function - `)); + function RBS_SM_1_getMocksByFunctionName() + if m._rMocksByFunctionName = invalid + m._rMocksByFunctionName = {} + end if + return m._rMocksByFunctionName + end function + `)); }); }); @@ -2277,7 +2285,8 @@ describe('RooibosPlugin', () => { if m.currentResult?.isFail = true then m.done() return invalid - end if `); + end if + `); }); it('correctly transpiles function invocations - simple object', async () => { @@ -2801,7 +2810,7 @@ function getTestFunctionContents() { function getTestSubContents() { const contents = getContents('test.spec.brs'); - const [, body] = /groupA_test1 \= sub\(\)([\S\s]*|.*)(?=end sub)/gim.exec(contents); + const [, body] = /rooiboos_test_case_[a-z0-9]+_\d+ \= sub\(\)([\S\s]*|.*)(?=end sub)/gim.exec(contents); let result = undent( body.split('end sub')[0] ); diff --git a/bsc-plugin/src/plugin.ts b/bsc-plugin/src/plugin.ts index 0685ade6..9b2d1321 100644 --- a/bsc-plugin/src/plugin.ts +++ b/bsc-plugin/src/plugin.ts @@ -175,7 +175,7 @@ export class RooibosPlugin implements CompilerPlugin { const modifiedTestCases = new Set(); testSuite.addDataFunctions(event.editor as any); for (let group of [...testSuite.testGroups.values()].filter((tg) => tg.isIncluded)) { - for (let testCase of [...group.testCases.values()].filter((tc) => tc.isIncluded)) { + for (let testCase of [...group.testCases].filter((tc) => tc.isIncluded)) { let caseName = group.testSuite.generatedNodeName + group.file.pkgPath + testCase.funcName; if (!modifiedTestCases.has(caseName)) { group.modifyAssertions(testCase, noEarlyExit, event.editor as any, this.session.namespaceLookup, scope);