Take Sam Elkhateeb's path for "path" dependencies and clean it up some.

utils/tests/pub/validator_test.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.
 
 library validator_test;
 
 import 'dart:async';
 import 'dart:io';
 import 'dart:json' as json;
 import 'dart:math' as math;
 
 import 'test_pub.dart';
-import '../../../pkg/unittest/lib/unittest.dart';
 import '../../../pkg/http/lib/http.dart' as http;
 import '../../../pkg/http/lib/testing.dart';
+import '../../../pkg/path/lib/path.dart' as path;
+import '../../../pkg/unittest/lib/unittest.dart';
 import '../../pub/entrypoint.dart';
 import '../../pub/io.dart';
 import '../../pub/validator.dart';
 import '../../pub/validator/compiled_dartdoc.dart';
 import '../../pub/validator/dependency.dart';
 import '../../pub/validator/directory.dart';
 import '../../pub/validator/lib.dart';
 import '../../pub/validator/license.dart';
 import '../../pub/validator/name.dart';
 import '../../pub/validator/pubspec_field.dart';
 import '../../pub/validator/size.dart';
 import '../../pub/validator/utf8_readme.dart';
 
 void expectNoValidationError(ValidatorCreator fn) {
   expectLater(schedulePackageValidation(fn), pairOf(isEmpty, isEmpty));
 }
 
 void expectValidationError(ValidatorCreator fn) {
   expectLater(schedulePackageValidation(fn), pairOf(isNot(isEmpty), anything));
 }
 
 void expectValidationWarning(ValidatorCreator fn) {
   expectLater(schedulePackageValidation(fn), pairOf(isEmpty, isNot(isEmpty)));
 }
 
+expectDependencyValidationError(String error) {
+  expectLater(schedulePackageValidation(dependency),
+      pairOf(someElement(contains(error)), isEmpty));
+}
+
+expectDependencyValidationWarning(String warning) {
+  expectLater(schedulePackageValidation(dependency),
+      pairOf(isEmpty, someElement(contains(warning))));
+}
+
 Validator compiledDartdoc(Entrypoint entrypoint) =>
   new CompiledDartdocValidator(entrypoint);
 
 Validator dependency(Entrypoint entrypoint) =>
   new DependencyValidator(entrypoint);
 
 Validator directory(Entrypoint entrypoint) =>
   new DirectoryValidator(entrypoint);
 
 Validator lib(Entrypoint entrypoint) => new LibValidator(entrypoint);
 
 Validator license(Entrypoint entrypoint) => new LicenseValidator(entrypoint);
 
 Validator name(Entrypoint entrypoint) => new NameValidator(entrypoint);
 
 Validator pubspecField(Entrypoint entrypoint) =>
   new PubspecFieldValidator(entrypoint);
 
 Function size(int size) {
   return (entrypoint) =>
       new SizeValidator(entrypoint, new Future.immediate(size));
 }
 
 Validator utf8Readme(Entrypoint entrypoint) =>
   new Utf8ReadmeValidator(entrypoint);
 
 void scheduleNormalPackage() => normalPackage.scheduleCreate();
 
