@angular-wave/angular.ts 0.0.21 → 0.0.23

package/test/router/ng-state-builder.spec.js

@@ -0,0 +1,81 @@
+import { StateBuilder } from "../../src/router/state/stateBuilder";
+
+describe("Ng1 StateBuilder", function () {
+  const parent = { name: "" };
+  let builder,
+    matcher,
+    urlMatcherFactoryProvider = {
+      compile: function () {},
+      isMatcher: function () {},
+    };
+
+  beforeEach(function () {
+    matcher = new StateBuilder({});
+    builder = new StateBuilder(matcher, urlMatcherFactoryProvider);
+    builder.builder("views", ng1ViewsBuilder);
+  });
+
+  it("should use the state object to build a default view, when no `views` property is found", function () {
+    const config = {
+      url: "/foo",
+      templateUrl: "/foo.html",
+      controller: "FooController",
+      parent: parent,
+    };
+    const built = builder.builder("views")(config);
+
+    expect(built.$default).not.toEqual(config);
+    expect(built.$default).toEqual(
+      expect.objectContaining({
+        templateUrl: "/foo.html",
+        controller: "FooController",
+        resolveAs: "$resolve",
+      }),
+    );
+  });
+
+  it("It should use the views object to build views, when defined", function () {
+    const config = { a: { foo: "bar", controller: "FooController" } };
+    const builtViews = builder.builder("views")({
+      parent: parent,
+      views: config,
+    });
+    expect(builtViews.a.foo).toEqual(config.a.foo);
+    expect(builtViews.a.controller).toEqual(config.a.controller);
+  });
+
+  it("should not allow a view config with both component and template keys", inject(function (
+    $injector,
+  ) {
+    const config = {
+      name: "foo",
+      url: "/foo",
+      template: "<h1>hey</h1>",
+      controller: "FooController",
+      parent: parent,
+    };
+    expect(() => builder.builder("views")(config)).not.toThrow();
+    expect(() =>
+      builder.builder("views")(
+        Object.assign({ component: "fooComponent" }, config),
+      ),
+    ).toThrow();
+    expect(() =>
+      builder.builder("views")(
+        Object.assign({ componentProvider: () => "fooComponent" }, config),
+      ),
+    ).toThrow();
+    expect(() =>
+      builder.builder("views")(Object.assign({ bindings: {} }, config)),
+    ).toThrow();
+  }));
+
+  it("should replace a resolve: string value with a function that injects the service of the same name", inject(function (
+    $injector,
+  ) {
+    const config = { resolve: { foo: "bar" } };
+    expect(builder.builder("resolvables")).toBeDefined();
+    const built = builder.builder("resolvables")(config);
+    expect(built[0].deps).toEqual(["bar"]);
+  }));
+});

package/test/router/services.spec.js

@@ -0,0 +1,70 @@
+import { Angular } from "../../src/loader";
+import { publishExternalAPI } from "../../src/public";
+
+describe("router services", () => {
+  let providers;
+  let $routerProvider;
+  let $injector;
+
+  beforeEach(() => {
+    window.angular = new Angular();
+    publishExternalAPI();
+    let module = window.angular.module("defaultModule", ["ui.router"]);
+    module.config(
+      (
+        _$routerProvider_,
+        $urlMatcherFactoryProvider,
+        $stateRegistryProvider,
+        $routerGlobalsProvider,
+        $transitionsProvider,
+        $stateProvider,
+      ) => {
+        $routerProvider = _$routerProvider_;
+        expect($routerProvider["router"]).toBe($routerProvider);
+        providers = {
+          $routerProvider,
+          $urlMatcherFactoryProvider,
+          $stateRegistryProvider,
+          $routerGlobalsProvider,
+          $transitionsProvider,
+          $stateProvider,
+        };
+      },
+    );
+
+    $injector = window.angular.bootstrap(document.getElementById("dummy"), [
+      "defaultModule",
+    ]);
+  });
+
+  it("Should expose ui-router providers from the UIRouter instance", () => {
+    expect(providers.$urlMatcherFactoryProvider).toBe(
+      $routerProvider.urlMatcherFactory,
+    );
+    expect(providers.$urlRouterProvider).toBe(
+      $routerProvider.urlRouterProvider,
+    );
+    expect(providers.$stateRegistryProvider).toBe(
+      $routerProvider.stateRegistry,
+    );
+    expect(providers.$routerGlobalsProvider).toBe($routerProvider.globals);
+    expect(providers.$transitionsProvider).toBe(
+      $routerProvider.transitionService,
+    );
+    expect(providers.$stateProvider).toBe($routerProvider.stateProvider);
+  });
+
+  it("Should expose ui-router services from the UIRouter instance", () => {
+    let $router = $injector.get("$router");
+    expect($router).toBe($routerProvider);
+    expect($injector.get("$urlMatcherFactory")).toBe($router.urlMatcherFactory);
+    expect($injector.get("$urlService")).toBe($router.urlService);
+    expect($injector.get("$stateRegistry")).toBe($router.stateRegistry);
+    expect($injector.get("$routerGlobals")).toBe($router.globals);
+    expect($injector.get("$transitions")).toBe($router.transitionService);
+    expect($injector.get("$state")).toBe($router.stateService);
+    expect($injector.get("$stateParams")).toBe($router.globals.params);
+    expect($injector.get("$view")).toBe($router.viewService);
+    expect($injector.get("$trace")).toBeDefined();
+  });
+});