testbed_test.dart 2.9 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 7
import 'dart:async';
import 'dart:io';

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

16 17
import '../src/common.dart';
import '../src/testbed.dart';
18 19 20 21 22 23 24

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

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

25
      late FileSystem localFileSystem;
26
      await testbed.run(() {
27
        localFileSystem = globals.fs;
28 29
      });

30 31 32
      expect(localFileSystem, isA<ErrorHandlingFileSystem>());
      expect((localFileSystem as ErrorHandlingFileSystem).fileSystem,
             isA<MemoryFileSystem>());
33 34 35 36 37 38 39
    });

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

40
      A? instance;
41 42 43 44 45 46 47 48 49 50 51 52
      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(),
      });

53
      A? instance;
54 55 56 57 58 59 60 61
      await testbed.run(() {
        instance = context.get<A>();
      }, overrides: <Type, Generator>{
        A: () => B(),
      });

      expect(instance, isA<B>());
    });
62 63 64 65 66

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

70
        expect(response.statusCode, HttpStatus.ok);
71 72 73 74 75 76 77 78 79
        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
80
      }), throwsStateError);
81 82
    });

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

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

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

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

102
class A { }
103

104
class B extends A { }