Resource/File/Folder interfaces and implementations for dart:io and memory.

pkg/analysis_server/test/resource_test.dart

Index: pkg/analysis_server/test/resource_test.dart
diff --git a/pkg/analysis_server/test/resource_test.dart b/pkg/analysis_server/test/resource_test.dart
new file mode 100644
index 0000000000000000000000000000000000000000..84cae35a0afdd1530753b4673e10871c17a0ec05
--- /dev/null
+++ b/pkg/analysis_server/test/resource_test.dart
@@ -0,0 +1,281 @@
+// Copyright (c) 2014, 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.
+
+library test.resource;
+
+import 'dart:io' as io;
+
+import 'package:analysis_server/src/resource.dart';
+import 'package:analyzer/src/generated/engine.dart' show TimestampedData;
+import 'package:analyzer/src/generated/source_io.dart';
+import 'package:path/path.dart';
+import 'package:unittest/unittest.dart';
+
+main() {
+  groupSep = ' | ';
+
+  group('MemoryResourceProvider', () {
+    MemoryResourceProvider provider;
+
+    setUp(() {
+      provider = new MemoryResourceProvider();
+    });
+
+    group('File', () {
+      group('==', () {
+        test('false', () {
+          File fileA = provider.getResource('/fileA.txt');
+          File fileB = provider.getResource('/fileB.txt');
+          expect(fileA == new Object(), isFalse);
+          expect(fileA == fileB, isFalse);
+        });
+
+        test('true', () {
+          File file = provider.getResource('/file.txt');
+          expect(file == file, isTrue);
+        });
+      });
+
+      group('exists', () {
+        test('false', () {
+          File file = provider.getResource('/file.txt');
+          expect(file, isNotNull);
+          expect(file.exists, isFalse);
+        });
+
+        test('true', () {
+          provider.newFile('/foo/file.txt', 'qwerty');
+          File file = provider.getResource('/foo/file.txt');
+          expect(file, isNotNull);
+          expect(file.exists, isTrue);
+        });
+      });
+
+      test('fullName', () {
+        File file = provider.getResource('/foo/bar/file.txt');
+        expect(file.fullName, '/foo/bar/file.txt');
+      });
+
+      test('hashCode', () {
+        File file = provider.getResource('/foo/bar/file.txt');
+        file.hashCode;
+      });
+
+      test('shortName', () {
+        File file = provider.getResource('/foo/bar/file.txt');
+        expect(file.shortName, 'file.txt');
+      });
+
+      test('toString', () {
+        File file = provider.getResource('/foo/bar/file.txt');
+        expect(file.toString(), '/foo/bar/file.txt');
+      });
+    });
+
+    group('Folder', () {
+      Folder folder;
+
+      setUp(() {
+        folder = provider.newFolder('/foo/bar');
+      });
+
+      group('getChild', () {
+        test('does not exist', () {
+          File file = folder.getChild('file.txt');
+          expect(file, isNotNull);
+          expect(file.exists, isFalse);
+        });
+
+        test('file', () {
+          provider.newFile('/foo/bar/file.txt', 'content');
+          File child = folder.getChild('file.txt');
+          expect(child, isNotNull);
+          expect(child.exists, isTrue);
+        });
+
+        test('folder', () {
+          provider.newFolder('/foo/bar/baz');
+          Folder child = folder.getChild('baz');
+          expect(child, isNotNull);
+          expect(child.exists, isTrue);
+        });
+      });
+
+      test('getChildren', () {
+        provider.newFile('/foo/bar/a.txt', 'aaa');
+        provider.newFolder('/foo/bar/bFolder');
+        provider.newFile('/foo/bar/c.txt', 'ccc');
+        // prepare 3 children
+        List<Resource> children = folder.getChildren();
+        expect(children, hasLength(3));
+        children.sort((a, b) => a.shortName.compareTo(b.shortName));
+        // check that each child exists
+        children.forEach((child) {
+          expect(child.exists, true);
+        });
+        // check names
+        expect(children[0].shortName, 'a.txt');
+        expect(children[1].shortName, 'bFolder');
+        expect(children[2].shortName, 'c.txt');
+        // check types
+        expect(children[0], _isFile);
+        expect(children[1], _isFolder);
+        expect(children[2], _isFile);
+      });
+    });
+
+    group('_MemoryFileSource', () {

[Brian Wilkerson, 2014/05/25 15:29:58]

It would be good to also test a non-existent file.

[scheglov, 2014/05/25 16:16:38]

Done.

+      Source source;
+
+      setUp(() {
+        File file = provider.newFile('/foo/test.dart', 'library test;');
+        source = file.createSource(UriKind.FILE_URI);
+      });
+
+      test('contents', () {
+        TimestampedData<String> contents = source.contents;
+        expect(contents.data, 'library test;');
+      });
+
+      test('encoding', () {
+        expect(source.encoding, 'f/foo/test.dart');
+      });
+
+      test('exists', () {
+        expect(source.exists(), isTrue);
+      });
+
+      test('fullName', () {
+        expect(source.fullName, '/foo/test.dart');
+      });
+
+      test('shortName', () {
+        expect(source.shortName, 'test.dart');
+      });
+
+      test('resolveRelative', () {
+        var relative = source.resolveRelative(new Uri.file('bar/baz.dart'));
+        expect(relative.fullName, '/foo/bar/baz.dart');
+      });
+    });
+  });
+
+  group('PhysicalResourceProvider', () {
+    io.Directory tempDirectory;
+    String tempPath;
+
+    setUp(() {
+      tempDirectory = io.Directory.systemTemp.createTempSync('test_resource');
+      tempPath = tempDirectory.absolute.path;
+    });
+
+    tearDown(() {
+      tempDirectory.deleteSync(recursive: true);
+    });
+
+    group('File', () {
+      String path;
+      File file;
+
+      setUp(() {
+        path = join(tempPath, 'file.txt');
+        file = PhysicalResourceProvider.INSTANCE.getResource(path);
+      });
+
+      test('createSource', () {
+        new io.File(path).writeAsStringSync('contents');
+        var source = file.createSource(UriKind.FILE_URI);
+        expect(source.uriKind, UriKind.FILE_URI);
+        expect(source.exists(), isTrue);
+        expect(source.contents.data, 'contents');
+      });
+
+      group('exists', () {
+        test('false', () {
+          expect(file.exists, isFalse);
+        });
+
+        test('true', () {
+          new io.File(path).writeAsStringSync('contents');
+          expect(file.exists, isTrue);
+        });
+      });
+
+      test('fullName', () {
+        expect(file.fullName, path);
+      });
+
+      test('hashCode', () {
+        file.hashCode;
+      });
+
+      test('shortName', () {
+        expect(file.shortName, 'file.txt');
+      });
+
+      test('toString', () {
+        expect(file.toString(), path);
+      });
+    });
+
+    group('Folder', () {
+      String path;
+      Folder folder;
+
+      setUp(() {
+        path = join(tempPath, 'folder');
+        new io.Directory(path).createSync();
+        folder = PhysicalResourceProvider.INSTANCE.getResource(path);
+      });
+
+      group('getChild', () {
+        test('does not exist', () {
+          var child = folder.getChild('no-such-resource');
+          expect(child, isNotNull);
+          expect(child.exists, isFalse);
+        });
+
+        test('file', () {
+          new io.File(join(path, 'myFile')).createSync();
+          var child = folder.getChild('myFile');
+          expect(child, _isFile);
+          expect(child.exists, isTrue);
+        });
+
+        test('folder', () {
+          new io.Directory(join(path, 'myFolder')).createSync();
+          var child = folder.getChild('myFolder');
+          expect(child, _isFolder);
+          expect(child.exists, isTrue);
+        });
+      });
+
+      test('getChildren', () {
+        // create 2 files and 1 folder
+        new io.File(join(path, 'a.txt')).createSync();
+        new io.Directory(join(path, 'bFolder')).createSync();
+        new io.File(join(path, 'c.txt')).createSync();
+        // prepare 3 children
+        List<Resource> children = folder.getChildren();
+        expect(children, hasLength(3));
+        children.sort((a, b) => a.shortName.compareTo(b.shortName));
+        // check that each child exists
+        children.forEach((child) {
+          expect(child.exists, true);
+        });
+        // check names
+        expect(children[0].shortName, 'a.txt');
+        expect(children[1].shortName, 'bFolder');
+        expect(children[2].shortName, 'c.txt');
+        // check types
+        expect(children[0], _isFile);
+        expect(children[1], _isFolder);
+        expect(children[2], _isFile);
+      });
+    });
+  });
+}
+
+var _isFile = new isInstanceOf<File>();
+var _isFolder = new isInstanceOf<Folder>();