Serialize results of certain file invocations to separate file. (flutter#19)

This uses the work that was done in flutter#18 to wire up special
handling of certain file operations such that their results
will be written out to dedicated recording files.

(more work towards flutter#11)

Author: tvolkert

lib/src/backends/record_replay/mutable_recording.dart

@@ -6,6 +6,7 @@ import 'dart:async';
 import 'dart:convert';
 
 import 'package:file/file.dart';
+import 'package:intl/intl.dart';
 
 import 'common.dart';
 import 'encoding.dart';
@@ -41,7 +42,7 @@ class MutableRecording implements LiveRecording {
         Iterable<Future<Null>> futures =
             _events.map((LiveInvocationEvent<dynamic> event) => event.done);
         await Future
-            .wait<String>(futures)
+            .wait<Null>(futures)
             .timeout(awaitPendingResults, onTimeout: () {});
       }
       Directory dir = destination;
@@ -53,6 +54,20 @@ class MutableRecording implements LiveRecording {
     }
   }
 
+  /// Returns a new file for use with this recording.
+  ///
+  /// The file name will combine the specified [name] with [newUid] to ensure
+  /// that its name is unique among all recording files.
+  ///
+  /// It is up to the caller to create the file - it will not exist in the
+  /// file system when it is returned from this method.
+  File newFile(String name) {
+    String basename = '${new NumberFormat('000').format(newUid())}.$name';
+    String dirname = destination.path;
+    String path = destination.fileSystem.path.join(dirname, basename);
+    return destination.fileSystem.file(path);
+  }
+
   /// Adds the specified [event] to this recording.
   void add(LiveInvocationEvent<dynamic> event) => _events.add(event);
 }

lib/src/backends/record_replay/recording_file.dart

@@ -8,10 +8,12 @@ import 'dart:convert';
 import 'package:file/file.dart';
 import 'package:file/src/io.dart' as io;
 
+import 'mutable_recording.dart';
 import 'recording_file_system.dart';
 import 'recording_file_system_entity.dart';
 import 'recording_io_sink.dart';
 import 'recording_random_access_file.dart';
+import 'result_reference.dart';
 
 /// [File] implementation that records all invocation activity to its file
 /// system's recording.
@@ -31,14 +33,14 @@ class RecordingFile extends RecordingFileSystemEntity<File, io.File>
       #lastModifiedSync: delegate.lastModifiedSync,
       #open: _open,
       #openSync: _openSync,
-      #openRead: delegate.openRead,
+      #openRead: _openRead,
       #openWrite: _openWrite,
-      #readAsBytes: delegate.readAsBytes,
-      #readAsBytesSync: delegate.readAsBytesSync,
-      #readAsString: delegate.readAsString,
-      #readAsStringSync: delegate.readAsStringSync,
-      #readAsLines: delegate.readAsLines,
-      #readAsLinesSync: delegate.readAsLinesSync,
+      #readAsBytes: _readAsBytes,
+      #readAsBytesSync: _readAsBytesSync,
+      #readAsString: _readAsString,
+      #readAsStringSync: _readAsStringSync,
+      #readAsLines: _readAsLines,
+      #readAsLinesSync: _readAsLinesSync,
       #writeAsBytes: _writeAsBytes,
       #writeAsBytesSync: delegate.writeAsBytesSync,
       #writeAsString: _writeAsString,
@@ -65,13 +67,60 @@ class RecordingFile extends RecordingFileSystemEntity<File, io.File>
   RandomAccessFile _openSync({FileMode mode: FileMode.READ}) =>
       _wrapRandomAccessFile(delegate.openSync(mode: mode));
 
+  StreamReference<List<int>> _openRead([int start, int end]) =>
+      new _ByteArrayStreamReference(
+        recording,
+        'openRead',
+        delegate.openRead(start, end),
+      );
+
   IOSink _openWrite({FileMode mode: FileMode.WRITE, Encoding encoding: UTF8}) {
     return new RecordingIOSink(
       fileSystem,
       delegate.openWrite(mode: mode, encoding: encoding),
     );
   }
 
