testbed_test.dart 2.91 KB
Newer Older
Ian Hickson's avatar
Ian Hickson committed
1
// Copyright 2014 The Flutter Authors. All rights reserved.
2 3 4
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

5 6
// @dart = 2.8

7 8 9
import 'dart:async';
import 'dart:io';

10
import 'package:file/file.dart';
11 12
import 'package:file/memory.dart';
import 'package:flutter_tools/src/base/context.dart';
13
import 'package:flutter_tools/src/base/error_handling_io.dart';
14
import 'package:flutter_tools/src/base/file_system.dart';
Dan Field's avatar
Dan Field committed
15
import 'package:flutter_tools/src/base/process.dart';
16
import 'package:flutter_tools/src/globals.dart' as globals;
17

18 19
import '../src/common.dart';
import '../src/testbed.dart';
20 21 22 23 24 25 26 27 28

void main() {
  group('Testbed', () {

    test('Can provide default interfaces', () async {
      final Testbed testbed = Testbed();

      FileSystem localFileSystem;
      await testbed.run(() {
29
        localFileSystem = globals.fs;
30 31
      });

32 33 34
      expect(localFileSystem, isA<ErrorHandlingFileSystem>());
      expect((localFileSystem as ErrorHandlingFileSystem).fileSystem,
             isA<MemoryFileSystem>());
35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63
    });

    test('Can provide setup interfaces', () async {
      final Testbed testbed = Testbed(overrides: <Type, Generator>{
        A: () => A(),
      });

      A instance;
      await testbed.run(() {
        instance = context.get<A>();
      });

      expect(instance, isA<A>());
    });

    test('Can provide local overrides', () async {
      final Testbed testbed = Testbed(overrides: <Type, Generator>{
        A: () => A(),
      });

      A instance;
      await testbed.run(() {
        instance = context.get<A>();
      }, overrides: <Type, Generator>{
        A: () => B(),
      });

      expect(instance, isA<B>());
    });
64 65 66 67 68

    test('provides a mocked http client', () async {
      final Testbed testbed = Testbed();
      await testbed.run(() async {
        final HttpClient client = HttpClient();
69
        final HttpClientRequest request = await client.getUrl(Uri.parse('http://foo.dev'));
70 71
        final HttpClientResponse response = await request.close();

72
        expect(response.statusCode, HttpStatus.ok);
73 74 75 76 77 78 79 80 81
        expect(response.contentLength, 0);
      });
    });

    test('Throws StateError if Timer is left pending', () async {
      final Testbed testbed = Testbed();

      expect(testbed.run(() async {
        Timer.periodic(const Duration(seconds: 1), (Timer timer) { });
Dan Field's avatar
Dan Field committed
82
      }), throwsStateError);
83 84
    });

85
    test("Doesn't throw a StateError if Timer is left cleaned up", () async {
86 87
      final Testbed testbed = Testbed();

88
      await testbed.run(() async {
89 90 91 92
        final Timer timer = Timer.periodic(const Duration(seconds: 1), (Timer timer) { });
        timer.cancel();
      });
    });
Dan Field's avatar
Dan Field committed
93 94 95 96 97 98

    test('Throws if ProcessUtils is injected',() {
      final Testbed testbed = Testbed(overrides: <Type, Generator>{
        ProcessUtils: () => null,
      });

99
      expect(() => testbed.run(() {}), throwsStateError);
Dan Field's avatar
Dan Field committed
100
    });
101 102 103
  });
}

104
class A { }
105

106
class B extends A { }