Make browser tests all run from a server instead of the local filesystem.

tools/testing/dart/test_suite.dart

 // Copyright (c) 2012, 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.
 
 /**
  * Classes and methods for enumerating and preparing tests.
  *
  * This library includes:
  *
  * - Creating tests by listing all the Dart files in certain directories,
  *   and creating [TestCase]s for those files that meet the relevant criteria.
  * - Preparing tests, including copying files and frameworks to temporary
  *   directories, and computing the command line and arguments to be run.
  */
 library test_suite;
 
 import "dart:async";
 import "dart:io";
 import "dart:isolate";
 import "status_file_parser.dart";
 import "test_runner.dart";
 import "multitest.dart";
 import "drt_updater.dart";
 import "dart:uri";
+import '../../../pkg/path/lib/path.dart' as pathLib;
 
 part "browser_test.dart";
 
 
 // TODO(rnystrom): Add to dart:core?
 /**
  * A simple function that tests [arg] and returns `true` or `false`.
  */
 typedef bool Predicate<T>(T arg);
 
@@ skipping 366 matching lines @@
  */
 class StandardTestSuite extends TestSuite {
   final Path suiteDir;
   final List<String> statusFilePaths;
   TestCaseEvent doTest;
   TestExpectations testExpectations;
   List<TestInformation> cachedTests;
   final Path dartDir;
   Predicate<String> isTestFilePredicate;
   final bool listRecursively;
+  /**
+   * The set of servers that have been started to run these tests (Could be
+   * none).
+   */
+  List serverList;
 
   StandardTestSuite(Map configuration,
                     String suiteName,
                     Path suiteDirectory,
                     this.statusFilePaths,
+                    this.serverList,

[ahe, 2013/01/10 09:17:58]

Why not use a named argument?

[Emily Fortuna, 2013/01/11 02:57:12]

good idea. fixed.

                     {this.isTestFilePredicate,
                     bool recursive: false})
   : super(configuration, suiteName),
     dartDir = TestUtils.dartDir(),
     listRecursively = recursive,
     suiteDir = TestUtils.dartDir().join(suiteDirectory);
 
   /**
    * Creates a test suite whose file organization matches an expected structure.
    * To use this, your suite should look like:
@@ skipping 13 matching lines @@
    * * The status file uses the same name.
    * * Test files are directly in that directory and end in "_test.dart".
    *
    * If you follow that convention, then you can construct one of these like:
    *
    * new StandardTestSuite.forDirectory(configuration, 'path/to/mytestsuite');
    *
    * instead of having to create a custom [StandardTestSuite] subclass. In
    * particular, if you add 'path/to/mytestsuite' to [TEST_SUITE_DIRECTORIES]
    * in test.dart, this will all be set up for you.
+   *
+   * The [StandardTestSuite] also optionally takes a list of servers that have
+   * been started up by the test harness, to be used by browser tests.
    */
   factory StandardTestSuite.forDirectory(
-      Map configuration, Path directory) {
+      Map configuration, Path directory, [List serverList = const []]) {
     final name = directory.filename;
 
     return new StandardTestSuite(configuration,
         name, directory,
         ['$directory/$name.status', '$directory/${name}_dart2js.status'],
+        serverList,
         isTestFilePredicate: (filename) => filename.endsWith('_test.dart'),
         recursive: true);
   }
 
   Collection<Uri> get dart2JsBootstrapDependencies {
     if (!useSdk) return [];
 
     var snapshotPath = TestUtils.absolutePath(new Path(buildDir).join(
         new Path('dart-sdk/lib/_internal/compiler/'
                  'implementation/dart2js.dart.snapshot'))).toString();
@@ skipping 386 matching lines @@
           dartLibraryFilename = new Path('test_as_library.dart');
           File file = new File('$tempDir/$dartLibraryFilename');
           RandomAccessFile dartLibrary = file.openSync(FileMode.WRITE);
           dartLibrary.writeStringSync(wrapDartTestInLibrary(filePath));
           dartLibrary.closeSync();
         }
 
         File file = new File(dartWrapperFilename);
         RandomAccessFile dartWrapper = file.openSync(FileMode.WRITE);
         dartWrapper.writeStringSync(
-            dartTestWrapper(dartDir, dartLibraryFilename));
+            dartTestWrapper(dartDir, file.name, dartLibraryFilename));
         dartWrapper.closeSync();
       } else {
         dartWrapperFilename = filename;
         // TODO(whesse): Once test.py is retired, adjust the relative path in
         // the client/samples/dartcombat test to its css file, remove the
         // "../../" from this path, and move this out of the isWebTest guard.
         // Also remove getHtmlName, and just use test.html.
         // TODO(efortuna): this shortening of htmlFilename is a band-aid until
         // the above TODO gets fixed. Windows cannot have paths that are longer
         // than 260 characters, and without this hack, we were running past the
         // the limit.
         String htmlFilename = getHtmlName(filename);
         while ('$tempDir/../$htmlFilename'.length >= 260) {
           htmlFilename = htmlFilename.substring(htmlFilename.length~/2);
         }
         htmlPath = '$tempDir/../$htmlFilename';
       }
       final String scriptPath = (compiler == 'none') ?
           dartWrapperFilename : compiledDartWrapperFilename;
       // Create the HTML file for the test.
       RandomAccessFile htmlTest = new File(htmlPath).openSync(FileMode.WRITE);
