describe('UserService', () => {
beforeEachProviders(() => [
UserService,
StorageService,
SessionService,
HttpService,
BaseRequestOptions,
MockBackend,
provide(Http, {
useFactory: (backend: MockBackend, defaultOptions: BaseRequestOptions) => {
return new Http(backend, defaultOptions);
},
deps: [MockBackend, BaseRequestOptions]
})
]);
// beforeEach(inject([MockBackend], (backend: MockBackend) => {
// const baseResponse = new Response(new ResponseOptions({ body: { id: 1, email: '*****@*****.**', username: '******', password: '******' } }));
// backend.connections.subscribe((c: MockConnection) => c.mockRespond(baseResponse));
// }));
it('should return token when authenticate worked',
inject([UserService, MockBackend], (userService: UserService, backend: MockBackend) => {
let token = 'eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJpZCI6MSwidXNlcm5hbWUiOiJzZXJ2ZXIiLCJlbWFpbCI6ImFAYS5jb20iLCJwYXNzd29yZCI6ImFAYS5jb20iLCJpYXQiOjE0NTk0NDc4ODAsImV4cCI6MTQ1OTUzNDI4MH0.b260_KHB1FBBNlu2avblbi9VzqSER9hnzzCzdf6cGA4';
let baseResponse = new Response(new ResponseOptions({ body: { success: true, message: 'Enjoy your token!', token: token } }));
backend.connections.subscribe((c: MockConnection) => c.mockRespond(baseResponse));
User.setNextId(0);
userService.authenticate('*****@*****.**', '*****@*****.**', false).subscribe((res: any) => {
expect(res.token).toBe(token);
});
})
);
it('should return user when authenticate worked',
inject([UserService, MockBackend], (userService: UserService, backend: MockBackend) => {
let token = 'eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJpZCI6MSwidXNlcm5hbWUiOiJzZXJ2ZXIiLCJlbWFpbCI6ImFAYS5jb20iLCJwYXNzd29yZCI6ImFAYS5jb20iLCJpYXQiOjE0NTk0NDc4ODAsImV4cCI6MTQ1OTUzNDI4MH0.b260_KHB1FBBNlu2avblbi9VzqSER9hnzzCzdf6cGA4';
let baseResponse = new Response(new ResponseOptions({ body: { success: true, message: 'Enjoy your token!', token: token } }));
backend.connections.subscribe((c: MockConnection) => c.mockRespond(baseResponse));
User.setNextId(0);
userService.authenticate('*****@*****.**', '*****@*****.**', false).subscribe((res: any) => {
expect(res.user.id).toBe(1);
expect(res.user.username).toBe('server');
expect(res.user.email).toBe('*****@*****.**');
});
})
);
it('should return a user without password when authenticate worked',
inject([UserService, MockBackend], (userService: UserService, backend: MockBackend) => {
let token = 'eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJpZCI6MSwidXNlcm5hbWUiOiJzZXJ2ZXIiLCJlbWFpbCI6ImFAYS5jb20iLCJwYXNzd29yZCI6ImFAYS5jb20iLCJpYXQiOjE0NTk0NDc4ODAsImV4cCI6MTQ1OTUzNDI4MH0.b260_KHB1FBBNlu2avblbi9VzqSER9hnzzCzdf6cGA4';
let baseResponse = new Response(new ResponseOptions({ body: { success: true, message: 'Enjoy your token!', token: token } }));
backend.connections.subscribe((c: MockConnection) => c.mockRespond(baseResponse));
User.setNextId(0);
userService.authenticate('*****@*****.**', '*****@*****.**', false).subscribe((res: any) => {
console.log('HERE', res);
expect(res.user.password).toBe(undefined);
});
})
);
});
describe('Blog Service', () => {
// All heed this block - it is required so that the test injector
// is properly set up. Without doing this, you won't get the
// fake backend injected into Http.
// Also, you need to inject MockBackend as a provider before you wire
// it to replace XHRBackend with the provide function! So this is all
// extremely important to set up right.
beforeEachProviders(() => {
return [
HTTP_PROVIDERS,
provide(XHRBackend, {useClass: MockBackend}),
BlogService
];
});
it('should get blogs', inject([XHRBackend, BlogService], (mockBackend, blogService) => {
mockBackend.connections.subscribe(
(connection: MockConnection) => {
connection.mockRespond(new Response(
new ResponseOptions({
body: [
{
id: 26,
contentRendered: "<p><b>Hi there</b></p>",
contentMarkdown: "*Hi there*"
}]
}
)));
});
blogService.getBlogs().subscribe((blogs: BlogEntry[]) => {
expect(blogs.length).toBe(1);
expect(blogs[0].id).toBe(26);
});
}));
it('should get blogs async', injectAsync([XHRBackend, BlogService], (mockBackend, blogService) => {
return new Promise((pass, fail) => {
mockBackend.connections.subscribe(
(connection: MockConnection) => {
connection.mockRespond(new Response(
new ResponseOptions({
body: [
{
id: 26,
contentRendered: "<p><b>Hi there</b></p>",
contentMarkdown: "*Hi there*"
}]
}
)));
});
blogService.getBlogs().subscribe(
(data) => {
expect(data.length).toBe(1);
expect(data[0].id).toBe(26);
expect(data[0].contentMarkdown).toBe('*Hi there*');
});
});
}), 3000);
it('should save updates to an existing blog entry',
injectAsync([XHRBackend, BlogService], (mockBackend, blogService) => {
return new Promise((resolve, reject) => {
mockBackend.connections.subscribe(connection => {
connection.mockRespond(new ResponseOptions({status: 200}));
});
let data: BlogEntry = new BlogEntry("Blog Entry", "<p><b>Hi</b></p>", "*Hi*", 10);
blogService.saveBlog(data).subscribe(
(successResult) => {
expect(successResult).toBeDefined( );
expect(successResult.status).toBe(200);
});
});
}), 300);
});
describe('DemoFormWithEvents', () => {
var _console;
var fakeConsole;
var el, input, form;
beforeEach(() => {
// declare a fake console to track all the logs
fakeConsole = {};
fakeConsole._logs = [];
fakeConsole.log = (...theArgs) => fakeConsole._logs.push(theArgs.join(' '));
// replace the real console with our fake version
_console = window.console;
window.console = fakeConsole;
});
// restores the real console
afterAll(() => window.console = _console);
beforeEachProviders(() => {
return [FormBuilder];
});
function createComponent(tcb: TestComponentBuilder): Promise<ComponentFixture> {
return tcb.createAsync(DemoFormWithEvents).then((fixture) => {
el = fixture.debugElement.nativeElement;
input = fixture.debugElement.query(By.css("input")).nativeElement;
form = fixture.debugElement.query(By.css("form")).nativeElement;
fixture.detectChanges();
return fixture;
});
}
it('displays errors with no sku', injectAsync([TestComponentBuilder], (tcb) => {
return createComponent(tcb).then((fixture) => {
input.value = '';
dispatchEvent(input, 'input');
fixture.detectChanges();
// no value on sku field, all error messages are displayed
let msgs = el.querySelectorAll('.ui.error.message');
expect(msgs[0]).toHaveText('SKU is invalid');
expect(msgs[1]).toHaveText('SKU is required');
});
}));
it('displays no errors when sku has a value', injectAsync([TestComponentBuilder], (tcb) => {
return createComponent(tcb).then((fixture) => {
input.value = 'XYZ';
dispatchEvent(input, 'input');
fixture.detectChanges();
let msgs = el.querySelectorAll('.ui.error.message');
expect(msgs.length).toEqual(0);
});
}));
it('handles sku value changes', inject([TestComponentBuilder],
fakeAsync((tcb) => {
createComponent(tcb).then((fixture) => {
input.value = 'XYZ';
dispatchEvent(input, 'input');
tick();
expect(fakeConsole._logs).toContain('sku changed to: XYZ');
});
})
));
it('handles form changes', inject([TestComponentBuilder],
fakeAsync((tcb) => {
createComponent(tcb).then((fixture) => {
input.value = 'XYZ';
dispatchEvent(input, 'input');
tick();
expect(fakeConsole._logs).toContain('form changed to: [object Object]');
});
})
));
it('handles form submission', inject([TestComponentBuilder],
fakeAsync((tcb) => {
createComponent(tcb).then((fixture) => {
input.value = 'ABC';
dispatchEvent(input, 'input');
tick();
fixture.detectChanges();
dispatchEvent(form, 'submit');
tick();
expect(fakeConsole._logs).toContain('you submitted value: ABC');
});
})
));
});
import { describe, it, expect, beforeEachProviders, inject } from 'angular2/testing'
import { ChatApp } from '../app/chatapp'
beforeEachProviders(() => [ChatApp]);
describe('ChatApp: Chatapp', () => {
});
import {describe, it, expect, beforeEachProviders, inject} from 'angular2/testing';
import {AppComponent} from './app.ts';
beforeEachProviders(() => [AppComponent]);
describe('Houston App', () => {
it('should initiate the data service upon bootstrap',
inject([AppComponent], (app: AppComponent) => {
expect(app['_dataService'].developers$).toBeDefined();
}));
});
describe('MarkPipes Pipe', () => {
beforeEachProviders(() => [MarkPipe]);
});
describe('RestService', () => {
beforeEachProviders(() => [
HTTP_PROVIDERS,
provide(XHRBackend, { useClass: MockBackend }),
RestService
]);
describe('Travel', () => {
it('get()', inject([RestService, XHRBackend], (rest: RestService, mockBackend: MockBackend) => {
mockBackend.connections.subscribe(c => {
if (c.request.url === `${BASE_API_URL}/api/explore/partyTypes` && c.request.method === 0) {
let res = new Response(
new ResponseOptions(
{
body: {
"results": [{
"category_id": "123",
"question_id": "123",
"image_url": "http://test",
"description": "I am a banana",
"goodFor": "Me",
"suggestions": "Good for you",
"self": "http://another-link",
"text": "This is all me"
}]
},
status: 200
}
)
);
c.mockRespond(res);
}
})
rest.traveling.get((err, response: Array<Travel>) => {
expect(response.length).toBe(1);
expect(response[0].category_id).toBeDefined();
expect(response[0].category_id).toBe("123");
});
}));
});
describe('Questions', () => {
var rest: RestService;
var mockBackend: MockBackend;
let before = (_rest, _mockBackend, cb) => {
rest = _rest;
mockBackend = _mockBackend;
mockBackend.connections.subscribe(c => {
let testPayload = {
"category_id": "123",
"question_id": "234",
"image_url": "test234",
"description": "this is a test",
"goodFor": "everyone",
"suggestions": "awesome stuff",
"self": "http://test",
"text": "this is some text"
};
if (c.request.url === `${BASE_API_URL}/api/explore/categories/123/questions` && c.request.method === 0) {
send200({
"results": [
testPayload
]
}, c);
return;
}
testPayload.question_id = "345";
if (c.request.url === `${BASE_API_URL}/api/explore/questions/345` && c.request.method === 0) {
send200({
"results": [
testPayload
]
}, c);
return;
}
});
cb();
}
it('get()', beforeHack(before, () => {
rest.questions.get(123, (err, questions: Array<Question>) => {
expect(questions.length).toBe(1);
expect(questions[0].question_id).toBe("234");
});
}));
it('getById()', beforeHack(before, () => {
rest.questions.get(345, (err, question: Question) => {
expect(question.question_id).toBe("345");
});
}));
});
describe('Categories', () => {
var rest: RestService;
var mockBackend: MockBackend;
let before = (_rest, _mockBackend, cb) => {
rest = _rest;
mockBackend = _mockBackend;
mockBackend.connections.subscribe(c => {
let questionPayload1 = {
"category_id": "234",
"question_id": "345",
"image_url": "test234",
"description": "this is a test",
"goodFor": "everyone",
"suggestions": "awesome stuff",
"self": "http://test",
"text": "this is some text"
};
let questionPayload0 = {
"category_id": "123",
"question_id": "234",
"image_url": "test234",
"description": "this is a test",
"goodFor": "everyone",
"suggestions": "awesome stuff",
"self": "http://test",
"text": "this is some text"
};
let categoryPayload0 = {
"category_id": "123",
"title": "test_category",
"image": "http://test.img"
};
let categoryPayload1 = {
"category_id": "234",
"title": "test_category",
"image": "http://test.img"
};
if (c.request.url === `${BASE_API_URL}/api/explore/categories/123/questions` && c.request.method === 0) {
send200({
"results": [
questionPayload0
]
}, c);
return;
}
if (c.request.url === `${BASE_API_URL}/api/explore/categories/234/questions` && c.request.method === 0) {
send200({
"results": [
questionPayload1
]
}, c);
return;
}
if (c.request.url === `${BASE_API_URL}/api/explore/categories` && c.request.method === 0) {
send200({
"results": [
categoryPayload0,
categoryPayload1
]
}, c);
return;
}
});
cb();
}
it('get()', beforeHack(before, () => {
rest.categories.get((err, categories: Array<Category>) => {
expect(categories.length).toBe(2);
expect(categories[0].title).toBe("test_category");
expect(categories[0].questions.length).toBe(1);
expect(categories[0].questions[0].description).toBe("this is a test");
});
}));
it('getNextId()', beforeHack(before, () => {
rest.categories.get((err, categories: Array<Category>) => {
expect(categories.length).toBe(2);
expect(categories[0].title).toBe("test_category");
expect(categories[0].questions.length).toBe(1);
expect(categories[0].questions[0].description).toBe("this is a test");
// get category_id
let category = rest.categories.getNextId(123);
expect(category.category_id).toBe(234);
expect(category.questions.length).toBe(1);
expect(category.questions[0].question_id).toBe(345);
});
}));
it('getById() -- cached', beforeHack(before, () => {
rest.categories.get(() => {
rest.categories.getById(123, (err, category) => {
expect(category.length).toBe(1);
expect(category.title).toBe("test_category");
expect(category.questions.length).toBe(1);
expect(category.questions[0].description).toBe("this is a test");
});
});
}));
it('getById() -- not cached', beforeHack(before, () => {
rest.categories.getById(123, (err, category) => {
expect(category.length).toBe(1);
expect(category.title).toBe("test_category");
expect(category.questions.length).toBe(1);
expect(category.questions[0].description).toBe("this is a test");
});
}));
// Not needed, tested through use of the other methods
it('fetchQuestionSummary()', beforeHack(before, () => {
}));
});
describe("Survey", () => {
let category: Category = null;
let survey: Survey = null;
let question: Question = null;
beforeEach(() => {
ls.clear();
question = new Question(
123,
123,
"http://test.img",
"test desc",
"everyone",
"test sugess",
"self test",
"text test"
);
survey = new Survey();
category = new Category(123, "test", "http://test.img");
category.questions = [question];
});
it('store()', () => {
// Tested by other methods, no tests necessary
});
it('like(category: Category, question: Question)', () => {
survey.dislike(category, question);
expect(ls('_disliked').length).toBe(1);
expect(ls('_disliked')[0]).toBe(123);
expect(survey.disliked.size).toBe(1);
expect(survey.disliked.has(123)).toBeTruthy();
survey.like(category, question);
expect(ls('_liked').length).toBe(1);
expect(ls('_liked')[0]).toBe(123);
expect(survey.liked.size).toBe(1);
expect(survey.liked.has(123)).toBeTruthy();
expect(ls('_disliked').length).toBe(0);
expect(survey.disliked.size).toBe(0);
expect(category.progress).toBe(100);
});
it('likq_q(question: Question)', () => {
survey.dislike(category, question);
expect(ls('_disliked').length).toBe(1);
expect(ls('_disliked')[0]).toBe(123);
expect(survey.disliked.size).toBe(1);
expect(survey.disliked.has(123)).toBeTruthy();
survey.like_q(question);
expect(ls('_liked').length).toBe(1);
expect(ls('_liked')[0]).toBe(123);
expect(survey.liked.size).toBe(1);
expect(survey.liked.has(123)).toBeTruthy();
expect(ls('_disliked').length).toBe(0);
expect(survey.disliked.size).toBe(0);
});
it('toggle_like(question_id: number)', () => {
survey.like(category, question);
expect(ls('_liked').length).toBe(1);
expect(ls('_liked')[0]).toBe(123);
expect(survey.liked.size).toBe(1);
expect(survey.liked.has(123)).toBeTruthy();
survey.toggle_like(question.question_id);
expect(ls('_liked').length).toBe(0);
expect(survey.liked.size).toBe(0);
});
it('dislike(category: Category, question: Question)', () => {
survey.like(category, question);
expect(ls('_liked').length).toBe(1);
expect(ls('_liked')[0]).toBe(123);
expect(survey.liked.size).toBe(1);
expect(survey.liked.has(123)).toBeTruthy();
survey.dislike(category, question);
expect(ls('_disliked').length).toBe(1);
expect(ls('_disliked')[0]).toBe(123);
expect(survey.disliked.size).toBe(1);
expect(survey.disliked.has(123)).toBeTruthy();
expect(ls('_liked').length).toBe(0);
expect(survey.liked.size).toBe(0);
expect(category.progress).toBe(100);
});
it('maybe(category: Category, question: Question)', () => {
survey.like(category, question);
expect(ls('_liked').length).toBe(1);
expect(ls('_liked')[0]).toBe(123);
expect(survey.liked.size).toBe(1);
expect(survey.liked.has(123)).toBeTruthy();
survey.maybe(category, question);
expect(ls('_neutral').length).toBe(1);
expect(ls('_neutral')[0]).toBe(123);
expect(survey.neutral.size).toBe(1);
expect(survey.neutral.has(123)).toBeTruthy();
expect(ls('_liked').length).toBe(0);
expect(survey.liked.size).toBe(0);
expect(category.progress).toBe(100);
});
it('answer(question_id: number)', () => {
expect(survey.answer(question.question_id)).toBe(-1);
survey.like(category, question);
expect(survey.answer(question.question_id)).toBe(2);
survey.dislike(category, question);
expect(survey.answer(question.question_id)).toBe(0);
survey.maybe(category, question);
expect(survey.answer(question.question_id)).toBe(1);
});
});
describe('Recommendations', () => {
var rest: RestService;
var mockBackend: MockBackend;
var recommendation_fixtures: Array<Recommendation>;
var category: Category;
var questions: Array<Question>;
beforeEach(() => {
console.log('is this working? 0');
recommendation_fixtures = new Array<Recommendation>();
// Fill this with random shit
for (let i = 0; i < recommendation_fixtures.length; i++) {
recommendation_fixtures[i] = new Recommendation(
faker.Lorem.words(),
faker.Lorem.words(),
faker.Lorem.words(),
faker.Lorem.words(),
faker.Lorem.words(),
faker.Lorem.words(),
faker.Lorem.words(),
faker.Lorem.words(),
faker.Lorem.words(),
faker.Lorem.words(),
faker.Lorem.words()
)
}
});
let before = (_rest, _mockBackend, cb) => {
rest = _rest;
mockBackend = _mockBackend;
category = new Category(123, "test", "http://test.img");
questions = new Array<Question>();
for (let i = 0; i < 3; i ++) {
questions.push(
new Question(
123,
i,
"faker.Lorem.words()",
"faker.Lorem.words()",
"faker.Lorem.words()",
"faker.Lorem.words()",
"faker.Lorem.words()",
"faker.Lorem.words()"
)
);
}
ls.clear();
rest.survey.like(category, questions[0]);
rest.survey.dislike(category, questions[1]);
rest.survey.maybe(category, questions[2]);
mockBackend.connections.subscribe(c => {
let match = c.request.url.match(/size=(\d+)/);
console.log(match);
if (match === null) throw new Error('Did not find parameter: size');
let size = match[1];
console.log('-----');
match = c.request.url.match(/start=(\d+)/);
console.log(match);
if (match === null) throw new Error('Did not find parameter: start');
let start = match[1];
console.log('-----');
console.log(`${BASE_API_URL}/api/explore/cruises?questions_liked=0&questions_disliked=1&questions_neutral=2&start=${start}&size=${size}`);
console.log(c.request.url);
// Handle all of our requests
if (c.request.url === `${BASE_API_URL}/api/explore/cruises?questions_liked=123&questions_disliked=234&questions_neutral=345&start=${start}&size=${size}` && c.request.method === 0) {
send200({
"results": recommendation_fixtures.slice(start, size)
}, c);
return;
}
});
cb();
};
it('querySet()', beforeHack(before, () => {
// This gets tested through our other methods
}));
it('initializeRecommendations()', beforeHack(before, () => {
console.log('is this working? 3');
// We expect to get only the first 10 paginated recommendations
rest.recommendations.initializeRecommendations((err, recommendations: Array<Recommendation>) => {
console.log('//////');
console.log(recommendations.length);
console.log('//////');
expect(recommendations.length).toBe(11);
});
}));
it('paginate()', beforeHack(before, () => {
}));
it('get()', beforeHack(before, () => {
}));
it('getDetail()', beforeHack(before, () => {
}));
});
describe('Favorites', () => {
var rest: RestService;
var mockBackend: MockBackend;
let before = (_rest, _mockBackend, cb) => {
rest = _rest;
mockBackend = _mockBackend;
mockBackend.connections.subscribe(c => {
});
};
it('get()', beforeHack(before, () => {
}));
it('getSummaries()', beforeHack(before, () => {
}));
it('has()', beforeHack(before, () => {
}));
it('cache()', beforeHack(before, () => {
}));
it('add()', beforeHack(before, () => {
}));
it('delete()', beforeHack(before, () => {
}));
it('emailFavorites()', beforeHack(before, () => {
}));
it('save()', beforeHack(before, () => {
}));
});
});
import {describe, it, expect, beforeEachProviders, inject} from 'angular2/testing';
import {GestaoLivreApp} from '../app/gestaolivre';
beforeEachProviders(() => [GestaoLivreApp]);
/*
describe('App: Gestaolivre', () => {
it('should have the `defaultMeaning` as 42', inject([GestaoLivreApp], (app: GestaoLivreApp) => {
expect(app.defaultMeaning).toBe(42);
}));
describe('#meaningOfLife', () => {
it('should get the meaning of life', inject([GestaoLivreApp], (app: GestaoLivreApp) => {
expect(app.meaningOfLife()).toBe('The meaning of life is 42');
expect(app.meaningOfLife(22)).toBe('The meaning of life is 22');
}));
});
});
*/
import {describe, it, expect, beforeEachProviders, inject} from 'angular2/testing';
import {MainApp} from '../app/main';
beforeEachProviders(() => [MainApp]);
import {describe, it, expect, beforeEachProviders, inject} from 'angular2/testing';
import {TourApp} from '../app/tour';
beforeEachProviders(() => [TourApp]);
describe('App: Tour', () => {
it('should have the `defaultMeaning` as 42', inject([TourApp], (app) => {
expect(app.defaultMeaning).toBe(42);
}));
describe('#meaningOfLife', () => {
it('should get the meaning of life', inject([TourApp], (app) => {
expect(app.meaningOfLife()).toBe('The meaning of life is 42');
expect(app.meaningOfLife(22)).toBe('The meaning of life is 22');
}));
});
});
