add FileBasedAsset* tests

Author: jakemac53

.gitignore

@@ -5,4 +5,4 @@ build/
 pubspec.lock
 
 # Include .packages files from tests which are hand coded
-!test/package_graph/**/.packages
+!test/fixtures/**/.packages

lib/build.dart

@@ -3,6 +3,7 @@
 // BSD-style license that can be found in the LICENSE file.
 export 'src/asset/asset.dart';
 export 'src/asset/exceptions.dart';
+export 'src/asset/file_based.dart';
 export 'src/asset/id.dart';
 export 'src/asset/reader.dart';
 export 'src/asset/writer.dart';

lib/src/asset/exceptions.dart

@@ -28,5 +28,16 @@ class InvalidOutputException implements Exception {
   InvalidOutputException(this.asset);
 
   @override
-  String toString() => 'InvalidOutputException: $asset';
+  String toString() => 'InvalidOutputException: $asset\n'
+      'Files may only be output in the root (application) package.';
+}
+
+class InvalidInputException implements Exception {
+  final AssetId assetId;
+
+  InvalidInputException(this.assetId);
+
+  @override
+  String toString() => 'InvalidInputException: $assetId\n'
+      'For package dependencies, only files under `lib` may be used as inputs.';
 }

lib/src/asset/file_based.dart

@@ -23,16 +23,29 @@ class FileBasedAssetReader implements AssetReader {
   FileBasedAssetReader(this.packageGraph);
 
   @override
-  Future<bool> hasInput(AssetId id) => _fileFor(id, packageGraph).exists();
+  Future<bool> hasInput(AssetId id) async {
+    _checkInput(id);
+    return _fileFor(id, packageGraph).exists();
+  }
 
   @override
   Future<String> readAsString(AssetId id, {Encoding encoding: UTF8}) async {
+    _checkInput(id);
+
     var file = await _fileFor(id, packageGraph);
     if (!await file.exists()) {
       throw new AssetNotFoundException(id);
     }
     return file.readAsString(encoding: encoding);
   }
+
+  /// Checks that [id] is a valid input, and throws an [InvalidInputException]
+  /// if its not.
+  void _checkInput(AssetId id) {
+    if (id.package != packageGraph.root.name && !id.path.startsWith('lib/')) {
+      throw new InvalidInputException(id);
+    }
+  }
 }
 
 /// Basic [AssetWriter] which uses a [PackageGraph] to look up where to write
