export default function(state = INITIAL_STATE, action) {
  switch(action.type) {
    case PUSH_DATA:
      const { keys, values } = action.payload;
      return SI.from(INITIAL_STATE).merge({keys, values}, {deep: true})
    case EDIT_DATA:
      const { id, field, value } = action.payload;
      return SI.from(state).setIn(['values', id, field], value)
    case NEW_NODE:
      return SI.from(state).merge(action.payload, {merger: mergers.concatArrayMerger, deep: true})
  }
  return state;
}

 private initCache(sampleIds:string[]) {
     const _cache:Cache<T> = {};
     for (const sampleId of sampleIds) {
         _cache[sampleId] = {
             fetchedWithoutGeneArgument: false,
             geneData: {}
         };
     }
     this._cache = Immutable.from<Cache<T>>(_cache);
 }

interface ExtendedUser extends User {
    address: Address;
}

//
// Constructors
// ---------------------------------------------------------------

{
    interface User {
        firstName: string;
        lastName: string;
    }

    const arrayOfNumbers1: Immutable.ImmutableArray<number> = Immutable.from([0, 2]);
    const arrayOfNumbers2: Immutable.ImmutableArray<number> = Immutable([0, 2]);
    const user1: Immutable.ImmutableObject<User> = Immutable.from({
        firstName: 'Angry',
        lastName: 'Monkey'
    });
    const user2: Immutable.ImmutableObject<User> = Immutable({
        firstName: 'Angry',
        lastName: 'Monkey'
    });
    const error: Error = Immutable.ImmutableError('error');
}

//
// Static utilities
// ---------------------------------------------------------------

import * as si from 'seamless-immutable';
import {createDispatchedActions, createReducer} from 'redux-typed-ducks';
import {columnDucks} from './column.ducks';
import {KanbanState} from '../types';

let prevState: KanbanState;
const initState: KanbanState = si.from({
    boards: [{ id: '0', title: ''}],
    cards: [],
    columns: [],
    activeBoard: '0'
});
const columnReducer = createReducer(columnDucks, initState);

describe('Column reducers', () => {
    describe('Creating an initial first column', () => {
        it('adds column to list', () => {
            const newColumn = { boardId: '0', title: 'new Column' };
            const createAction = columnDucks.create(newColumn);
            const nextState = columnReducer(initState, createAction);

            expect(nextState.columns.length).toBe(1);
            expect(nextState.columns[0].boardId).toBe('0');
            expect(nextState.columns[0].title).toBe('new Column');
        });

        it('generates a column id', () => {
            const newColumn = { boardId: '0', title: 'new Column' };
            const createAction = columnDucks.create(newColumn);
            const nextState = columnReducer(initState, createAction);

import * as si from 'seamless-immutable';
import {createDispatchedActions, createReducer} from 'redux-typed-ducks';
import {boardDucks} from './board.ducks';
import {KanbanState} from '../types';

let prevState: KanbanState;
const initState: KanbanState = si.from({
    boards: [],
    cards: [],
    columns: [],
});
const boardReducer = createReducer(boardDucks, initState);

describe('Board reducers', () => {
    describe('Creating an initial first board', () => {
        const newBoard = { title: 'new Board' };
        const createAction = boardDucks.create(newBoard);

        it('adds board to list', () => {
            const nextState = boardReducer(initState, createAction);

            expect(nextState.boards.length).toBe(1);
            expect(nextState.boards[0].title).toBe('new Board');
        });

        it('generates a board id', () => {
            const nextState = boardReducer(initState, createAction);
            expect(nextState.boards[0].id.length).toBeGreaterThan(0);
        });

        it('activates new board', () => {

 private init() {
     this.pending = {};
     this._cache = Immutable.from<Cache<Data, Metadata>>({});
     this.promises = [];
 }

 constructor()
 {
     this._cache = Immutable.from<ICache<T>>({});
     this._pendingCache = {};
 }