• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1'use strict';
2
3const common = require('../common');
4const { Readable } = require('stream');
5const assert = require('assert');
6
7{
8  const read = new Readable({
9    read() {}
10  });
11  read.resume();
12
13  read.on('close', common.mustCall());
14
15  read.destroy();
16  assert.strictEqual(read.destroyed, true);
17}
18
19{
20  const read = new Readable({
21    read() {}
22  });
23  read.resume();
24
25  const expected = new Error('kaboom');
26
27  read.on('end', common.mustNotCall('no end event'));
28  read.on('close', common.mustCall());
29  read.on('error', common.mustCall((err) => {
30    assert.strictEqual(err, expected);
31  }));
32
33  read.destroy(expected);
34  assert.strictEqual(read.destroyed, true);
35}
36
37{
38  const read = new Readable({
39    read() {}
40  });
41
42  read._destroy = common.mustCall(function(err, cb) {
43    assert.strictEqual(err, expected);
44    cb(err);
45  });
46
47  const expected = new Error('kaboom');
48
49  read.on('end', common.mustNotCall('no end event'));
50  read.on('close', common.mustCall());
51  read.on('error', common.mustCall((err) => {
52    assert.strictEqual(err, expected);
53  }));
54
55  read.destroy(expected);
56  assert.strictEqual(read.destroyed, true);
57}
58
59{
60  const read = new Readable({
61    read() {},
62    destroy: common.mustCall(function(err, cb) {
63      assert.strictEqual(err, expected);
64      cb();
65    })
66  });
67
68  const expected = new Error('kaboom');
69
70  read.on('end', common.mustNotCall('no end event'));
71
72  // Error is swallowed by the custom _destroy
73  read.on('error', common.mustNotCall('no error event'));
74  read.on('close', common.mustCall());
75
76  read.destroy(expected);
77  assert.strictEqual(read.destroyed, true);
78}
79
80{
81  const read = new Readable({
82    read() {}
83  });
84
85  read._destroy = common.mustCall(function(err, cb) {
86    assert.strictEqual(err, null);
87    cb();
88  });
89
90  read.destroy();
91  assert.strictEqual(read.destroyed, true);
92}
93
94{
95  const read = new Readable({
96    read() {}
97  });
98  read.resume();
99
100  read._destroy = common.mustCall(function(err, cb) {
101    assert.strictEqual(err, null);
102    process.nextTick(() => {
103      this.push(null);
104      cb();
105    });
106  });
107
108  const fail = common.mustNotCall('no end event');
109
110  read.on('end', fail);
111  read.on('close', common.mustCall());
112
113  read.destroy();
114
115  read.removeListener('end', fail);
116  read.on('end', common.mustCall());
117  assert.strictEqual(read.destroyed, true);
118}
119
120{
121  const read = new Readable({
122    read() {}
123  });
124
125  const expected = new Error('kaboom');
126
127  read._destroy = common.mustCall(function(err, cb) {
128    assert.strictEqual(err, null);
129    cb(expected);
130  });
131
132  read.on('end', common.mustNotCall('no end event'));
133  read.on('error', common.mustCall((err) => {
134    assert.strictEqual(err, expected);
135  }));
136
137  read.destroy();
138  assert.strictEqual(read.destroyed, true);
139}
140
141{
142  const read = new Readable({
143    read() {}
144  });
145  read.resume();
146
147  read.destroyed = true;
148  assert.strictEqual(read.destroyed, true);
149
150  // The internal destroy() mechanism should not be triggered
151  read.on('end', common.mustNotCall());
152  read.destroy();
153}
154
155{
156  function MyReadable() {
157    assert.strictEqual(this.destroyed, false);
158    this.destroyed = false;
159    Readable.call(this);
160  }
161
162  Object.setPrototypeOf(MyReadable.prototype, Readable.prototype);
163  Object.setPrototypeOf(MyReadable, Readable);
164
165  new MyReadable();
166}
167
168{
169  // Destroy and destroy callback
170  const read = new Readable({
171    read() {}
172  });
173  read.resume();
174
175  const expected = new Error('kaboom');
176
177  read.on('close', common.mustCall());
178  read.destroy(expected, common.mustCall(function(err) {
179    assert.strictEqual(err, expected);
180  }));
181}
182
183{
184  const read = new Readable({
185    read() {}
186  });
187
188  read.destroy();
189  read.push('hi');
190  read.on('data', common.mustNotCall());
191}
192
193{
194  const read = new Readable({
195    read: common.mustNotCall(function() {})
196  });
197  read.destroy();
198  assert.strictEqual(read.destroyed, true);
199  read.read();
200}
201