TypeScript mocha.describe函数代码示例

describe("Test: app.spec.ts", () => {
  it("can instantiate", async(() => {
    let store = new Store(null);
    assert(!!store);
  }));

  describe("---", () => {
    it("instanceof Store", async(() => {
      const sc = new StoreController(new Store(null));
      const store = sc.getStoreSafely();
      assert(store instanceof Store);
    }));

    it("store.key check", async(() => {
      const sc = new StoreController([new Store(null), new Store('second')]);
      const mainStore = sc.getStoreSafely();
      const secondStore = sc.getStoreSafely('second');
      assert(mainStore.key === '__main__');
      assert(secondStore.key === 'second');
    }));

    it('should fail', async(() => {
      assert('2' === '3');
    }));
  });
});

describe('Component: WeatherWidget', () => {
  let builder: TestComponentBuilder;

  beforeEachProviders(() => [KelvinToCelsiusPipe]);

  beforeEach(inject([ TestComponentBuilder ], (tcb: TestComponentBuilder) => {
    builder = tcb.overrideProviders(
      WeatherWidget,
      [ provide(OpenWeatherApi, { useClass : MockOpenWeatherApi }) ]);
  }));

  it('can create', () => {
    return builder.createAsync(WeatherWidget).then(fixture => {
      expect(fixture).to.exist;
    });
  });

  it('should display the city name', () => {
    return builder.createAsync(WeatherWidget).then(fixture => {
      let component = fixture.componentInstance,
          element = fixture.nativeElement;

      component.city = 'Berlin';

      fixture.detectChanges();
      expect(element.querySelector('.weather__city').innerText)
        .to.equal('Berlin');
    });
  });

  it('should transform the temperature from Kelvin to Celcius and display it',
     () => {
       return builder.createAsync(WeatherWidget).then(fixture => {
         let component = fixture.componentInstance,
             element = fixture.nativeElement;

         component.city = 'Berlin';

         fixture.detectChanges();
         expect(element.querySelector('.weather__detail__temp').innerText)
           .to.equal('21.91°C');
       });
     });

  it('should contain an icon with a url by open weather api', () => {
    return builder.createAsync(WeatherWidget).then(fixture => {
      let component = fixture.componentInstance,
          element = fixture.nativeElement;

      component.city = 'Berlin';

      fixture.detectChanges();
      expect(element.querySelector('img').getAttribute('src'))
        .to.equal('http://openweathermap.org/img/w/01d.png');
      expect(component.generateIconUrl())
        .to.equal('http://openweathermap.org/img/w/01d.png');
    });
  });
});

describe('WeatherWidget: Open Weather API Service', () => {
  beforeEachProviders(() => [BaseRequestOptions, MockBackend, provide(Http, {
                               useFactory : (backend: MockBackend,
                                             options: BaseRequestOptions) => {
                                 return new Http(backend, options);
                               },
                               deps : [ MockBackend, BaseRequestOptions ]
                             }),
                             OpenWeatherApi]);

  it('can instantiate',
     inject([ OpenWeatherApi ],
            (service: OpenWeatherApi) => { expect(service).to.be.exist; }));

  xdescribe('getWeatherForCity', () => {
    beforeEach(inject([ MockBackend ], (backend: MockBackend) => {
      backend.connections.subscribe((c: MockConnection) => {
        c.mockRespond(new Response(
          new ResponseOptions({ status : 200, body : { 'city' : 'Berlin' } })));
      });
    }));

    it('should return the mock data',
       async(inject([ OpenWeatherApi ], (service: OpenWeatherApi) => {
         service.getWeatherForCity('Berlin').toPromise().then(
           resp => { expect(resp).to.exist; });
       })));
  });
});

describe('AppComponent', () => {
  let builder: TestComponentBuilder;

  beforeEach(inject([TestComponentBuilder], (tcb: TestComponentBuilder) => {
    builder = tcb.overrideProviders(AppComponent, []);
  }));

  it("can create", async(() => {
    builder.createAsync(AppComponent)
      .then(fixture => {
        assert(!!fixture);
      });
  }));

  it("should has text: 'My First Angular 2 App'", async(() => {
    builder.createAsync(AppComponent)
      .then(fixture => {
        let el = fixture.debugElement;
        assert(el.query(By.css("h1")).nativeElement.innerHTML === "My First Angular 2 App");
      });
  }));

  it("should has text: 'My Test'", async(() => {
    builder.createAsync(AppComponent)
      .then(fixture => {
        let el = fixture.debugElement;
        assert(el.query(By.css("p")).nativeElement.innerHTML === "My Test");
      });
  }));

  it("should fail", async(() => {
    let app = new AppComponent();
    let num = app.getNumber();
    assert(num === 101);
  }));
});

import "zone.js/dist/async-test";
import "rxjs/add/operator/toPromise";

import {assert} from "./test_util";
import {describe, it} from "angular2-testing-lite/mocha";
import {resetBaseTestProviders, setBaseTestProviders} from "angular2-testing-lite/core";
import {TEST_BROWSER_STATIC_PLATFORM_PROVIDERS, ADDITIONAL_TEST_BROWSER_PROVIDERS} from "@angular/platform-browser/testing/browser_static";
import {BROWSER_APP_DYNAMIC_PROVIDERS} from "@angular/platform-browser-dynamic";

resetBaseTestProviders();
setBaseTestProviders(TEST_BROWSER_STATIC_PLATFORM_PROVIDERS, [BROWSER_APP_DYNAMIC_PROVIDERS, ADDITIONAL_TEST_BROWSER_PROVIDERS]);

describe("dummy", () => {
  it("dummy", () => {
    assert.ok(true);
  });
});

import "./app/app-root.spec";
import "./app/components/about/about.spec";
import "./app/components/home/home.spec";
import "./app/components/repo-browser/repo-browser.spec";
import "./app/components/repo-detail/repo-detail.spec";
import "./app/components/repo-list/repo-list.spec";
import "./app/services/github.spec";