@@ -43,17 +56,14 @@ class FileBasedAssetWriter implements AssetWriter {
   FileBasedAssetWriter(this.packageGraph);
 
   @override
-  // Not using async/await here so that the first check can throw synchronously
-  // which helps with debugging.
-  Future writeAsString(Asset asset, {Encoding encoding: UTF8}) {
+  Future writeAsString(Asset asset, {Encoding encoding: UTF8}) async {
     if (asset.id.package != packageGraph.root.name) {
       throw new InvalidOutputException(asset);
     }
 
     var file = _fileFor(asset.id, packageGraph);
-    return file.create(recursive: true).then((_) {
-      return file.writeAsString(asset.stringContents, encoding: encoding);
-    });
+    await file.create(recursive: true);
+    await file.writeAsString(asset.stringContents, encoding: encoding);
   }
 }
 

test/asset/file_based_test.dart

@@ -0,0 +1,97 @@
+// Copyright (c) 2016, 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.
+@TestOn('vm')
+import 'dart:async';
+import 'dart:io';
+
+import 'package:test/test.dart';
+
+import 'package:build/build.dart';
+import '../common/common.dart';
+
+main() async {
+  final packageGraph = new PackageGraph.forPath('test/fixtures/basic_pkg');
+  final assetNotFoundException = new isInstanceOf<AssetNotFoundException>();
+  final invalidInputException = new isInstanceOf<InvalidInputException>();
+  final invalidOutputException = new isInstanceOf<InvalidOutputException>();
+  final packageNotFoundException = new isInstanceOf<PackageNotFoundException>();
+
+  group('FileBasedAssetReader', () {
+    final reader = new FileBasedAssetReader(packageGraph);
+
+    test('can read any application package files', () async {
+      expect(await reader.readAsString(makeAssetId('basic_pkg|hello.txt')),
+          'world\n');
+      expect(await reader.readAsString(makeAssetId('basic_pkg|lib/hello.txt')),
+          'world\n');
+      expect(await reader.readAsString(makeAssetId('basic_pkg|web/hello.txt')),
+          'world\n');
+    });
+
+    test('can only read package dependency files in the lib dir', () async {
+      expect(await reader.readAsString(makeAssetId('a|lib/a.txt')), 'A\n');
+      expect(reader.readAsString(makeAssetId('a|web/a.txt')),
+          throwsA(invalidInputException));
+      expect(reader.readAsString(makeAssetId('a|a.txt')),
+          throwsA(invalidInputException));
+    });
+
+    test('can check for existence of any application package files', () async {
+      expect(await reader.hasInput(makeAssetId('basic_pkg|hello.txt')), isTrue);
+      expect(await reader.hasInput(makeAssetId('basic_pkg|lib/hello.txt')),
+          isTrue);
+      expect(await reader.hasInput(makeAssetId('basic_pkg|web/hello.txt')),
+          isTrue);
+
+      expect(await reader.hasInput(makeAssetId('basic_pkg|a.txt')), isFalse);
+      expect(
+          await reader.hasInput(makeAssetId('basic_pkg|lib/a.txt')), isFalse);
+    });
+
+    test('can only check for existence of package dependency files in lib',
+        () async {
+      expect(await reader.hasInput(makeAssetId('a|lib/a.txt')), isTrue);
+      expect(await reader.hasInput(makeAssetId('a|lib/b.txt')), isFalse);
+      expect(reader.hasInput(makeAssetId('a|web/a.txt')),
+          throwsA(invalidInputException));
+      expect(reader.hasInput(makeAssetId('a|a.txt')),
+          throwsA(invalidInputException));
+      expect(reader.hasInput(makeAssetId('foo|bar.txt')),
+          throwsA(invalidInputException));
+    });
+
+    test('throws when attempting to read a non-existent file', () async {
+      expect(reader.readAsString(makeAssetId('basic_pkg|foo.txt')),
+          throwsA(assetNotFoundException));
+      expect(reader.readAsString(makeAssetId('a|lib/b.txt')),
+          throwsA(assetNotFoundException));
+      expect(reader.readAsString(makeAssetId('foo|lib/bar.txt')),
+          throwsA(packageNotFoundException));
+    });
+  });
+
+  group('FileBasedAssetWriter', () {
+    final writer = new FileBasedAssetWriter(packageGraph);
+
+    test('can output files in the application package', () async {
+      var asset = makeAsset('basic_pkg|test_file.txt', 'test');
+      await writer.writeAsString(asset);
+      var id = asset.id;
+      var file = new File('test/fixtures/${id.package}/${id.path}');
+      expect(await file.exists(), isTrue);
+      expect(await file.readAsString(), 'test');
+      await file.delete();
+    });
+
+    test('can\'t output files in package dependencies', () async {
+      var asset = makeAsset('a|test.txt');
+      expect(writer.writeAsString(asset), throwsA(invalidOutputException));
+    });
+
+    test('can\'t output files in arbitrary packages', () async {
+      var asset = makeAsset('foo|bar.txt');
+      expect(writer.writeAsString(asset), throwsA(invalidOutputException));
+    });
+  });
+}

test/package_graph/basic_pkg/.packages renamed to test/fixtures/basic_pkg/.packages

@@ -0,0 +1 @@
+world

test/fixtures/basic_pkg/hello.txt

@@ -0,0 +1 @@
+world

test/fixtures/basic_pkg/lib/hello.txt

@@ -0,0 +1 @@
+A

test/fixtures/basic_pkg/pkg/a/a.txt

@@ -0,0 +1 @@
+A