Dart: Allows the mojom package's generate script to download .mojoms.

mojo/dart/mojom/test/generate_test.dart

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 import 'dart:io';
 
 import 'package:mojom/generate.dart' as generate;
 import 'package:path/path.dart' as path;
 import 'package:unittest/unittest.dart';
 
 final mojomContents = '''
 module generated;
 
 struct Transform {
   // Row major order.
   array<float, 16> matrix;
 };
 ''';
 
-void main() {
+final dldMojomContents1 = '''
+module downloaded;
+
+struct Downloaded1 {
+  int32 status;
+};
+''';
+
+final dldMojomContents2 = '''
+module downloaded;
+
+struct Downloaded2 {
+  int32 status;
+};
+''';
+
+main() async {
+  String mojoSdk;
+  if (Platform.environment['MOJO_SDK'] != null) {
+    mojoSdk = Platform.environment['MOJO_SDK'];
+  } else {
+    mojoSdk = path.normalize(path.join(
+        path.dirname(Platform.script.path), '..', '..', '..', 'public'));
+  }
+  if (!await new Directory(mojoSdk).exists()) {
+    fail("Could not find the Mojo SDK");
+  }
+
   final scriptPath = path.dirname(Platform.script.path);
   final testPackagePath = path.join(scriptPath, 'test_packages');
   final testMojomPath = path.join(testPackagePath, 'mojom');
 
   final pregenPath = path.join(testPackagePath, 'pregen');
   final pregenFilePath =
       path.join(pregenPath, 'mojom', 'pregen', 'pregen.mojom.dart');
 
   final additionalRootPath = path.join(scriptPath, 'additional_dir');
   final additionalPath = path.join(
       additionalRootPath, 'additional', 'additional.mojom.dart');
 
+  final downloadedPackagePath = path.join(testPackagePath, 'downloaded');
+  final dotMojomsPath = path.join(downloadedPackagePath, '.mojoms');
+
+  final pkcert = Platform.script.resolve('pkcert').toFilePath();
+  SecureSocket.initialize(database: pkcert, password: 'dartdart');
+
   setUp(() async {
     await new Directory(testMojomPath).create(recursive: true);
     await new File(pregenFilePath).create(recursive: true);
     await new File(additionalPath).create(recursive: true);
 
     final generatedMojomFile = new File(path.join(testPackagePath, 'generated',
         'mojom', 'generated', 'public', 'interfaces', 'generated.mojom'));
     await generatedMojomFile.create(recursive: true);
     await generatedMojomFile.writeAsString(mojomContents);
+
+    await new Directory(downloadedPackagePath).create(recursive: true);
   });
 
   tearDown(() async {
     await new Directory(additionalRootPath).delete(recursive: true);
     await new Directory(testPackagePath).delete(recursive: true);
   });
 
-  group('end-to-end', () {
+  group('No Download', () {
     test('Copy', () async {
-      await generate.main(['-p', testPackagePath]);
+      await generate.main(['-p', testPackagePath, '-m', mojoSdk]);
       final pregenFile = new File(
           path.join(testMojomPath, 'pregen', 'pregen.mojom.dart'));
       expect(await pregenFile.exists(), isTrue);
     });
 
     test('Copy and Additional', () async {
-      await generate.main(['-p', testPackagePath, '-a', additionalRootPath]);
+      await generate.main(['-p', testPackagePath, '-m', mojoSdk,
+          '-a', additionalRootPath]);
       final additionalFile = new File(
           path.join(testMojomPath, 'additional', 'additional.mojom.dart'));
       expect(await additionalFile.exists(), isTrue);
     });
 
     test('Copy and Generate', () async {
-      if (Platform.environment['MOJO_SDK'] != null) {
-        await generate.main(['-g', '-p', testPackagePath]);
-        final generatedFile = new File(
-            path.join(testMojomPath, 'generated', 'generated.mojom.dart'));
-        expect(await generatedFile.exists(), isTrue);
-      }
+      await generate.main(['-g', '-p', testPackagePath, '-m', mojoSdk]);
+      final generatedFile = new File(
+          path.join(testMojomPath, 'generated', 'generated.mojom.dart'));
+      expect(await generatedFile.exists(), isTrue);
     });
 
     test('All', () async {
-      if (Platform.environment['MOJO_SDK'] != null) {
-        await generate.main([
-            '-g', '-p', testPackagePath, '-a', additionalRootPath]);
+      await generate.main([
+          '-g', '-p', testPackagePath, '-m', mojoSdk,
+          '-a', additionalRootPath]);
 
-        final pregenFile = new File(
-            path.join(testMojomPath, 'pregen', 'pregen.mojom.dart'));
-        expect(await pregenFile.exists(), isTrue);
+      final pregenFile = new File(
+          path.join(testMojomPath, 'pregen', 'pregen.mojom.dart'));
+      expect(await pregenFile.exists(), isTrue);
 
-        final additionalFile = new File(
-            path.join(testMojomPath, 'additional', 'additional.mojom.dart'));
-        expect(await additionalFile.exists(), isTrue);
+      final additionalFile = new File(
+          path.join(testMojomPath, 'additional', 'additional.mojom.dart'));
+      expect(await additionalFile.exists(), isTrue);
 
-        final generatedFile = new File(
-            path.join(testMojomPath, 'generated', 'generated.mojom.dart'));
-        expect(await generatedFile.exists(), isTrue);
-      }
+      final generatedFile = new File(
+          path.join(testMojomPath, 'generated', 'generated.mojom.dart'));
+      expect(await generatedFile.exists(), isTrue);
     });
   });
 
+  group('Download', () {
+    var httpServer;
+    setUp(() async {
+      httpServer = await HttpServer.bindSecure(
+          "localhost",
+          0,
+          certificateName: 'localhost_cert',
+          requestClientCertificate: true);
+      httpServer.listen((HttpRequest request) {
+        String path = request.uri.path;
+        if (path.endsWith('path/to/mojom/download_one.mojom')) {
+          request.response.write(dldMojomContents1);
+        } else if (path.endsWith('path/to/mojom/download_two.mojom')) {
+          request.response.write(dldMojomContents2);
+        } else {
+          request.response.statusCode = HttpStatus.NOT_FOUND;
+        }
+        request.response.close();
+      });
+    });
+
+    tearDown(() {
+      httpServer.close();
+    });
+
+    test('simple', () async {
+      final mojomsFile = new File(dotMojomsPath);
+      await mojomsFile.create(recursive: true);
+      await mojomsFile.writeAsString(
+          "root: https://localhost:${httpServer.port}\n"
+          "path/to/mojom/download_one.mojom\n");
+      await generate.main(['-p', testPackagePath, '-m', mojoSdk, '-d', '-g']);
+      final downloadedFile = new File(
+          path.join(testMojomPath, 'downloaded', 'download_one.mojom.dart'));
+      expect(await downloadedFile.exists(), isTrue);
+      await mojomsFile.delete();
+    });
+
+    test('two files', () async {
+      final mojomsFile = new File(dotMojomsPath);
+      await mojomsFile.create(recursive: true);
+      await mojomsFile.writeAsString(
+          "root: https://localhost:${httpServer.port}\n"
+          "path/to/mojom/download_one.mojom\n"
+          "path/to/mojom/download_two.mojom\n");
+      await generate.main(['-p', testPackagePath, '-m', mojoSdk, '-d', '-g']);
+      final downloaded1File = new File(
+          path.join(testMojomPath, 'downloaded', 'download_one.mojom.dart'));
+      expect(await downloaded1File.exists(), isTrue);
+      final downloaded2File = new File(
+          path.join(testMojomPath, 'downloaded', 'download_two.mojom.dart'));
+      expect(await downloaded2File.exists(), isTrue);
+      await mojomsFile.delete();
+    });
+
+    test('two roots', () async {
+      final mojomsFile = new File(dotMojomsPath);
+      await mojomsFile.create(recursive: true);
+      await mojomsFile.writeAsString(
+          "root: https://localhost:${httpServer.port}\n"
+          "path/to/mojom/download_one.mojom\n"
+          "root: https://localhost:${httpServer.port}\n"
+          "path/to/mojom/download_two.mojom\n");
+      await generate.main(['-p', testPackagePath, '-m', mojoSdk, '-d', '-g']);
+      final downloaded1File = new File(
+          path.join(testMojomPath, 'downloaded', 'download_one.mojom.dart'));
+      expect(await downloaded1File.exists(), isTrue);
+      final downloaded2File = new File(
+          path.join(testMojomPath, 'downloaded', 'download_two.mojom.dart'));
+      expect(await downloaded2File.exists(), isTrue);
+      await mojomsFile.delete();
+    });
+
+    test('simple-comment', () async {
+      final mojomsFile = new File(dotMojomsPath);
+      await mojomsFile.create(recursive: true);
+      await mojomsFile.writeAsString(
+          "# Comments are allowed\n"
+          "root: https://localhost:${httpServer.port}\n\n\n\n"
+          "# Here too\n"
+          "path/to/mojom/download_one.mojom\n"
+          "# And here\n");
+      await generate.main(['-p', testPackagePath, '-m', mojoSdk, '-d', '-g']);
+      final downloadedFile = new File(
+          path.join(testMojomPath, 'downloaded', 'download_one.mojom.dart'));
+      expect(await downloadedFile.exists(), isTrue);
+      await mojomsFile.delete();
+    });
+
+    test('404', () async {
+      final mojomsFile = new File(dotMojomsPath);
+      await mojomsFile.create(recursive: true);
+      await mojomsFile.writeAsString(
+          "root: https://localhost:${httpServer.port}\n"
+          "blah\n");
+      var fail = false;
+      try {
+        await generate.main(['-p', testPackagePath, '-m', mojoSdk, '-d', '-g']);
+      } on generate.DownloadError {
+        fail = true;
+      }
+      expect(fail, isTrue);
+      await mojomsFile.delete();
+    });
+  });
+
   group('Failures', () {
     test('Bad Package Root',() async {
       final dummyPackageRoot = path.join(scriptPath, 'dummyPackageRoot');
       var fail = false;
       try {
-        await generate.main(['-p', dummyPackageRoot]);
+        await generate.main(['-p', dummyPackageRoot, '-m', mojoSdk]);
       } on generate.CommandLineError {
         fail = true;
       }
       expect(fail, isTrue);
     });
 
     test('Non-absolute PackageRoot', () async {
       final dummyPackageRoot = 'dummyPackageRoot';
       var fail = false;
       try {
-        await generate.main(['-p', dummyPackageRoot]);
+        await generate.main(['-p', dummyPackageRoot, '-m', mojoSdk]);
       } on generate.CommandLineError {
         fail = true;
       }
       expect(fail, isTrue);
     });
 
     test('Bad Additional Dir', () async {
       final dummyAdditional = path.join(scriptPath, 'dummyAdditional');
       var fail = false;
       try {
-        await generate.main(['-a', dummyAdditional, '-p', testPackagePath]);
+        await generate.main(['-a', dummyAdditional, '-p', testPackagePath,
+            '-m', mojoSdk]);
       } on generate.CommandLineError {
         fail = true;
       }
       expect(fail, isTrue);
     });
 
     test('Non-absolute Additional Dir', () async {
       final dummyAdditional = 'dummyAdditional';
       var fail = false;
       try {
-        await generate.main(['-a', dummyAdditional, '-p', testPackagePath]);
+        await generate.main(['-a', dummyAdditional, '-p', testPackagePath,
+            '-m', mojoSdk]);
       } on generate.CommandLineError {
         fail = true;
       }
       expect(fail, isTrue);
     });
 
     test('No Mojo Package', () async {
       final dummyPackageRoot = path.join(scriptPath, 'dummyPackageRoot');
       final dummyPackageDir = new Directory(dummyPackageRoot);
       await dummyPackageDir.create(recursive: true);
 
       var fail = false;
       try {
-        await generate.main(['-p', dummyPackageRoot]);
+        await generate.main(['-p', dummyPackageRoot, '-m', mojoSdk]);
       } on generate.CommandLineError {
         fail = true;
       }
       await dummyPackageDir.delete(recursive: true);
       expect(fail, isTrue);
     });
 
     test('Bad Mojo SDK', () async {
       final dummySdk = path.join(scriptPath, 'dummySdk');
       var fail = false;
       try {
         await generate.main(['-g', '-m', dummySdk, '-p', testPackagePath]);
       } on generate.CommandLineError {
         fail = true;
       }
       expect(fail, isTrue);
     });
+
+    test('Download No Server', () async {
+      final mojomsFile = new File(dotMojomsPath);
+      await mojomsFile.create(recursive: true);
+      await mojomsFile.writeAsString(
+          "root: https://localhost\n"
+          "path/to/mojom/download_one.mojom\n");
+      var fail = false;
+      try {
+        await generate.main(['-p', testPackagePath, '-m', mojoSdk, '-d', '-g']);
+      } on generate.DownloadError {
+        fail = true;
+      }
+      expect(fail, isTrue);
+      await mojomsFile.delete();
+    });
+
+    test('.mojoms no root', () async {
+      final mojomsFile = new File(dotMojomsPath);
+      await mojomsFile.create(recursive: true);
+      await mojomsFile.writeAsString(
+          "path/to/mojom/download_one.mojom\n");
+      var fail = false;
+      try {
+        await generate.main(['-p', testPackagePath, '-m', mojoSdk, '-d', '-g']);
+      } on generate.DownloadError {
+        fail = true;
+      }
+      expect(fail, isTrue);
+      await mojomsFile.delete();
+    });
+
+    test('.mojoms blank root', () async {
+      final mojomsFile = new File(dotMojomsPath);
+      await mojomsFile.create(recursive: true);
+      await mojomsFile.writeAsString(
+          "root:\n"
+          "path/to/mojom/download_one.mojom\n");
+      var fail = false;
+      try {
+        await generate.main(['-p', testPackagePath, '-m', mojoSdk, '-d', '-g']);
+      } on generate.DownloadError {
+        fail = true;
+      }
+      expect(fail, isTrue);
+      await mojomsFile.delete();
+    });
+
+    test('.mojoms root not https', () async {
+      final mojomsFile = new File(dotMojomsPath);
+      await mojomsFile.create(recursive: true);
+      await mojomsFile.writeAsString(
+          "root: http://localhost\n"
+          "path/to/mojom/download_one.mojom\n");
+      var fail = false;
+      try {
+        await generate.main(['-p', testPackagePath, '-m', mojoSdk, '-d', '-g']);
+      } on generate.DownloadError {
+        fail = true;
+      }
+      expect(fail, isTrue);
+      await mojomsFile.delete();
+    });
+
+    test('.mojoms root malformed', () async {
+      final mojomsFile = new File(dotMojomsPath);
+      await mojomsFile.create(recursive: true);
+      await mojomsFile.writeAsString(
+          "root: gobledygook\n"
+          "path/to/mojom/download_one.mojom\n");
+      var fail = false;
+      try {
+        await generate.main(['-p', testPackagePath, '-m', mojoSdk, '-d', '-g']);
+      } on generate.DownloadError {
+        fail = true;
+      }
+      expect(fail, isTrue);
+      await mojomsFile.delete();
+    });
+
+    test('.mojoms root without mojom', () async {
+      final mojomsFile = new File(dotMojomsPath);
+      await mojomsFile.create(recursive: true);
+      await mojomsFile.writeAsString(
+          "root: http://localhost\n"
+          "root: http://localhost\n"
+          "path/to/mojom/download_one.mojom\n");
+      var fail = false;
+      try {
+        await generate.main(['-p', testPackagePath, '-m', mojoSdk, '-d', '-g']);
+      } on generate.DownloadError {
+        fail = true;
+      }
+      expect(fail, isTrue);
+      await mojomsFile.delete();
+    });
   });
 }