blob: a91aa4b42fb918cf4823298318e635e6dec44d9e [file] [log] [blame]
// 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.memory_file_system;
import 'dart:async';
import 'package:analyzer/src/generated/engine.dart' show TimestampedData;
import 'package:analyzer/src/generated/source.dart';
import 'package:path/path.dart';
import 'package:unittest/unittest.dart';
import 'package:watcher/watcher.dart';
import 'package:analyzer/file_system/memory_file_system.dart';
import 'package:analyzer/file_system/file_system.dart';
var _isFile = new isInstanceOf<File>();
var _isFolder = new isInstanceOf<Folder>();
var _isMemoryResourceException = new isInstanceOf<MemoryResourceException>();
main() {
groupSep = ' | ';
group('MemoryResourceProvider', () {
MemoryResourceProvider provider;
setUp(() {
provider = new MemoryResourceProvider();
});
test('MemoryResourceException', () {
var exception = new MemoryResourceException('/my/path', 'my message');
expect(exception.path, '/my/path');
expect(exception.message, 'my message');
expect(exception.toString(),
'MemoryResourceException(path=/my/path; message=my message)');
});
group('Watch', () {
Future delayed(computation()) {
return new Future.delayed(Duration.ZERO, computation);
}
watchingFolder(String path, test(List<WatchEvent> changesReceived)) {
Folder folder = provider.getResource(path);
var changesReceived = <WatchEvent>[];
folder.changes.listen(changesReceived.add);
return test(changesReceived);
}
test('create file', () {
String rootPath = '/my/path';
provider.newFolder(rootPath);
watchingFolder(rootPath, (changesReceived) {
expect(changesReceived, hasLength(0));
String path = posix.join(rootPath, 'foo');
provider.newFile(path, 'contents');
return delayed(() {
expect(changesReceived, hasLength(1));
expect(changesReceived[0].type, equals(ChangeType.ADD));
expect(changesReceived[0].path, equals(path));
});
});
});
test('modify file', () {
String rootPath = '/my/path';
provider.newFolder(rootPath);
String path = posix.join(rootPath, 'foo');
provider.newFile(path, 'contents 1');
return watchingFolder(rootPath, (changesReceived) {
expect(changesReceived, hasLength(0));
provider.modifyFile(path, 'contents 2');
return delayed(() {
expect(changesReceived, hasLength(1));
expect(changesReceived[0].type, equals(ChangeType.MODIFY));
expect(changesReceived[0].path, equals(path));
});
});
});
test('modify file in subdir', () {
String rootPath = '/my/path';
provider.newFolder(rootPath);
String subdirPath = posix.join(rootPath, 'foo');
provider.newFolder(subdirPath);
String path = posix.join(rootPath, 'bar');
provider.newFile(path, 'contents 1');
return watchingFolder(rootPath, (changesReceived) {
expect(changesReceived, hasLength(0));
provider.modifyFile(path, 'contents 2');
return delayed(() {
expect(changesReceived, hasLength(1));
expect(changesReceived[0].type, equals(ChangeType.MODIFY));
expect(changesReceived[0].path, equals(path));
});
});
});
test('delete file', () {
String rootPath = '/my/path';
provider.newFolder(rootPath);
String path = posix.join(rootPath, 'foo');
provider.newFile(path, 'contents 1');
return watchingFolder(rootPath, (changesReceived) {
expect(changesReceived, hasLength(0));
provider.deleteFile(path);
return delayed(() {
expect(changesReceived, hasLength(1));
expect(changesReceived[0].type, equals(ChangeType.REMOVE));
expect(changesReceived[0].path, equals(path));
});
});
});
});
group('newFolder', () {
test('empty path', () {
expect(() {
provider.newFolder('');
}, throwsA(new isInstanceOf<ArgumentError>()));
});
test('not absolute', () {
expect(() {
provider.newFolder('not/absolute');
}, throwsA(new isInstanceOf<ArgumentError>()));
});
group('already exists', () {
test('as folder', () {
Folder folder = provider.newFolder('/my/folder');
Folder newFolder = provider.newFolder('/my/folder');
expect(newFolder, folder);
});
test('as file', () {
File file = provider.newFile('/my/file', 'qwerty');
expect(() {
provider.newFolder('/my/file');
}, throwsA(new isInstanceOf<ArgumentError>()));
});
});
});
group('modifyFile', () {
test('nonexistent', () {
String path = '/my/file';
expect(() {
provider.modifyFile(path, 'contents');
}, throwsA(new isInstanceOf<ArgumentError>()));
Resource file = provider.getResource(path);
expect(file, isNotNull);
expect(file.exists, isFalse);
});
test('is folder', () {
String path = '/my/file';
provider.newFolder(path);
expect(() {
provider.modifyFile(path, 'contents');
}, throwsA(new isInstanceOf<ArgumentError>()));
expect(provider.getResource(path), new isInstanceOf<Folder>());
});
test('successful', () {
String path = '/my/file';
provider.newFile(path, 'contents 1');
Resource file = provider.getResource(path);
expect(file, new isInstanceOf<File>());
Source source = (file as File).createSource();
expect(source.contents.data, equals('contents 1'));
provider.modifyFile(path, 'contents 2');
expect(source.contents.data, equals('contents 2'));
});
});
group('deleteFile', () {
test('nonexistent', () {
String path = '/my/file';
expect(() {
provider.deleteFile(path);
}, throwsA(new isInstanceOf<ArgumentError>()));
Resource file = provider.getResource(path);
expect(file, isNotNull);
expect(file.exists, isFalse);
});
test('is folder', () {
String path = '/my/file';
provider.newFolder(path);
expect(() {
provider.deleteFile(path);
}, throwsA(new isInstanceOf<ArgumentError>()));
expect(provider.getResource(path), new isInstanceOf<Folder>());
});
test('successful', () {
String path = '/my/file';
provider.newFile(path, 'contents');
Resource file = provider.getResource(path);
expect(file, new isInstanceOf<File>());
expect(file.exists, isTrue);
provider.deleteFile(path);
expect(file.exists, isFalse);
});
});
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);
});
test('before and after creation', () {
String path = '/file.txt';
File file1 = provider.getResource(path);
provider.newFile(path, 'contents');
File file2 = provider.getResource(path);
expect(file1 == file2, 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.path, '/foo/bar/file.txt');
});
test('hashCode', () {
String path = '/foo/bar/file.txt';
File file1 = provider.getResource(path);
provider.newFile(path, 'contents');
File file2 = provider.getResource(path);
expect(file1.hashCode, equals(file2.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');
});
test('parent', () {
provider.newFile('/foo/bar/file.txt', 'content');
File file = provider.getResource('/foo/bar/file.txt');
Resource parent = file.parent;
expect(parent, new isInstanceOf<Folder>());
expect(parent.path, equals('/foo/bar'));
});
});
group('Folder', () {
Folder folder;
const String path = '/foo/bar';
setUp(() {
folder = provider.newFolder(path);
});
test('hashCode', () {
Folder folder2 = provider.getResource(path);
expect(folder.hashCode, equals(folder2.hashCode));
});
test('equality: same path', () {
Folder folder2 = provider.getResource(path);
expect(folder == folder2, isTrue);
});
test('equality: different paths', () {
String path2 = '/foo/baz';
Folder folder2 = provider.newFolder(path2);
expect(folder == folder2, isFalse);
});
test('contains', () {
expect(folder.contains('/foo/bar/aaa.txt'), isTrue);
expect(folder.contains('/foo/bar/aaa/bbb.txt'), isTrue);
expect(folder.contains('/baz.txt'), isFalse);
expect(folder.contains('/foo/bar'), isFalse);
});
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);
});
test('parent', () {
Resource parent1 = folder.parent;
expect(parent1, new isInstanceOf<Folder>());
expect(parent1.path, equals('/foo'));
Resource parent2 = parent1.parent;
expect(parent2, new isInstanceOf<Folder>());
expect(parent2.path, equals('/'));
expect(parent2.parent, isNull);
});
test('canonicalizePath', () {
expect(folder.canonicalizePath('baz'), equals('/foo/bar/baz'));
expect(folder.canonicalizePath('/baz'), equals('/baz'));
expect(folder.canonicalizePath('../baz'), equals('/foo/baz'));
expect(folder.canonicalizePath('/a/b/../c'), equals('/a/c'));
expect(folder.canonicalizePath('./baz'), equals('/foo/bar/baz'));
expect(folder.canonicalizePath('/a/b/./c'), equals('/a/b/c'));
});
});
group('_MemoryFileSource', () {
Source source;
group('existent', () {
setUp(() {
File file = provider.newFile('/foo/test.dart', 'library test;');
source = file.createSource();
});
group('==', () {
group('true', () {
test('self', () {
File file = provider.newFile('/foo/test.dart', '');
Source source = file.createSource();
expect(source == source, isTrue);
});
test('same file', () {
File file = provider.newFile('/foo/test.dart', '');
Source sourceA = file.createSource();
Source sourceB = file.createSource();
expect(sourceA == sourceB, isTrue);
});
});
group('false', () {
test('not a memory Source', () {
File file = provider.newFile('/foo/test.dart', '');
Source source = file.createSource();
expect(source == new Object(), isFalse);
});
test('different file', () {
File fileA = provider.newFile('/foo/a.dart', '');
File fileB = provider.newFile('/foo/b.dart', '');
Source sourceA = fileA.createSource();
Source sourceB = fileB.createSource();
expect(sourceA == sourceB, isFalse);
});
});
});
test('contents', () {
TimestampedData<String> contents = source.contents;
expect(contents.data, 'library test;');
});
test('encoding', () {
expect(source.encoding, 'file:///foo/test.dart');
});
test('exists', () {
expect(source.exists(), isTrue);
});
test('fullName', () {
expect(source.fullName, '/foo/test.dart');
});
test('hashCode', () {
source.hashCode;
});
test('shortName', () {
expect(source.shortName, 'test.dart');
});
test('resolveRelative', () {
Uri relative = source.resolveRelativeUri(new Uri.file('bar/baz.dart'));
expect(relative.path, '/foo/bar/baz.dart');
});
});
group('non-existent', () {
setUp(() {
File file = provider.getResource('/foo/test.dart');
source = file.createSource();
});
test('contents', () {
expect(() {
source.contents;
}, throwsA(_isMemoryResourceException));
});
test('encoding', () {
expect(source.encoding, 'file:///foo/test.dart');
});
test('exists', () {
expect(source.exists(), isFalse);
});
test('fullName', () {
expect(source.fullName, '/foo/test.dart');
});
test('shortName', () {
expect(source.shortName, 'test.dart');
});
test('resolveRelative', () {
Uri relative = source.resolveRelativeUri(new Uri.file('bar/baz.dart'));
expect(relative.path, '/foo/bar/baz.dart');
});
});
});
});
}