pkg/stub_core_library/test/stub_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 stub_core_libraries.test;

import 'dart:io';

import 'package:path/path.dart' as p;
import 'package:stub_core_library/stub_core_library.dart';
import 'package:unittest/unittest.dart';

String sandbox;

main() {
  setUp(() {
    sandbox = Directory.systemTemp.createTempSync('stub_core_library_').path;
  });

  tearDown(() => new Directory(sandbox).deleteSync(recursive: true));

  group("imports", () {
    test("dart: imports are preserved by default", () {
      expectStub("""
        import "dart:core";
        import "dart:html";
        import "dart:fblthp";
      """, """
        import "dart:core";
        import "dart:html";
        import "dart:fblthp";
      """);
    });

    test("internal dart: imports are removed", () {
      expectStub("""
        import "dart:_internal";
        import "dart:_blink" as _blink;
        import "dart:_fblthp";
      """, "");
    });

    test("replaced imports are replaced", () {
      expectStub("""
        import "dart:html";
        import "foo.dart" as foo;
      """, """
        import "dart_html.dart";
        import "bar.dart" as foo;
      """, {
        "dart:html": "dart_html.dart",
        "foo.dart": "bar.dart"
      });
    });

    test("exports are replaced as well", () {
      expectStub("""
        export "dart:html";
        export "foo.dart" show foo;
      """, """
        export "dart_html.dart";
        export "bar.dart" show foo;
      """, {
        "dart:html": "dart_html.dart",
        "foo.dart": "bar.dart"
      });
    });
  });

  test("a parted file is stubbed and included inline", () {
    new File(p.join(sandbox, "part.dart")).writeAsStringSync("""
      part of lib;
      void foo() => print('foo!');
    """);

    expectStub("""
      library lib;
      part "part.dart";
    """, """
      library lib;
      void foo() { ${unsupported("foo()")}; }
    """);
  });

  test("a class declaration's native clause is removed", () {
    expectStub("class Foo native 'Foo' {}", "class Foo {}");
  });

  group("constructors", () {
    test("a constructor's body is stubbed out", () {
      expectStub("""
        class Foo {
          Foo() { print("Created a foo!"); }
        }
      """, """
        class Foo {
          Foo() { ${unsupported("new Foo()")}; }
        }
      """);
    });

    test("a constructor's empty body is stubbed out", () {
      expectStub("class Foo { Foo(); }", """
        class Foo {
          Foo() { ${unsupported("new Foo()")}; }
        }
      """);
    });

    test("a constructor's external declaration is removed", () {
      expectStub("class Foo { external Foo(); }", """
        class Foo {
          Foo() { ${unsupported("new Foo()")}; }
        }
      """);
    });

    test("a constructor's field initializers are removed", () {
      expectStub("""
        class Foo {
          final _field1;
          final _field2;

          Foo()
            : _field1 = 1,
              _field2 = 2;
        }
      """, """
        class Foo {
          Foo() { ${unsupported("new Foo()")}; }
        }
      """);
    });

    test("a constructor's redirecting initializers are removed", () {
      expectStub("""
        class Foo {
          Foo() : this.create();
          Foo.create();
        }
      """, """
        class Foo {
          Foo() { ${unsupported("new Foo()")}; }
          Foo.create() { ${unsupported("new Foo.create()")}; }
        }
      """);
    });

    test("a constructor's superclass calls are preserved", () {
      expectStub("""
        class Foo {
          Foo(int i, int j, {int k});
        }

        class Bar extends Foo {
          Bar() : super(1, 2, k: 3);
        }
      """, """
        class Foo {
          Foo(int i, int j, {int k}) { ${unsupported("new Foo()")}; }
        }

        class Bar extends Foo {
          Bar()
              : super(${unsupported("new Bar()")}, null) {
            ${unsupported("new Bar()")};
          }
        }
      """);
    });

    test("a constructor's initializing formals are replaced with normal "
        "parameters", () {
      expectStub("""
        class Foo {
          final int _i;
          var _j;
          final List<int> _k;

          Foo(this._i, this._j, this._k);
        }
      """, """
        class Foo {
          Foo(int _i, _j, List<int> _k) { ${unsupported("new Foo()")}; }
        }
      """);
    });

    test("a const constructor isn't stubbed", () {
      expectStub("class Foo { const Foo(); }", "class Foo { const Foo(); }");
    });

    test("a const constructor's superclass calls are fully preserved", () {
      expectStub("""
        class Foo {
          const Foo(int i, int j, int k);
        }

        class Bar extends Foo {
          const Bar() : super(1, 2, 3);
        }
      """, """
        class Foo {
          const Foo(int i, int j, int k);
        }

        class Bar extends Foo {
          const Bar() : super(1, 2, 3);
        }
      """);
    });

    test("a redirecting const constructor stops redirecting", () {
      expectStub("""
        class Foo {
          const Foo.named(int i, int j, int k)
              : this(i, j, k);
          const Foo(int i, int j, int k);
        }
      """, """
        class Foo {
          const Foo.named(int i, int j, int k);
          const Foo(int i, int j, int k);
        }
      """);
    });
  });

  group("functions", () {
    test("stubs a top-level function", () {
      expectStub("void foo() => print('hello!');",
          "void foo() { ${unsupported('foo()')}; }");
    });

    test("stubs a private top-level function", () {
      expectStub("void _foo() => print('hello!');",
          "void _foo() { ${unsupported('_foo()')}; }");
    });

    test("stubs a method", () {
      expectStub("""
        class Foo {
          foo() => print("hello!");
        }
      """, """
        class Foo {
          foo() { ${unsupported('Foo.foo()')}; }
        }
      """);
    });

    test("empties a method in an unconstructable class", () {
      expectStub("""
        class Foo {
          Foo();
          foo() => print("hello!");
        }
      """, """
        class Foo {
          Foo() { ${unsupported('new Foo()')}; }
          foo() {}
        }
      """);
    });

    test("removes a private instance method", () {
      expectStub("""
        class Foo {
          _foo() => print("hello!");
        }
      """, "class Foo {}");
    });

    test("stubs a private static method", () {
      expectStub("""
        class Foo {
          static _foo() => print("hello!");
        }
      """, """
        class Foo {
          static _foo() { ${unsupported('Foo._foo()')}; }
        }
      """);
    });

    test("preserves an abstract instance method", () {
      expectStub("abstract class Foo { foo(); }",
          "abstract class Foo { foo(); }");
    });

    test("removes a native function body", () {
      expectStub("void foo() native 'foo';",
          "void foo() { ${unsupported('foo()')}; }");
    });
  });

  group("top-level fields", () {
    test("stubs out a top-level field", () {
      expectStub("int foo;", """
        int get foo => ${unsupported('foo')};
        set foo(int _) { ${unsupported('foo=')}; }
      """);
    });

    test("stubs out a top-level field with a value", () {
      expectStub("int foo = 12;", """
        int get foo => ${unsupported('foo')};
        set foo(int _) { ${unsupported('foo=')}; }
      """);
    });

    test("stubs out a final top-level field", () {
      expectStub("final int foo = 12;",
          "int get foo => ${unsupported('foo')};");
    });

    test("preserves a const top-level field", () {
      expectStub("const foo = 12;", "const foo = 12;");
    });

    test("removes a private top-level field", () {
      expectStub("int _foo = 12;", "");
    });

    test("preserves a private const top-level field", () {
      expectStub("const _foo = 12;", "const _foo = 12;");
    });

    test("splits a multiple-declaration top-level field", () {
      expectStub("int foo, bar, baz;", """
        int get foo => ${unsupported('foo')};
        set foo(int _) { ${unsupported('foo=')}; }
        int get bar => ${unsupported('bar')};
        set bar(int _) { ${unsupported('bar=')}; }
        int get baz => ${unsupported('baz')};
        set baz(int _) { ${unsupported('baz=')}; }
      """);
    });
  });

  group("instance fields", () {
    test("stubs out an instance field", () {
      expectStub("class Foo { int foo; }", """
        class Foo {
          int get foo => ${unsupported('Foo.foo')};
          set foo(int _) { ${unsupported('Foo.foo=')}; }
        }
      """);
    });

    test("stubs out an instance field with a value", () {
      expectStub("class Foo { int foo = 12; }", """
        class Foo {
          int get foo => ${unsupported('Foo.foo')};
          set foo(int _) { ${unsupported('Foo.foo=')}; }
        }
      """);
    });

    test("stubs out a final instance field", () {
      expectStub("class Foo { final int foo = 12; }", """
        class Foo {
           int get foo => ${unsupported('Foo.foo')};
        }
      """);
    });

    test("removes a private instance field", () {
      expectStub("class Foo { int _foo = 12; }", "class Foo { }");
    });

    test("stubs out a static instance field", () {
      expectStub("class Foo { static int foo = 12; }", """
        class Foo {
           static int get foo => ${unsupported('Foo.foo')};
           static set foo(int _) { ${unsupported('Foo.foo=')}; }
        }
      """);
    });

    test("removes a private static instance field", () {
      expectStub("class Foo { static int _foo = 12; }", "class Foo { }");
    });

    test("preserves a static const instance field", () {
      expectStub("class Foo { static const foo = 12; }",
          "class Foo { static const foo = 12; }");
    });

    test("nulls a field for an unconstructable class", () {
      expectStub("""
        class Foo {
          Foo();
          final foo = 12;
        }
      """, """
        class Foo {
          Foo() { ${unsupported("new Foo()")}; }
          final foo = null;
        }
      """);
    });

    test("splits a multiple-declaration instance field", () {
      expectStub("class Foo { int foo, bar, baz; }", """
        class Foo {
          int get foo => ${unsupported('Foo.foo')};
          set foo(int _) { ${unsupported('Foo.foo=')}; }
          int get bar => ${unsupported('Foo.bar')};
          set bar(int _) { ${unsupported('Foo.bar=')}; }
          int get baz => ${unsupported('Foo.baz')};
          set baz(int _) { ${unsupported('Foo.baz=')}; }
        }
      """);
    });
  });
}

/// Expects that [source] will transform into [expected] when stubbed.
void expectStub(String source, String expected,
    [Map<String, String> importReplacements]) {
  expect(stubCode(source, p.join(sandbox, 'source.dart'), importReplacements),
      equalsIgnoringWhitespace(expected));
}

/// Returns code for throwing an [UnsupportedError] for the given name.
String unsupported(String name) => 'throw new UnsupportedError("$name is '
    'unsupported on this platform.")';