cargdev/angular
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

refactor(browser): merge static & dynamic platforms

Browse Source
This commit is contained in:
Victor Berchet
2016-05-19 14:31:21 -07:00
parent 6c99746f0b
commit 54f8308999
163 changed files with 443 additions and 3958 deletions
Download Patch File Download Diff File Expand all files Collapse all files

28
modules/@angular/platform-browser/test/browser/bootstrap_spec.ts
View File

@ -10,27 +10,21 @@ import {
xdescribe,
xit
} from '@angular/core/testing/testing_internal';
import {
fakeAsync,
flushMicrotasks,
Log,
tick,
} from '@angular/core/testing';
import {Log} from '@angular/core/testing';
import {AsyncTestCompleter} from '@angular/core/testing/testing_internal';
import {IS_DART, isPresent, stringify} from '../../src/facade/lang';
import {BROWSER_PROVIDERS} from '@angular/platform-browser';
import {BROWSER_APP_DYNAMIC_PROVIDERS} from '@angular/platform-browser-dynamic';
import {bootstrap} from '@angular/platform-browser-dynamic';
import {ApplicationRef, PlatformRef} from '@angular/core/src/application_ref';
import {stringify} from '../../src/facade/lang';
import {BROWSER_PLATFORM_PROVIDERS} from '@angular/platform-browser';
import {BROWSER_APP_PROVIDERS} from '@angular/platform-browser';
import {bootstrap} from '@angular/platform-browser';
import {ApplicationRef} from '@angular/core/src/application_ref';
import {Console} from '@angular/core/src/console';
import {Component, Directive, OnDestroy} from '@angular/core';
import {getDOM} from '@angular/platform-browser/src/dom/dom_adapter';
import {DOCUMENT} from '@angular/platform-browser/src/dom/dom_tokens';
import {PromiseWrapper, TimerWrapper} from '../../src/facade/async';
import {PromiseWrapper} from '../../src/facade/async';
import {
provide,
Inject,
Injector,
PLATFORM_INITIALIZER,
APP_INITIALIZER,
coreLoadAndBootstrap,
@ -215,9 +209,9 @@ export function main() {
it('should unregister change detectors when components are disposed',
inject([AsyncTestCompleter], (async) => {
var platform = createPlatform(ReflectiveInjector.resolveAndCreate(BROWSER_PROVIDERS));
var platform = createPlatform(ReflectiveInjector.resolveAndCreate(BROWSER_PLATFORM_PROVIDERS));
var app =
ReflectiveInjector.resolveAndCreate([BROWSER_APP_DYNAMIC_PROVIDERS, testProviders],
ReflectiveInjector.resolveAndCreate([BROWSER_APP_PROVIDERS, testProviders],
platform.injector)
.get(ApplicationRef);
coreLoadAndBootstrap(app.injector, HelloRootCmp)
@ -251,7 +245,7 @@ export function main() {
it("should run platform initializers", inject([Log], (log: Log) => {
let p = createPlatform(ReflectiveInjector.resolveAndCreate([
BROWSER_PROVIDERS,
BROWSER_PLATFORM_PROVIDERS,
provide(PLATFORM_INITIALIZER, {useValue: log.fn("platform_init1"), multi: true}),
provide(PLATFORM_INITIALIZER, {useValue: log.fn("platform_init2"), multi: true})
]));
@ -259,7 +253,7 @@ export function main() {
log.clear();
var a = ReflectiveInjector.resolveAndCreate(
[
BROWSER_APP_DYNAMIC_PROVIDERS,
BROWSER_APP_PROVIDERS,
provide(APP_INITIALIZER, {useValue: log.fn("app_init1"), multi: true}),
provide(APP_INITIALIZER, {useValue: log.fn("app_init2"), multi: true})
],

5
modules/@angular/platform-browser/test/browser/rectangle_mock.dart
View File

@ -1,5 +0,0 @@
import 'dart:html';
Rectangle createRectangle(left, top, width, height) {
return new Rectangle(left, top, width, height);
}

50
modules/@angular/platform-browser/test/browser/ruler_spec.ts
View File

@ -1,50 +0,0 @@
import {
inject,
describe,
it,
expect,
} from '@angular/core/testing/testing_internal';
import {AsyncTestCompleter, SpyObject} from '@angular/core/testing/testing_internal';
import {getDOM} from '@angular/platform-browser/src/dom/dom_adapter';
import {Ruler, Rectangle} from '@angular/platform-browser/src/browser/ruler';
import {createRectangle} from './rectangle_mock';
import {SpyDomAdapter, SpyElementRef} from '@angular/core/test/spies';
function assertDimensions(rect: Rectangle, left, right, top, bottom, width, height) {
expect(rect.left).toEqual(left);
expect(rect.right).toEqual(right);
expect(rect.top).toEqual(top);
expect(rect.bottom).toEqual(bottom);
expect(rect.width).toEqual(width);
expect(rect.height).toEqual(height);
}
export function main() {
describe('ruler service', () => {
it('should allow measuring ElementRefs', inject([AsyncTestCompleter], (async) => {
var ruler = new Ruler(SpyObject.stub(
new SpyDomAdapter(), {'getBoundingClientRect': createRectangle(10, 20, 200, 100)}));
var elRef = <any>new SpyElementRef();
ruler.measure(elRef).then((rect) => {
assertDimensions(rect, 10, 210, 20, 120, 200, 100);
async.done();
});
}));
it('should return 0 for all rectangle values while measuring elements in a document fragment',
inject([AsyncTestCompleter], (async) => {
var ruler = new Ruler(getDOM());
var elRef = <any>new SpyElementRef();
elRef.prop("nativeElement", getDOM().createElement('div'));
ruler.measure(elRef).then((rect) => {
// here we are using an element created in a doc fragment so all the measures will come
// back as 0
assertDimensions(rect, 0, 0, 0, 0, 0, 0);
async.done();
});
}));
});
}

1
modules/@angular/platform-browser/test/browser/static_assets/200.html Normal file
View File

@ -0,0 +1 @@
<p>hey</p>

2
modules/@angular/platform-browser/test/browser_util_spec.ts
View File

@ -1,5 +1,5 @@
import {describe, it, iit, ddescribe, expect} from '@angular/core/testing';
import {BrowserDetection} from '@angular/platform-browser/testing';
import {BrowserDetection} from '../testing/browser_util';
import {StringMapWrapper} from '../src/facade/collection';
export function main() {

194
modules/@angular/platform-browser/test/testing_public_browser_spec.ts Normal file
View File

@ -0,0 +1,194 @@
import {
it,
iit,
xit,
describe,
ddescribe,
xdescribe,
expect,
beforeEach,
beforeEachProviders,
inject,
} from '@angular/core/testing';
import {
async,
fakeAsync,
flushMicrotasks,
Log,
tick,
} from '@angular/core/testing';
import {ROUTER_FAKE_PROVIDERS} from '@angular/router/testing';
import {ROUTER_DIRECTIVES, Routes, Route} from '@angular/router';
import {Component, bind} from '@angular/core';
import {PromiseWrapper} from '../src/facade/promise';
import {XHR} from '@angular/compiler';
import {XHRImpl} from '../src/xhr/xhr_impl';
import {TestComponentBuilder} from '@angular/compiler/testing';
// Components for the tests.
class FancyService {
value: string = 'real value';
getAsyncValue() { return Promise.resolve('async value'); }
getTimeoutValue() {
return new Promise((resolve, reject) => { setTimeout(() => {resolve('timeout value')}, 10); })
}
}
@Component({
selector: 'external-template-comp',
templateUrl: '/base/modules/@angular/platform-browser/test/static_assets/test.html'
})
class ExternalTemplateComp {
}
@Component({selector: 'bad-template-comp', templateUrl: 'non-existant.html'})
class BadTemplateUrl {
}
@Component({
selector: 'test-router-cmp',
template: `<a [routerLink]="['One']">one</a> <a [routerLink]="['Two']">two</a><router-outlet></router-outlet>`,
directives: [ROUTER_DIRECTIVES]
})
@Routes([
new Route({path: '/One', component: BadTemplateUrl}),
new Route({path: '/Two', component: ExternalTemplateComp}),
])
class TestRouterComponent {
}
// Tests for angular2/testing bundle specific to the browser environment.
// For general tests, see test/testing/testing_public_spec.ts.
export function main() {
describe('test APIs for the browser', () => {
describe('angular2 jasmine matchers', () => {
describe('toHaveCssClass', () => {
it('should assert that the CSS class is present', () => {
var el = document.createElement('div');
el.classList.add('matias');
expect(el).toHaveCssClass('matias');
});
it('should assert that the CSS class is not present', () => {
var el = document.createElement('div');
el.classList.add('matias');
expect(el).not.toHaveCssClass('fatias');
});
});
describe('toHaveCssStyle', () => {
it('should assert that the CSS style is present', () => {
var el = document.createElement('div');
expect(el).not.toHaveCssStyle('width');
el.style.setProperty('width', '100px');
expect(el).toHaveCssStyle('width');
});
it('should assert that the styles are matched against the element', () => {
var el = document.createElement('div');
expect(el).not.toHaveCssStyle({width: '100px', height: '555px'});
el.style.setProperty('width', '100px');
expect(el).toHaveCssStyle({width: '100px'});
expect(el).not.toHaveCssStyle({width: '100px', height: '555px'});
el.style.setProperty('height', '555px');
expect(el).toHaveCssStyle({height: '555px'});
expect(el).toHaveCssStyle({width: '100px', height: '555px'});
});
});
});
describe('using the async helper', () => {
var actuallyDone: boolean;
beforeEach(() => { actuallyDone = false; });
afterEach(() => { expect(actuallyDone).toEqual(true); });
it('should run async tests with XHRs', async(() => {
var xhr = new XHRImpl();
xhr.get('/base/modules/@angular/platform-browser/test/static_assets/test.html')
.then(() => { actuallyDone = true; });
}),
10000); // Long timeout here because this test makes an actual XHR.
});
describe('using the test injector with the inject helper', () => {
describe('setting up Providers', () => {
beforeEachProviders(() => [bind(FancyService).toValue(new FancyService())]);
it('provides a real XHR instance',
inject([XHR], (xhr) => { expect(xhr).toBeAnInstanceOf(XHRImpl); }));
it('should allow the use of fakeAsync', fakeAsync(inject([FancyService], (service) => {
var value;
service.getAsyncValue().then(function(val) { value = val; });
tick();
expect(value).toEqual('async value');
})));
});
});
describe('errors', () => {
var originalJasmineIt: any;
var patchJasmineIt = () => {
var deferred = PromiseWrapper.completer();
originalJasmineIt = jasmine.getEnv().it;
jasmine.getEnv().it = (description: string, fn) => {
var done = () => { deferred.resolve() };
(<any>done).fail = (err) => { deferred.reject(err) };
fn(done);
return null;
};
return deferred.promise;
};
var restoreJasmineIt = () => { jasmine.getEnv().it = originalJasmineIt; };
it('should fail when an XHR fails', (done) => {
var itPromise = patchJasmineIt();
it('should fail with an error from a promise',
async(inject([TestComponentBuilder],
(tcb) => { return tcb.createAsync(BadTemplateUrl); })));
itPromise.then(() => { done.fail('Expected test to fail, but it did not'); }, (err) => {
expect(err).toEqual('Uncaught (in promise): Failed to load non-existant.html');
done();
});
restoreJasmineIt();
}, 10000);
});
describe('test component builder', function() {
it('should allow an external templateUrl',
async(inject([TestComponentBuilder],
(tcb: TestComponentBuilder) => {
tcb.createAsync(ExternalTemplateComp)
.then((componentFixture) => {
componentFixture.detectChanges();
expect(componentFixture.debugElement.nativeElement)
.toHaveText('from external template\n');
});
})),
10000); // Long timeout here because this test makes an actual XHR, and is slow on Edge.
});
});
describe('apps with router components', () => {
beforeEachProviders(() => [ROUTER_FAKE_PROVIDERS]);
it('should build without a problem',
async(inject([TestComponentBuilder], (tcb: TestComponentBuilder) => {
tcb.createAsync(TestRouterComponent)
.then((fixture) => { expect(fixture.nativeElement).toHaveText('one two'); });
})));
});
}

7
modules/@angular/platform-browser/test/testing_public_spec.dart
View File

@ -1,7 +0,0 @@
library angular2.test.testing.testing_spec;
/**
* This is intentionally left blank. The public test lib is only for TS/JS
* apps.
*/
main() {}

29
modules/@angular/platform-browser/test/web_workers/debug_tools/bootstrap.server.spec.dart
View File

@ -1,29 +0,0 @@
library angular2.test.web_workers.debug_tools.bootstrap;
import 'package:angular2/src/platform/server/html_adapter.dart';
import "package:angular2/src/testing/testing_internal_core.dart";
import "package:angular2/src/core/reflection/reflection_capabilities.dart";
import "package:angular2/src/core/reflection/reflection.dart";
import "package:angular2/src/platform/worker_app_common.dart"
show WORKER_APP_APPLICATION_COMMON;
import "package:angular2/platform/worker_app.dart" show WORKER_APP_PLATFORM;
import "package:angular2/core.dart";
import "../shared/web_worker_test_util.dart";
import "dart:convert";
main() {
Html5LibDomAdapter.makeCurrent();
testSetup();
describe("WORKER_APP_COMMON_PROVIDERS", () {
it("should be able to load in a Dart VM", () {
reflector.reflectionCapabilities = new ReflectionCapabilities();
var buses = createPairedMessageBuses();
disposePlatform();
var platform = createPlatform(ReflectiveInjector.resolveAndCreate(WORKER_APP_PLATFORM));
var appInjector = ReflectiveInjector.resolveAndCreate(WORKER_APP_APPLICATION_COMMON,
platform.injector);
appInjector.get(ApplicationRef);
});
});
}

24
modules/@angular/platform-browser/test/web_workers/debug_tools/message_bus_common.dart
View File

@ -1,24 +0,0 @@
library angular2.test.web_workers.debug_tools.message_bus_common;
import "dart:convert" show JSON;
import "package:angular2/src/web_workers/shared/message_bus.dart";
import "package:angular2/src/testing/testing_internal_core.dart"
show AsyncTestCompleter, expect, SpyObject;
var MESSAGE = const {'test': 10};
const CHANNEL = "TEST_CHANNEL";
void expectSinkSendsEncodedJson(SpyObject socket, MessageBusSink sink,
String sendMethodName, AsyncTestCompleter async) {
socket.spy(sendMethodName).andCallFake((message) {
expectMessageEquality(message, MESSAGE, CHANNEL);
async.done();
});
sink.to(CHANNEL).add(MESSAGE);
}
void expectMessageEquality(String message, Map expectedData, String channel) {
expect(JSON.decode(message)).toEqual([
{'channel': channel, 'message': expectedData}
]);
}

235
modules/@angular/platform-browser/test/web_workers/debug_tools/multi_client_server_message_bus.server.spec.dart
View File

@ -1,235 +0,0 @@
library angular2.test.web_workers.debug_tools.multi_client_server_message_bus;
import "dart:io";
import "dart:async";
import "package:angular2/src/testing/testing_internal_core.dart"
show
AsyncTestCompleter,
SpyObject,
beforeEach,
beforeEachProviders,
describe,
expect,
iit,
inject,
it,
proxy,
testSetup;
import 'package:angular2/src/platform/server/html_adapter.dart';
import "package:angular2/src/web_workers/debug_tools/multi_client_server_message_bus.dart";
import "package:angular2/src/web_workers/shared/messaging_api.dart";
import "./message_bus_common.dart";
import "./spy_web_socket.dart";
import "dart:convert" show JSON;
import 'dart:math';
main() {
Html5LibDomAdapter.makeCurrent();
testSetup();
List<String> messageHistory = new List<String>();
List<int> resultMarkers = new List<int>();
describe("MultiClientServerMessageBusSink", () {
const CHANNEL = "TEST_CHANNEL";
var MESSAGE = const {'test': 10};
beforeEach(() {
messageHistory.clear();
resultMarkers.clear();
});
it(
"should send messages to all connected clients",
inject([AsyncTestCompleter], (async) {
const NUM_CLIENTS = 5;
var sink = new MultiClientServerMessageBusSink();
sink.initChannel(CHANNEL, false);
int numMessagesSent = 0;
// initialize all the sockets
var sockets = new List<WebSocketWrapper>(NUM_CLIENTS);
for (var i = 0; i < sockets.length; i++) {
var messageSent =
false; // ensure this socket only receives one message
var socketWrapper = createSocket(messageHandler: (message) {
expect(messageSent).toEqual(false);
messageSent = true;
expectMessageEquality(message, MESSAGE, CHANNEL);
numMessagesSent++;
if (numMessagesSent == NUM_CLIENTS) {
async.done();
}
});
var socket = socketWrapper.socket;
sockets[i] =
new WebSocketWrapper(messageHistory, resultMarkers, socket);
sink.addConnection(sockets[i]);
}
sink.to(CHANNEL).add(MESSAGE);
}));
});
describe("WebSocketWrapper", () {
beforeEach(() {
messageHistory.clear();
resultMarkers.clear();
});
/**
* Generates the given number of random messages, inserts them into messageHistory,
* and then returns a cloned version of messageHistory
*/
List<String> generateRandomMessages(int numMessages) {
const MAX = 1 << 31;
var random = new Random();
for (var i = 0; i < numMessages; i++) {
var message = {'value': random.nextInt(MAX)};
messageHistory.add(JSON.encode([
{'channel': CHANNEL, 'message': message}
]));
}
// copy the message history to ensure the test fails if the wrapper modifies the list
return new List.from(messageHistory);
}
it(
"should send all messages when there are no markers",
inject([AsyncTestCompleter], (async) {
const NUM_MESSAGES = 10;
var messageHistoryClone = generateRandomMessages(NUM_MESSAGES);
int numMessagesSent = 0;
var socketWrapper = createSocket(messageHandler: (message) {
expect(message).toEqual(messageHistoryClone[numMessagesSent]);
//expectMessageEquality(message, expected, CHANNEL);
numMessagesSent++;
if (numMessagesSent == messageHistoryClone.length) {
async.done();
}
});
var wrapper = new WebSocketWrapper(
messageHistory, resultMarkers, socketWrapper.socket);
wrapper.sendToMarker(0);
}));
it(
"should send between two markers",
inject([AsyncTestCompleter], (async) {
const NUM_MESSAGES = 50;
const FIRST_MARKER = 5;
const SECOND_MARKER = 15;
var messageHistoryClone = generateRandomMessages(NUM_MESSAGES);
int numMessagesSent = 0;
resultMarkers.add(FIRST_MARKER);
resultMarkers.add(SECOND_MARKER);
var socketWrapper = createSocket(messageHandler: (message) {
expect(message)
.toEqual(messageHistoryClone[FIRST_MARKER + numMessagesSent]);
numMessagesSent++;
if (numMessagesSent == SECOND_MARKER - FIRST_MARKER) {
async.done();
}
});
var wrapper = new WebSocketWrapper(
messageHistory, resultMarkers, socketWrapper.socket);
wrapper.sendToMarker(1);
}));
});
describe("MultiClientServerMessageBusSource", () {
beforeEach(() {
messageHistory.clear();
resultMarkers.clear();
});
void sendMessage(StreamController controller, dynamic message) {
controller.add(JSON.encode([message]));
}
void testForwardingMessages(bool primary, bool events, Function done) {
var result = createSocket();
var controller = result.controller;
var socket =
new WebSocketWrapper(messageHistory, resultMarkers, result.socket);
socket.setPrimary(primary);
var source = new MultiClientServerMessageBusSource();
source.addConnection(socket);
var channel = events ? EVENT_CHANNEL : CHANNEL;
source.initChannel(channel, false);
source.from(channel).listen((message) {
expect(message).toEqual(MESSAGE);
done();
});
var message = {'channel': channel, 'message': MESSAGE};
sendMessage(controller, message);
}
it(
"should forward messages from the primary",
inject([AsyncTestCompleter], (async) {
testForwardingMessages(true, false, async.done);
}));
it(
"should forward event channel messages from non primaries",
inject([AsyncTestCompleter], (async) {
testForwardingMessages(false, true, async.done);
}));
it(
"should forward event channel messages from the primary",
inject([AsyncTestCompleter], (async) {
testForwardingMessages(true, true, async.done);
}));
it(
"should mark results from the primary",
inject([AsyncTestCompleter], (async) {
var result = createSocket();
var controller = result.controller;
var socket = new WebSocketWrapper(
messageHistory, resultMarkers, result.socket);
socket.setPrimary(true);
var source = new MultiClientServerMessageBusSource();
source.onResult.listen((result) => async.done());
source.initChannel(CHANNEL, false);
source.addConnection(socket);
var message = {
'channel': CHANNEL,
'message': {'type': 'result'}
};
sendMessage(controller, message);
}));
});
}
/**
* Returns a new SpyWebSocket that calls messageHandler when a new message is sent.
* Also returns a StreamController instance that you can use to send messages to anything
* that is subscribed to this socket.
*/
SpySocketWrapper createSocket({Function messageHandler}) {
var socket = new SpyWebSocket();
if (messageHandler != null) {
socket.spy("add").andCallFake(messageHandler);
socket
.spy("addStream")
.andCallFake((Stream stream) => stream.listen(messageHandler));
}
var controller = new StreamController<String>.broadcast();
socket.spy("asBroadcastStream").andCallFake(() => controller.stream);
return new SpySocketWrapper(socket, controller);
}
class SpySocketWrapper {
SpyWebSocket socket;
StreamController controller;
SpySocketWrapper(this.socket, this.controller);
}

106
modules/@angular/platform-browser/test/web_workers/debug_tools/single_client_server_message_bus.server.spec.dart
View File

@ -1,106 +0,0 @@
library angular2.test.web_workers.debug_tools.single_client_server_message_bus;
import "dart:io";
import "dart:async";
import "package:angular2/src/testing/testing_internal_core.dart"
show
AsyncTestCompleter,
SpyObject,
beforeEach,
beforeEachProviders,
describe,
expect,
inject,
it,
proxy,
testSetup;
import 'package:angular2/src/platform/server/html_adapter.dart';
import "package:angular2/src/web_workers/debug_tools/single_client_server_message_bus.dart";
import "./message_bus_common.dart";
import "./spy_web_socket.dart";
import "dart:convert" show JSON;
main() {
Html5LibDomAdapter.makeCurrent();
testSetup();
var MESSAGE = const {'test': 10};
const CHANNEL = "TEST_CHANNEL";
describe("SingleClientServerMessageBusSink", () {
it(
"should send JSON encoded data over the WebSocket",
inject([AsyncTestCompleter], (async) {
var socket = new SpyWebSocket();
var sink = new SingleClientServerMessageBusSink();
sink.initChannel(CHANNEL, false);
sink.setConnection(socket);
expectSinkSendsEncodedJson(socket, sink, "add", async);
}));
it(
"should buffer messages before connect",
inject([AsyncTestCompleter], (async) {
var sink = new SingleClientServerMessageBusSink();
sink.initChannel(CHANNEL, false);
sink.to(CHANNEL).add(MESSAGE);
var socket = new SpyWebSocket();
socket.spy("add").andCallFake((message) {
expectMessageEquality(message, MESSAGE, CHANNEL);
async.done();
});
sink.setConnection(socket);
}));
it(
"should buffer messages in between disconnect and connect",
inject([AsyncTestCompleter], (async) {
var SECOND_MESSAGE = const {'test': 12, 'second': 'hi'};
var sink = new SingleClientServerMessageBusSink();
sink.initChannel(CHANNEL, false);
sink.to(CHANNEL).add(MESSAGE);
var socket = new SpyWebSocket();
sink.setConnection(socket);
int numMessages = 0;
socket.spy("add").andCallFake((message) {
numMessages++;
if (numMessages == 1) {
expectMessageEquality(message, MESSAGE, CHANNEL);
} else {
expectMessageEquality(message, SECOND_MESSAGE, CHANNEL);
async.done();
}
});
sink.removeConnection();
sink.to(CHANNEL).add(SECOND_MESSAGE);
sink.setConnection(socket);
}));
});
describe("SingleClientServerMessageBusSource", () {
it(
"should decode JSON messages and emit them",
inject([AsyncTestCompleter], (async) {
StreamController<String> controller =
new StreamController.broadcast();
var source = new SingleClientServerMessageBusSource();
source.initChannel(CHANNEL, false);
source.attachTo(controller.stream);
source.from(CHANNEL).listen((message) {
expect(message).toEqual(MESSAGE);
async.done();
});
controller.add(JSON.encode([
{'channel': CHANNEL, 'message': MESSAGE}
]));
}));
});
}

15
modules/@angular/platform-browser/test/web_workers/debug_tools/spy_web_socket.dart
View File

@ -1,15 +0,0 @@
/**
* Contains code shared between all server message bus tests
*/
library angular2.test.web_workers.debug_tools.server_message_bus_common;
import "package:angular2/src/testing/testing_internal_core.dart";
import "dart:io";
@proxy
class SpyWebSocket extends SpyObject implements WebSocket {
SpyWebSocket() : super(SpyWebSocket);
noSuchMethod(m) {
return super.noSuchMethod(m);
}
}

67
modules/@angular/platform-browser/test/web_workers/debug_tools/web_socket_message_bus_spec.dart
View File

@ -1,67 +0,0 @@
library angular2.test.web_workers.debug_tools.web_socket_server_message_bus;
import "package:angular2/testing_internal.dart"
show
AsyncTestCompleter,
inject,
describe,
it,
expect,
beforeEach,
beforeEachProviders,
SpyObject;
import "package:angular2/src/web_workers/debug_tools/web_socket_message_bus.dart";
import "dart:html" show WebSocket, MessageEvent;
import "./message_bus_common.dart";
import "dart:async";
import "dart:convert" show JSON;
main() {
var MESSAGE = const {'test': 10};
const CHANNEL = "TEST_CHANNEL";
describe("WebSocketMessageBusSink", () {
it(
"should send JSON encoded data over the WebSocket",
inject([AsyncTestCompleter], (async) {
var socket = new SpyWebSocket();
var sink = new WebSocketMessageBusSink(socket);
sink.initChannel(CHANNEL, false);
expectSinkSendsEncodedJson(socket, sink, "send", async);
}));
});
describe("WebSocketMessageBusSource", () {
it(
"should decode JSON messages and emit them",
inject([AsyncTestCompleter], (async) {
var socket = new SpyWebSocket();
StreamController<MessageEvent> controller =
new StreamController.broadcast();
socket.spy("get:onMessage").andCallFake(() => controller.stream);
var source = new WebSocketMessageBusSource(socket);
source.initChannel(CHANNEL, false);
source.from(CHANNEL).listen((message) {
expect(message).toEqual(MESSAGE);
async.done();
});
var event = new SpyMessageEvent();
event.spy("get:data").andCallFake(() => JSON.encode([
{'channel': CHANNEL, 'message': MESSAGE}
]));
controller.add(event);
}));
});
}
@proxy
class SpyMessageEvent extends SpyObject implements MessageEvent {
SpyMessageEvent() : super(SpyMessageEvent);
}
@proxy
class SpyWebSocket extends SpyObject implements WebSocket {
SpyWebSocket() : super(SpyWebSocket);
}

20
modules/@angular/platform-browser/test/web_workers/shared/message_bus_util.dart
View File

@ -1,20 +0,0 @@
library angular2.test.web_workers.shared.message_bus_util;
import 'dart:isolate';
import 'package:angular2/src/web_workers/shared/message_bus.dart'
show MessageBus;
import 'package:angular2/src/web_workers/shared/isolate_message_bus.dart';
/*
* Returns an IsolateMessageBus thats sink is connected to its own source.
* Useful for testing the sink and source.
*/
MessageBus createConnectedMessageBus() {
var receivePort = new ReceivePort();
var sendPort = receivePort.sendPort;
var sink = new IsolateMessageBusSink(sendPort);
var source = new IsolateMessageBusSource(receivePort);
return new IsolateMessageBus(sink, source);
}

21
modules/@angular/platform-browser/test/web_workers/shared/mock_event_emitter.dart
View File

@ -1,21 +0,0 @@
library angular2.test.web_workers.worker.mock_event_emitter;
import 'dart:core';
import 'dart:async';
import "package:angular2/src/facade/async.dart";
class MockEventEmitter<T> extends EventEmitter<T> {
final controller = new StreamController.broadcast(sync: true);
@override
StreamSubscription listen(void onData(dynamic line),
{void onError(Error error), void onDone(), bool cancelOnError}) {
return controller.stream.listen(onData,
onError: onError, onDone: onDone, cancelOnError: cancelOnError);
}
@override
void add(value) {
controller.add(value);
}
}

7
modules/@angular/platform-browser/test/web_workers/worker/spies.dart
View File

@ -1,7 +0,0 @@
library web_workers.spies;
import 'package:angular2/src/web_workers/shared/client_message_broker.dart';
import 'package:angular2/src/testing/testing_internal_core.dart';
@proxy
class SpyMessageBroker extends SpyObject implements ClientMessageBroker {}

29
modules/@angular/platform-browser/test/web_workers/worker/xhr_impl_spec.ts Normal file
View File

@ -0,0 +1,29 @@
import {inject, describe, it, expect} from '@angular/core/testing/testing_internal';
import {AsyncTestCompleter} from '@angular/core/testing/testing_internal';
import {SpyMessageBroker} from '@angular/platform-browser/test/web_workers/worker/spies';
import {WebWorkerXHRImpl} from '@angular/platform-browser/src/web_workers/worker/xhr_impl';
import {PromiseWrapper} from '../../../src/facade/async';
import {
MockMessageBrokerFactory,
expectBrokerCall
} from '@angular/platform-browser/test/web_workers/shared/web_worker_test_util';
export function main() {
describe("WebWorkerXHRImpl", () => {
it("should pass requests through the broker and return the response",
inject([AsyncTestCompleter], (async) => {
const URL = "http://www.example.com/test";
const RESPONSE = "Example response text";
var messageBroker = new SpyMessageBroker();
expectBrokerCall(messageBroker, "get", [URL],
(_) => { return PromiseWrapper.wrap(() => { return RESPONSE; }); });
var xhrImpl = new WebWorkerXHRImpl(new MockMessageBrokerFactory(<any>messageBroker));
xhrImpl.get(URL).then((response) => {
expect(response).toEqual(RESPONSE);
async.done();
});
}));
});
}

3
modules/@angular/platform-browser/test/xhr/xhr_cache_setter.ts Normal file
View File

@ -0,0 +1,3 @@
export function setTemplateCache(cache): void {
(<any>window).$templateCache = cache;
}

85
modules/@angular/platform-browser/test/xhr/xhr_cache_spec.ts Normal file
View File

@ -0,0 +1,85 @@
import {Component, provide} from '@angular/core';
import {UrlResolver, XHR} from '@angular/compiler';
import {
beforeEach,
beforeEachProviders,
ddescribe,
describe,
iit,
inject,
it,
xit
} from '@angular/core/testing/testing_internal';
import {expect} from '@angular/platform-browser/testing';
import {AsyncTestCompleter} from '@angular/core/testing/testing_internal';
import {
fakeAsync,
flushMicrotasks,
Log,
tick,
} from '@angular/core/testing';
import {TestComponentBuilder, ComponentFixture} from '@angular/compiler/testing';
import {BaseException} from '../../src/facade/exceptions';
import {CachedXHR} from '../../src/xhr/xhr_cache';
import {setTemplateCache} from './xhr_cache_setter';
export function main() {
describe('CachedXHR', () => {
var xhr: CachedXHR;
function createCachedXHR(): CachedXHR {
setTemplateCache({'test.html': '<div>Hello</div>'});
return new CachedXHR();
}
beforeEachProviders(() => [
provide(UrlResolver, {useClass: TestUrlResolver}),
provide(XHR, {useFactory: createCachedXHR})
]);
it('should throw exception if $templateCache is not found', () => {
setTemplateCache(null);
expect(() => { xhr = new CachedXHR(); })
.toThrowErrorWith('CachedXHR: Template cache was not found in $templateCache.');
});
it('should resolve the Promise with the cached file content on success',
inject([AsyncTestCompleter], (async) => {
setTemplateCache({'test.html': '<div>Hello</div>'});
xhr = new CachedXHR();
xhr.get('test.html')
.then((text) => {
expect(text).toEqual('<div>Hello</div>');
async.done();
});
}));
it('should reject the Promise on failure', inject([AsyncTestCompleter], (async) => {
xhr = new CachedXHR();
xhr.get('unknown.html')
.then((text) => { throw new BaseException('Not expected to succeed.'); })
.catch((error) => { async.done(); });
}));
it('should allow fakeAsync Tests to load components with templateUrl synchronously',
fakeAsync(inject([TestComponentBuilder], (tcb: TestComponentBuilder) => {
let fixture = tcb.createFakeAsync(TestComponent);
// This should initialize the fixture.
tick();
expect(fixture.debugElement.children[0].nativeElement).toHaveText('Hello');
})));
});
}
@Component({selector: 'test-cmp', templateUrl: 'test.html'})
class TestComponent {
}
class TestUrlResolver extends UrlResolver {
resolve(baseUrl: string, url: string): string {
// Don't use baseUrl to get the same URL as templateUrl.
// This is to remove any difference between Dart and TS tests.
return url;
}
}

48
modules/@angular/platform-browser/test/xhr/xhr_impl_spec.ts Normal file
View File

@ -0,0 +1,48 @@
import {
beforeEach,
ddescribe,
describe,
expect,
iit,
inject,
it,
xit,
AsyncTestCompleter
} from '@angular/core/testing/testing_internal';
import {XHRImpl} from '../../src/xhr/xhr_impl';
import {PromiseWrapper} from '../../src/facade/async';
import {IS_DART} from '../../src/facade/lang';
export function main() {
describe('XHRImpl', () => {
var xhr: XHRImpl;
// TODO(juliemr): This file currently won't work with dart unit tests run using
// exclusive it or describe (iit or ddescribe). This is because when
// pub run test is executed against this specific file the relative paths
// will be relative to here, so url200 should look like
// static_assets/200.html.
// We currently have no way of detecting this.
var urlBase = IS_DART ? '' : '/base/modules/@angular/';
var url200 = urlBase + 'platform-browser/test/browser/static_assets/200.html';
var url404 = '/bad/path/404.html';
beforeEach(() => { xhr = new XHRImpl(); });
it('should resolve the Promise with the file content on success',
inject([AsyncTestCompleter], (async) => {
xhr.get(url200).then((text) => {
expect(text.trim()).toEqual('<p>hey</p>');
async.done();
});
}), 10000);
it('should reject the Promise on failure', inject([AsyncTestCompleter], (async) => {
PromiseWrapper.catchError(xhr.get(url404), (e) => {
expect(e).toEqual(`Failed to load ${url404}`);
async.done();
return null;
});
}), 10000);
});
}