| require("should"); |
| |
| const _ = require("lodash"); |
| const path = require("path"); |
| const zlib = require("zlib"); |
| const async = require("async"); |
| const stream = require("stream"); |
| const fs = require("fs-extra"); |
| const proxyquire = require("proxyquire").noPreserveCache(); |
| |
| let fakeNow = new Date(2012, 8, 12, 10, 37, 11); |
| const mockNow = () => fakeNow; |
| const RollingFileWriteStream = proxyquire("../lib/RollingFileWriteStream", { |
| "./now": mockNow |
| }); |
| let fakedFsDate = fakeNow; |
| const mockFs = require("fs-extra"); |
| const oldStatSync = mockFs.statSync; |
| mockFs.statSync = fd => { |
| const result = oldStatSync(fd); |
| result.birthtime = fakedFsDate; |
| return result; |
| }; |
| |
| function generateTestFile(fileName) { |
| const dirName = path.join( |
| __dirname, |
| "tmp_" + Math.floor(Math.random() * new Date()) |
| ); |
| fileName = fileName || "ignored.log"; |
| const fileNameObj = path.parse(fileName); |
| return { |
| dir: dirName, |
| base: fileNameObj.base, |
| name: fileNameObj.name, |
| ext: fileNameObj.ext, |
| path: path.join(dirName, fileName) |
| }; |
| } |
| |
| function resetTime() { |
| fakeNow = new Date(2012, 8, 12, 10, 37, 11); |
| fakedFsDate = fakeNow; |
| } |
| |
| describe("RollingFileWriteStream", () => { |
| beforeEach(() => { |
| resetTime(); |
| }); |
| |
| after(() => { |
| fs.readdirSync(__dirname) |
| .filter(f => f.startsWith("tmp_")) |
| .forEach(f => fs.removeSync(path.join(__dirname, f))); |
| }); |
| |
| describe("with no arguments", () => { |
| it("should throw an error", () => { |
| (() => new RollingFileWriteStream()).should.throw( |
| /(the )?"?path"? (argument )?must be (a|of type) string\. received (type )?undefined/i |
| ); |
| }); |
| }); |
| |
| describe("with invalid options", () => { |
| after(done => { |
| fs.remove("filename", done); |
| }); |
| |
| it("should complain about a negative maxSize", () => { |
| (() => { |
| new RollingFileWriteStream("filename", { maxSize: -3 }); |
| }).should.throw("options.maxSize (-3) should be > 0"); |
| (() => { |
| new RollingFileWriteStream("filename", { maxSize: 0 }); |
| }).should.throw("options.maxSize (0) should be > 0"); |
| }); |
| |
| it("should complain about a negative numToKeep", () => { |
| (() => { |
| new RollingFileWriteStream("filename", { numToKeep: -3 }); |
| }).should.throw("options.numToKeep (-3) should be > 0"); |
| (() => { |
| new RollingFileWriteStream("filename", { numToKeep: 0 }); |
| }).should.throw("options.numToKeep (0) should be > 0"); |
| }); |
| }); |
| |
| describe("with default arguments", () => { |
| const fileObj = generateTestFile(); |
| let s; |
| |
| before(() => { |
| s = new RollingFileWriteStream(fileObj.path); |
| }); |
| |
| after(() => { |
| s.end(); |
| fs.removeSync(fileObj.dir); |
| }); |
| |
| it("should take a filename and options, return Writable", () => { |
| s.should.be.an.instanceOf(stream.Writable); |
| s.currentFileStream.path.should.eql(fileObj.path); |
| s.currentFileStream.mode.should.eql(420); |
| s.currentFileStream.flags.should.eql("a"); |
| }); |
| |
| it("should apply default options", () => { |
| s.options.maxSize.should.eql(Number.MAX_SAFE_INTEGER); |
| s.options.encoding.should.eql("utf8"); |
| s.options.mode.should.eql(420); |
| s.options.flags.should.eql("a"); |
| s.options.compress.should.eql(false); |
| s.options.keepFileExt.should.eql(false); |
| }); |
| }); |
| |
| describe("with 5 maxSize, rotating daily", () => { |
| const fileObj = generateTestFile("noExtension"); |
| let s; |
| |
| before(done => { |
| fakeNow = new Date(2012, 8, 12, 10, 37, 11); |
| s = new RollingFileWriteStream(fileObj.path, { |
| pattern: "yyyy-MM-dd", |
| maxSize: 5 |
| }); |
| const flows = Array.from(Array(38).keys()).map(i => cb => { |
| fakeNow = new Date(2012, 8, 12 + parseInt(i / 5, 10), 10, 37, 11); |
| s.write(i.toString(), "utf8", cb); |
| }); |
| async.waterfall(flows, () => done()); |
| }); |
| |
| after(done => { |
| fs.removeSync(fileObj.dir); |
| done(); |
| }); |
| |
| it("should rotate using filename with no extension", () => { |
| const files = fs.readdirSync(fileObj.dir); |
| const expectedFileList = [ |
| fileObj.base, //353637 |
| fileObj.base + ".2012-09-12.1", // 01234 |
| fileObj.base + ".2012-09-13.1", // 56789 |
| fileObj.base + ".2012-09-14.2", // 101112 |
| fileObj.base + ".2012-09-14.1", // 1314 |
| fileObj.base + ".2012-09-15.2", // 151617 |
| fileObj.base + ".2012-09-15.1", // 1819 |
| fileObj.base + ".2012-09-16.2", // 202122 |
| fileObj.base + ".2012-09-16.1", // 2324 |
| fileObj.base + ".2012-09-17.2", // 252627 |
| fileObj.base + ".2012-09-17.1", // 2829 |
| fileObj.base + ".2012-09-18.2", // 303132 |
| fileObj.base + ".2012-09-18.1" // 3334 |
| ]; |
| files.should.containDeep(expectedFileList); |
| files.length.should.equal(expectedFileList.length); |
| fs.readFileSync(path.format(fileObj)) |
| .toString() |
| .should.equal("353637"); |
| fs.readFileSync( |
| path.format( |
| _.assign({}, fileObj, { |
| base: fileObj.base + ".2012-09-12.1" |
| }) |
| ) |
| ) |
| .toString() |
| .should.equal("01234"); |
| fs.readFileSync( |
| path.format( |
| _.assign({}, fileObj, { |
| base: fileObj.base + ".2012-09-13.1" |
| }) |
| ) |
| ) |
| .toString() |
| .should.equal("56789"); |
| fs.readFileSync( |
| path.format( |
| _.assign({}, fileObj, { |
| base: fileObj.base + ".2012-09-14.2" |
| }) |
| ) |
| ) |
| .toString() |
| .should.equal("101112"); |
| fs.readFileSync( |
| path.format( |
| _.assign({}, fileObj, { |
| base: fileObj.base + ".2012-09-14.1" |
| }) |
| ) |
| ) |
| .toString() |
| .should.equal("1314"); |
| fs.readFileSync( |
| path.format( |
| _.assign({}, fileObj, { |
| base: fileObj.base + ".2012-09-15.2" |
| }) |
| ) |
| ) |
| .toString() |
| .should.equal("151617"); |
| fs.readFileSync( |
| path.format( |
| _.assign({}, fileObj, { |
| base: fileObj.base + ".2012-09-15.1" |
| }) |
| ) |
| ) |
| .toString() |
| .should.equal("1819"); |
| fs.readFileSync( |
| path.format( |
| _.assign({}, fileObj, { |
| base: fileObj.base + ".2012-09-16.2" |
| }) |
| ) |
| ) |
| .toString() |
| .should.equal("202122"); |
| fs.readFileSync( |
| path.format( |
| _.assign({}, fileObj, { |
| base: fileObj.base + ".2012-09-16.1" |
| }) |
| ) |
| ) |
| .toString() |
| .should.equal("2324"); |
| fs.readFileSync( |
| path.format( |
| _.assign({}, fileObj, { |
| base: fileObj.base + ".2012-09-17.2" |
| }) |
| ) |
| ) |
| .toString() |
| .should.equal("252627"); |
| fs.readFileSync( |
| path.format( |
| _.assign({}, fileObj, { |
| base: fileObj.base + ".2012-09-17.1" |
| }) |
| ) |
| ) |
| .toString() |
| .should.equal("2829"); |
| fs.readFileSync( |
| path.format( |
| _.assign({}, fileObj, { |
| base: fileObj.base + ".2012-09-18.2" |
| }) |
| ) |
| ) |
| .toString() |
| .should.equal("303132"); |
| fs.readFileSync( |
| path.format( |
| _.assign({}, fileObj, { |
| base: fileObj.base + ".2012-09-18.1" |
| }) |
| ) |
| ) |
| .toString() |
| .should.equal("3334"); |
| }); |
| }); |
| |
| describe("with default arguments and recreated in the same day", () => { |
| const fileObj = generateTestFile(); |
| let s; |
| |
| before(done => { |
| const flows = Array.from(Array(3).keys()).map(() => cb => { |
| s = new RollingFileWriteStream(fileObj.path); |
| s.write("abc", "utf8", cb); |
| s.end(); |
| }); |
| async.waterfall(flows, () => done()); |
| }); |
| |
| after(() => { |
| fs.removeSync(fileObj.dir); |
| }); |
| |
| it("should have only 1 file", () => { |
| const files = fs.readdirSync(fileObj.dir); |
| const expectedFileList = [fileObj.base]; |
| files.should.containDeep(expectedFileList); |
| files.length.should.equal(expectedFileList.length); |
| fs.readFileSync( |
| path.format( |
| _.assign({}, fileObj, { |
| base: fileObj.base |
| }) |
| ) |
| ) |
| .toString() |
| .should.equal("abcabcabc"); |
| }); |
| }); |
| |
| describe("with 5 maxSize, using filename with extension", () => { |
| const fileObj = generateTestFile("withExtension.log"); |
| let s; |
| |
| before(done => { |
| fakeNow = new Date(2012, 8, 12, 10, 37, 11); |
| s = new RollingFileWriteStream(fileObj.path, { |
| pattern: "yyyy-MM-dd", |
| maxSize: 5 |
| }); |
| const flows = Array.from(Array(38).keys()).map(i => cb => { |
| fakeNow = new Date(2012, 8, 12 + parseInt(i / 10, 10), 10, 37, 11); |
| s.write(i.toString(), "utf8", cb); |
| }); |
| async.waterfall(flows, () => done()); |
| }); |
| |
| after(done => { |
| fs.removeSync(fileObj.dir); |
| done(); |
| }); |
| |
| it("should rotate files within the day, and when the day changes", () => { |
| const files = fs.readdirSync(fileObj.dir); |
| const expectedFileList = [ |
| fileObj.base, //3637 |
| fileObj.base + ".2012-09-12.2", //01234 |
| fileObj.base + ".2012-09-12.1", //56789 |
| fileObj.base + ".2012-09-13.4", //101112 |
| fileObj.base + ".2012-09-13.3", //131415 |
| fileObj.base + ".2012-09-13.2", //161718 |
| fileObj.base + ".2012-09-13.1", //19 |
| fileObj.base + ".2012-09-14.4", //202122 |
| fileObj.base + ".2012-09-14.3", //232425 |
| fileObj.base + ".2012-09-14.2", //262728 |
| fileObj.base + ".2012-09-14.1", //29 |
| fileObj.base + ".2012-09-15.2", //303132 |
| fileObj.base + ".2012-09-15.1" //333435 |
| ]; |
| files.should.containDeep(expectedFileList); |
| files.length.should.equal(expectedFileList.length); |
| fs.readFileSync(path.format(fileObj)) |
| .toString() |
| .should.equal("3637"); |
| fs.readFileSync( |
| path.format( |
| _.assign({}, fileObj, { |
| base: fileObj.base + ".2012-09-12.2" |
| }) |
| ) |
| ) |
| .toString() |
| .should.equal("01234"); |
| fs.readFileSync( |
| path.format( |
| _.assign({}, fileObj, { |
| base: fileObj.base + ".2012-09-12.1" |
| }) |
| ) |
| ) |
| .toString() |
| .should.equal("56789"); |
| fs.readFileSync( |
| path.format( |
| _.assign({}, fileObj, { |
| base: fileObj.base + ".2012-09-13.4" |
| }) |
| ) |
| ) |
| .toString() |
| .should.equal("101112"); |
| fs.readFileSync( |
| path.format( |
| _.assign({}, fileObj, { |
| base: fileObj.base + ".2012-09-13.3" |
| }) |
| ) |
| ) |
| .toString() |
| .should.equal("131415"); |
| fs.readFileSync( |
| path.format( |
| _.assign({}, fileObj, { |
| base: fileObj.base + ".2012-09-13.2" |
| }) |
| ) |
| ) |
| .toString() |
| .should.equal("161718"); |
| fs.readFileSync( |
| path.format( |
| _.assign({}, fileObj, { |
| base: fileObj.base + ".2012-09-13.1" |
| }) |
| ) |
| ) |
| .toString() |
| .should.equal("19"); |
| fs.readFileSync( |
| path.format( |
| _.assign({}, fileObj, { |
| base: fileObj.base + ".2012-09-14.4" |
| }) |
| ) |
| ) |
| .toString() |
| .should.equal("202122"); |
| fs.readFileSync( |
| path.format( |
| _.assign({}, fileObj, { |
| base: fileObj.base + ".2012-09-14.3" |
| }) |
| ) |
| ) |
| .toString() |
| .should.equal("232425"); |
| fs.readFileSync( |
| path.format( |
| _.assign({}, fileObj, { |
| base: fileObj.base + ".2012-09-14.2" |
| }) |
| ) |
| ) |
| .toString() |
| .should.equal("262728"); |
| fs.readFileSync( |
| path.format( |
| _.assign({}, fileObj, { |
| base: fileObj.base + ".2012-09-14.1" |
| }) |
| ) |
| ) |
| .toString() |
| .should.equal("29"); |
| fs.readFileSync( |
| path.format( |
| _.assign({}, fileObj, { |
| base: fileObj.base + ".2012-09-15.2" |
| }) |
| ) |
| ) |
| .toString() |
| .should.equal("303132"); |
| fs.readFileSync( |
| path.format( |
| _.assign({}, fileObj, { |
| base: fileObj.base + ".2012-09-15.1" |
| }) |
| ) |
| ) |
| .toString() |
| .should.equal("333435"); |
| }); |
| }); |
| |
| describe("with 5 maxSize and 3 files limit", () => { |
| const fileObj = generateTestFile(); |
| let s; |
| |
| before(done => { |
| fakeNow = new Date(2012, 8, 12, 10, 37, 11); |
| s = new RollingFileWriteStream(fileObj.path, { |
| maxSize: 5, |
| numToKeep: 3 |
| }); |
| const flows = Array.from(Array(38).keys()).map(i => cb => { |
| fakeNow = new Date(2012, 8, 12 + parseInt(i / 5), 10, 37, 11); |
| s.write(i.toString(), "utf8", cb); |
| }); |
| async.waterfall(flows, () => done()); |
| }); |
| |
| after(() => { |
| s.end(); |
| fs.removeSync(fileObj.dir); |
| }); |
| |
| it("should rotate with at most 3 backup files not including the hot one", () => { |
| const files = fs.readdirSync(fileObj.dir); |
| const expectedFileList = [ |
| fileObj.base, |
| fileObj.base + ".1", |
| fileObj.base + ".2", |
| fileObj.base + ".3" |
| ]; |
| files.should.containDeep(expectedFileList); |
| files.length.should.equal(expectedFileList.length); |
| fs.readFileSync(path.format(fileObj)) |
| .toString() |
| .should.equal("37"); |
| fs.readFileSync( |
| path.format( |
| _.assign({}, fileObj, { |
| base: fileObj.base + ".1" |
| }) |
| ) |
| ) |
| .toString() |
| .should.equal("343536"); |
| fs.readFileSync( |
| path.format( |
| _.assign({}, fileObj, { |
| base: fileObj.base + ".2" |
| }) |
| ) |
| ) |
| .toString() |
| .should.equal("313233"); |
| fs.readFileSync( |
| path.format( |
| _.assign({}, fileObj, { |
| base: fileObj.base + ".3" |
| }) |
| ) |
| ) |
| .toString() |
| .should.equal("282930"); |
| }); |
| }); |
| |
| describe("with 5 maxSize and 3 files limit, rotating daily", () => { |
| const fileObj = generateTestFile(); |
| let s; |
| |
| before(done => { |
| fakeNow = new Date(2012, 8, 12, 10, 37, 11); |
| s = new RollingFileWriteStream(fileObj.path, { |
| maxSize: 5, |
| pattern: "yyyy-MM-dd", |
| numToKeep: 3 |
| }); |
| const flows = Array.from(Array(38).keys()).map(i => cb => { |
| fakeNow = new Date(2012, 8, 12 + parseInt(i / 10), 10, 37, 11); |
| s.write(i.toString(), "utf8", cb); |
| }); |
| async.waterfall(flows, () => done()); |
| }); |
| |
| after(() => { |
| s.end(); |
| fs.removeSync(fileObj.dir); |
| }); |
| |
| it("should rotate with at most 3 backup files not including the hot one", () => { |
| const files = fs.readdirSync(fileObj.dir); |
| const expectedFileList = [ |
| fileObj.base, //3637 |
| fileObj.base + ".2012-09-14.1", //29 |
| fileObj.base + ".2012-09-15.2", //303132 |
| fileObj.base + ".2012-09-15.1" //333435 |
| ]; |
| files.should.containDeep(expectedFileList); |
| files.length.should.equal(expectedFileList.length); |
| fs.readFileSync(path.format(fileObj)) |
| .toString() |
| .should.equal("3637"); |
| fs.readFileSync( |
| path.format( |
| _.assign({}, fileObj, { |
| base: fileObj.base + ".2012-09-15.1" |
| }) |
| ) |
| ) |
| .toString() |
| .should.equal("333435"); |
| fs.readFileSync( |
| path.format( |
| _.assign({}, fileObj, { |
| base: fileObj.base + ".2012-09-15.2" |
| }) |
| ) |
| ) |
| .toString() |
| .should.equal("303132"); |
| fs.readFileSync( |
| path.format( |
| _.assign({}, fileObj, { |
| base: fileObj.base + ".2012-09-14.1" |
| }) |
| ) |
| ) |
| .toString() |
| .should.equal("29"); |
| }); |
| }); |
| |
| describe("with date pattern dd-MM-yyyy", () => { |
| const fileObj = generateTestFile(); |
| let s; |
| |
| before(done => { |
| fakeNow = new Date(2012, 8, 12, 10, 37, 11); |
| s = new RollingFileWriteStream(fileObj.path, { |
| maxSize: 5, |
| pattern: "dd-MM-yyyy" |
| }); |
| const flows = Array.from(Array(8).keys()).map(i => cb => { |
| fakeNow = new Date(2012, 8, 12 + parseInt(i / 5, 10), 10, 37, 11); |
| s.write(i.toString(), "utf8", cb); |
| }); |
| async.waterfall(flows, () => done()); |
| }); |
| |
| after(done => { |
| s.end(() => { |
| fs.remove(fileObj.dir, done); |
| }); |
| }); |
| |
| it("should rotate with date pattern dd-MM-yyyy in the file name", () => { |
| const files = fs.readdirSync(fileObj.dir); |
| const expectedFileList = [fileObj.base, fileObj.base + ".12-09-2012.1"]; |
| files.should.containDeep(expectedFileList); |
| files.length.should.equal(expectedFileList.length); |
| fs.readFileSync(path.format(fileObj)) |
| .toString() |
| .should.equal("567"); |
| fs.readFileSync( |
| path.format( |
| _.assign({}, fileObj, { |
| base: fileObj.base + ".12-09-2012.1" |
| }) |
| ) |
| ) |
| .toString() |
| .should.equal("01234"); |
| }); |
| }); |
| |
| describe("with compress true", () => { |
| const fileObj = generateTestFile(); |
| let s; |
| |
| before(done => { |
| fakeNow = new Date(2012, 8, 12, 10, 37, 11); |
| s = new RollingFileWriteStream(fileObj.path, { |
| maxSize: 5, |
| pattern: "yyyy-MM-dd", |
| compress: true |
| }); |
| const flows = Array.from(Array(8).keys()).map(i => cb => { |
| fakeNow = new Date(2012, 8, 12 + parseInt(i / 5, 10), 10, 37, 11); |
| s.write(i.toString(), "utf8", cb); |
| }); |
| async.waterfall(flows, () => done()); |
| }); |
| |
| after(() => { |
| s.end(); |
| fs.removeSync(fileObj.dir); |
| }); |
| |
| it("should rotate with gunzip", () => { |
| const files = fs.readdirSync(fileObj.dir); |
| const expectedFileList = [ |
| fileObj.base, |
| fileObj.base + ".2012-09-12.1.gz" |
| ]; |
| files.should.containDeep(expectedFileList); |
| files.length.should.equal(expectedFileList.length); |
| |
| fs.readFileSync(path.format(fileObj)) |
| .toString() |
| .should.equal("567"); |
| const content = fs.readFileSync( |
| path.format( |
| _.assign({}, fileObj, { |
| base: fileObj.base + ".2012-09-12.1.gz" |
| }) |
| ) |
| ); |
| zlib |
| .gunzipSync(content) |
| .toString() |
| .should.equal("01234"); |
| }); |
| }); |
| |
| describe("with keepFileExt", () => { |
| const fileObj = generateTestFile("keepFileExt.log"); |
| let s; |
| |
| before(done => { |
| fakeNow = new Date(2012, 8, 12, 10, 37, 11); |
| s = new RollingFileWriteStream(fileObj.path, { |
| pattern: "yyyy-MM-dd", |
| maxSize: 5, |
| keepFileExt: true |
| }); |
| const flows = Array.from(Array(8).keys()).map(i => cb => { |
| fakeNow = new Date(2012, 8, 12 + parseInt(i / 5, 10), 10, 37, 11); |
| s.write(i.toString(), "utf8", cb); |
| }); |
| async.waterfall(flows, () => done()); |
| }); |
| |
| after(done => { |
| s.end(); |
| fs.removeSync(fileObj.dir); |
| done(); |
| }); |
| |
| it("should rotate with the same extension", () => { |
| const files = fs.readdirSync(fileObj.dir); |
| const expectedFileList = [ |
| fileObj.base, |
| fileObj.name + ".2012-09-12.1.log" |
| ]; |
| files.should.containDeep(expectedFileList); |
| files.length.should.equal(expectedFileList.length); |
| |
| fs.readFileSync(path.format(fileObj)) |
| .toString() |
| .should.equal("567"); |
| fs.readFileSync( |
| path.format({ |
| dir: fileObj.dir, |
| base: fileObj.name + ".2012-09-12.1" + fileObj.ext |
| }) |
| ) |
| .toString() |
| .should.equal("01234"); |
| }); |
| }); |
| |
| describe("with keepFileExt and compress", () => { |
| const fileObj = generateTestFile("keepFileExt.log"); |
| let s; |
| |
| before(done => { |
| fakeNow = new Date(2012, 8, 12, 10, 37, 11); |
| s = new RollingFileWriteStream(fileObj.path, { |
| maxSize: 5, |
| pattern: "yyyy-MM-dd", |
| keepFileExt: true, |
| compress: true |
| }); |
| const flows = Array.from(Array(8).keys()).map(i => cb => { |
| fakeNow = new Date(2012, 8, 12 + parseInt(i / 5, 10), 10, 37, 11); |
| s.write(i.toString(), "utf8", cb); |
| }); |
| async.waterfall(flows, () => done()); |
| }); |
| |
| after(done => { |
| s.end(); |
| fs.removeSync(fileObj.dir); |
| done(); |
| }); |
| |
| it("should rotate with the same extension", () => { |
| const files = fs.readdirSync(fileObj.dir); |
| const expectedFileList = [ |
| fileObj.base, |
| fileObj.name + ".2012-09-12.1.log.gz" |
| ]; |
| files.should.containDeep(expectedFileList); |
| files.length.should.equal(expectedFileList.length); |
| |
| fs.readFileSync(path.format(fileObj)) |
| .toString() |
| .should.equal("567"); |
| const content = fs.readFileSync( |
| path.format( |
| _.assign({}, fileObj, { |
| base: fileObj.name + ".2012-09-12.1.log.gz" |
| }) |
| ) |
| ); |
| zlib |
| .gunzipSync(content) |
| .toString() |
| .should.equal("01234"); |
| }); |
| }); |
| |
| describe("with alwaysIncludePattern and keepFileExt", () => { |
| const fileObj = generateTestFile("keepFileExt.log"); |
| let s; |
| |
| before(done => { |
| fakeNow = new Date(2012, 8, 12, 10, 37, 11); |
| s = new RollingFileWriteStream(fileObj.path, { |
| maxSize: 5, |
| pattern: "yyyy-MM-dd", |
| keepFileExt: true, |
| alwaysIncludePattern: true |
| }); |
| const flows = Array.from(Array(8).keys()).map(i => cb => { |
| fakeNow = new Date(2012, 8, 12 + parseInt(i / 5, 10), 10, 37, 11); |
| s.write(i.toString(), "utf8", cb); |
| }); |
| async.waterfall(flows, () => done()); |
| }); |
| |
| after(done => { |
| s.end(); |
| fs.removeSync(fileObj.dir); |
| done(); |
| }); |
| |
| it("should rotate with the same extension and keep date in the filename", () => { |
| const files = fs.readdirSync(fileObj.dir); |
| const expectedFileList = [ |
| fileObj.name + ".2012-09-12.1.log", |
| fileObj.name + ".2012-09-13.log" |
| ]; |
| files.should.containDeep(expectedFileList); |
| files.length.should.equal(expectedFileList.length); |
| fs.readFileSync( |
| path.format( |
| _.assign({}, fileObj, { |
| base: fileObj.name + ".2012-09-13.log" |
| }) |
| ) |
| ) |
| .toString() |
| .should.equal("567"); |
| fs.readFileSync( |
| path.format( |
| _.assign({}, fileObj, { |
| base: fileObj.name + ".2012-09-12.1.log" |
| }) |
| ) |
| ) |
| .toString() |
| .should.equal("01234"); |
| }); |
| }); |
| |
| describe("with 5 maxSize, compress, keepFileExt and alwaysIncludePattern", () => { |
| const fileObj = generateTestFile("keepFileExt.log"); |
| let s; |
| |
| before(done => { |
| fakeNow = new Date(2012, 8, 12, 10, 37, 11); |
| s = new RollingFileWriteStream(fileObj.path, { |
| maxSize: 5, |
| compress: true, |
| keepFileExt: true, |
| alwaysIncludePattern: true, |
| pattern: "yyyy-MM-dd" |
| }); |
| const flows = Array.from(Array(38).keys()).map(i => cb => { |
| fakeNow = new Date(2012, 8, 12 + parseInt(i / 5, 10), 10, 37, 11); |
| s.write(i.toString(), "utf8", cb); |
| }); |
| async.waterfall(flows, () => done()); |
| }); |
| |
| after(done => { |
| s.end(); |
| fs.removeSync(fileObj.dir); |
| done(); |
| }); |
| |
| it("should rotate every day", () => { |
| const files = fs.readdirSync(fileObj.dir); |
| const expectedFileList = [ |
| fileObj.name + ".2012-09-12.1.log.gz", //01234 |
| fileObj.name + ".2012-09-13.1.log.gz", //56789 |
| fileObj.name + ".2012-09-14.2.log.gz", //101112 |
| fileObj.name + ".2012-09-14.1.log.gz", //1314 |
| fileObj.name + ".2012-09-15.2.log.gz", //151617 |
| fileObj.name + ".2012-09-15.1.log.gz", //1819 |
| fileObj.name + ".2012-09-16.2.log.gz", //202122 |
| fileObj.name + ".2012-09-16.1.log.gz", //2324 |
| fileObj.name + ".2012-09-17.2.log.gz", //252627 |
| fileObj.name + ".2012-09-17.1.log.gz", //2829 |
| fileObj.name + ".2012-09-18.2.log.gz", //303132 |
| fileObj.name + ".2012-09-18.1.log.gz", //3334 |
| fileObj.name + ".2012-09-19.log" //353637 |
| ]; |
| files.should.containDeep(expectedFileList); |
| files.length.should.equal(expectedFileList.length); |
| fs.readFileSync( |
| path.format( |
| _.assign({}, fileObj, { |
| base: fileObj.name + ".2012-09-19.log" |
| }) |
| ) |
| ) |
| .toString() |
| .should.equal("353637"); |
| zlib |
| .gunzipSync( |
| fs.readFileSync( |
| path.format( |
| _.assign({}, fileObj, { |
| base: fileObj.name + ".2012-09-18.1.log.gz" |
| }) |
| ) |
| ) |
| ) |
| .toString() |
| .should.equal("3334"); |
| zlib |
| .gunzipSync( |
| fs.readFileSync( |
| path.format( |
| _.assign({}, fileObj, { |
| base: fileObj.name + ".2012-09-18.2.log.gz" |
| }) |
| ) |
| ) |
| ) |
| .toString() |
| .should.equal("303132"); |
| zlib |
| .gunzipSync( |
| fs.readFileSync( |
| path.format( |
| _.assign({}, fileObj, { |
| base: fileObj.name + ".2012-09-17.1.log.gz" |
| }) |
| ) |
| ) |
| ) |
| .toString() |
| .should.equal("2829"); |
| zlib |
| .gunzipSync( |
| fs.readFileSync( |
| path.format( |
| _.assign({}, fileObj, { |
| base: fileObj.name + ".2012-09-17.2.log.gz" |
| }) |
| ) |
| ) |
| ) |
| .toString() |
| .should.equal("252627"); |
| zlib |
| .gunzipSync( |
| fs.readFileSync( |
| path.format( |
| _.assign({}, fileObj, { |
| base: fileObj.name + ".2012-09-16.1.log.gz" |
| }) |
| ) |
| ) |
| ) |
| .toString() |
| .should.equal("2324"); |
| zlib |
| .gunzipSync( |
| fs.readFileSync( |
| path.format( |
| _.assign({}, fileObj, { |
| base: fileObj.name + ".2012-09-16.2.log.gz" |
| }) |
| ) |
| ) |
| ) |
| .toString() |
| .should.equal("202122"); |
| zlib |
| .gunzipSync( |
| fs.readFileSync( |
| path.format( |
| _.assign({}, fileObj, { |
| base: fileObj.name + ".2012-09-15.1.log.gz" |
| }) |
| ) |
| ) |
| ) |
| .toString() |
| .should.equal("1819"); |
| zlib |
| .gunzipSync( |
| fs.readFileSync( |
| path.format( |
| _.assign({}, fileObj, { |
| base: fileObj.name + ".2012-09-15.2.log.gz" |
| }) |
| ) |
| ) |
| ) |
| .toString() |
| .should.equal("151617"); |
| zlib |
| .gunzipSync( |
| fs.readFileSync( |
| path.format( |
| _.assign({}, fileObj, { |
| base: fileObj.name + ".2012-09-14.1.log.gz" |
| }) |
| ) |
| ) |
| ) |
| .toString() |
| .should.equal("1314"); |
| zlib |
| .gunzipSync( |
| fs.readFileSync( |
| path.format( |
| _.assign({}, fileObj, { |
| base: fileObj.name + ".2012-09-14.2.log.gz" |
| }) |
| ) |
| ) |
| ) |
| .toString() |
| .should.equal("101112"); |
| zlib |
| .gunzipSync( |
| fs.readFileSync( |
| path.format( |
| _.assign({}, fileObj, { |
| base: fileObj.name + ".2012-09-13.1.log.gz" |
| }) |
| ) |
| ) |
| ) |
| .toString() |
| .should.equal("56789"); |
| zlib |
| .gunzipSync( |
| fs.readFileSync( |
| path.format( |
| _.assign({}, fileObj, { |
| base: fileObj.name + ".2012-09-12.1.log.gz" |
| }) |
| ) |
| ) |
| ) |
| .toString() |
| .should.equal("01234"); |
| }); |
| }); |
| |
| describe("when old files exist", () => { |
| const fileObj = generateTestFile(); |
| let s; |
| |
| before(done => { |
| fakeNow = new Date(2012, 8, 12, 10, 37, 11); |
| fs.ensureFileSync(fileObj.path); |
| fs.writeFileSync(fileObj.path, "exist"); |
| s = new RollingFileWriteStream(fileObj.path); |
| s.write("now", "utf8", done); |
| }); |
| |
| after(() => { |
| s.end(); |
| fs.removeSync(fileObj.dir); |
| }); |
| |
| it("should use write in the old file if not reach the maxSize limit", () => { |
| const files = fs.readdirSync(fileObj.dir); |
| const expectedFileList = [fileObj.base]; |
| files.should.containDeep(expectedFileList); |
| files.length.should.equal(expectedFileList.length); |
| |
| fs.readFileSync(path.format(fileObj)) |
| .toString() |
| .should.equal("existnow"); |
| }); |
| }); |
| |
| describe("when old files exist with contents", () => { |
| const fileObj = generateTestFile(); |
| let s; |
| |
| before(done => { |
| fakeNow = new Date(2012, 8, 12, 10, 37, 11); |
| fs.ensureFileSync(fileObj.path); |
| fs.writeFileSync(fileObj.path, "This is exactly 30 bytes long\n"); |
| s = new RollingFileWriteStream(fileObj.path, { maxSize: 35 }); |
| s.write("one\n", "utf8"); //34 |
| s.write("two\n", "utf8"); //38 - file should be rotated next time |
| s.write("three\n", "utf8", done); // this should be in a new file. |
| }); |
| |
| after(() => { |
| s.end(); |
| fs.removeSync(fileObj.dir); |
| }); |
| |
| it("should respect the existing file size", () => { |
| const files = fs.readdirSync(fileObj.dir); |
| const expectedFileList = [fileObj.base, fileObj.base + ".1"]; |
| files.should.containDeep(expectedFileList); |
| files.length.should.equal(expectedFileList.length); |
| |
| fs.readFileSync(path.format(fileObj)) |
| .toString() |
| .should.equal("three\n"); |
| fs.readFileSync(path.join(fileObj.dir, fileObj.base + ".1")) |
| .toString() |
| .should.equal("This is exactly 30 bytes long\none\ntwo\n"); |
| }); |
| }); |
| |
| describe("when old files exist with indices", () => { |
| const fileObj = generateTestFile(); |
| let s; |
| |
| before(done => { |
| fs.ensureFileSync(fileObj.path); |
| fs.writeFileSync( |
| fileObj.path, |
| "This was the base file and it should be more than 30 bytes\n" |
| ); // base |
| fs.writeFileSync(fileObj.path + ".1", "This was the first old file\n"); // base.1 |
| s = new RollingFileWriteStream(fileObj.path, { |
| maxSize: 30, |
| numToKeep: 5 |
| }); |
| s.write("This is exactly 30 bytes long\n", "utf8"); // base.1 -> base.2, base -> base.1 |
| s.write("This is exactly 30 bytes long\n", "utf8"); // base.2 -> base.3, base.1 -> base.2, base -> base.1 |
| s.write("three\n", "utf8", done); // base.3 -> base.4, base.2 -> base.3, base.1 -> base.2, base -> base.1 |
| }); |
| |
| after(() => { |
| s.end(); |
| fs.removeSync(fileObj.dir); |
| }); |
| |
| it("should rotate the old file indices", () => { |
| const files = fs.readdirSync(fileObj.dir); |
| const expectedFileList = [ |
| fileObj.base, |
| fileObj.base + ".1", |
| fileObj.base + ".2", |
| fileObj.base + ".3", |
| fileObj.base + ".4" |
| ]; |
| files.should.containDeep(expectedFileList); |
| files.length.should.equal(expectedFileList.length); |
| |
| fs.readFileSync(path.format(fileObj)) |
| .toString() |
| .should.equal("three\n"); |
| fs.readFileSync(path.join(fileObj.dir, fileObj.base + ".1")) |
| .toString() |
| .should.equal("This is exactly 30 bytes long\n"); |
| fs.readFileSync(path.join(fileObj.dir, fileObj.base + ".2")) |
| .toString() |
| .should.equal("This is exactly 30 bytes long\n"); |
| fs.readFileSync(path.join(fileObj.dir, fileObj.base + ".3")) |
| .toString() |
| .should.equal( |
| "This was the base file and it should be more than 30 bytes\n" |
| ); |
| fs.readFileSync(path.join(fileObj.dir, fileObj.base + ".4")) |
| .toString() |
| .should.equal("This was the first old file\n"); |
| }); |
| }); |
| |
| describe("when old files exist with contents and rolling by date", () => { |
| const fileObj = generateTestFile(); |
| let s; |
| |
| before(done => { |
| fakeNow = new Date(2012, 8, 12, 10, 37, 11); |
| fs.ensureFileSync(fileObj.path); |
| fs.writeFileSync(fileObj.path, "This was created Sept 12, 2012.\n"); |
| fakeNow = new Date(2012, 8, 13, 10, 53, 12); |
| s = new RollingFileWriteStream(fileObj.path, { pattern: "yyyy-MM-dd" }); |
| s.write("It is now Sept 13, 2012.\n", "utf8", done); // this should be in a new file. |
| }); |
| |
| after(() => { |
| s.end(); |
| fs.removeSync(fileObj.dir); |
| }); |
| |
| it("should respect the existing file date", () => { |
| const files = fs.readdirSync(fileObj.dir); |
| const expectedFileList = [fileObj.base, fileObj.base + ".2012-09-12"]; |
| files.should.containDeep(expectedFileList); |
| files.length.should.equal(expectedFileList.length); |
| |
| fs.readFileSync(path.format(fileObj)) |
| .toString() |
| .should.equal("It is now Sept 13, 2012.\n"); |
| fs.readFileSync(path.join(fileObj.dir, fileObj.base + ".2012-09-12")) |
| .toString() |
| .should.equal("This was created Sept 12, 2012.\n"); |
| }); |
| }); |
| |
| describe("when old files exist with contents and stream created with overwrite flag", () => { |
| const fileObj = generateTestFile(); |
| let s; |
| |
| before(done => { |
| fakeNow = new Date(2012, 8, 12, 10, 37, 11); |
| fs.ensureFileSync(fileObj.path); |
| fs.writeFileSync(fileObj.path, "This is exactly 30 bytes long\n"); |
| s = new RollingFileWriteStream(fileObj.path, { maxSize: 35, flags: "w" }); |
| s.write("there should only be this\n", "utf8", done); |
| }); |
| |
| after(() => { |
| s.end(); |
| fs.removeSync(fileObj.dir); |
| }); |
| |
| it("should ignore the existing file size", () => { |
| const files = fs.readdirSync(fileObj.dir); |
| const expectedFileList = [fileObj.base]; |
| files.should.containDeep(expectedFileList); |
| files.length.should.equal(expectedFileList.length); |
| |
| s.state.currentSize.should.equal(26); |
| |
| fs.readFileSync(path.format(fileObj)) |
| .toString() |
| .should.equal("there should only be this\n"); |
| }); |
| }); |
| |
| describe("when dir does not exist", () => { |
| const fileObj = generateTestFile(); |
| let s; |
| |
| before(done => { |
| fs.removeSync(fileObj.dir); |
| fakeNow = new Date(2012, 8, 12, 10, 37, 11); |
| s = new RollingFileWriteStream(fileObj.path); |
| s.write("test", "utf8", done); |
| }); |
| |
| after(() => { |
| s.end(); |
| fs.removeSync(fileObj.dir); |
| }); |
| |
| it("should create the dir", () => { |
| const files = fs.readdirSync(fileObj.dir); |
| const expectedFileList = [fileObj.base]; |
| files.should.containDeep(expectedFileList); |
| files.length.should.equal(expectedFileList.length); |
| |
| fs.readFileSync(path.format(fileObj)) |
| .toString() |
| .should.equal("test"); |
| }); |
| }); |
| |
| describe("when given just a base filename with no dir", () => { |
| let s; |
| before(done => { |
| s = new RollingFileWriteStream("test.log"); |
| s.write("this should not cause any problems", "utf8", done); |
| }); |
| |
| after(() => { |
| s.end(); |
| fs.removeSync("test.log"); |
| }); |
| |
| it("should use process.cwd() as the dir", () => { |
| const files = fs.readdirSync(process.cwd()); |
| files.should.containDeep(["test.log"]); |
| |
| fs.readFileSync(path.join(process.cwd(), "test.log")) |
| .toString() |
| .should.equal("this should not cause any problems"); |
| }); |
| }); |
| |
| describe("with no callback to write", () => { |
| let s; |
| before(done => { |
| s = new RollingFileWriteStream("no-callback.log"); |
| s.write("this is all very nice", "utf8", done); |
| }); |
| |
| after(done => { |
| fs.remove("no-callback.log", done); |
| }); |
| |
| it("should not complain", done => { |
| s.write("I am not bothered if this succeeds or not"); |
| s.end(done); |
| }); |
| }); |
| |
| describe("events", () => { |
| let s; |
| before(done => { |
| s = new RollingFileWriteStream("test-events.log"); |
| s.write("this should not cause any problems", "utf8", done); |
| }); |
| |
| after(() => { |
| s.end(); |
| fs.removeSync("test-events.log"); |
| }); |
| |
| it("should emit the error event of the underlying stream", done => { |
| s.on("error", e => { |
| e.message.should.equal("oh no"); |
| done(); |
| }); |
| s.currentFileStream.emit("error", new Error("oh no")); |
| }); |
| }); |
| }); |
