pkgs/test_api/test/frontend/tear_down_all_test.dart

// Copyright (c) 2015, the Dart project authors.  Please see the AUTHORS file
// for details. All rights reserved. Use of this source code is governed by a
// BSD-style license that can be found in the LICENSE file.

import 'package:async/async.dart';
import 'package:test/test.dart';

import '../utils.dart';

void main() {
  test('runs once after all tests', () {
    return expectTestsPass(() {
      var test1Run = false;
      var test2Run = false;
      var tearDownAllRun = false;
      tearDownAll(() {
        expect(test1Run, isTrue);
        expect(test2Run, isTrue);
        expect(tearDownAllRun, isFalse);
        tearDownAllRun = true;
      });

      test('test 1', () {
        expect(tearDownAllRun, isFalse);
        test1Run = true;
      });

      test('test 2', () {
        expect(tearDownAllRun, isFalse);
        test2Run = true;
      });
    });
  });

  test('runs once per group, inside-out', () {
    return expectTestsPass(() {
      var tearDownAll1Run = false;
      var tearDownAll2Run = false;
      var tearDownAll3Run = false;
      var testRun = false;
      tearDownAll(() {
        expect(tearDownAll1Run, isFalse);
        expect(tearDownAll2Run, isTrue);
        expect(tearDownAll3Run, isTrue);
        expect(testRun, isTrue);
        tearDownAll1Run = true;
      });

      group('mid', () {
        tearDownAll(() {
          expect(tearDownAll1Run, isFalse);
          expect(tearDownAll2Run, isFalse);
          expect(tearDownAll3Run, isTrue);
          expect(testRun, isTrue);
          tearDownAll2Run = true;
        });

        group('inner', () {
          tearDownAll(() {
            expect(tearDownAll1Run, isFalse);
            expect(tearDownAll2Run, isFalse);
            expect(tearDownAll3Run, isFalse);
            expect(testRun, isTrue);
            tearDownAll3Run = true;
          });

          test('test', () {
            expect(tearDownAll1Run, isFalse);
            expect(tearDownAll2Run, isFalse);
            expect(tearDownAll3Run, isFalse);
            testRun = true;
          });
        });
      });
    });
  });

  test('runs after tearDowns', () {
    return expectTestsPass(() {
      var tearDown1Run = false;
      var tearDown2Run = false;
      var tearDownAllRun = false;
      tearDown(() {
        expect(tearDownAllRun, isFalse);
        tearDown1Run = true;
      });

      tearDownAll(() {
        expect(tearDown1Run, isTrue);
        expect(tearDown2Run, isTrue);
        expect(tearDownAllRun, isFalse);
        tearDownAllRun = true;
      });

      tearDown(() {
        expect(tearDownAllRun, isFalse);
        tearDown2Run = true;
      });

      test('test', () {
        expect(tearDownAllRun, isFalse);
      });
    });
  });

  test('multiples run in reverse order', () {
    return expectTestsPass(() {
      var tearDownAll1Run = false;
      var tearDownAll2Run = false;
      var tearDownAll3Run = false;
      tearDownAll(() {
        expect(tearDownAll1Run, isFalse);
        expect(tearDownAll2Run, isTrue);
        expect(tearDownAll3Run, isTrue);
        tearDownAll1Run = true;
      });

      tearDownAll(() {
        expect(tearDownAll1Run, isFalse);
        expect(tearDownAll2Run, isFalse);
        expect(tearDownAll3Run, isTrue);
        tearDownAll2Run = true;
      });

      tearDownAll(() {
        expect(tearDownAll1Run, isFalse);
        expect(tearDownAll2Run, isFalse);
        expect(tearDownAll3Run, isFalse);
        tearDownAll3Run = true;
      });

      test('test', () {
        expect(tearDownAll1Run, isFalse);
        expect(tearDownAll2Run, isFalse);
        expect(tearDownAll3Run, isFalse);
      });
    });
  });

  group('asynchronously', () {
    test('blocks additional tearDownAlls on in-band async', () {
      return expectTestsPass(() {
        var tearDownAll1Run = false;
        var tearDownAll2Run = false;
        var tearDownAll3Run = false;
        tearDownAll(() async {
          expect(tearDownAll1Run, isFalse);
          expect(tearDownAll2Run, isTrue);
          expect(tearDownAll3Run, isTrue);
          await pumpEventQueue();
          tearDownAll1Run = true;
        });

        tearDownAll(() async {
          expect(tearDownAll1Run, isFalse);
          expect(tearDownAll2Run, isFalse);
          expect(tearDownAll3Run, isTrue);
          await pumpEventQueue();
          tearDownAll2Run = true;
        });

        tearDownAll(() async {
          expect(tearDownAll1Run, isFalse);
          expect(tearDownAll2Run, isFalse);
          expect(tearDownAll3Run, isFalse);
          await pumpEventQueue();
          tearDownAll3Run = true;
        });

        test('test', () {
          expect(tearDownAll1Run, isFalse);
          expect(tearDownAll2Run, isFalse);
          expect(tearDownAll3Run, isFalse);
        });
      });
    });

    test("doesn't block additional tearDownAlls on out-of-band async", () {
      return expectTestsPass(() {
        var tearDownAll1Run = false;
        var tearDownAll2Run = false;
        var tearDownAll3Run = false;
        tearDownAll(() {
          expect(tearDownAll1Run, isFalse);
          expect(tearDownAll2Run, isFalse);
          expect(tearDownAll3Run, isFalse);

          expect(Future(() {
            tearDownAll1Run = true;
          }), completes);
        });

        tearDownAll(() {
          expect(tearDownAll1Run, isFalse);
          expect(tearDownAll2Run, isFalse);
          expect(tearDownAll3Run, isFalse);

          expect(Future(() {
            tearDownAll2Run = true;
          }), completes);
        });

        tearDownAll(() {
          expect(tearDownAll1Run, isFalse);
          expect(tearDownAll2Run, isFalse);
          expect(tearDownAll3Run, isFalse);

          expect(Future(() {
            tearDownAll3Run = true;
          }), completes);
        });

        test('test', () {
          expect(tearDownAll1Run, isFalse);
          expect(tearDownAll2Run, isFalse);
          expect(tearDownAll3Run, isFalse);
        });
      });
    });

    test('blocks further tests on in-band async', () {
      return expectTestsPass(() {
        var tearDownAllRun = false;
        group('group', () {
          tearDownAll(() async {
            expect(tearDownAllRun, isFalse);
            await pumpEventQueue();
            tearDownAllRun = true;
          });

          test('test', () {});
        });

        test('after', () {
          expect(tearDownAllRun, isTrue);
        });
      });
    });

    test('blocks further tests on out-of-band async', () {
      return expectTestsPass(() {
        var tearDownAllRun = false;
        group('group', () {
          tearDownAll(() async {
            expect(tearDownAllRun, isFalse);
            expect(
                pumpEventQueue().then((_) {
                  tearDownAllRun = true;
                }),
                completes);
          });

          test('test', () {});
        });

        test('after', () {
          expect(tearDownAllRun, isTrue);
        });
      });
    });
  });

  test("isn't run for a skipped group", () async {
    // Declare this in the outer test so if it runs, the outer test will fail.
    var shouldNotRun = expectAsync0(() {}, count: 0);

    var engine = declareEngine(() {
      group('skipped', () {
        tearDownAll(shouldNotRun);

        test('test', () {});
      }, skip: true);
    });

    await engine.run();
    expect(engine.liveTests, hasLength(1));
    expect(engine.skipped, hasLength(1));
    expect(engine.liveTests, equals(engine.skipped));
  });

  test('is emitted through Engine.onTestStarted', () async {
    var engine = declareEngine(() {
      tearDownAll(() {});

      test('test', () {});
    });

    var queue = StreamQueue(engine.onTestStarted);
    var liveTestFuture = queue.next;
    var tearDownAllFuture = queue.next;

    await engine.run();

    var tearDownAllLiveTest = await tearDownAllFuture;
    expect(tearDownAllLiveTest.test.name, equals('(tearDownAll)'));
    expectTestPassed(tearDownAllLiveTest);

    // The fake test for tearDownAll should be removed from the engine's live
    // test list so that reporters don't display it as a passed test.
    expect(engine.liveTests, isNot(contains(tearDownAllLiveTest)));
    expect(engine.passed, isNot(contains(tearDownAllLiveTest)));
    expect(engine.failed, isNot(contains(tearDownAllLiveTest)));
    expect(engine.skipped, isNot(contains(tearDownAllLiveTest)));
    expect(engine.active, isNot(contains(tearDownAllLiveTest)));

    var liveTest = await liveTestFuture;
    expectTestPassed(await liveTestFuture);
    expect(engine.liveTests, contains(liveTest));
    expect(engine.passed, contains(liveTest));
  });

  group('with an error', () {
    test('reports the error and remains in Engine.liveTests', () async {
      var engine = declareEngine(() {
        tearDownAll(() => throw TestFailure('fail'));

        test('test', () {});
      });

      var queue = StreamQueue(engine.onTestStarted);
      expect(queue.next, completes);
      var tearDownAllFuture = queue.next;

      expect(await engine.run(), isFalse);

      var tearDownAllLiveTest = await tearDownAllFuture;
      expect(tearDownAllLiveTest.test.name, equals('(tearDownAll)'));
      expectTestFailed(tearDownAllLiveTest, 'fail');

      // The fake test for tearDownAll should be removed from the engine's live
      // test list so that reporters don't display it as a passed test.
      expect(engine.liveTests, contains(tearDownAllLiveTest));
      expect(engine.failed, contains(tearDownAllLiveTest));
      expect(engine.passed, isNot(contains(tearDownAllLiveTest)));
      expect(engine.skipped, isNot(contains(tearDownAllLiveTest)));
      expect(engine.active, isNot(contains(tearDownAllLiveTest)));
    });

    test('runs further tearDownAlls', () async {
      // Declare this in the outer test so if it doesn't runs, the outer test
      // will fail.
      var shouldRun = expectAsync0(() {});

      var engine = declareEngine(() {
        tearDownAll(() => throw 'error');
        tearDownAll(shouldRun);

        test('test', () {});
      });

      expect(await engine.run(), isFalse);
    });

    test('runs outer tearDownAlls', () async {
      // Declare this in the outer test so if it doesn't runs, the outer test
      // will fail.
      var shouldRun = expectAsync0(() {});

      var engine = declareEngine(() {
        tearDownAll(shouldRun);

        group('group', () {
          tearDownAll(() => throw 'error');

          test('test', () {});
        });
      });

      expect(await engine.run(), isFalse);
    });
  });
}