Future-ify all the html methods and add named parameters

tests/html/fileapi_test.dart

 library fileapi;
 import '../../pkg/unittest/lib/unittest.dart';
 import '../../pkg/unittest/lib/html_individual_config.dart';
 import 'dart:html';
 
 void fail(message) {
   guardAsync(() {
     expect(false, isTrue, reason: message);
   });
 }
 
 FileSystem fs;
 
 main() {
   useHtmlIndividualConfiguration();
 
   group('supported', () {
     test('supported', () {
       expect(FileSystem.supported, true);
     });
   });
 
   getFileSystem() {
-    window.requestFileSystem(Window.TEMPORARY, 100,
-        expectAsync1((FileSystem fileSystem) {
+    return window.requestFileSystem(Window.TEMPORARY, 100).then(
+        (FileSystem fileSystem) {
           fs = fileSystem;
-        }),
+        }).catchError(

[blois, 2013/03/06 00:34:29]

Should not need to do the catch error- it should propagate automatically.

[Emily Fortuna, 2013/03/06 21:29:18]

Done.

         (e) {
-          fail('Got file error: ${e.code}');
+          fail('Got file error: ${e.error.code}');
         });
   }
 
   group('unsupported_throws', () {
     test('requestFileSystem', () {
       var expectation = FileSystem.supported ? returnsNormally : throws;
       expect(() {
-        window.requestFileSystem(Window.TEMPORARY, 100, (_) {}, (_) {});
+        window.requestFileSystem(Window.TEMPORARY, 100);
       }, expectation);
     });
   });
 
   group('getDirectory', () {
     if (FileSystem.supported) {
       test('getFileSystem', getFileSystem);
 
       test('directoryDoesntExist', () {
-        fs.root.getDirectory(
+        return fs.root.getDirectory(
             'directory2',
-            options: {},
-            successCallback: (e) {
-              fail('Should not be reached');
-            },
-            errorCallback: expectAsync1((FileError e) {
-              expect(e.code, equals(FileError.NOT_FOUND_ERR));
-            }));
+            options: {}).then(
+              (e) {
+                fail('Should not be reached');
+              }).catchError(
+                (AsyncError e) {

[blois, 2013/03/06 00:34:29]

Should probably provide a test function as well and let all other errors
propagate though.

+                  expect(e.error.code, equals(FileError.NOT_FOUND_ERR));
+                });
         });
 
       test('directoryCreate', () {
-        fs.root.getDirectory(
+        return fs.root.getDirectory(
             'directory3',
-            options: {'create': true},
-            successCallback: expectAsync1((DirectoryEntry e) {
-              expect(e.name, equals('directory3'));
-            }),
-            errorCallback: (e) {
-              fail('Got file error: ${e.code}');
-            });
+            options: {'create': true}).then(
+              (DirectoryEntry e) {
+                expect(e.name, equals('directory3'));
+              }).catchError(
+              (e) {

[blois, 2013/03/06 00:34:29]

Can just ignore this error, test framework will get it.

[Emily Fortuna, 2013/03/06 21:29:18]

Done.

+                fail('Got file error: ${e.error.code}');
+              });
         });
     }
   });
 
   group('getFile', () {
     if (FileSystem.supported) {
       test('getFileSystem', getFileSystem);
 
       test('fileDoesntExist', () {
-        fs.root.getFile(
+        return fs.root.getFile(
             'file2',
-            options: {},
-            successCallback: (e) {
-              fail('Should not be reached');
-            },
-            errorCallback: expectAsync1((FileError e) {
-              expect(e.code, equals(FileError.NOT_FOUND_ERR));
-            }));
+            options: {}).then(
+              (e) {
+                fail('Should not be reached');
+              }).catchError(
+                (AsyncError e) {
+                  expect(e.error.code, equals(FileError.NOT_FOUND_ERR));

[blois, 2013/03/06 00:34:29]

Ditto for test function for catchError.

+                });
       });
 
       test('fileCreate', () {
-        fs.root.getFile(
+        return fs.root.getFile(
             'file4',
-            options: {'create': true},
-            successCallback: expectAsync1((FileEntry e) {
-              expect(e.name, equals('file4'));
-              expect(e.isFile, isTrue);
+            options: {'create': true}).then(
+              (FileEntry e) {
+                expect(e.name, equals('file4'));
+                expect(e.isFile, isTrue);
 
-              e.getMetadata(expectAsync1((Metadata metadata) {
-                var changeTime = metadata.modificationTime;
-                expect(new DateTime.now().difference(changeTime).inSeconds,
-                  lessThan(60));
-              }));
-            }),
-            errorCallback: (e) {
-              fail('Got file error: ${e.code}');
-            });
+                return e.getMetadata().then((Metadata metadata) {

[blois, 2013/03/06 00:34:29]

sent mail with suggested style changes.

+                  var changeTime = metadata.modificationTime;
+                  expect(new DateTime.now().difference(changeTime).inSeconds,
+                    lessThan(60));
+                  expect(metadata.size, equals(0));
+                });
+              }).catchError(
+              (e) {
+                fail('Got file error: ${e.error.code}');

[blois, 2013/03/06 00:34:29]

Don't need catchError.

[Emily Fortuna, 2013/03/06 21:29:18]

Done.

+              });
         });
     }
   });
+
+  // Do the boilerplate to get several files and directories created to then
+  // test the functions that use those items.
+  Future doDirSetup(successCallback) {

[blois, 2013/03/06 00:34:29]

Seems like this should have a class which holds the success args and just
returns that in the future. A bit odd to have the callback & future.

+    return fs.root.getFile(
+      'file4',
+      options: {'create': true}).then(

[blois, 2013/03/06 00:34:29]

ditto on style changes.

+        (FileEntry file) {
+          return fs.root.getDirectory(
+              'directory3',
+              options: {'create': true}).then(
+              (DirectoryEntry dir) {
+                return successCallback(file, dir);
+              });
+        });
+  }
+
+  group('directoryReader', () {
+    if (FileSystem.supported) {
+      test('getFileSystem', getFileSystem);
+
+      test('readEntries', () {
+        return doDirSetup((file, dir) {
+            var reader = dir.createReader();
+            reader.readEntries().then(
+                    (entries) { expect(entries is List, true);})
+                .catchError(
+                    (e) {

[blois, 2013/03/06 00:34:29]

don't need catchError

[Emily Fortuna, 2013/03/06 21:29:18]

Done.

+                      fail("Shouldn't be reached error: ${e.error.code}");
+                    });
+        });
+      });
+    }
+  });
+
+  group('entry', () {
+    if (FileSystem.supported) {
+      test('getFileSystem', getFileSystem);
+
+      test('copyTo', () {
+        return doDirSetup((file, dir) {
+            return file.copyTo(dir, name: 'copiedFile').then(
+              (entry) {
+                expect(entry.isFile, true);
+                expect(entry.name, 'copiedFile');
+              }).catchError(
+              (error) { fail('CopyToFailure ${error.error.code}'); }); });
+      });
+
+      test('getParent', () {
+        return doDirSetup((file, dir) {
+            return file.getParent().then((entry) {
+                expect(entry.name, '');
+                expect(entry.isFile, false);
+              });
+        });
+      });
+
+      test('moveTo', () {
+        return doDirSetup((file, dir) {
+            return file.moveTo(dir, name: 'movedFile').then(
+                (entry) {
+                    expect(entry.name, 'movedFile');
+                    expect(entry.fullPath, '/directory3/movedFile');
+                    return fs.root.getFile('file4', options: {'create': false})
+                        .then(
+                            (e) { fail("File should be moved."); })
+                        .catchError(
+                            (e) {
+                              expect(e.error.code,
+                                  equals(FileError.NOT_FOUND_ERR));
+                            });
+                  })
+                .catchError((e) { fail("Failed move to ${e.error.code}"); });
+        });
+      });
+
+      test('remove', () {
+        return doDirSetup((file, dir) {
+            return file.remove().then((_) {})
+                .catchError((e) { fail("Failed move to ${e.error.code}"); });
+        });
+      });
+    }
+  });
+
+  group('fileEntry', () {
+    if (FileSystem.supported) {
+      test('getFileSystem', getFileSystem);
+
+      test('createWriter', () {
+        return doDirSetup((file, dir) {
+            return file.createWriter().then(
+                    (writer) {
+                      expect(writer.position, 0);
+                      expect(writer.readyState, FileWriter.INIT);
+                      expect(writer.length, 0);
+                    }).catchError((e) {
+                      fail("Create writer failed. ${e.error.code}");
+                    });
+        });
+      });
+
+      test('file', () {
+        return doDirSetup((file, dir) {
+            return file.file().then(
+                (fileObj) {
+                  expect(fileObj.name, file.name);
+                  expect(fileObj.relativePath, '');
+                  expect(new DateTime.now().difference(
+                      fileObj.lastModifiedDate).inSeconds, lessThan(60));
+                }).catchError((e) {
+                  fail("File failed. ${e.error.code}");
+                });
+        });
+      });
+    }
+  });
 }