expect-immutable/index-test.js at master · hunterc/expect-immutable · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
import Immutable from 'immutable';
import expect from 'expect';
import expectImmutable from './index';

expect.extend(expectImmutable);

describe('expect immutable', () => {
  context('api', () => {
    it('has toEqualImmutable', () =>
      expect(expect().toEqualImmutable).toBeA('function')
    );
    it('has toNotEqualImmutable', () =>
      expect(expect().toNotEqualImmutable).toBeA('function')
    );
  });

  context('toEqualImmutable', () => {
    it('throws when called on a non-iterable', () => {
      expect(() =>
        expect({}).toEqualImmutable(Immutable.Map())
      ).toThrow(
        'Expected {} to be an Immutable Iterable'
      );
    });

    it('throws when called with a non-iterable', () => {
      expect(() =>
        expect(Immutable.Map()).toEqualImmutable({})
      ).toThrow(
        'Expected {} to be an Immutable Iterable'
      );
    });

    it('throws when Maps are different', () => {
      expect(() =>
        expect(Immutable.Map({})).toEqualImmutable(Immutable.Map({ a: 1 }))
      ).toThrow(
        'Expected {} to equal { a: 1 }'
      );
    });

    it('does not throw when empty Maps are compared', () => {
      expect(Immutable.Map({})).toEqualImmutable(Immutable.Map({}));
    });

    it('does not throw when Maps are the same', () => {
      expect(Immutable.Map({ a: 1 })).toEqualImmutable(Immutable.Map({ a: 1 }));
    });

    it('throws when Lists are different', () => {
      expect(() =>
        expect(Immutable.List([])).toEqualImmutable(Immutable.List([1]))
      ).toThrow(
        'Expected [] to equal [ 1 ]'
      );
    });

    it('does not throw when empty Lists are compared', () => {
      expect(Immutable.List([])).toEqualImmutable(Immutable.List([]));
    });

    it('does not throw when Lists are the same', () => {
      expect(Immutable.List([1])).toEqualImmutable(Immutable.List([1]));
    });
  });

  context('toNotEqualImmutable', () => {
    it('throws when called on a non-iterable', () => {
      expect(() =>
        expect({}).toEqualImmutable(Immutable.Map())
      ).toThrow(
        'Expected {} to be an Immutable Iterable'
      );
    });

    it('throws when called with a non-iterable', () => {
      expect(() =>
        expect(Immutable.Map()).toEqualImmutable({})
      ).toThrow(
        'Expected {} to be an Immutable Iterable'
      );
    });

    it('does not throw when Maps are different', () => {
      expect(Immutable.Map({})).toNotEqualImmutable(Immutable.Map({ a: 1 }));
    });

    it('throws when Maps are the same', () => {
      expect(() =>
        expect(Immutable.Map({ a: 1 })).toNotEqualImmutable(Immutable.Map({ a: 1 }))
      ).toThrow(
        'Expected { a: 1 } to not equal { a: 1 }'
      );
    });

    it('does not throw when Lists are different', () => {
      expect(Immutable.List([1])).toNotEqualImmutable(Immutable.List([]));
    });

    it('throws when Lists are the same', () => {
      expect(() =>
        expect(Immutable.List([1])).toNotEqualImmutable(Immutable.List([1]))
      ).toThrow(
        'Expected [ 1 ] to not equal [ 1 ]'
      );
    });
  });
});