it('returns an ordered map from an ordered collection', () => {
    var seq = Seq.of('Z','Y','X','Z','Y','X');
    expect(Iterable.isOrdered(seq)).toBe(true);
    var seqGroups = seq.groupBy(x => x);
    expect(Iterable.isOrdered(seqGroups)).toBe(true);

    var map = Map({ x: 1, y: 2 });
    expect(Iterable.isOrdered(map)).toBe(false);
    var mapGroups = map.groupBy(x => x);
    expect(Iterable.isOrdered(mapGroups)).toBe(false);
  })

const stateTransformer = (state) => {
    const newState = {};
    for (let i of Object.keys(state)) {
        newState[i] = Iterable.isIterable(state[i]) ? state[i].toJS() : state[i];
    }
    return newState;
};

function stateTransformer(state) {
  const newState = {};
  for (const i of Object.keys(state)) {
    newState[i] = Iterable.isIterable(state[i]) ? state[i].toJS() : state[i];
  }
  return newState;
}

function mkShard(reqs: Iterable<number, Request> = List<Request>(), locked = false): Shard {
  return {
    leaderId: undefined,
    label: undefined,
    locked: locked,
    ordered: false,
    delivered: false,
    requests: reqs.toList(),
  }
}

 stateTransformer: (state) => {
     let newState = {};
     for (let i of Object.keys(state)) {
         if (Iterable.isIterable(state[i])) {
             newState[i] = state[i].toJS();
         } else {
             newState[i] = state[i];
         }
     };
     return newState;
 }

function multiShard(): T {
  const shards = List.of(
    mkShard(reqs.slice(3, 5)),
    mkShard(reqs.slice(5, 10))
  )
  return mkOrder(reqs.slice(0, 3), shards)
}

    context('some locks', function() {
      const locked = mkShard(reqs.slice(2, 10), true)
      const oldState = mkOrder(
        reqs.slice(0, 2),
        List.of(
          locked,
          mkShard(reqs.slice(10, 20)),
          mkShard(reqs.slice(20, 30))
        )
      )
      const newState = reducer(oldState, orderActions.balanceShards({maxSize: 4, userId: 'bepis'}))
      const unlocked = newState.shards.filter(s => !s.locked)

      sameSize(oldState, newState)

      it('preserves the locked shard', function() {
        const newLocked = newState.shards.find(s => s.locked)
        assert.strictEqual(newLocked, locked, 'locked shard unchanged')
        assert.strictEqual(newLocked.requests.size, 8, 'still has 8 reqs')
      })

      it('has a bunch of unlocked shards', function() {
        assert.ok(unlocked.size > 2, 'yerp')
      })

      it('unlocked shards all have size < max size', function() {
        unlocked.forEach(
          (s, i) => assert.ok(s.requests.size <= 4, `bigger shard ${i}`))
      })

    })

    it('does not add a second request for the same user', function() {
      const oldState = mkOrder(reqs.slice(0, 1))
      const req = reqs.get(0)
      const newState = reducer(oldState, orderActions.makeRequest(
        {userId: '0', text: 'bla', createdAt: new Date()}))

      assert.strictEqual(oldState.unshardedRequests.size, 1, 'one requests before')
      assert.strictEqual(newState.unshardedRequests.size, 1, 'now 1 req')
    });