+  FutureReference<List<int>> _readAsBytes() => new _ByteArrayFutureReference(
+        recording,
+        'readAsBytes',
+        delegate.readAsBytes(),
+      );
+
+  ResultReference<List<int>> _readAsBytesSync() => new _ByteArrayReference(
+        recording,
+        'readAsBytesSync',
+        delegate.readAsBytesSync(),
+      );
+
+  FutureReference<String> _readAsString({Encoding encoding: UTF8}) =>
+      new _FileContentFutureReference(
+        recording,
+        'readAsString',
+        delegate.readAsString(encoding: encoding),
+      );
+
+  ResultReference<String> _readAsStringSync({Encoding encoding: UTF8}) =>
+      new _FileContentReference(
+        recording,
+        'readAsStringSync',
+        delegate.readAsStringSync(encoding: encoding),
+      );
+
+  FutureReference<List<String>> _readAsLines({Encoding encoding: UTF8}) =>
+      new _LinesFutureReference(
+        recording,
+        'readAsLines',
+        delegate.readAsLines(encoding: encoding),
+      );
+
+  ResultReference<List<String>> _readAsLinesSync({Encoding encoding: UTF8}) =>
+      new _LinesReference(
+        recording,
+        'readAsLinesSync',
+        delegate.readAsLinesSync(encoding: encoding),
+      );
+
   Future<File> _writeAsBytes(
     List<int> bytes, {
     FileMode mode: FileMode.WRITE,
@@ -89,3 +138,156 @@ class RecordingFile extends RecordingFileSystemEntity<File, io.File>
           .writeAsString(contents, mode: mode, encoding: encoding, flush: flush)
           .then(wrap);
 }
+
+class _ByteArrayStreamReference extends StreamReference<List<int>> {
+  final File file;
+  IOSink _sink;
+
+  _ByteArrayStreamReference(
+      MutableRecording recording, String name, Stream<List<int>> stream)
+      : file = recording.newFile(name)..createSync(),
+        super(stream);
+
+  @override
+  void onData(List<int> event) {
+    if (_sink == null) {
+      _sink = file.openWrite();
+    }
+    _sink.add(event);
+  }
+
+  @override
+  void onDone() {
+    if (_sink != null) {
+      _sink.close();
+    }
+  }
+
+  @override
+  dynamic get serializedValue => '!${file.basename}';
+
+  // TODO(tvolkert): remove `.then()` once Dart 1.22 is in stable
+  @override
+  Future<Null> get complete =>
+      Future.wait(<Future<dynamic>>[super.complete, _sink.done]).then((_) {});
+}
+
+class _ByteArrayFutureReference extends FutureReference<List<int>> {
+  final File file;
+
+  _ByteArrayFutureReference(
+      MutableRecording recording, String name, Future<List<int>> future)
+      : file = recording.newFile(name),
+        super(future);
+
+  @override
+  Future<List<int>> get value {
+    return super.value.then((List<int> bytes) async {
+      await file.writeAsBytes(bytes, flush: true);
+      return bytes;
+    });
+  }
+
+  @override
+  dynamic get serializedValue => '!${file.basename}';
+}
+
+class _ByteArrayReference extends ResultReference<List<int>> {
+  final File file;
+  final List<int> bytes;
+
+  _ByteArrayReference(MutableRecording recording, String name, this.bytes)
+      : file = recording.newFile(name);
+
+  @override
+  List<int> get value {
+    file.writeAsBytesSync(bytes, flush: true);
+    return bytes;
+  }
+
+  @override
+  List<int> get recordedValue => bytes;
+
+  @override
+  dynamic get serializedValue => '!${file.basename}';
+}
+
+class _FileContentFutureReference extends FutureReference<String> {
+  final File file;
+
+  _FileContentFutureReference(
+      MutableRecording recording, String name, Future<String> future)
+      : file = recording.newFile(name),
+        super(future);
+
+  @override
+  Future<String> get value {
+    return super.value.then((String content) async {
+      await file.writeAsString(content, flush: true);
+      return content;
+    });
+  }
+
+  @override
+  dynamic get serializedValue => '!${file.basename}';
+}
+
+class _FileContentReference extends ResultReference<String> {
+  final File file;
+  final String content;
+
+  _FileContentReference(MutableRecording recording, String name, this.content)
+      : file = recording.newFile(name);
+
+  @override
+  String get value {
+    file.writeAsStringSync(content, flush: true);
+    return content;
+  }
+
+  @override
+  String get recordedValue => content;
+
+  @override
+  dynamic get serializedValue => '!${file.basename}';
+}
+
+class _LinesFutureReference extends FutureReference<List<String>> {
+  final File file;
+
+  _LinesFutureReference(
+      MutableRecording recording, String name, Future<List<String>> future)
+      : file = recording.newFile(name),
+        super(future);
+
+  @override
+  Future<List<String>> get value {
+    return super.value.then((List<String> lines) async {
+      await file.writeAsString(lines.join('\n'), flush: true);
+      return lines;
+    });
+  }
+
+  @override
+  dynamic get serializedValue => '!${file.basename}';
+}
+
+class _LinesReference extends ResultReference<List<String>> {
+  final File file;
+  final List<String> lines;
+
+  _LinesReference(MutableRecording recording, String name, this.lines)
+      : file = recording.newFile(name);
+
+  @override
+  List<String> get value {
+    file.writeAsStringSync(lines.join('\n'), flush: true);
+    return lines;
+  }
+
+  @override
+  List<String> get recordedValue => lines;
+
+  @override
+  dynamic get serializedValue => '!${file.basename}';
+}

lib/src/backends/record_replay/result_reference.dart

@@ -4,6 +4,8 @@
 
 import 'dart:async';
 
+import 'package:meta/meta.dart';
+
 import 'encoding.dart';
 import 'events.dart';
 import 'recording_proxy_mixin.dart';
@@ -87,8 +89,9 @@ class FutureReference<T> extends ResultReference<Future<T>> {
   @override
   T get recordedValue => _value;
 
+  // TODO(tvolkert): remove `.then()` once Dart 1.22 is in stable
   @override
-  Future<Null> get complete => value;
+  Future<Null> get complete => value.then<Null>((_) {});
 }
 
 /// Wraps a stream result.
@@ -128,19 +131,35 @@ class StreamReference<T> extends ResultReference<Stream<T>> {
     return _stream.listen(
       (T element) {
         _data.add(element);
+        onData(element);
         _controller.add(element);
       },
       onError: (dynamic error, StackTrace stackTrace) {
         // TODO(tvolkert): Record errors
         _controller.addError(error, stackTrace);
       },
       onDone: () {
+        onDone();
         _completer.complete();
         _controller.close();
       },
     );
   }
 
+  /// Called when an event is received from the underlying delegate stream.
+  ///
+  /// Subclasses may override this method to be notified when events are
+  /// fired from the underlying stream.
+  @protected
+  void onData(T event) {}
+
+  /// Called when the underlying delegate stream fires a "done" event.
+  ///
+  /// Subclasses may override this method to be notified when the underlying
+  /// stream is done.
+  @protected
+  void onDone() {}
+
   @override
   Stream<T> get value => _controller.stream;
 

lib/src/testing/core_matchers.dart

@@ -57,6 +57,10 @@ void expectFileSystemException(dynamic message, void callback()) {
   expect(callback, throwsFileSystemException(message));
 }
 
+/// Matcher that successfully matches against a [FileSystemEntity] that
+/// exists ([FileSystemEntity.existsSync] returns true).
+const Matcher exists = const _Exists();
+
 class _FileSystemException extends Matcher {
   final Matcher _matcher;
 
@@ -109,3 +113,25 @@ class _HasPath extends Matcher {
     return desc;
   }
 }
+
+class _Exists extends Matcher {
+  const _Exists();
+
+  @override
+  bool matches(dynamic item, Map<dynamic, dynamic> matchState) =>
+      item is FileSystemEntity && item.existsSync();
+
+  @override
+  Description describe(Description description) =>
+      description.add('a file system entity that exists');
+
+  @override
+  Description describeMismatch(
+    dynamic item,
+    Description description,
+    Map<dynamic, dynamic> matchState,
+    bool verbose,
+  ) {
+    return description.add('does not exist');
+  }
+}

pubspec.yaml

@@ -8,6 +8,7 @@ description: A pluggable, mockable file system abstraction for Dart.
 homepage: https://github.com/matanlurey/file
 
 dependencies:
+  intl: ^0.14.0
   meta: ^1.0.4
   path: ^1.4.0