Reset the env state between parallel batches

spec/core/SuiteBuilderSpec.js

@@ -175,4 +175,69 @@ describe('SuiteBuilder', function() {
       }
     };
   }
+
+  describe('#parallelReset', function() {
+    it('removes children of the top suite', function() {
+      const env = { configuration: () => ({}) };
+      const suiteBuilder = new jasmineUnderTest.SuiteBuilder({ env });
+      suiteBuilder.describe('a suite', function() {
+        suiteBuilder.it('a nested spec');
+      });
+      suiteBuilder.it('a spec');
+
+      suiteBuilder.parallelReset();
+
+      expect(suiteBuilder.topSuite.children).toEqual([]);
+    });
+
+    it('preserves top suite befores and afters', function() {
+      const env = { configuration: () => ({}) };
+      const suiteBuilder = new jasmineUnderTest.SuiteBuilder({ env });
+
+      function beforeAll() {}
+      function beforeEach() {}
+      function afterEach() {}
+      function afterAll() {}
+
+      suiteBuilder.beforeAll(beforeAll);
+      suiteBuilder.beforeEach(beforeEach);
+      suiteBuilder.afterEach(afterEach);
+      suiteBuilder.afterAll(afterAll);
+
+      suiteBuilder.parallelReset();
+
+      expect(suiteBuilder.topSuite.beforeAllFns).toEqual([
+        jasmine.objectContaining({ fn: beforeAll })
+      ]);
+      expect(suiteBuilder.topSuite.beforeFns).toEqual([
+        jasmine.objectContaining({ fn: beforeEach })
+      ]);
+      expect(suiteBuilder.topSuite.afterFns).toEqual([
+        jasmine.objectContaining({ fn: afterEach })
+      ]);
+      expect(suiteBuilder.topSuite.afterAllFns).toEqual([
+        jasmine.objectContaining({ fn: afterAll })
+      ]);
+    });
+
+    it('resets totalSpecsDefined', function() {
+      const env = { configuration: () => ({}) };
+      const suiteBuilder = new jasmineUnderTest.SuiteBuilder({ env });
+      suiteBuilder.it('a spec');
+
+      suiteBuilder.parallelReset();
+
+      expect(suiteBuilder.totalSpecsDefined).toEqual(0);
+    });
+
+    it('resets focusedRunables', function() {
+      const env = { configuration: () => ({}) };
+      const suiteBuilder = new jasmineUnderTest.SuiteBuilder({ env });
+      suiteBuilder.fit('a spec', function() {});
+
+      suiteBuilder.parallelReset();
+
+      expect(suiteBuilder.focusedRunables).toEqual([]);
+    });
+  });
 });

spec/core/integration/ParallelSpec.js

@@ -0,0 +1,104 @@
+describe('Support for parallel execution', function() {
+  let env;
+
+  beforeEach(function() {
+    env = new jasmineUnderTest.Env();
+  });
+
+  afterEach(function() {
+    env.cleanup_();
+  });
+
+  it('removes specs and suites from previous batches', async function() {
+    env.describe('a suite', function() {
+      env.it('a spec', function() {});
+    });
+    env.it('a spec', function() {});
+
+    await env.execute();
+    env.parallelReset();
+
+    env.describe('a suite in a new batch', function() {
+      env.it('a spec in a new batch', function() {});
+    });
+    const reporter = jasmine.createSpyObj('reporter', [
+      'suiteDone',
+      'specDone'
+    ]);
+    env.addReporter(reporter);
+
+    await env.execute();
+
+    expect(reporter.suiteDone).toHaveBeenCalledOnceWith(
+      jasmine.objectContaining({
+        fullName: 'a suite in a new batch'
+      })
+    );
+    expect(reporter.specDone).toHaveBeenCalledOnceWith(
+      jasmine.objectContaining({
+        fullName: 'a suite in a new batch a spec in a new batch'
+      })
+    );
+  });
+
+  it('preserves top-level before and after fns from previous batches', async function() {
+    const beforeAll = jasmine.createSpy('beforeAll');
+    const beforeEach = jasmine.createSpy('beforeEach');
+    const afterEach = jasmine.createSpy('afterEach');
+    const afterAll = jasmine.createSpy('afterAll');
+    env.beforeAll(beforeAll);
+    env.beforeEach(beforeEach);
+    env.afterEach(afterEach);
+    env.afterAll(afterAll);
+
+    env.parallelReset();
+    env.it('a spec', function() {});
+    await env.execute();
+
+    expect(beforeAll).toHaveBeenCalled();
+    expect(beforeEach).toHaveBeenCalled();
+    expect(afterEach).toHaveBeenCalled();
+    expect(afterAll).toHaveBeenCalled();
+  });
+
+  it('does not remember focused runables from previous batches', async function() {
+    env.fit('a focused spec', function() {});
+    env.parallelReset();
+    env.it('a spec', function() {});
+    const reporter = jasmine.createSpyObj('reporter', [
+      'specDone',
+      'jasmineDone'
+    ]);
+    env.addReporter(reporter);
+    await env.execute();
+
+    expect(reporter.specDone).toHaveBeenCalledOnceWith(
+      jasmine.objectContaining({
+        fullName: 'a spec',
+        status: 'passed'
+      })
+    );
+    expect(reporter.jasmineDone).toHaveBeenCalledWith(
+      jasmine.objectContaining({ overallStatus: 'passed' })
+    );
+  });
+
+  it('does not remember failures from previous batches', async function() {
+    env.it('a failing spec', function() {
+      env.expect(true).toBe(false);
+    });
+    await env.execute();
+    env.parallelReset();
+    env.it('a spec', function() {});
+    const reporter = jasmine.createSpyObj('reporter', [
+      'specDone',
+      'jasmineDone'
+    ]);
+    env.addReporter(reporter);
+    await env.execute();
+
+    expect(reporter.jasmineDone).toHaveBeenCalledWith(
+      jasmine.objectContaining({ overallStatus: 'passed' })
+    );
+  });
+});