updux/dist/test.js
2019-11-04 20:34:14 -05:00

153 lines
4.5 KiB
JavaScript

"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
const _1 = __importDefault(require("."));
test('actions from mutations', () => {
const { actions: { foo, bar }, } = new _1.default({
mutations: {
foo: () => (x) => x,
},
});
expect(foo()).toEqual({ type: 'foo' });
expect(foo(true)).toEqual({ type: 'foo', payload: true });
expect(foo({ bar: 2 }, { timestamp: 613 })).toEqual({
type: 'foo',
payload: { bar: 2 },
meta: { timestamp: 613 },
});
});
test('reducer', () => {
const { actions, reducer } = new _1.default({
initial: { counter: 1 },
mutations: {
inc: () => ({ counter }) => ({ counter: counter + 1 }),
},
});
let state = reducer(undefined, { type: 'noop' });
expect(state).toEqual({ counter: 1 });
state = reducer(state, actions.inc());
expect(state).toEqual({ counter: 2 });
});
test('sub reducers', () => {
const foo = new _1.default({
initial: 1,
mutations: {
doFoo: () => (x) => x + 1,
doAll: () => (x) => x + 10,
},
});
const bar = new _1.default({
initial: 'a',
mutations: {
doBar: () => (x) => x + 'a',
doAll: () => (x) => x + 'b',
}
});
const { initial, actions, reducer } = new _1.default({
subduxes: {
foo, bar
}
});
expect(initial).toEqual({ foo: 1, bar: 'a' });
expect(Object.keys(actions)).toHaveLength(3);
let state = reducer(undefined, { type: 'noop' });
expect(state).toEqual({ foo: 1, bar: 'a' });
state = reducer(state, actions.doFoo());
expect(state).toEqual({ foo: 2, bar: 'a' });
state = reducer(state, actions.doBar());
expect(state).toEqual({ foo: 2, bar: 'aa' });
state = reducer(state, actions.doAll());
expect(state).toEqual({ foo: 12, bar: 'aab' });
});
test('precedence between root and sub-reducers', () => {
const { initial, reducer, actions, } = new _1.default({
initial: {
foo: { bar: 4 },
},
mutations: {
inc: () => (state) => {
return {
...state,
surprise: state.foo.bar
};
}
},
subduxes: {
foo: {
initial: {
bar: 2,
quux: 3,
},
mutations: {
inc: () => (state) => ({ ...state, bar: state.bar + 1 })
},
},
}
});
expect(initial).toEqual({
foo: { bar: 4, quux: 3 }
});
expect(reducer(undefined, actions.inc())).toEqual({
foo: { bar: 5, quux: 3 }, surprise: 5
});
});
function timeout(ms) {
return new Promise(resolve => setTimeout(resolve, ms));
}
test('middleware', async () => {
const { middleware, createStore } = new _1.default({
initial: "",
mutations: {
inc: (addition) => (state) => state + addition,
doEeet: () => (state) => {
return state + 'Z';
},
},
effects: {
doEeet: api => next => async (action) => {
api.dispatch.inc('a');
next(action);
await timeout(1000);
api.dispatch.inc('c');
}
},
subduxes: {
foo: {
effects: {
doEeet: (api) => (next) => (action) => {
api.dispatch({ type: 'inc', payload: 'b' });
next(action);
}
}
},
}
});
const store = createStore();
store.dispatch.doEeet();
expect(store.getState()).toEqual('abZ');
await timeout(1000);
expect(store.getState()).toEqual('abZc');
});
test("subduxes and mutations", () => {
const foo = new _1.default({ mutations: {
quux: () => () => 'x',
blart: () => () => 'a',
} });
const bar = new _1.default({ mutations: {
quux: () => () => 'y'
} });
const baz = new _1.default({
mutations: {
quux: () => (state) => ({ ...state, "baz": "z" })
}, subduxes: { foo, bar }
});
let state = baz.reducer(undefined, baz.actions.quux());
expect(state).toEqual({
foo: "x",
bar: "y",
baz: "z",
});
});
//# sourceMappingURL=test.js.map