+/// Sets up a test package with dependency [dep] and mocks a server with
+/// [hostedVersions] of the package available.
+setUpDependency(Map dep, {List<String> hostedVersions}) {
+  useMockClient(new MockClient((request) {
+    expect(request.method, equals("GET"));
+    expect(request.url.path, equals("/packages/foo.json"));
+
+    if (hostedVersions == null) {
+      return new Future.immediate(new http.Response("not found", 404));
+    } else {
+      return new Future.immediate(new http.Response(json.stringify({
+        "name": "foo",
+        "uploaders": ["nweiz@google.com"],
+        "versions": hostedVersions
+      }), 200));
+    }
+  }));
+
+  dir(appPath, [
+    libPubspec("test_pkg", "1.0.0", deps: [dep])
+  ]).scheduleCreate();
+}
+
 main() {
+  initConfig();
   group('should consider a package valid if it', () {
     setUp(scheduleNormalPackage);
 
     integration('looks normal', () {
       dir(appPath, [libPubspec("test_pkg", "1.0.0")]).scheduleCreate();
       expectNoValidationError(dependency);
       expectNoValidationError(lib);
       expectNoValidationError(license);
       expectNoValidationError(name);
       expectNoValidationError(pubspecField);
@@ skipping 239 matching lines @@
     integration('has a lib directory containing only src', () {
       file(join(appPath, "lib", "test_pkg.dart"), '').scheduleDelete();
       dir(appPath, [
         dir("lib", [
           dir("src", [file("test_pkg.dart", "int i = 0;")])
         ])
       ]).scheduleCreate();
       expectValidationError(lib);
     });
 
-    group('has a dependency with a non-hosted source', () {
-      group('where a hosted version of that dependency exists', () {
-        integration("and should suggest the hosted package's primary "
-            "version", () {
-          useMockClient(new MockClient((request) {
-            expect(request.method, equals("GET"));
-            expect(request.url.path, equals("/packages/foo.json"));
-
-            return new Future.immediate(new http.Response(json.stringify({
-              "name": "foo",
-              "uploaders": ["nweiz@google.com"],
-              "versions": ["3.0.0-pre", "2.0.0", "1.0.0"]
-            }), 200));
-          }));
-
-          dir(appPath, [
-            libPubspec("test_pkg", "1.0.0", deps: [
-              {'git': 'git://github.com/dart-lang/foo'}
-            ])
-          ]).scheduleCreate();
-
-          expectLater(schedulePackageValidation(dependency),
-              pairOf(isEmpty, someElement(contains(
-                  '  foo: ">=2.0.0 <3.0.0"'))));
+    group('has a git dependency', () {
+      group('where a hosted version exists', () {
+        integration("and should suggest the hosted primary version", () {
+          setUpDependency({'git': 'git://github.com/dart-lang/foo'},
+              hostedVersions: ["3.0.0-pre", "2.0.0", "1.0.0"]);
+          expectDependencyValidationWarning('  foo: ">=2.0.0 <3.0.0"');
         });
 
-        integration("and should suggest the hosted package's prerelease "
-            "version if it's the only version available", () {
-          useMockClient(new MockClient((request) {
-            expect(request.method, equals("GET"));
-            expect(request.url.path, equals("/packages/foo.json"));
-
-            return new Future.immediate(new http.Response(json.stringify({
-              "name": "foo",
-              "uploaders": ["nweiz@google.com"],
-              "versions": ["3.0.0-pre", "2.0.0-pre"]
-            }), 200));
-          }));
-
-          dir(appPath, [
-            libPubspec("test_pkg", "1.0.0", deps: [
-              {'git': 'git://github.com/dart-lang/foo'}
-            ])
-          ]).scheduleCreate();
-
-          expectLater(schedulePackageValidation(dependency),
-              pairOf(isEmpty, someElement(contains(
-                  '  foo: ">=3.0.0-pre <4.0.0"'))));
+        integration("and should suggest the hosted prerelease version if "
+                    "it's the only version available", () {
+          setUpDependency({'git': 'git://github.com/dart-lang/foo'},
+              hostedVersions: ["3.0.0-pre", "2.0.0-pre"]);
+          expectDependencyValidationWarning('  foo: ">=3.0.0-pre <4.0.0"');
         });
 
-        integration("and should suggest a tighter constraint if the primary "
-            "version is pre-1.0.0", () {
-          useMockClient(new MockClient((request) {
-            expect(request.method, equals("GET"));
-            expect(request.url.path, equals("/packages/foo.json"));
-
-            return new Future.immediate(new http.Response(json.stringify({
-              "name": "foo",
-              "uploaders": ["nweiz@google.com"],
-              "versions": ["0.0.1", "0.0.2"]
-            }), 200));
-          }));
-
-          dir(appPath, [
-            libPubspec("test_pkg", "1.0.0", deps: [
-              {'git': 'git://github.com/dart-lang/foo'}
-            ])
-          ]).scheduleCreate();
-
-          expectLater(schedulePackageValidation(dependency),
-              pairOf(isEmpty, someElement(contains(
-                  '  foo: ">=0.0.2 <0.0.3"'))));
+        integration("and should suggest a tighter constraint if primary is "
+                    "pre-1.0.0", () {
+          setUpDependency({'git': 'git://github.com/dart-lang/foo'},
+              hostedVersions: ["0.0.1", "0.0.2"]);
+          expectDependencyValidationWarning('  foo: ">=0.0.2 <0.0.3"');
         });
       });
 
-      group('where no hosted version of that dependency exists', () {
+      group('where no hosted version exists', () {
         integration("and should use the other source's version", () {
-          useMockClient(new MockClient((request) {
-            expect(request.method, equals("GET"));
-            expect(request.url.path, equals("/packages/foo.json"));
-
-            return new Future.immediate(new http.Response("not found", 404));
-          }));
-
-          dir(appPath, [
-            libPubspec("test_pkg", "1.0.0", deps: [
-              {
-                'git': {'url': 'git://github.com/dart-lang/foo'},
-                'version': '>=1.0.0 <2.0.0'
-              }
-            ])
-          ]).scheduleCreate();
-
-          expectLater(schedulePackageValidation(dependency),
-              pairOf(isEmpty, someElement(contains(
-                  '  foo: ">=1.0.0 <2.0.0"'))));
+          setUpDependency({
+            'git': 'git://github.com/dart-lang/foo',
+            'version': '>=1.0.0 <2.0.0'
+          });
+          expectDependencyValidationWarning('  foo: ">=1.0.0 <2.0.0"');
         });
 
         integration("and should use the other source's unquoted version if "
-            "it's concrete", () {
-          useMockClient(new MockClient((request) {
-            expect(request.method, equals("GET"));
-            expect(request.url.path, equals("/packages/foo.json"));
-
-            return new Future.immediate(new http.Response("not found", 404));
-          }));
-
-          dir(appPath, [
-            libPubspec("test_pkg", "1.0.0", deps: [
-              {
-                'git': {'url': 'git://github.com/dart-lang/foo'},
-                'version': '0.2.3'
-              }
-            ])
-          ]).scheduleCreate();
-
-          expectLater(schedulePackageValidation(dependency),
-              pairOf(isEmpty, someElement(contains('  foo: 0.2.3'))));
+                    "concrete", () {
+          setUpDependency({
+            'git': 'git://github.com/dart-lang/foo',
+            'version': '0.2.3'
+          });
+          expectDependencyValidationWarning('  foo: 0.2.3');
         });
       });
     });
+
+    group('has a path dependency', () {
+      group('where a hosted version exists', () {
+        integration("and should suggest the hosted primary version", () {
+          setUpDependency({'path': path.join(sandboxDir, 'foo')},
+              hostedVersions: ["3.0.0-pre", "2.0.0", "1.0.0"]);
+          expectDependencyValidationError('  foo: ">=2.0.0 <3.0.0"');
+        });
+
+        integration("and should suggest the hosted prerelease version if "
+                    "it's the only version available", () {
+          setUpDependency({'path': path.join(sandboxDir, 'foo')},
+              hostedVersions: ["3.0.0-pre", "2.0.0-pre"]);
+          expectDependencyValidationError('  foo: ">=3.0.0-pre <4.0.0"');
+        });
+
+        integration("and should suggest a tighter constraint if primary is "
+                    "pre-1.0.0", () {
+          setUpDependency({'path': path.join(sandboxDir, 'foo')},
+              hostedVersions: ["0.0.1", "0.0.2"]);
+          expectDependencyValidationError('  foo: ">=0.0.2 <0.0.3"');
+        });
+      });
+
+      group('where no hosted version exists', () {
+        integration("and should use the other source's version", () {
+          setUpDependency({
+            'path': path.join(sandboxDir, 'foo'),
+            'version': '>=1.0.0 <2.0.0'
+          });
+          expectDependencyValidationError('  foo: ">=1.0.0 <2.0.0"');
+        });
+
+        integration("and should use the other source's unquoted version if "
+                    "concrete", () {
+          setUpDependency({
+            'path': path.join(sandboxDir, 'foo'),
+            'version': '0.2.3'
+          });
+          expectDependencyValidationError('  foo: 0.2.3');
+        });
+      });
+    });
 
     group('has an unconstrained dependency', () {
       group('and it should not suggest a version', () {
         integration("if there's no lockfile", () {
           dir(appPath, [
             libPubspec("test_pkg", "1.0.0", deps: [
               {'hosted': 'foo'}
             ])
           ]).scheduleCreate();
 
@@ skipping 40 matching lines @@
                   'source': 'hosted',
                   'description': {
                     'name': 'foo',
                     'url': 'http://pub.dartlang.org'
                   }
                 }
               }
             }))
           ]).scheduleCreate();
 
-          expectLater(schedulePackageValidation(dependency),
-              pairOf(isEmpty, someElement(contains(
-                  '  foo: ">=1.2.3 <2.0.0"'))));
+          expectDependencyValidationWarning('  foo: ">=1.2.3 <2.0.0"');
         });
 
         integration('and it should suggest a concrete constraint if the locked '
             'version is pre-1.0.0', () {
           dir(appPath, [
             libPubspec("test_pkg", "1.0.0", deps: [
               {'hosted': 'foo'}
             ]),
             file("pubspec.lock", json.stringify({
               'packages': {
                 'foo': {
                   'version': '0.1.2',
                   'source': 'hosted',
                   'description': {
                     'name': 'foo',
                     'url': 'http://pub.dartlang.org'
                   }
                 }
               }
             }))
           ]).scheduleCreate();
 
-          expectLater(schedulePackageValidation(dependency),
-              pairOf(isEmpty, someElement(contains(
-                  '  foo: ">=0.1.2 <0.1.3"'))));
+          expectDependencyValidationWarning('  foo: ">=0.1.2 <0.1.3"');
         });
       });
     });
 
     integration('has a hosted dependency on itself', () {
       dir(appPath, [
         libPubspec("test_pkg", "1.0.0", deps: [
           {'hosted': {'name': 'test_pkg', 'version': '>=1.0.0'}}
         ])
       ]).scheduleCreate();
@@ skipping 32 matching lines @@
     });
 
     test('has a README with invalid utf-8', () {
       dir(appPath, [
         binaryFile("README", [192])
       ]).scheduleCreate();
       expectValidationWarning(utf8Readme);
     });
   });
 }