Skip to content

Commit ccd1df9

Browse files
kasperisagerfeross
kasperisager
and
feross
authoredJun 9, 2022
Implement as class and port tests to Brittle (#27)
* Implement as class and port tests to Brittle * Remove `mkdirp-classis` Co-authored-by: Feross Aboukhadijeh <[email protected]> * Export class * Use default params * Update example * No need for that * Ignore more dirs Co-authored-by: Feross Aboukhadijeh <[email protected]>
·
v4.1.2v3.0.0
1 parent 58d9e1a commit ccd1df9

File tree

6 files changed

+322
-298
lines changed

6 files changed

+322
-298
lines changed
 

‎.gitignore

+3
Original file line numberDiff line numberDiff line change
@@ -1 +1,4 @@
11
node_modules
2+
sandbox
3+
coverage
4+
package-lock.json

‎README.md

+3-3
Original file line numberDiff line numberDiff line change
@@ -15,9 +15,9 @@ random-access-file allows you to do just this.
1515
## Usage
1616

1717
``` js
18-
var randomAccessFile = require('random-access-file')
18+
const RandomAccessFile = require('random-access-file')
1919

20-
var file = randomAccessFile('my-file.txt')
20+
const file = new RandomAccessFile('my-file.txt')
2121

2222
file.write(10, Buffer.from('hello'), function(err) {
2323
// write a buffer to offset 10
@@ -34,7 +34,7 @@ file will use an open file descriptor. When you are done with the file you shoul
3434

3535
## API
3636

37-
#### `var file = randomAccessFile(filename, [options])`
37+
#### `const file = new RandomAccessFile(filename, [options])`
3838

3939
Create a new file. Options include:
4040

‎example.js

+5-5
Original file line numberDiff line numberDiff line change
@@ -1,11 +1,11 @@
1-
var raf = require('random-access-file')
2-
var file = raf('hello.txt')
1+
const RAF = require('.')
2+
const file = new RAF('hello.txt')
33

4-
var max = 500 * 1024 * 1024
5-
var buf = Buffer.alloc(1024)
4+
const max = 500 * 1024 * 1024
5+
const buf = Buffer.alloc(1024)
66
buf.fill('lo')
77

8-
var offset = 0
8+
let offset = 0
99
write()
1010

1111
function write () {

‎index.js

+133-137
Original file line numberDiff line numberDiff line change
@@ -1,176 +1,172 @@
1-
var inherits = require('util').inherits
2-
var RandomAccess = require('random-access-storage')
3-
var fs = require('fs')
4-
var mkdirp = require('mkdirp-classic')
5-
var path = require('path')
6-
var constants = fs.constants || require('constants') // eslint-disable-line
7-
8-
var READONLY = constants.O_RDONLY
9-
var READWRITE = constants.O_RDWR | constants.O_CREAT
10-
11-
module.exports = RandomAccessFile
12-
13-
function RandomAccessFile (filename, opts) {
14-
if (!(this instanceof RandomAccessFile)) return new RandomAccessFile(filename, opts)
15-
RandomAccess.call(this)
16-
17-
if (!opts) opts = {}
18-
if (opts.directory) filename = path.join(opts.directory, path.resolve('/', filename).replace(/^\w+:\\/, ''))
19-
20-
this.directory = opts.directory || null
21-
this.filename = filename
22-
this.fd = 0
23-
24-
// makes random-access-storage open in writable mode first
25-
if (opts.writable || opts.truncate) this.preferReadonly = false
26-
27-
this._size = opts.size || opts.length || 0
28-
this._truncate = !!opts.truncate || this._size > 0
29-
this._rmdir = !!opts.rmdir
30-
this._lock = opts.lock || noLock
31-
this._sparse = opts.sparse || noLock
32-
this._alloc = opts.alloc || Buffer.allocUnsafe
33-
}
1+
const RandomAccessStorage = require('random-access-storage')
2+
const fs = require('fs')
3+
const path = require('path')
4+
const constants = fs.constants || require('constants') // eslint-disable-line n/no-deprecated-api
345

35-
inherits(RandomAccessFile, RandomAccess)
6+
const READONLY = constants.O_RDONLY
7+
const READWRITE = constants.O_RDWR | constants.O_CREAT
368

37-
RandomAccessFile.prototype._open = function (req) {
38-
var self = this
9+
module.exports = class RandomAccessFile extends RandomAccessStorage {
10+
constructor (filename, opts = {}) {
11+
super()
3912

40-
mkdirp(path.dirname(this.filename), ondir)
13+
if (opts.directory) filename = path.join(opts.directory, path.resolve('/', filename).replace(/^\w+:\\/, ''))
4114

42-
function ondir (err) {
43-
if (err) return req.callback(err)
44-
open(self, READWRITE, req)
45-
}
46-
}
15+
this.directory = opts.directory || null
16+
this.filename = filename
17+
this.fd = 0
4718

48-
RandomAccessFile.prototype._openReadonly = function (req) {
49-
open(this, READONLY, req)
50-
}
19+
// makes random-access-storage open in writable mode first
20+
if (opts.writable || opts.truncate) this.preferReadonly = false
5121

52-
RandomAccessFile.prototype._write = function (req) {
53-
var data = req.data
54-
var fd = this.fd
55-
56-
fs.write(fd, data, 0, req.size, req.offset, onwrite)
22+
this._size = opts.size || opts.length || 0
23+
this._truncate = !!opts.truncate || this._size > 0
24+
this._rmdir = !!opts.rmdir
25+
this._lock = opts.lock || noLock
26+
this._sparse = opts.sparse || noLock
27+
this._alloc = opts.alloc || Buffer.allocUnsafe
28+
}
5729

58-
function onwrite (err, wrote) {
59-
if (err) return req.callback(err)
30+
_open (req) {
31+
const self = this
6032

61-
req.size -= wrote
62-
req.offset += wrote
33+
fs.mkdir(path.dirname(this.filename), { recursive: true }, ondir)
6334

64-
if (!req.size) return req.callback(null)
65-
fs.write(fd, data, data.length - req.size, req.size, req.offset, onwrite)
35+
function ondir (err) {
36+
if (err) return req.callback(err)
37+
self._openMode(READWRITE, req)
38+
}
6639
}
67-
}
6840

69-
RandomAccessFile.prototype._read = function (req) {
70-
var self = this
71-
var data = req.data || this._alloc(req.size)
72-
var fd = this.fd
41+
_openReadonly (req) {
42+
this._openMode(READONLY, req)
43+
}
7344

74-
if (!req.size) return process.nextTick(readEmpty, req)
75-
fs.read(fd, data, 0, req.size, req.offset, onread)
45+
_openMode (mode, req) {
46+
const self = this
7647

77-
function onread (err, read) {
78-
if (err) return req.callback(err)
79-
if (!read) return req.callback(createReadError(self.filename, req.offset, req.size))
48+
if (this.fd) fs.close(this.fd, oncloseold)
49+
else fs.open(this.filename, mode, onopen)
8050

81-
req.size -= read
82-
req.offset += read
51+
function onopen (err, fd) {
52+
if (err) return req.callback(err)
53+
self.fd = fd
54+
if (!self._lock(self.fd)) return req.callback(createLockError(self.filename)) // TODO: fix fd leak here
55+
if (!self._sparse(self.fd)) return req.callback(createSparseError(self.filename))
56+
if (!self._truncate || mode === READONLY) return req.callback(null)
57+
fs.ftruncate(self.fd, self._size, ontruncate)
58+
}
8359

84-
if (!req.size) return req.callback(null, data)
85-
fs.read(fd, data, data.length - req.size, req.size, req.offset, onread)
60+
function oncloseold (err) {
61+
if (err) return onerrorafteropen(err)
62+
self.fd = 0
63+
fs.open(self.filename, mode, onopen)
64+
}
65+
66+
function ontruncate (err) {
67+
if (err) return onerrorafteropen(err)
68+
req.callback(null)
69+
}
70+
71+
function onerrorafteropen (err) {
72+
fs.close(self.fd, function () {
73+
self.fd = 0
74+
req.callback(err)
75+
})
76+
}
8677
}
87-
}
8878

89-
RandomAccessFile.prototype._del = function (req) {
90-
var fd = this.fd
79+
_write (req) {
80+
const data = req.data
81+
const fd = this.fd
9182

92-
fs.fstat(fd, onstat)
83+
fs.write(fd, data, 0, req.size, req.offset, onwrite)
9384

94-
function onstat (err, st) {
95-
if (err) return req.callback(err)
96-
if (req.offset + req.size < st.size) return req.callback(null)
97-
fs.ftruncate(fd, req.offset, ontruncate)
98-
}
85+
function onwrite (err, wrote) {
86+
if (err) return req.callback(err)
9987

100-
function ontruncate (err) {
101-
req.callback(err)
88+
req.size -= wrote
89+
req.offset += wrote
90+
91+
if (!req.size) return req.callback(null)
92+
fs.write(fd, data, data.length - req.size, req.size, req.offset, onwrite)
93+
}
10294
}
103-
}
10495

105-
RandomAccessFile.prototype._stat = function (req) {
106-
fs.fstat(this.fd, onstat)
96+
_read (req) {
97+
const self = this
98+
const data = req.data || this._alloc(req.size)
99+
const fd = this.fd
107100

108-
function onstat (err, st) {
109-
req.callback(err, st)
110-
}
111-
}
101+
if (!req.size) return process.nextTick(readEmpty, req)
102+
fs.read(fd, data, 0, req.size, req.offset, onread)
112103

113-
RandomAccessFile.prototype._close = function (req) {
114-
var self = this
104+
function onread (err, read) {
105+
if (err) return req.callback(err)
106+
if (!read) return req.callback(createReadError(self.filename, req.offset, req.size))
115107

116-
fs.close(this.fd, onclose)
108+
req.size -= read
109+
req.offset += read
117110

118-
function onclose (err) {
119-
if (err) return req.callback(err)
120-
self.fd = 0
121-
req.callback(null)
111+
if (!req.size) return req.callback(null, data)
112+
fs.read(fd, data, data.length - req.size, req.size, req.offset, onread)
113+
}
122114
}
123-
}
124115

125-
RandomAccessFile.prototype._destroy = function (req) {
126-
var self = this
116+
_del (req) {
117+
const fd = this.fd
127118

128-
var root = this.directory && path.resolve(path.join(this.directory, '.'))
129-
var dir = path.resolve(path.dirname(this.filename))
119+
fs.fstat(fd, onstat)
130120

131-
fs.unlink(this.filename, onunlink)
121+
function onstat (err, st) {
122+
if (err) return req.callback(err)
123+
if (req.offset + req.size < st.size) return req.callback(null)
124+
fs.ftruncate(fd, req.offset, ontruncate)
125+
}
132126

133-
function onunlink (err) {
134-
if (!self._rmdir || !root || dir === root) return req.callback(err)
135-
fs.rmdir(dir, onrmdir)
127+
function ontruncate (err) {
128+
req.callback(err)
129+
}
136130
}
137131

138-
function onrmdir (err) {
139-
dir = path.join(dir, '..')
140-
if (err || dir === root) return req.callback(null)
141-
fs.rmdir(dir, onrmdir)
142-
}
143-
}
132+
_stat (req) {
133+
fs.fstat(this.fd, onstat)
144134

145-
function open (self, mode, req) {
146-
if (self.fd) fs.close(self.fd, oncloseold)
147-
else fs.open(self.filename, mode, onopen)
148-
149-
function onopen (err, fd) {
150-
if (err) return req.callback(err)
151-
self.fd = fd
152-
if (!self._lock(self.fd)) return req.callback(createLockError(self.filename)) // TODO: fix fd leak here
153-
if (!self._sparse(self.fd)) return req.callback(createSparseError(self.filename))
154-
if (!self._truncate || mode === READONLY) return req.callback(null)
155-
fs.ftruncate(self.fd, self._size, ontruncate)
135+
function onstat (err, st) {
136+
req.callback(err, st)
137+
}
156138
}
157139

158-
function oncloseold (err) {
159-
if (err) return onerrorafteropen(err)
160-
self.fd = 0
161-
fs.open(self.filename, mode, onopen)
162-
}
140+
_close (req) {
141+
const self = this
163142

164-
function ontruncate (err) {
165-
if (err) return onerrorafteropen(err)
166-
req.callback(null)
167-
}
143+
fs.close(this.fd, onclose)
168144

169-
function onerrorafteropen (err) {
170-
fs.close(self.fd, function () {
145+
function onclose (err) {
146+
if (err) return req.callback(err)
171147
self.fd = 0
172-
req.callback(err)
173-
})
148+
req.callback(null)
149+
}
150+
}
151+
152+
_destroy (req) {
153+
const self = this
154+
155+
const root = this.directory && path.resolve(path.join(this.directory, '.'))
156+
let dir = path.resolve(path.dirname(this.filename))
157+
158+
fs.unlink(this.filename, onunlink)
159+
160+
function onunlink (err) {
161+
if (!self._rmdir || !root || dir === root) return req.callback(err)
162+
fs.rmdir(dir, onrmdir)
163+
}
164+
165+
function onrmdir (err) {
166+
dir = path.join(dir, '..')
167+
if (err || dir === root) return req.callback(null)
168+
fs.rmdir(dir, onrmdir)
169+
}
174170
}
175171
}
176172

@@ -183,21 +179,21 @@ function noLock (fd) {
183179
}
184180

185181
function createSparseError (path) {
186-
var err = new Error('ENOTSPARSE: File could not be marked as sparse')
182+
const err = new Error('ENOTSPARSE: File could not be marked as sparse')
187183
err.code = 'ENOTSPARSE'
188184
err.path = path
189185
return err
190186
}
191187

192188
function createLockError (path) {
193-
var err = new Error('ELOCKED: File is locked')
189+
const err = new Error('ELOCKED: File is locked')
194190
err.code = 'ELOCKED'
195191
err.path = path
196192
return err
197193
}
198194

199195
function createReadError (path, offset, size) {
200-
var err = new Error('Could not satisfy length')
196+
const err = new Error('Could not satisfy length')
201197
err.code = 'EPARTIALREAD'
202198
err.path = path
203199
err.offset = offset

‎package.json

+3-4
Original file line numberDiff line numberDiff line change
@@ -4,16 +4,15 @@
44
"description": "Continuous reading or writing to a file using random offsets and lengths",
55
"main": "index.js",
66
"scripts": {
7-
"test": "standard && tape test.js"
7+
"test": "standard && brittle test.js"
88
},
99
"browser": "./browser.js",
1010
"dependencies": {
11-
"mkdirp-classic": "^0.5.2",
1211
"random-access-storage": "^1.1.1"
1312
},
1413
"devDependencies": {
15-
"standard": "^15.0.0",
16-
"tape": "^4.8.0"
14+
"brittle": "^2.3.1",
15+
"standard": "^17.0.0"
1716
},
1817
"repository": {
1918
"type": "git",

‎test.js

+175-149
Original file line numberDiff line numberDiff line change
@@ -1,247 +1,268 @@
1-
var raf = require('./')
2-
var tape = require('tape')
3-
var os = require('os')
4-
var path = require('path')
5-
var fs = require('fs')
6-
var mkdirp = require('mkdirp')
7-
var isWin = process.platform === 'win32'
1+
const test = require('brittle')
2+
const os = require('os')
3+
const path = require('path')
4+
const fs = require('fs')
5+
const RAF = require('.')
86

9-
var tmp = path.join(os.tmpdir(), 'random-access-file-' + process.pid + '-' + Date.now())
10-
var i = 0
7+
const tmp = path.join(os.tmpdir(), 'random-access-file-' + process.pid + '-' + Date.now())
8+
let i = 0
119

12-
mkdirp.sync(tmp)
10+
fs.mkdirSync(tmp, { recursive: true })
1311

14-
tape('write and read', function (t) {
15-
var file = raf(gen())
12+
test('write and read', function (t) {
13+
t.plan(4)
14+
15+
const file = new RAF(gen())
1616

1717
file.write(0, Buffer.from('hello'), function (err) {
18-
t.error(err, 'no error')
18+
t.absent(err, 'no error')
1919
file.read(0, 5, function (err, buf) {
20-
t.error(err, 'no error')
21-
t.same(buf, Buffer.from('hello'))
22-
file.destroy(() => t.end())
20+
t.absent(err, 'no error')
21+
t.alike(buf, Buffer.from('hello'))
22+
file.destroy(() => t.pass())
2323
})
2424
})
2525
})
2626

27-
tape('read empty', function (t) {
28-
var file = raf(gen(), { writable: true })
27+
test('read empty', function (t) {
28+
t.plan(3)
29+
30+
const file = new RAF(gen(), { writable: true })
2931

3032
file.read(0, 0, function (err, buf) {
31-
t.error(err, 'no error')
32-
t.same(buf, Buffer.alloc(0), 'empty buffer')
33-
file.destroy(() => t.end())
33+
t.absent(err, 'no error')
34+
t.alike(buf, Buffer.alloc(0), 'empty buffer')
35+
file.destroy(() => t.pass())
3436
})
3537
})
3638

37-
tape('read range > file', function (t) {
38-
var file = raf(gen())
39+
test('read range > file', function (t) {
40+
t.plan(2)
41+
42+
const file = new RAF(gen())
3943

4044
file.read(0, 5, function (err, buf) {
4145
t.ok(err, 'not satisfiable')
42-
file.destroy(() => t.end())
46+
file.destroy(() => t.pass())
4347
})
4448
})
4549

46-
tape('read range > file with data', function (t) {
47-
var file = raf(gen())
50+
test('read range > file with data', function (t) {
51+
t.plan(3)
52+
53+
const file = new RAF(gen())
4854

4955
file.write(0, Buffer.from('hello'), function (err) {
50-
t.error(err, 'no error')
56+
t.absent(err, 'no error')
5157
file.read(0, 10, function (err, buf) {
5258
t.ok(err, 'not satisfiable')
53-
file.destroy(() => t.end())
59+
file.destroy(() => t.pass())
5460
})
5561
})
5662
})
5763

58-
tape('random access write and read', function (t) {
59-
var file = raf(gen())
64+
test('random access write and read', function (t) {
65+
t.plan(8)
66+
67+
const file = new RAF(gen())
6068

6169
file.write(10, Buffer.from('hi'), function (err) {
62-
t.error(err, 'no error')
70+
t.absent(err, 'no error')
6371
file.write(0, Buffer.from('hello'), function (err) {
64-
t.error(err, 'no error')
72+
t.absent(err, 'no error')
6573
file.read(10, 2, function (err, buf) {
66-
t.error(err, 'no error')
67-
t.same(buf, Buffer.from('hi'))
74+
t.absent(err, 'no error')
75+
t.alike(buf, Buffer.from('hi'))
6876
file.read(0, 5, function (err, buf) {
69-
t.error(err, 'no error')
70-
t.same(buf, Buffer.from('hello'))
77+
t.absent(err, 'no error')
78+
t.alike(buf, Buffer.from('hello'))
7179
file.read(5, 5, function (err, buf) {
72-
t.error(err, 'no error')
73-
t.same(buf, Buffer.from([0, 0, 0, 0, 0]))
74-
t.end()
80+
t.absent(err, 'no error')
81+
t.alike(buf, Buffer.from([0, 0, 0, 0, 0]))
7582
})
7683
})
7784
})
7885
})
7986
})
8087
})
8188

82-
tape('re-open', function (t) {
83-
var name = gen()
84-
var file = raf(name)
89+
test('re-open', function (t) {
90+
t.plan(3)
91+
92+
const name = gen()
93+
const file = new RAF(name)
8594

8695
file.write(10, Buffer.from('hello'), function (err) {
87-
t.error(err, 'no error')
88-
var file2 = raf(name)
96+
t.absent(err, 'no error')
97+
const file2 = new RAF(name)
8998
file2.read(10, 5, function (err, buf) {
90-
t.error(err, 'no error')
91-
t.same(buf, Buffer.from('hello'))
92-
t.end()
99+
t.absent(err, 'no error')
100+
t.alike(buf, Buffer.from('hello'))
93101
})
94102
})
95103
})
96104

97-
tape('re-open and truncate', function (t) {
98-
var name = gen()
99-
var file = raf(name)
105+
test('re-open and truncate', function (t) {
106+
t.plan(2)
107+
108+
const name = gen()
109+
const file = new RAF(name)
100110

101111
file.write(10, Buffer.from('hello'), function (err) {
102-
t.error(err, 'no error')
103-
var file2 = raf(name, { truncate: true })
112+
t.absent(err, 'no error')
113+
const file2 = new RAF(name, { truncate: true })
104114
file2.read(10, 5, function (err, buf) {
105115
t.ok(err, 'file should be truncated')
106-
t.end()
107116
})
108117
})
109118
})
110119

111-
tape('truncate with size', function (t) {
112-
var file = raf(gen(), { size: 100, writable: true })
120+
test('truncate with size', function (t) {
121+
t.plan(3)
122+
123+
const file = new RAF(gen(), { size: 100, writable: true })
113124

114125
file.stat(function (err, st) {
115-
t.error(err, 'no error')
116-
t.same(st.size, 100)
117-
file.destroy(() => t.end())
126+
t.absent(err, 'no error')
127+
t.is(st.size, 100)
128+
file.destroy(() => t.pass())
118129
})
119130
})
120131

121-
tape('bad open', function (t) {
122-
if (isWin) return t.end() // windows apparently allow you to open dirs :/
132+
test('bad open', {
133+
// windows apparently allow you to open dirs :/
134+
skip: process.platform === 'win32'
135+
}, function (t) {
136+
t.plan(2)
123137

124-
var file = raf(tmp, { writable: true })
138+
const file = new RAF(tmp, { writable: true })
125139

126140
file.open(function (err) {
127141
t.ok(err)
128-
file.close(() => t.end())
142+
file.close(() => t.pass())
129143
})
130144
})
131145

132-
tape('mkdir path', function (t) {
133-
var name = path.join(tmp, ++i + '-folder', 'test.txt')
134-
var file = raf(name)
146+
test('mkdir path', function (t) {
147+
t.plan(4)
148+
149+
const name = path.join(tmp, ++i + '-folder', 'test.txt')
150+
const file = new RAF(name)
135151

136152
file.write(0, Buffer.from('hello'), function (err) {
137-
t.error(err, 'no error')
153+
t.absent(err, 'no error')
138154
file.read(0, 5, function (err, buf) {
139-
t.error(err, 'no error')
140-
t.same(buf, Buffer.from('hello'))
141-
t.end()
142-
file.destroy()
155+
t.absent(err, 'no error')
156+
t.alike(buf, Buffer.from('hello'))
157+
file.destroy(() => t.pass())
143158
})
144159
})
145160
})
146161

147-
tape('write/read big chunks', function (t) {
148-
var file = raf(gen())
149-
var bigBuffer = Buffer.alloc(10 * 1024 * 1024)
150-
var missing = 2
162+
test('write/read big chunks', async function (t) {
163+
t.plan(2)
164+
165+
const file = new RAF(gen())
166+
const bigBuffer = Buffer.alloc(10 * 1024 * 1024)
151167

152168
bigBuffer.fill('hey. hey. how are you doing?. i am good thanks how about you? i am good')
153169

170+
const io = t.test('write and read')
171+
io.plan(6)
172+
154173
file.write(0, bigBuffer, function (err) {
155-
t.error(err, 'no error')
174+
io.absent(err, 'no error')
156175
file.read(0, bigBuffer.length, function (err, buf) {
157-
t.error(err, 'no error')
158-
t.same(buf, bigBuffer)
159-
done()
176+
io.absent(err, 'no error')
177+
io.alike(buf, bigBuffer)
160178
})
161179
})
162180
file.write(bigBuffer.length * 2, bigBuffer, function (err) {
163-
t.error(err, 'no error')
181+
io.absent(err, 'no error')
164182
file.read(bigBuffer.length * 2, bigBuffer.length, function (err, buf) {
165-
t.error(err, 'no error')
166-
t.same(buf, bigBuffer)
167-
done()
183+
io.absent(err, 'no error')
184+
io.alike(buf, bigBuffer)
168185
})
169186
})
170187

171-
function done () {
172-
if (!--missing) file.destroy(() => t.end())
173-
}
188+
await io
189+
190+
file.destroy(() => t.pass())
174191
})
175192

176-
tape('rmdir option', function (t) {
177-
var name = path.join('rmdir', ++i + '', 'folder', 'test.txt')
178-
var file = raf(name, { rmdir: true, directory: tmp })
193+
test('rmdir option', function (t) {
194+
t.plan(5)
195+
196+
const name = path.join('rmdir', ++i + '', 'folder', 'test.txt')
197+
const file = new RAF(name, { rmdir: true, directory: tmp })
179198

180199
file.write(0, Buffer.from('hi'), function (err) {
181-
t.error(err, 'no error')
200+
t.absent(err, 'no error')
182201
file.read(0, 2, function (err, buf) {
183-
t.error(err, 'no error')
184-
t.same(buf, Buffer.from('hi'))
202+
t.absent(err, 'no error')
203+
t.alike(buf, Buffer.from('hi'))
185204
file.destroy(ondestroy)
186205
})
187206
})
188207

189208
function ondestroy (err) {
190-
t.error(err, 'no error')
209+
t.absent(err, 'no error')
191210
fs.stat(path.join(tmp, 'rmdir'), function (err) {
192-
t.same(err && err.code, 'ENOENT', 'should be removed')
193-
t.end()
211+
t.is(err && err.code, 'ENOENT', 'should be removed')
194212
})
195213
}
196214
})
197215

198-
tape('rmdir option with non empty parent', function (t) {
199-
var name = path.join('rmdir', ++i + '', 'folder', 'test.txt')
200-
var nonEmpty = path.join(tmp, name, '../..')
201-
var file = raf(name, { rmdir: true, directory: tmp })
216+
test('rmdir option with non empty parent', function (t) {
217+
t.plan(7)
218+
219+
const name = path.join('rmdir', ++i + '', 'folder', 'test.txt')
220+
const nonEmpty = path.join(tmp, name, '../..')
221+
const file = new RAF(name, { rmdir: true, directory: tmp })
202222

203223
file.write(0, Buffer.from('hi'), function (err) {
204-
t.error(err, 'no error')
224+
t.absent(err, 'no error')
205225
fs.writeFileSync(path.join(nonEmpty, 'thing'), '')
206226
file.read(0, 2, function (err, buf) {
207-
t.error(err, 'no error')
208-
t.same(buf, Buffer.from('hi'))
227+
t.absent(err, 'no error')
228+
t.alike(buf, Buffer.from('hi'))
209229
file.destroy(ondestroy)
210230
})
211231
})
212232

213233
function ondestroy (err) {
214-
t.error(err, 'no error')
234+
t.absent(err, 'no error')
215235
fs.stat(path.join(tmp, 'rmdir'), function (err) {
216-
t.error(err, 'should not be removed')
236+
t.absent(err, 'should not be removed')
217237
fs.readdir(nonEmpty, function (err, list) {
218-
t.error(err, 'no error')
219-
t.same(list, ['thing'], 'should only be one entry')
220-
t.end()
238+
t.absent(err, 'no error')
239+
t.alike(list, ['thing'], 'should only be one entry')
221240
})
222241
})
223242
}
224243
})
225244

226-
tape('del', function (t) {
227-
var file = raf(gen())
245+
test('del', function (t) {
246+
t.plan(10)
247+
248+
const file = new RAF(gen())
228249

229250
file.write(0, Buffer.alloc(100), function (err) {
230-
t.error(err, 'no error')
251+
t.absent(err, 'no error')
231252
file.stat(function (err, st) {
232-
t.error(err, 'no error')
233-
t.same(st.size, 100)
253+
t.absent(err, 'no error')
254+
t.is(st.size, 100)
234255
file.del(0, 40, function (err) {
235-
t.error(err, 'no error')
256+
t.absent(err, 'no error')
236257
file.stat(function (err, st) {
237-
t.error(err, 'no error')
238-
t.same(st.size, 100, 'inplace del, same size')
258+
t.absent(err, 'no error')
259+
t.is(st.size, 100, 'inplace del, same size')
239260
file.del(50, 50, function (err) {
240-
t.error(err, 'no error')
261+
t.absent(err, 'no error')
241262
file.stat(function (err, st) {
242-
t.error(err, 'no error')
243-
t.same(st.size, 50)
244-
file.destroy(() => t.end())
263+
t.absent(err, 'no error')
264+
t.is(st.size, 50)
265+
file.destroy(() => t.pass())
245266
})
246267
})
247268
})
@@ -250,25 +271,27 @@ tape('del', function (t) {
250271
})
251272
})
252273

253-
tape('open and close many times', function (t) {
254-
var name = gen()
255-
var file = raf(name)
256-
var buf = Buffer.alloc(4)
274+
test('open and close many times', function (t) {
275+
t.plan(3)
276+
277+
const name = gen()
278+
const file = new RAF(name)
279+
const buf = Buffer.alloc(4)
257280

258281
file.write(0, buf, function (err) {
259-
t.error(err, 'no error')
282+
t.absent(err, 'no error')
260283
loop(5000, function (err) {
261-
t.error(err, 'no error')
262-
file.destroy(() => t.end())
284+
t.absent(err, 'no error')
285+
file.destroy(() => t.pass())
263286
})
264287
})
265288

266289
function loop (n, cb) {
267-
var file = raf(name)
290+
const file = new RAF(name)
268291
file.read(0, 4, function (err, buffer) {
269292
if (err) return cb(err)
270293
if (!buf.equals(buffer)) {
271-
t.same(buffer, buf)
294+
t.alike(buffer, buf)
272295
return cb()
273296
}
274297
buf.writeUInt32BE(n)
@@ -283,48 +306,51 @@ tape('open and close many times', function (t) {
283306
}
284307
})
285308

286-
tape('trigger bad open', function (t) {
287-
var file = raf(gen(), { writable: true })
309+
test('trigger bad open', function (t) {
310+
t.plan(3)
311+
312+
const file = new RAF(gen(), { writable: true })
288313

289314
file.fd = 10000
290315
file.open(function (err) {
291316
t.ok(err, 'should error trying to close old fd')
292317
file.open(function (err) {
293-
t.error(err, 'no error')
294-
file.destroy(() => t.end())
318+
t.absent(err, 'no error')
319+
file.destroy(() => t.pass())
295320
})
296321
})
297322
})
298323

299-
tape('trigger lock', function (t) {
300-
var p = gen()
301-
var file = raf(p, { writable: true, lock: () => false })
324+
test('trigger lock', function (t) {
325+
t.plan(4)
326+
327+
const p = gen()
328+
const file = new RAF(p, { writable: true, lock: () => false })
302329

303330
file.open(function (err) {
304331
t.ok(err, 'should error because it is locked')
305-
t.same(err.message, 'ELOCKED: File is locked')
306-
t.same(err.path, p)
307-
t.same(err.code, 'ELOCKED')
308-
t.end()
332+
t.is(err.message, 'ELOCKED: File is locked')
333+
t.is(err.path, p)
334+
t.is(err.code, 'ELOCKED')
309335
})
310336
})
311337

312-
tape('cannot escape directory', function (t) {
313-
var name = '../../../../../../../../../../../../../tmp'
314-
var file = raf(name, { writable: true, directory: tmp })
338+
test('cannot escape directory', function (t) {
339+
t.plan(2)
340+
341+
const name = '../../../../../../../../../../../../../tmp'
342+
const file = new RAF(name, { writable: true, directory: tmp })
315343

316344
file.open(function (err) {
317-
t.error(err, 'no error')
318-
t.same(file.filename, path.join(tmp, 'tmp'))
319-
t.end()
345+
t.absent(err, 'no error')
346+
t.is(file.filename, path.join(tmp, 'tmp'))
320347
})
321348
})
322349

323-
tape('directory filename resolves correctly', function (t) {
324-
var name = 'test.txt'
325-
var file = raf(name, { writable: true, directory: tmp })
326-
t.same(file.filename, path.join(tmp, name))
327-
t.end()
350+
test('directory filename resolves correctly', function (t) {
351+
const name = 'test.txt'
352+
const file = new RAF(name, { writable: true, directory: tmp })
353+
t.is(file.filename, path.join(tmp, name))
328354
})
329355

330356
function gen () {

0 commit comments

Comments
 (0)
Please sign in to comment.