-      String filePrefix = '';
-      if (Platform.operatingSystem == 'windows') {
-        // Firefox on Windows does not like absolute file path names that start
-        // with 'C:' adding 'file:///' solves the problem.
-        filePrefix = 'file:///';
-      }
       String content = null;
       Path dir = filePath.directoryPath;
       String nameNoExt = filePath.filenameWithoutExtension;
       Path pngPath = dir.append('$nameNoExt.png');
       Path txtPath = dir.append('$nameNoExt.txt');
       Path expectedOutput = null;
       if (new File.fromPath(pngPath).existsSync()) {
         expectedOutput = pngPath;
-        content = getHtmlLayoutContents(scriptType, '$filePrefix$scriptPath');
+        content = getHtmlLayoutContents(scriptType, pathLib.relative(scriptPath,
+            from: pathLib.dirname(htmlPath)));
       } else if (new File.fromPath(txtPath).existsSync()) {
         expectedOutput = txtPath;
-        content = getHtmlLayoutContents(scriptType, '$filePrefix$scriptPath');
+        content = getHtmlLayoutContents(scriptType, pathLib.relative(scriptPath,
+            from: pathLib.dirname(htmlPath)));
       } else {
         final htmlLocation = new Path.fromNative(htmlPath);
         content = getHtmlContents(
           filename,
           dartDir.append('pkg/unittest/test_controller.js')
               .relativeTo(htmlLocation),
           dartDir.append('pkg/browser/lib/dart.js').relativeTo(htmlLocation),
           scriptType,
           new Path.fromNative(scriptPath).relativeTo(htmlLocation));
       }
