mirror of
https://github.com/wekan/wekan.git
synced 2025-12-16 23:40:13 +01:00
366 lines
11 KiB
JavaScript
366 lines
11 KiB
JavaScript
var fs = Npm.require('fs');
|
|
var temp = Npm.require('temp');
|
|
|
|
// Automatically track and cleanup files at exit
|
|
temp.track();
|
|
|
|
// Set up HTTP method URL used by client tests
|
|
HTTP.methods({
|
|
'test': {
|
|
get: function () {
|
|
var buf = new Buffer('Hello World');
|
|
this.setContentType('text/plain');
|
|
return buf;
|
|
},
|
|
head: function () {
|
|
var buf = new Buffer('Hello World');
|
|
this.setContentType('text/plain');
|
|
this.addHeader('Content-Length', buf.length);
|
|
buf = null;
|
|
}
|
|
}
|
|
});
|
|
|
|
// Save temp file for testing with
|
|
function openTempFile(name, callback) {
|
|
return temp.open(name, callback);
|
|
}
|
|
var openTempFileSync = Meteor.wrapAsync(openTempFile);
|
|
|
|
var info = openTempFileSync(null);
|
|
var tempFilePath = info.path;
|
|
fs.writeSync(info.fd, 'Hello World');
|
|
fs.closeSync(info.fd);
|
|
|
|
var bufferData;
|
|
var arrayBufferData;
|
|
var binaryData;
|
|
var dataUriData;
|
|
var urlData;
|
|
var filePathData;
|
|
var streamData;
|
|
|
|
// Init with Buffer
|
|
Tinytest.addAsync('cfs-data - server - Init with Buffer', function(test, onComplete) {
|
|
bufferData = new DataMan(new Buffer('Hello World'), "text/plain");
|
|
test.instanceOf(bufferData.source, DataMan.Buffer);
|
|
test.equal(bufferData.type(), "text/plain");
|
|
onComplete();
|
|
});
|
|
|
|
// Init with ArrayBuffer
|
|
Tinytest.addAsync('cfs-data - server - Init with ArrayBuffer', function(test, onComplete) {
|
|
arrayBufferData = new DataMan(str2ab('Hello World'), "text/plain");
|
|
// Should be converted upon init to a Buffer
|
|
test.instanceOf(arrayBufferData.source, DataMan.Buffer);
|
|
test.equal(arrayBufferData.type(), "text/plain");
|
|
onComplete();
|
|
});
|
|
|
|
// Init with Binary
|
|
Tinytest.addAsync('cfs-data - server - Init with Binary', function(test, onComplete) {
|
|
binaryData = new DataMan(new Uint8Array(str2ab('Hello World')), "text/plain");
|
|
// Should be converted upon init to a Buffer
|
|
test.instanceOf(arrayBufferData.source, DataMan.Buffer);
|
|
test.equal(binaryData.type(), "text/plain");
|
|
onComplete();
|
|
});
|
|
|
|
// Init with data URI string
|
|
Tinytest.addAsync('cfs-data - server - Init with data URI string', function(test, onComplete) {
|
|
var dataUri = 'data:text/plain;base64,SGVsbG8gV29ybGQ='; //'Hello World'
|
|
dataUriData = new DataMan(dataUri);
|
|
// Data URIs are not converted to Buffers upon init
|
|
test.instanceOf(dataUriData.source, DataMan.DataURI);
|
|
test.equal(dataUriData.type(), "text/plain"); //should be extracted from data URI
|
|
onComplete();
|
|
});
|
|
|
|
// Init with URL string
|
|
Tinytest.addAsync('cfs-data - server - Init with URL string', function(test, onComplete) {
|
|
var url = Meteor.absoluteUrl('test');
|
|
urlData = new DataMan(url, "text/plain"); //'Hello World'
|
|
// URLs are not converted to Buffers upon init
|
|
test.instanceOf(urlData.source, DataMan.URL);
|
|
test.equal(urlData.type(), "text/plain");
|
|
onComplete();
|
|
});
|
|
|
|
// Init with filepath string
|
|
Tinytest.addAsync('cfs-data - server - Init with filepath string', function(test, onComplete) {
|
|
filePathData = new DataMan(tempFilePath, "text/plain");
|
|
// filepaths are not converted to Buffers upon init
|
|
test.instanceOf(filePathData.source, DataMan.FilePath);
|
|
test.equal(filePathData.type(), "text/plain");
|
|
onComplete();
|
|
});
|
|
|
|
// Init with readable stream
|
|
Tinytest.addAsync('cfs-data - server - Init with readable stream', function(test, onComplete) {
|
|
streamData = new DataMan(fs.createReadStream(tempFilePath), "text/plain");
|
|
// filepaths are not converted to Buffers upon init
|
|
test.instanceOf(streamData.source, DataMan.ReadStream);
|
|
test.equal(streamData.type(), "text/plain");
|
|
onComplete();
|
|
});
|
|
|
|
// getBuffer
|
|
Tinytest.addAsync('cfs-data - server - getBuffer', function(test, onComplete) {
|
|
var total = 12, done = 0;
|
|
|
|
function testBuffer(error, buffer, testType) {
|
|
test.isFalse(!!error, testType + ' got error: ' + (error && error.message));
|
|
test.instanceOf(buffer, Buffer);
|
|
|
|
if (buffer instanceof Buffer) {
|
|
test.equal(buffer.toString(), 'Hello World', testType + ' got back buffer with incorrect data');
|
|
}
|
|
|
|
done++;
|
|
if (total === done) {
|
|
onComplete();
|
|
}
|
|
}
|
|
|
|
// from Buffer (async)
|
|
bufferData.getBuffer(function (error, buffer) {
|
|
testBuffer(error, buffer, 'getBuffer from Buffer async');
|
|
});
|
|
|
|
// from Buffer (sync)
|
|
testBuffer(null, bufferData.getBuffer(), 'getBuffer from Buffer sync');
|
|
|
|
// from ArrayBuffer (async)
|
|
arrayBufferData.getBuffer(function (error, buffer) {
|
|
testBuffer(error, buffer, 'getBuffer from ArrayBuffer async');
|
|
});
|
|
|
|
// from ArrayBuffer (sync)
|
|
testBuffer(null, arrayBufferData.getBuffer(), 'getBuffer from ArrayBuffer sync');
|
|
|
|
// from binary (async)
|
|
binaryData.getBuffer(function (error, buffer) {
|
|
testBuffer(error, buffer, 'getBuffer from binary async');
|
|
});
|
|
|
|
// from binary (sync)
|
|
testBuffer(null, binaryData.getBuffer(), 'getBuffer from binary sync');
|
|
|
|
// from data URI (async)
|
|
dataUriData.getBuffer(function (error, buffer) {
|
|
testBuffer(error, buffer, 'getBuffer from data URI async');
|
|
});
|
|
|
|
// from data URI (sync)
|
|
testBuffer(null, dataUriData.getBuffer(), 'getBuffer from data URI sync');
|
|
|
|
// from URL (async)
|
|
urlData.getBuffer(function (error, buffer) {
|
|
testBuffer(error, buffer, 'getBuffer from URL async');
|
|
});
|
|
|
|
// from URL (sync)
|
|
testBuffer(null, urlData.getBuffer(), 'getBuffer from URL sync');
|
|
|
|
// from filepath (async)
|
|
filePathData.getBuffer(function (error, buffer) {
|
|
testBuffer(error, buffer, 'getBuffer filepath async');
|
|
});
|
|
|
|
// from filepath (sync)
|
|
testBuffer(null, filePathData.getBuffer(), 'getBuffer filepath sync');
|
|
});
|
|
|
|
// getDataUri
|
|
Tinytest.addAsync('cfs-data - server - getDataUri', function(test, onComplete) {
|
|
var total = 12, done = 0;
|
|
function testURI(error, uri, testType) {
|
|
test.isFalse(!!error, testType + ' got error: ' + (error && error.message));
|
|
test.equal(typeof uri, "string", testType + ' got no URI string');
|
|
test.equal(uri, 'data:text/plain;base64,SGVsbG8gV29ybGQ=', testType + ' got invalid URI');
|
|
|
|
done++;
|
|
if (total === done) {
|
|
onComplete();
|
|
}
|
|
}
|
|
|
|
// from Buffer (async)
|
|
bufferData.getDataUri(function (error, uri) {
|
|
testURI(error, uri, 'getDataUri from Buffer async');
|
|
});
|
|
|
|
// from Buffer (sync)
|
|
testURI(null, bufferData.getDataUri(), 'getDataUri from Buffer sync');
|
|
|
|
// from ArrayBuffer (async)
|
|
arrayBufferData.getDataUri(function (error, uri) {
|
|
testURI(error, uri, 'getDataUri from ArrayBuffer async');
|
|
});
|
|
|
|
// from ArrayBuffer (sync)
|
|
testURI(null, arrayBufferData.getDataUri(), 'getDataUri from ArrayBuffer sync');
|
|
|
|
// from binary (async)
|
|
binaryData.getDataUri(function (error, uri) {
|
|
testURI(error, uri, 'getDataUri from binary async');
|
|
});
|
|
|
|
// from binary (sync)
|
|
testURI(null, binaryData.getDataUri(), 'getDataUri from binary sync');
|
|
|
|
// from data URI (async)
|
|
dataUriData.getDataUri(function (error, uri) {
|
|
testURI(error, uri, 'getDataUri from data URI async');
|
|
});
|
|
|
|
// from data URI (sync)
|
|
testURI(null, dataUriData.getDataUri(), 'getDataUri from data URI sync');
|
|
|
|
// from URL (async)
|
|
urlData.getDataUri(function (error, uri) {
|
|
testURI(error, uri, 'getDataUri from URL async');
|
|
});
|
|
|
|
// from URL (sync)
|
|
testURI(null, urlData.getDataUri(), 'getDataUri from URL sync');
|
|
|
|
// from filepath (async)
|
|
filePathData.getDataUri(function (error, uri) {
|
|
testURI(error, uri, 'getDataUri filepath async');
|
|
});
|
|
|
|
// from filepath (sync)
|
|
testURI(null, filePathData.getDataUri(), 'getDataUri filepath sync');
|
|
});
|
|
|
|
// size
|
|
Tinytest.addAsync('cfs-data - server - size', function(test, onComplete) {
|
|
var total = 6, done = 0;
|
|
function testSize(size, testType) {
|
|
test.equal(size, 11, testType + ' got wrong size');
|
|
|
|
done++;
|
|
if (total === done) {
|
|
onComplete();
|
|
}
|
|
}
|
|
|
|
// from Buffer
|
|
testSize(bufferData.size(), 'size from Buffer');
|
|
|
|
// from ArrayBuffer
|
|
testSize(arrayBufferData.size(), 'size from ArrayBuffer');
|
|
|
|
// from binary
|
|
testSize(binaryData.size(), 'size from binary');
|
|
|
|
// from data URI
|
|
testSize(dataUriData.size(), 'size from data URI');
|
|
|
|
// from URL
|
|
testSize(urlData.size(), 'size from URL');
|
|
|
|
// from filepath
|
|
testSize(filePathData.size(), 'size from filepath');
|
|
});
|
|
|
|
// saveToFile
|
|
// Since saveToFile uses createReadStream, this tests that function also
|
|
Tinytest.addAsync('cfs-data - server - saveToFile', function(test, onComplete) {
|
|
var total = 12, done = 0;
|
|
function testSave(dataInstance) {
|
|
var tempName = temp.path({suffix: '.txt'});
|
|
dataInstance.saveToFile(tempName, function (error) {
|
|
test.isFalse(!!error);
|
|
test.equal(fs.readFileSync(tempName, {encoding: 'utf8'}), 'Hello World', 'file was not saved with correct data');
|
|
done++;
|
|
if (total === done) {
|
|
onComplete();
|
|
}
|
|
});
|
|
}
|
|
|
|
function testSaveSync(dataInstance) {
|
|
var tempName = temp.path({suffix: '.txt'});
|
|
dataInstance.saveToFile(tempName);
|
|
test.equal(fs.readFileSync(tempName, {encoding: 'utf8'}), 'Hello World', 'file was not saved with correct data');
|
|
done++;
|
|
if (total === done) {
|
|
onComplete();
|
|
}
|
|
}
|
|
|
|
// from Buffer
|
|
testSave(bufferData);
|
|
testSaveSync(bufferData);
|
|
|
|
// from ArrayBuffer
|
|
testSave(arrayBufferData);
|
|
testSaveSync(arrayBufferData);
|
|
|
|
// from binary
|
|
testSave(binaryData);
|
|
testSaveSync(binaryData);
|
|
|
|
// from data URI
|
|
testSave(dataUriData);
|
|
testSaveSync(dataUriData);
|
|
|
|
// from URL
|
|
testSave(urlData);
|
|
testSaveSync(urlData);
|
|
|
|
// from filepath
|
|
testSave(filePathData);
|
|
testSaveSync(filePathData);
|
|
});
|
|
|
|
// Ensure that URL createReadStream can be piped after delay
|
|
// https://github.com/mikeal/request/issues/887
|
|
Tinytest.addAsync('cfs-data - server - createReadStream delay', function(test, onComplete) {
|
|
var readStream = urlData.createReadStream();
|
|
|
|
// wait for 5 seconds, then pipe
|
|
Meteor.setTimeout(function() {
|
|
var tempName = temp.path({suffix: '.txt'});
|
|
|
|
try {
|
|
var writeStream = readStream.pipe(fs.createWriteStream(tempName));
|
|
|
|
writeStream.on('finish', Meteor.bindEnvironment(function() {
|
|
test.equal(fs.readFileSync(tempName, {encoding: 'utf8'}), 'Hello World', 'file was not saved with correct data');
|
|
onComplete();
|
|
}));
|
|
|
|
writeStream.on('error', Meteor.bindEnvironment(function(err) {
|
|
test.isFalse(!!err);
|
|
}));
|
|
} catch (err) {
|
|
test.isFalse(!!err);
|
|
onComplete();
|
|
}
|
|
|
|
}, 5000);
|
|
|
|
});
|
|
|
|
//Test API:
|
|
//test.isFalse(v, msg)
|
|
//test.isTrue(v, msg)
|
|
//test.equalactual, expected, message, not
|
|
//test.length(obj, len)
|
|
//test.include(s, v)
|
|
//test.isNaN(v, msg)
|
|
//test.isUndefined(v, msg)
|
|
//test.isNotNull
|
|
//test.isNull
|
|
//test.throws(func)
|
|
//test.instanceOf(obj, klass)
|
|
//test.notEqual(actual, expected, message)
|
|
//test.runId()
|
|
//test.exception(exception)
|
|
//test.expect_fail()
|
|
//test.ok(doc)
|
|
//test.fail(doc)
|
|
//test.equal(a, b, msg)
|