@sigi/core/es2015/__tests__/smoking.spec.js

Sigi core library

import { __decorate, __metadata } from "tslib";
import '@abraham/reflection';
import { rootInjector } from '@sigi/di';
import { Observable } from 'rxjs';
import { delay, map, tap } from 'rxjs/operators';
import { Reducer, Effect } from '../decorators';
import { EffectModule } from '../module';
import { Module } from '../module.decorator';
import { Store } from '../store';
describe('Smoking tests', () => {
    it('Module should be able to work without effects', () => {
        const store = new Store('store', (state, action) => {
            if (action.type === 'foo') {
                return Object.assign(Object.assign({}, state), { name: action.payload });
            }
            return state;
        });
        store.setup({ name: 'bar' });
        const action = {
            type: 'foo',
            payload: 'foo',
            store,
        };
        store.dispatch(action);
        expect(store.state.name).toBe(action.payload);
        store.dispose();
    });
    it('should be able to dispatch actions from the other module', () => {
        const asyncTimeToDelay = 2000;
        const timer = jest.useFakeTimers();
        const spy = jest.fn();
        let FooModule = class FooModule extends EffectModule {
            constructor() {
                super(...arguments);
                this.defaultState = {
                    foo: '1',
                };
            }
            set(state, payload) {
                spy(state, payload);
                return Object.assign(Object.assign({}, state), { foo: payload });
            }
        };
        __decorate([
            Reducer(),
            __metadata("design:type", Function),
            __metadata("design:paramtypes", [Object, String]),
            __metadata("design:returntype", void 0)
        ], FooModule.prototype, "set", null);
        FooModule = __decorate([
            Module('Foo')
        ], FooModule);
        let BarModule = class BarModule extends EffectModule {
            constructor(fooModule) {
                super();
                this.fooModule = fooModule;
                this.defaultState = {};
            }
            asyncSetFoo(payload$) {
                return payload$.pipe(delay(asyncTimeToDelay), map((payload) => this.fooModule.getActions().set(payload)));
            }
        };
        __decorate([
            Effect(),
            __metadata("design:type", Function),
            __metadata("design:paramtypes", [Observable]),
            __metadata("design:returntype", void 0)
        ], BarModule.prototype, "asyncSetFoo", null);
        BarModule = __decorate([
            Module('Bar'),
            __metadata("design:paramtypes", [FooModule])
        ], BarModule);
        const fooModule = rootInjector.getInstance(FooModule);
        const fooStore = fooModule.store;
        const barModule = rootInjector.getInstance(BarModule);
        const barStore = barModule.store;
        const payload = 'whatever';
        const action = barModule.getActions().asyncSetFoo(payload);
        expect(action.payload).toBe(payload);
        fooStore.dispatch(action);
        timer.advanceTimersByTime(asyncTimeToDelay);
        expect(fooModule.state.foo).toBe(payload);
        const [[fooState, fooPayload]] = spy.mock.calls;
        expect(fooState).not.toBe(null);
        expect(fooPayload).toBe(payload);
        fooStore.dispose();
        barStore.dispose();
        jest.useRealTimers();
        rootInjector.reset();
    });
    it('should skip all effects restored from persisted state', () => {
        const staticState = { foo: 'foo', bar: 42 };
        global['SIGI_STATE'] = {
            SSRPersistModule: staticState,
        };
        const spy = jest.fn();
        let SSRPersistModule = class SSRPersistModule extends EffectModule {
            constructor() {
                super(...arguments);
                this.defaultState = {
                    foo: '1',
                    bar: 2,
                };
            }
            set(state, payload) {
                if (typeof payload === 'string') {
                    return Object.assign(Object.assign({}, state), { foo: payload });
                }
                else {
                    return Object.assign(Object.assign({}, state), { bar: payload });
                }
            }
            setFoo(payload$) {
                return payload$.pipe(tap(spy), map((payload) => this.getActions().set(payload)));
            }
            setBar(payload$) {
                return payload$.pipe(tap(spy), map((payload) => this.getActions().set(payload)));
            }
        };
        __decorate([
            Reducer(),
            __metadata("design:type", Function),
            __metadata("design:paramtypes", [Object, Object]),
            __metadata("design:returntype", void 0)
        ], SSRPersistModule.prototype, "set", null);
        __decorate([
            Effect({
                payloadGetter: () => '2',
            }),
            __metadata("design:type", Function),
            __metadata("design:paramtypes", [Observable]),
            __metadata("design:returntype", void 0)
        ], SSRPersistModule.prototype, "setFoo", null);
        __decorate([
            Effect({
                payloadGetter: () => 3,
            }),
            __metadata("design:type", Function),
            __metadata("design:paramtypes", [Observable]),
            __metadata("design:returntype", void 0)
        ], SSRPersistModule.prototype, "setBar", null);
        SSRPersistModule = __decorate([
            Module('SSRPersistModule')
        ], SSRPersistModule);
        const module = rootInjector.getInstance(SSRPersistModule);
        module.dispatchers.setFoo(staticState.foo + 1);
        module.dispatchers.setBar(staticState.bar + 1);
        expect(spy).toHaveBeenCalledTimes(0);
        expect(module.state.foo).toBe(staticState.foo);
        expect(module.state.bar).toBe(staticState.bar);
        module.store.dispose();
    });
});
//# sourceMappingURL=smoking.spec.js.map