701 lines
20 KiB
TypeScript
701 lines
20 KiB
TypeScript
describe('temporary disabled', () => {
|
|
it('temporary disabled', () => {});
|
|
});
|
|
// import { Component, Injectable } from '@angular/core';
|
|
// import { fakeAsync, TestBed, tick } from '@angular/core/testing';
|
|
// import { Router } from '@angular/router';
|
|
// import { RouterTestingModule } from '@angular/router/testing';
|
|
// import { Actions, Effect, EffectsModule, ofType } from '@ngrx/effects';
|
|
// import { provideMockActions } from '@ngrx/effects/testing';
|
|
// import {
|
|
// StoreRouterConnectingModule,
|
|
// DefaultRouterStateSerializer,
|
|
// } from '@ngrx/router-store';
|
|
// import { Store, StoreModule } from '@ngrx/store';
|
|
// import { Observable, of, Subject, throwError } from 'rxjs';
|
|
// import { delay, withLatestFrom } from 'rxjs/operators';
|
|
//
|
|
// import {
|
|
// DataPersistence,
|
|
// pessimisticUpdate,
|
|
// optimisticUpdate,
|
|
// fetch,
|
|
// NxModule,
|
|
// } from '../index';
|
|
// import { readAll } from '../testing';
|
|
//
|
|
// // interfaces
|
|
// type Todo = {
|
|
// id: number;
|
|
// user: string;
|
|
// };
|
|
// type Todos = {
|
|
// selected: Todo;
|
|
// };
|
|
// type TodosState = {
|
|
// todos: Todos;
|
|
// user: string;
|
|
// };
|
|
//
|
|
// // actions
|
|
// type TodoLoaded = {
|
|
// type: 'TODO_LOADED';
|
|
// payload: Todo;
|
|
// };
|
|
// type UpdateTodo = {
|
|
// type: 'UPDATE_TODO';
|
|
// payload: { newTitle: string };
|
|
// };
|
|
// type Action = TodoLoaded;
|
|
//
|
|
// // reducers
|
|
// function todosReducer(state: Todos, action: Action): Todos {
|
|
// if (action.type === 'TODO_LOADED') {
|
|
// return { selected: action.payload };
|
|
// } else {
|
|
// return state;
|
|
// }
|
|
// }
|
|
//
|
|
// function userReducer(): string {
|
|
// return 'bob';
|
|
// }
|
|
//
|
|
// @Component({
|
|
// template: ` ROOT[<router-outlet></router-outlet>] `,
|
|
// })
|
|
// class RootCmp {}
|
|
//
|
|
// @Component({
|
|
// template: `
|
|
// Todo [
|
|
// <div *ngIf="todo | async as t">ID {{ t.id }} User {{ t.user }}</div>
|
|
// ]
|
|
// `,
|
|
// })
|
|
// class TodoComponent {
|
|
// todo = this.store.select('todos', 'selected');
|
|
// constructor(private store: Store<TodosState>) {}
|
|
// }
|
|
//
|
|
// xdescribe('DataPersistence', () => {
|
|
// describe('navigation', () => {
|
|
// beforeEach(() => {
|
|
// TestBed.configureTestingModule({
|
|
// declarations: [RootCmp, TodoComponent],
|
|
// imports: [
|
|
// StoreModule.forRoot(
|
|
// { todos: todosReducer, user: userReducer },
|
|
// {
|
|
// runtimeChecks: {
|
|
// strictStateImmutability: false,
|
|
// strictStateSerializability: false,
|
|
// },
|
|
// }
|
|
// ),
|
|
// StoreRouterConnectingModule.forRoot({
|
|
// serializer: DefaultRouterStateSerializer,
|
|
// }),
|
|
// RouterTestingModule.withRoutes([
|
|
// { path: 'todo/:id', component: TodoComponent },
|
|
// ]),
|
|
// NxModule.forRoot(),
|
|
// ],
|
|
// });
|
|
// });
|
|
//
|
|
// describe('successful navigation', () => {
|
|
// @Injectable()
|
|
// class TodoEffects {
|
|
// @Effect()
|
|
// loadTodo = this.s.navigation(TodoComponent, {
|
|
// run: (a, state) => {
|
|
// return {
|
|
// type: 'TODO_LOADED',
|
|
// payload: { id: a.params['id'], user: state.user },
|
|
// };
|
|
// },
|
|
// onError: () => null,
|
|
// });
|
|
//
|
|
// constructor(private s: DataPersistence<TodosState>) {}
|
|
// }
|
|
//
|
|
// beforeEach(() => {
|
|
// TestBed.configureTestingModule({
|
|
// imports: [EffectsModule.forRoot([TodoEffects])],
|
|
// });
|
|
// });
|
|
//
|
|
// it('should work', fakeAsync(() => {
|
|
// const root = TestBed.createComponent(RootCmp);
|
|
//
|
|
// const router: Router = TestBed.get(Router);
|
|
// router.navigateByUrl('/todo/123');
|
|
// tick(0);
|
|
// root.detectChanges(false);
|
|
//
|
|
// expect(root.elementRef.nativeElement.innerHTML).toContain('ID 123');
|
|
// expect(root.elementRef.nativeElement.innerHTML).toContain('User bob');
|
|
// }));
|
|
// });
|
|
//
|
|
// describe('`run` throwing an error', () => {
|
|
// @Injectable()
|
|
// class TodoEffects {
|
|
// @Effect()
|
|
// loadTodo = this.s.navigation(TodoComponent, {
|
|
// run: (a, state) => {
|
|
// if (a.params['id'] === '123') {
|
|
// throw new Error('boom');
|
|
// } else {
|
|
// return {
|
|
// type: 'TODO_LOADED',
|
|
// payload: { id: a.params['id'], user: state.user },
|
|
// };
|
|
// }
|
|
// },
|
|
// onError: (a, e) => ({ type: 'ERROR', payload: { error: e } }),
|
|
// });
|
|
// constructor(private s: DataPersistence<TodosState>) {}
|
|
// }
|
|
//
|
|
// beforeEach(() => {
|
|
// TestBed.configureTestingModule({
|
|
// imports: [EffectsModule.forRoot([TodoEffects])],
|
|
// });
|
|
// });
|
|
//
|
|
// it('should work', fakeAsync(() => {
|
|
// const root = TestBed.createComponent(RootCmp);
|
|
//
|
|
// const router: Router = TestBed.get(Router);
|
|
// let actions: any[] = [];
|
|
// TestBed.get(Actions).subscribe((a: any) => actions.push(a));
|
|
//
|
|
// router.navigateByUrl('/todo/123');
|
|
// tick(0);
|
|
// root.detectChanges(false);
|
|
// expect(root.elementRef.nativeElement.innerHTML).not.toContain('ID 123');
|
|
// expect(actions.map((a) => a.type)).toContain('ERROR');
|
|
// expect(
|
|
// actions.find((a) => a.type === 'ERROR').payload.error.message
|
|
// ).toEqual('boom');
|
|
//
|
|
// // can recover after an error
|
|
// router.navigateByUrl('/todo/456');
|
|
// tick(0);
|
|
// root.detectChanges(false);
|
|
// expect(root.elementRef.nativeElement.innerHTML).toContain('ID 456');
|
|
// }));
|
|
// });
|
|
//
|
|
// describe('`run` returning an error observable', () => {
|
|
// @Injectable()
|
|
// class TodoEffects {
|
|
// @Effect()
|
|
// loadTodo = this.s.navigation(TodoComponent, {
|
|
// run: (a, state) => {
|
|
// if (a.params['id'] === '123') {
|
|
// return throwError('boom');
|
|
// } else {
|
|
// return {
|
|
// type: 'TODO_LOADED',
|
|
// payload: { id: a.params['id'], user: state.user },
|
|
// };
|
|
// }
|
|
// },
|
|
// onError: (a, e) => ({ type: 'ERROR', payload: { error: e } }),
|
|
// });
|
|
// constructor(private s: DataPersistence<TodosState>) {}
|
|
// }
|
|
//
|
|
// beforeEach(() => {
|
|
// TestBed.configureTestingModule({
|
|
// imports: [EffectsModule.forRoot([TodoEffects])],
|
|
// });
|
|
// });
|
|
//
|
|
// it('should work', fakeAsync(() => {
|
|
// const root = TestBed.createComponent(RootCmp);
|
|
//
|
|
// const router: Router = TestBed.get(Router);
|
|
// let actions: any[] = [];
|
|
// TestBed.get(Actions).subscribe((a: any) => actions.push(a));
|
|
//
|
|
// router.navigateByUrl('/todo/123');
|
|
// tick(0);
|
|
// root.detectChanges(false);
|
|
// expect(root.elementRef.nativeElement.innerHTML).not.toContain('ID 123');
|
|
// expect(actions.map((a) => a.type)).toContain('ERROR');
|
|
// expect(actions.find((a) => a.type === 'ERROR').payload.error).toEqual(
|
|
// 'boom'
|
|
// );
|
|
//
|
|
// router.navigateByUrl('/todo/456');
|
|
// tick(0);
|
|
// root.detectChanges(false);
|
|
// expect(root.elementRef.nativeElement.innerHTML).toContain('ID 456');
|
|
// }));
|
|
// });
|
|
// });
|
|
//
|
|
// describe('fetch', () => {
|
|
// beforeEach(() => {
|
|
// TestBed.configureTestingModule({ providers: [DataPersistence] });
|
|
// });
|
|
//
|
|
// describe('no id', () => {
|
|
// type GetTodos = {
|
|
// type: 'GET_TODOS';
|
|
// };
|
|
//
|
|
// @Injectable()
|
|
// class TodoEffects {
|
|
// @Effect()
|
|
// loadTodos = this.s.fetch<GetTodos>('GET_TODOS', {
|
|
// run: (a, state) => {
|
|
// // we need to introduce the delay to "enable" switchMap
|
|
// return of({
|
|
// type: 'TODOS',
|
|
// payload: { user: state.user, todos: 'some todos' },
|
|
// }).pipe(delay(1));
|
|
// },
|
|
//
|
|
// onError: () => null,
|
|
// });
|
|
//
|
|
// @Effect()
|
|
// loadTodosWithOperator = this.s.actions.pipe(
|
|
// ofType<GetTodos>('GET_TODOS'),
|
|
// withLatestFrom(this.s.store),
|
|
// fetch({
|
|
// run: (action, state) => {
|
|
// return of({
|
|
// type: 'TODOS',
|
|
// payload: { user: state.user, todos: 'some todos' },
|
|
// }).pipe(delay(1));
|
|
// },
|
|
// })
|
|
// );
|
|
//
|
|
// constructor(private s: DataPersistence<TodosState>) {}
|
|
// }
|
|
//
|
|
// function userReducer() {
|
|
// return 'bob';
|
|
// }
|
|
//
|
|
// let actions: Observable<any>;
|
|
//
|
|
// beforeEach(() => {
|
|
// actions = new Subject<any>();
|
|
// TestBed.configureTestingModule({
|
|
// providers: [TodoEffects, provideMockActions(() => actions)],
|
|
// imports: [
|
|
// StoreModule.forRoot(
|
|
// { user: userReducer },
|
|
// {
|
|
// runtimeChecks: {
|
|
// strictStateImmutability: false,
|
|
// strictStateSerializability: false,
|
|
// },
|
|
// }
|
|
// ),
|
|
// ],
|
|
// });
|
|
// });
|
|
//
|
|
// it('should work', async (done) => {
|
|
// actions = of(
|
|
// { type: 'GET_TODOS', payload: {} },
|
|
// { type: 'GET_TODOS', payload: {} }
|
|
// );
|
|
//
|
|
// expect(await readAll(TestBed.get(TodoEffects).loadTodos)).toEqual([
|
|
// { type: 'TODOS', payload: { user: 'bob', todos: 'some todos' } },
|
|
// { type: 'TODOS', payload: { user: 'bob', todos: 'some todos' } },
|
|
// ]);
|
|
//
|
|
// done();
|
|
// });
|
|
//
|
|
// it('should work with an operator', async (done) => {
|
|
// actions = of(
|
|
// { type: 'GET_TODOS', payload: {} },
|
|
// { type: 'GET_TODOS', payload: {} }
|
|
// );
|
|
//
|
|
// expect(
|
|
// await readAll(TestBed.get(TodoEffects).loadTodosWithOperator)
|
|
// ).toEqual([
|
|
// { type: 'TODOS', payload: { user: 'bob', todos: 'some todos' } },
|
|
// { type: 'TODOS', payload: { user: 'bob', todos: 'some todos' } },
|
|
// ]);
|
|
//
|
|
// done();
|
|
// });
|
|
// });
|
|
//
|
|
// describe('id', () => {
|
|
// type GetTodo = {
|
|
// type: 'GET_TODO';
|
|
// payload: { id: string };
|
|
// };
|
|
//
|
|
// @Injectable()
|
|
// class TodoEffects {
|
|
// @Effect()
|
|
// loadTodo = this.s.fetch<GetTodo>('GET_TODO', {
|
|
// id: (a) => a.payload.id,
|
|
// run: (a) => of({ type: 'TODO', payload: a.payload }).pipe(delay(1)),
|
|
// onError: () => null,
|
|
// });
|
|
//
|
|
// constructor(private s: DataPersistence<TodosState>) {}
|
|
// }
|
|
//
|
|
// function userReducer() {
|
|
// return 'bob';
|
|
// }
|
|
//
|
|
// let actions: Observable<any>;
|
|
//
|
|
// beforeEach(() => {
|
|
// actions = new Subject<any>();
|
|
// TestBed.configureTestingModule({
|
|
// providers: [TodoEffects, provideMockActions(() => actions)],
|
|
// imports: [
|
|
// StoreModule.forRoot(
|
|
// { user: userReducer },
|
|
// {
|
|
// runtimeChecks: {
|
|
// strictStateImmutability: false,
|
|
// strictStateSerializability: false,
|
|
// },
|
|
// }
|
|
// ),
|
|
// ],
|
|
// });
|
|
// });
|
|
//
|
|
// it('should work', async (done) => {
|
|
// actions = of(
|
|
// { type: 'GET_TODO', payload: { id: 1, value: '1' } },
|
|
// { type: 'GET_TODO', payload: { id: 2, value: '2a' } },
|
|
// { type: 'GET_TODO', payload: { id: 2, value: '2b' } }
|
|
// );
|
|
//
|
|
// expect(await readAll(TestBed.get(TodoEffects).loadTodo)).toEqual([
|
|
// { type: 'TODO', payload: { id: 1, value: '1' } },
|
|
// { type: 'TODO', payload: { id: 2, value: '2b' } },
|
|
// ]);
|
|
//
|
|
// done();
|
|
// });
|
|
// });
|
|
// });
|
|
//
|
|
// describe('pessimisticUpdate', () => {
|
|
// beforeEach(() => {
|
|
// TestBed.configureTestingModule({ providers: [DataPersistence] });
|
|
// });
|
|
//
|
|
// describe('successful', () => {
|
|
// @Injectable()
|
|
// class TodoEffects {
|
|
// @Effect()
|
|
// loadTodo = this.s.pessimisticUpdate<UpdateTodo>('UPDATE_TODO', {
|
|
// run: (a, state) => ({
|
|
// type: 'TODO_UPDATED',
|
|
// payload: { user: state.user, newTitle: a.payload.newTitle },
|
|
// }),
|
|
// onError: () => null,
|
|
// });
|
|
//
|
|
// @Effect()
|
|
// loadTodoWithOperator = this.s.actions.pipe(
|
|
// ofType<UpdateTodo>('UPDATE_TODO'),
|
|
// withLatestFrom(this.s.store),
|
|
// pessimisticUpdate({
|
|
// run: (a, state) => ({
|
|
// type: 'TODO_UPDATED',
|
|
// payload: { user: state.user, newTitle: a.payload.newTitle },
|
|
// }),
|
|
// onError: () => null,
|
|
// })
|
|
// );
|
|
//
|
|
// constructor(private s: DataPersistence<TodosState>) {}
|
|
// }
|
|
//
|
|
// function userReducer() {
|
|
// return 'bob';
|
|
// }
|
|
//
|
|
// let actions: Observable<any>;
|
|
//
|
|
// beforeEach(() => {
|
|
// actions = new Subject<any>();
|
|
// TestBed.configureTestingModule({
|
|
// providers: [TodoEffects, provideMockActions(() => actions)],
|
|
// imports: [
|
|
// StoreModule.forRoot(
|
|
// { user: userReducer },
|
|
// {
|
|
// runtimeChecks: {
|
|
// strictStateImmutability: false,
|
|
// strictStateSerializability: false,
|
|
// },
|
|
// }
|
|
// ),
|
|
// ],
|
|
// });
|
|
// });
|
|
//
|
|
// it('should work', async (done) => {
|
|
// actions = of({
|
|
// type: 'UPDATE_TODO',
|
|
// payload: { newTitle: 'newTitle' },
|
|
// });
|
|
//
|
|
// expect(await readAll(TestBed.get(TodoEffects).loadTodo)).toEqual([
|
|
// {
|
|
// type: 'TODO_UPDATED',
|
|
// payload: { user: 'bob', newTitle: 'newTitle' },
|
|
// },
|
|
// ]);
|
|
//
|
|
// done();
|
|
// });
|
|
//
|
|
// it('should work with an operator', async (done) => {
|
|
// actions = of({
|
|
// type: 'UPDATE_TODO',
|
|
// payload: { newTitle: 'newTitle' },
|
|
// });
|
|
//
|
|
// expect(
|
|
// await readAll(TestBed.get(TodoEffects).loadTodoWithOperator)
|
|
// ).toEqual([
|
|
// {
|
|
// type: 'TODO_UPDATED',
|
|
// payload: { user: 'bob', newTitle: 'newTitle' },
|
|
// },
|
|
// ]);
|
|
//
|
|
// done();
|
|
// });
|
|
// });
|
|
//
|
|
// describe('`run` throws an error', () => {
|
|
// @Injectable()
|
|
// class TodoEffects {
|
|
// @Effect()
|
|
// loadTodo = this.s.pessimisticUpdate<UpdateTodo>('UPDATE_TODO', {
|
|
// run: () => {
|
|
// throw new Error('boom');
|
|
// },
|
|
//
|
|
// onError: (a, e: any) => ({
|
|
// type: 'ERROR',
|
|
// payload: { error: e },
|
|
// }),
|
|
// });
|
|
//
|
|
// constructor(private s: DataPersistence<TodosState>) {}
|
|
// }
|
|
//
|
|
// function userReducer() {
|
|
// return 'bob';
|
|
// }
|
|
//
|
|
// let actions: Observable<any>;
|
|
//
|
|
// beforeEach(() => {
|
|
// actions = new Subject<any>();
|
|
// TestBed.configureTestingModule({
|
|
// providers: [TodoEffects, provideMockActions(() => actions)],
|
|
// imports: [
|
|
// StoreModule.forRoot(
|
|
// { user: userReducer },
|
|
// {
|
|
// runtimeChecks: {
|
|
// strictStateImmutability: false,
|
|
// strictStateSerializability: false,
|
|
// },
|
|
// }
|
|
// ),
|
|
// ],
|
|
// });
|
|
// });
|
|
//
|
|
// it('should work', async (done) => {
|
|
// actions = of({
|
|
// type: 'UPDATE_TODO',
|
|
// payload: { newTitle: 'newTitle' },
|
|
// });
|
|
//
|
|
// const [a]: any = await readAll(TestBed.get(TodoEffects).loadTodo);
|
|
//
|
|
// expect(a.type).toEqual('ERROR');
|
|
// expect(a.payload.error.message).toEqual('boom');
|
|
//
|
|
// done();
|
|
// });
|
|
// });
|
|
//
|
|
// describe('`run` returns an observable that errors', () => {
|
|
// @Injectable()
|
|
// class TodoEffects {
|
|
// @Effect()
|
|
// loadTodo = this.s.pessimisticUpdate<UpdateTodo>('UPDATE_TODO', {
|
|
// run: () => {
|
|
// return throwError('boom');
|
|
// },
|
|
//
|
|
// onError: (a, e: any) => ({
|
|
// type: 'ERROR',
|
|
// payload: { error: e },
|
|
// }),
|
|
// });
|
|
//
|
|
// constructor(private s: DataPersistence<TodosState>) {}
|
|
// }
|
|
//
|
|
// function userReducer() {
|
|
// return 'bob';
|
|
// }
|
|
//
|
|
// let actions: Observable<any>;
|
|
//
|
|
// beforeEach(() => {
|
|
// actions = new Subject<any>();
|
|
// TestBed.configureTestingModule({
|
|
// providers: [TodoEffects, provideMockActions(() => actions)],
|
|
// imports: [
|
|
// StoreModule.forRoot(
|
|
// { user: userReducer },
|
|
// {
|
|
// runtimeChecks: {
|
|
// strictStateImmutability: false,
|
|
// strictStateSerializability: false,
|
|
// },
|
|
// }
|
|
// ),
|
|
// ],
|
|
// });
|
|
// });
|
|
//
|
|
// it('should work', async (done) => {
|
|
// actions = of({
|
|
// type: 'UPDATE_TODO',
|
|
// payload: { newTitle: 'newTitle' },
|
|
// });
|
|
//
|
|
// const [a]: any = await readAll(TestBed.get(TodoEffects).loadTodo);
|
|
//
|
|
// expect(a.type).toEqual('ERROR');
|
|
// expect(a.payload.error).toEqual('boom');
|
|
//
|
|
// done();
|
|
// });
|
|
// });
|
|
// });
|
|
//
|
|
// describe('optimisticUpdate', () => {
|
|
// beforeEach(() => {
|
|
// TestBed.configureTestingModule({ providers: [DataPersistence] });
|
|
// });
|
|
//
|
|
// describe('`run` throws an error', () => {
|
|
// @Injectable()
|
|
// class TodoEffects {
|
|
// @Effect()
|
|
// loadTodo = this.s.optimisticUpdate<UpdateTodo>('UPDATE_TODO', {
|
|
// run: () => {
|
|
// throw new Error('boom');
|
|
// },
|
|
//
|
|
// undoAction: (a) => ({
|
|
// type: 'UNDO_UPDATE_TODO',
|
|
// payload: a.payload,
|
|
// }),
|
|
// });
|
|
//
|
|
// @Effect()
|
|
// loadTodoWithOperator = this.s.actions.pipe(
|
|
// ofType<UpdateTodo>('UPDATE_TODO'),
|
|
// withLatestFrom(this.s.store),
|
|
// optimisticUpdate({
|
|
// run: () => {
|
|
// throw new Error('boom');
|
|
// },
|
|
//
|
|
// undoAction: (a) => ({
|
|
// type: 'UNDO_UPDATE_TODO',
|
|
// payload: a.payload,
|
|
// }),
|
|
// })
|
|
// );
|
|
//
|
|
// constructor(private s: DataPersistence<TodosState>) {}
|
|
// }
|
|
//
|
|
// function userReducer() {
|
|
// return 'bob';
|
|
// }
|
|
//
|
|
// let actions: Observable<any>;
|
|
//
|
|
// beforeEach(() => {
|
|
// actions = new Subject<any>();
|
|
// TestBed.configureTestingModule({
|
|
// providers: [TodoEffects, provideMockActions(() => actions)],
|
|
// imports: [
|
|
// StoreModule.forRoot(
|
|
// { user: userReducer },
|
|
// {
|
|
// runtimeChecks: {
|
|
// strictStateImmutability: false,
|
|
// strictStateSerializability: false,
|
|
// },
|
|
// }
|
|
// ),
|
|
// ],
|
|
// });
|
|
// });
|
|
//
|
|
// it('should work', async (done) => {
|
|
// actions = of({
|
|
// type: 'UPDATE_TODO',
|
|
// payload: { newTitle: 'newTitle' },
|
|
// });
|
|
//
|
|
// const [a]: any = await readAll(TestBed.get(TodoEffects).loadTodo);
|
|
//
|
|
// expect(a.type).toEqual('UNDO_UPDATE_TODO');
|
|
// expect(a.payload.newTitle).toEqual('newTitle');
|
|
//
|
|
// done();
|
|
// });
|
|
//
|
|
// it('should work with an operator', async (done) => {
|
|
// actions = of({
|
|
// type: 'UPDATE_TODO',
|
|
// payload: { newTitle: 'newTitle' },
|
|
// });
|
|
//
|
|
// const [a]: any = await readAll(
|
|
// TestBed.get(TodoEffects).loadTodoWithOperator
|
|
// );
|
|
//
|
|
// expect(a.type).toEqual('UNDO_UPDATE_TODO');
|
|
// expect(a.payload.newTitle).toEqual('newTitle');
|
|
//
|
|
// done();
|
|
// });
|
|
// });
|
|
// });
|
|
// });
|