@@ skipping 29 matching lines @@
       do {
         List<Command> commandSet = new List<Command>.from(commands);
         if (subtestIndex != 0) {
           // NOTE: The first time we enter this loop, all the compilation
           // commands will be executed. On subsequent loop iterations, we
           // don't need to do any compilations. Thus we set "commandSet = []".
           commandSet = [];
         }
 
         List<String> args = <String>[];
-        String fullHtmlPath = htmlPath.startsWith('http:') ? htmlPath :
-            (htmlPath.startsWith('/') ?
-             'file://$htmlPath' :
-             'file:///$htmlPath');
+        var basePath = TestUtils.dartDir().toString();
+        if (!htmlPath.startsWith('/') && !htmlPath.startsWith('http')) {
+          htmlPath = '/$htmlPath';
+        }
+        htmlPath = htmlPath.startsWith(basePath) ?
+            htmlPath.substring(basePath.length) : htmlPath;
+        String fullHtmlPath = htmlPath;
+        if (!htmlPath.startsWith('http')) {
+          fullHtmlPath = 'http://127.0.0.1:${serverList[0].port}$htmlPath?'
+              'crossOriginPort=${serverList[1].port}';
+        }
         if (info.optionsFromFile['isMultiHtmlTest']
             && subtestNames.length > 0) {
           fullHtmlPath = '${fullHtmlPath}#${subtestNames[subtestIndex]}';
         }
 
         if (TestUtils.usesWebDriver(runtime)) {
           args = [
               dartDir.append('tools/testing/run_selenium.py').toNativePath(),
               '--browser=$runtime',
               '--timeout=${configuration["timeout"] - 2}',
               '--out="$fullHtmlPath"'];
           if (runtime == 'dartium') {
             args.add('--executable=$dartiumFilename');
           }
           if (subtestIndex != 0) {
             args.add('--force-refresh');
           }
           commandSet.add(new Command('python', args));
         } else {
           Expect.isTrue(runtime == "drt");
 
           var dartFlags = [];
           var dumpRenderTreeOptions = [];
-          var packageRootUri;
 
           dumpRenderTreeOptions.add('--no-timeout');
 
           if (compiler == 'none' || compiler == 'dart2dart') {
             dartFlags.add('--ignore-unrecognized-flags');
             if (configuration["checked"]) {
               dartFlags.add('--enable_asserts');
               dartFlags.add("--enable_type_checks");
             }
             dartFlags.addAll(vmOptions);
           }
-          if (compiler == 'none') {
-            var packageRootPath = packageRoot(optionsFromFile['packageRoot']);
-            if (packageRootPath != null) {
-              var absolutePath =
-                  TestUtils.absolutePath(new Path(packageRootPath));
-              packageRootUri = new Uri.fromComponents(
-                  scheme: 'file',
-                  path: absolutePath.toString());
-            }
-          }
 
           if (expectedOutput != null) {
             if (expectedOutput.toNativePath().endsWith('.png')) {
               // pixel tests are specified by running DRT "foo.html'-p"
               dumpRenderTreeOptions.add('--notree');
               fullHtmlPath = "${fullHtmlPath}'-p";
             }
           }
           commandSet.add(new DumpRenderTreeCommand(dumpRenderTreeFilename,
                                                    fullHtmlPath,
                                                    dumpRenderTreeOptions,
                                                    dartFlags,
-                                                   packageRootUri,
                                                    expectedOutput));
         }
 
         // Create BrowserTestCase and queue it.
         String testDisplayName = '$suiteName/$testName';
         var testCase;
         if (info.optionsFromFile['isMultiHtmlTest']) {
           testDisplayName = '$testDisplayName/${subtestNames[subtestIndex]}';
           testCase = new BrowserTestCase(testDisplayName,
               commandSet, configuration, completeHandler,
@@ skipping 73 matching lines @@
     }
 
     // Create '[build dir]/generated_tests/$compiler-$runtime/$testUniqueName',
     // including any intermediate directories that don't exist.
     // If the tests are run in checked or minified mode we add that to the
     // '$compile-$runtime' directory name.
     var checked = configuration['checked'] ? '-checked' : '';
     var minified = configuration['minified'] ? '-minified' : '';
     var dirName = "${configuration['compiler']}-${configuration['runtime']}"
                   "$checked$minified";
-    Path generatedTestPath = new Path.fromNative(buildDir)
+    Path generatedTestPath = new Path.fromNative(dartDir.toString())
+        .append(buildDir.toString())
         .append('generated_tests')
         .append(dirName)
         .append(testUniqueName);
 
     TestUtils.mkdirRecursive(new Path('.'), generatedTestPath);
     return new File.fromPath(generatedTestPath).fullPathSync()
         .replaceAll('\\', '/');
   }
 
   String get scriptType {
@@ skipping 320 matching lines @@
   List<String> _testDirs;
 
   DartcCompilationTestSuite(Map configuration,
                             String suiteName,
                             String directoryPath,
                             List<String> this._testDirs,
                             List<String> expectations)
       : super(configuration,
               suiteName,
               new Path.fromNative(directoryPath),
-              expectations);
+              expectations,
+              []);
 
   List<String> additionalOptions(Path filePath) {
     return ['--fatal-warnings', '--fatal-type-errors'];
   }
 
   Future enqueueTests() {
     var group = new FutureGroup();
 
     for (String testDir in _testDirs) {
       Directory dir = new Directory.fromPath(suiteDir.append(testDir));
@@ skipping 290 matching lines @@
       outputDir = 'out/';
     } else if (system == 'macos') {
       outputDir = 'xcodebuild/';
     } else if (system == 'windows') {
       outputDir = 'build/';
     }
     return "$outputDir${configurationDir(configuration)}";
   }
 
   static String configurationDir(Map configuration) {
+    // For regular dart checkouts, the configDir by default is mode+arch.
+    // For Dartium, the configDir by default is mode (as defined by the Chrome
+    // build setup). We can detect this because in the dartium checkout, the
+    // "output" directory is a sibling of the dart directory instead of a child.
     var mode = (configuration['mode'] == 'debug') ? 'Debug' : 'Release';
     var arch = configuration['arch'].toUpperCase();
-    return '$mode$arch';
+    if (currentWorkingDirectory != dartDir()) {
+      return '$mode$arch';
+    } else {
+      return mode;
+    }
+  }
+
+  /**
+   * Returns the path to the dart binary checked into the repo, used for
+   * bootstrapping test.dart.
+   */
+  static String get dartTestExecutable {
+    var path = '${TestUtils.dartDir()}/tools/testing/bin/'
+        '${Platform.operatingSystem}/dart';
+    if (Platform.operatingSystem == 'windows') {
+      path.append('.exe');
+    }
+    return path;

[kustermann, 2013/01/10 09:05:42]

We should really use the Path class everywhere we can. There are currently a lot
of places where we use Strings instead.

   }
 }
 
 class SummaryReport {
   static int total = 0;
   static int skipped = 0;
   static int noCrash = 0;
   static int pass = 0;
   static int failOk = 0;
   static int fail = 0;
@@ skipping 41 matching lines @@
  * $pass tests are expected to pass
  * $failOk tests are expected to fail that we won't fix
  * $fail tests are expected to fail that we should fix
  * $crash tests are expected to crash that we should fix
  * $timeout tests are allowed to timeout
  * $compileErrorSkip tests are skipped on browsers due to compile-time error
 """;
     print(report);
    }
 }