Add watch and modify/delete support to MemoryFile.

pkg/analysis_server/test/resource_test.dart

 // 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:async';
 import 'dart:io' as io;
 
+import 'mocks.dart';
+
 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';
 import 'package:watcher/watcher.dart';
 
 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 pumpEventQueue().then((_) => computation());
+      }
+
+      watchingFolder(String path, test(List<WatchEvent> changesReceived)) {
+        Folder folder = provider.getResource(path);
+        var changesReceived = <WatchEvent>[];
+        var subscription = folder.changes.listen(changesReceived.add);
+        return test(changesReceived);
+      }
+
+      test('create file', () {
+        var rootPath = '/my/path';
+        provider.newFolder(rootPath);
+        watchingFolder(rootPath, (changesReceived) {
+          expect(changesReceived, hasLength(0));
+          var 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', () {
+        var rootPath = '/my/path';
+        provider.newFolder(rootPath);
+        var path = 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', () {
+        var rootPath = '/my/path';
+        provider.newFolder(rootPath);
+        var subdirPath = join(rootPath, 'foo');
+        provider.newFolder(subdirPath);
+        var path = 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', () {
+        var rootPath = '/my/path';
+        provider.newFolder(rootPath);
+        var path = 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>())
         );
       });
 
@@ skipping 18 matching lines @@
           expect(
             () {
             provider.newFolder('/my/file');
             },
             throwsA(new isInstanceOf<ArgumentError>())
           );
         });
       });
     });
 
+    group('modifyFile', () {
+      test('nonexistent', () {
+        var path = '/my/file';
+        expect(() { provider.modifyFile(path, 'contents'); },
+            throwsA(new isInstanceOf<ArgumentError>()));
+        var file = provider.getResource(path);
+        expect(file, isNotNull);
+        expect(file.exists, isFalse);
+      });
+
+      test('is folder', () {
+        var path = '/my/file';
+        provider.newFolder(path);
+        expect(() { provider.modifyFile(path, 'contents'); },
+            throwsA(new isInstanceOf<ArgumentError>()));
+        expect(provider.getResource(path), new isInstanceOf<Folder>());
+      });
+
+      test('successful', () {
+        var path = '/my/file';
+        provider.newFile(path, 'contents 1');
+        var file = provider.getResource(path);
+        expect(file, new isInstanceOf<File>());
+        var source = file.createSource(UriKind.FILE_URI);
+        expect(source.contents.data, equals('contents 1'));
+        provider.modifyFile(path, 'contents 2');
+        expect(source.contents.data, equals('contents 2'));
+      });
+    });
+
+    group('deleteFile', () {
+      test('nonexistent', () {
+        var path = '/my/file';
+        expect(() { provider.deleteFile(path); },
+            throwsA(new isInstanceOf<ArgumentError>()));
+        var file = provider.getResource(path);
+        expect(file, isNotNull);
+        expect(file.exists, isFalse);
+      });
+
+      test('is folder', () {
+        var path = '/my/file';
+        provider.newFolder(path);
+        expect(() { provider.deleteFile(path); },
+            throwsA(new isInstanceOf<ArgumentError>()));
+        expect(provider.getResource(path), new isInstanceOf<Folder>());
+      });
+
+      test('successful', () {
+        var path = '/my/file';
+        provider.newFile(path, 'contents');
+        var 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', () {
@@ skipping 400 matching lines @@
         expect(children[1], _isFolder);
         expect(children[2], _isFile);
       });
     });
   });
 }
 
 var _isFile = new isInstanceOf<File>();
 var _isFolder = new isInstanceOf<Folder>();
 var _isMemoryResourceException = new isInstanceOf<MemoryResourceException>();