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

import 'dart:async';
import 'dart:io' as io;

8
import 'package:file/memory.dart';
9 10 11
import 'package:flutter_tools/src/base/io.dart';
import 'package:mockito/mockito.dart';

12 13
import '../../src/common.dart';
import '../../src/context.dart';
14
import '../../src/io.dart';
15 16

void main() {
17 18 19 20 21 22 23
  test('IOOverrides can inject a memory file system', () async {
    final MemoryFileSystem memoryFileSystem = MemoryFileSystem();
    final FlutterIOOverrides flutterIOOverrides = FlutterIOOverrides(fileSystem: memoryFileSystem);
    await io.IOOverrides.runWithIOOverrides(() async {
      // statics delegate correctly.
      expect(io.FileSystemEntity.isWatchSupported, memoryFileSystem.isWatchSupported);
      expect(io.Directory.systemTemp.path, memoryFileSystem.systemTempDirectory.path);
24

25 26 27 28 29
      // can create and write to files/directories sync.
      final io.File file = io.File('abc');
      file.writeAsStringSync('def');
      final io.Directory directory = io.Directory('foobar');
      directory.createSync();
30

31 32 33
      expect(memoryFileSystem.file('abc').existsSync(), true);
      expect(memoryFileSystem.file('abc').readAsStringSync(), 'def');
      expect(memoryFileSystem.directory('foobar').existsSync(), true);
34

35 36 37 38 39
      // can create and write to files/directories async.
      final io.File fileB = io.File('xyz');
      await fileB.writeAsString('def');
      final io.Directory directoryB = io.Directory('barfoo');
      await directoryB.create();
40

41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69
      expect(memoryFileSystem.file('xyz').existsSync(), true);
      expect(memoryFileSystem.file('xyz').readAsStringSync(), 'def');
      expect(memoryFileSystem.directory('barfoo').existsSync(), true);

      // Links
      final io.Link linkA = io.Link('hhh');
      final io.Link linkB = io.Link('ggg');
      io.File('jjj').createSync();
      io.File('lll').createSync();
      await linkA.create('jjj');
      linkB.createSync('lll');

      expect(await memoryFileSystem.link('hhh').resolveSymbolicLinks(), await linkA.resolveSymbolicLinks());
      expect(memoryFileSystem.link('ggg').resolveSymbolicLinksSync(), linkB.resolveSymbolicLinksSync());
    }, flutterIOOverrides);
  });
  testUsingContext('ProcessSignal signals are properly delegated', () async {
    final MockIoProcessSignal mockSignal = MockIoProcessSignal();
    final ProcessSignal signalUnderTest = ProcessSignal(mockSignal);
    final StreamController<io.ProcessSignal> controller = StreamController<io.ProcessSignal>();

    when(mockSignal.watch()).thenAnswer((Invocation invocation) => controller.stream);
    controller.add(mockSignal);

    expect(signalUnderTest, await signalUnderTest.watch().first);
  });

  testUsingContext('ProcessSignal toString() works', () async {
    expect(io.ProcessSignal.sigint.toString(), ProcessSignal.SIGINT.toString());
70
  });
71 72

  test('exit throws a StateError if called without being overriden', () {
Dan Field's avatar
Dan Field committed
73
    expect(() => exit(0), throwsAssertionError);
74 75 76
  });

  test('exit does not throw a StateError if overriden', () {
Dan Field's avatar
Dan Field committed
77 78
    try {
      setExitFunctionForTests((int value) {});
79

Dan Field's avatar
Dan Field committed
80 81 82 83
      expect(() => exit(0), returnsNormally);
    } finally {
      restoreExitFunction();
    }
84
  });
85 86 87 88

  test('test_api defines the Declarer in a known place', () {
    expect(Zone.current[#test.declarer], isNotNull);
  });
89 90 91 92 93 94 95 96 97 98 99 100 101 102

  test('listNetworkInterfaces() uses overrides', () async {
    setNetworkInterfaceLister(
      ({
        bool includeLoopback,
        bool includeLinkLocal,
        InternetAddressType type,
      }) async => <NetworkInterface>[],
    );

    expect(await listNetworkInterfaces(), isEmpty);

    resetNetworkInterfaceLister();
  });
103 104
}

105
class MockIoProcessSignal extends Mock implements io.ProcessSignal {}