expect-immutable/index-test.js at 21a643ccd2f197ccee4258de9bfe25aaacaffbb2 · 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
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
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]));
    });

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

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

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

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

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

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

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

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

    it('does not throw when Seq.Indexed are the same', () => {
      expect(Immutable.Seq([1])).toEqualImmutable(Immutable.Seq([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 ]'
      );
    });

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

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

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

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