UNPKG

5.21 kBJavaScriptView Raw
1'use strict';
2
3var tape = require('../');
4var tap = require('tap');
5var concat = require('concat-stream');
6var tapParser = require('tap-parser');
7var common = require('./common');
8
9var getDiag = common.getDiag;
10var stripFullStack = common.stripFullStack;
11
12tap.test('deep equal failure', function (assert) {
13 var test = tape.createHarness({ exit: false });
14 var stream = test.createStream();
15 var parser = tapParser();
16 assert.plan(3);
17
18 stream.pipe(parser);
19 stream.pipe(concat(function (body) {
20 assert.deepEqual(stripFullStack(body.toString('utf8')), [
21 'TAP version 13',
22 '# deep equal',
23 'not ok 1 should be strictly equal',
24 ' ---',
25 ' operator: equal',
26 ' expected: |-',
27 ' { b: 2 }',
28 ' actual: |-',
29 ' { a: 1 }',
30 ' at: Test.<anonymous> ($TEST/deep-equal-failure.js:$LINE:$COL)',
31 ' stack: |-',
32 ' Error: should be strictly equal',
33 ' [... stack stripped ...]',
34 ' at Test.<anonymous> ($TEST/deep-equal-failure.js:$LINE:$COL)',
35 ' [... stack stripped ...]',
36 ' ...',
37 '',
38 '1..1',
39 '# tests 1',
40 '# pass 0',
41 '# fail 1',
42 ''
43 ]);
44
45 assert.deepEqual(getDiag(body), {
46 operator: 'equal',
47 expected: '{ b: 2 }',
48 actual: '{ a: 1 }'
49 });
50 }));
51
52 parser.once('assert', function (data) {
53 assert.deepEqual(data, {
54 ok: false,
55 id: 1,
56 name: 'should be strictly equal',
57 diag: {
58 operator: 'equal',
59 expected: '{ b: 2 }',
60 actual: '{ a: 1 }',
61 // we don't care about these next two
62 stack: data.diag.stack,
63 at: data.diag.at
64 }
65 });
66 });
67
68 test('deep equal', function (t) {
69 t.plan(1);
70 t.equal({ a: 1 }, { b: 2 });
71 });
72});
73
74tap.test('deep equal failure, depth 6, with option', function (assert) {
75 var test = tape.createHarness({ exit: false });
76 var stream = test.createStream();
77 var parser = tapParser();
78 assert.plan(3);
79
80 stream.pipe(parser);
81 stream.pipe(concat(function (body) {
82 assert.deepEqual(stripFullStack(body.toString('utf8')), [
83 'TAP version 13',
84 '# deep equal',
85 'not ok 1 should be strictly equal',
86 ' ---',
87 ' operator: equal',
88 ' expected: |-',
89 ' { a: { a1: { a2: { a3: { a4: { a5: 2 } } } } } }',
90 ' actual: |-',
91 ' { a: { a1: { a2: { a3: { a4: { a5: 1 } } } } } }',
92 ' at: Test.<anonymous> ($TEST/deep-equal-failure.js:$LINE:$COL)',
93 ' stack: |-',
94 ' Error: should be strictly equal',
95 ' [... stack stripped ...]',
96 ' at Test.<anonymous> ($TEST/deep-equal-failure.js:$LINE:$COL)',
97 ' [... stack stripped ...]',
98 ' ...',
99 '',
100 '1..1',
101 '# tests 1',
102 '# pass 0',
103 '# fail 1',
104 ''
105 ]);
106
107 assert.deepEqual(getDiag(body), {
108 operator: 'equal',
109 expected: '{ a: { a1: { a2: { a3: { a4: { a5: 2 } } } } } }',
110 actual: '{ a: { a1: { a2: { a3: { a4: { a5: 1 } } } } } }'
111 });
112 }));
113
114 parser.once('assert', function (data) {
115 assert.deepEqual(data, {
116 ok: false,
117 id: 1,
118 name: 'should be strictly equal',
119 diag: {
120 operator: 'equal',
121 expected: '{ a: { a1: { a2: { a3: { a4: { a5: 2 } } } } } }',
122 actual: '{ a: { a1: { a2: { a3: { a4: { a5: 1 } } } } } }',
123 // we don't care about these next two
124 stack: data.diag.stack,
125 at: data.diag.at
126 }
127 });
128 });
129
130 test('deep equal', { objectPrintDepth: 6 }, function (t) {
131 t.plan(1);
132 t.equal({ a: { a1: { a2: { a3: { a4: { a5: 1 } } } } } }, { a: { a1: { a2: { a3: { a4: { a5: 2 } } } } } });
133 });
134});
135
136tap.test('deep equal failure, depth 6, without option', function (assert) {
137 var test = tape.createHarness({ exit: false });
138 var stream = test.createStream();
139 var parser = tapParser();
140 assert.plan(3);
141
142 stream.pipe(parser);
143 stream.pipe(concat(function (body) {
144 assert.deepEqual(stripFullStack(body.toString('utf8')), [
145 'TAP version 13',
146 '# deep equal',
147 'not ok 1 should be strictly equal',
148 ' ---',
149 ' operator: equal',
150 ' expected: |-',
151 ' { a: { a1: { a2: { a3: { a4: [Object] } } } } }',
152 ' actual: |-',
153 ' { a: { a1: { a2: { a3: { a4: [Object] } } } } }',
154 ' at: Test.<anonymous> ($TEST/deep-equal-failure.js:$LINE:$COL)',
155 ' stack: |-',
156 ' Error: should be strictly equal',
157 ' [... stack stripped ...]',
158 ' at Test.<anonymous> ($TEST/deep-equal-failure.js:$LINE:$COL)',
159 ' [... stack stripped ...]',
160 ' ...',
161 '',
162 '1..1',
163 '# tests 1',
164 '# pass 0',
165 '# fail 1',
166 ''
167 ]);
168
169 assert.deepEqual(getDiag(body), {
170 operator: 'equal',
171 expected: '{ a: { a1: { a2: { a3: { a4: [Object] } } } } }',
172 actual: '{ a: { a1: { a2: { a3: { a4: [Object] } } } } }'
173 });
174 }));
175
176 parser.once('assert', function (data) {
177 assert.deepEqual(data, {
178 ok: false,
179 id: 1,
180 name: 'should be strictly equal',
181 diag: {
182 operator: 'equal',
183 expected: '{ a: { a1: { a2: { a3: { a4: [Object] } } } } }',
184 actual: '{ a: { a1: { a2: { a3: { a4: [Object] } } } } }',
185 // we don't care about these next two
186 stack: data.diag.stack,
187 at: data.diag.at
188 }
189 });
190 });
191
192 test('deep equal', function (t) {
193 t.plan(1);
194 t.equal({ a: { a1: { a2: { a3: { a4: { a5: 1 } } } } } }, { a: { a1: { a2: { a3: { a4: { a5: 2 } } } } } });
195 });
196});