From 852cd15ea0d99cf7fafc6ff2531290c87ca3371b Mon Sep 17 00:00:00 2001 From: Christopher Dwyer-Perkins Date: Thu, 20 Feb 2025 16:08:51 -0400 Subject: [PATCH 1/2] Cleaned up formatting --- .../src/lib/rooibos/TestSuiteBuilder.spec.ts | 1471 +++++++++-------- 1 file changed, 752 insertions(+), 719 deletions(-) diff --git a/bsc-plugin/src/lib/rooibos/TestSuiteBuilder.spec.ts b/bsc-plugin/src/lib/rooibos/TestSuiteBuilder.spec.ts index e662a73..ae2b145 100644 --- a/bsc-plugin/src/lib/rooibos/TestSuiteBuilder.spec.ts +++ b/bsc-plugin/src/lib/rooibos/TestSuiteBuilder.spec.ts @@ -36,133 +36,141 @@ 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 - `); + 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); }); @@ -170,74 +178,74 @@ describe('TestSuiteBuilder tests ', () => { 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); }); }); From 973d6f23c7304163fe35dc031cb64624217510d0 Mon Sep 17 00:00:00 2001 From: Christopher Dwyer-Perkins Date: Thu, 20 Feb 2025 16:14:50 -0400 Subject: [PATCH 2/2] more indentation clean up --- bsc-plugin/src/plugin.spec.ts | 178 +++++++++++++++++----------------- 1 file changed, 90 insertions(+), 88 deletions(-) diff --git a/bsc-plugin/src/plugin.spec.ts b/bsc-plugin/src/plugin.spec.ts index 462f8f5..d54f2fc 100644 --- a/bsc-plugin/src/plugin.spec.ts +++ b/bsc-plugin/src/plugin.spec.ts @@ -351,8 +351,8 @@ describe('RooibosPlugin', () => { 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") @@ -1446,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; @@ -1458,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; @@ -1535,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; @@ -1586,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 + `)); }); }); @@ -2284,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 () => {