exports["test zip"] = function(assert){
"use strict";
// create directory
io.mkpath("/tmp/zip-test");
// create first file with content
var path = "/tmp/zip-test/1";
var stream = io.open(path, "w");
if (!stream.closed) {
stream.write("Content of 1");
stream.close();
}
// create first file with content
var path2 = "/tmp/zip-test/2";
var stream2 = io.open(path, "w");
if (!stream2.closed) {
stream2.write("Content of 2");
stream2.close();
}
archiver._zip("/tmp/zip-test", "/tmp/zip-test.zip");
removeFolder("/tmp/zip-test");
assert.ok(io.exists("/tmp/zip-test.zip"), "zip exists");
io.remove("/tmp/zip-test.zip");
};
purge: function JsonStore_purge() {
try {
// This'll throw if the file doesn't exist.
file.remove(this.filename);
this._root = {}
} catch (err) {}
},
exports.testReadLengths = function (assert) {
let fname = dataFileFilename();
let str = "exports.testReadLengths data!";
let stream = open(assert, fname, true);
stream.write(str);
stream.close();
stream = open(assert, fname);
assert.equal(stream.read(str.length * 1000), str,
"stream.read with big byte length should return string " +
"written");
stream.close();
stream = open(assert, fname);
assert.equal(stream.read(0), "",
"string.read with zero byte length should return empty " +
"string");
stream.close();
stream = open(assert, fname);
assert.equal(stream.read(-1), "",
"string.read with negative byte length should return " +
"empty string");
stream.close();
file.remove(fname);
};
exports.testWriteReadChunks = function (assert) {
let str = "";
let bufLen = BUFFER_BYTE_LEN;
let fileSize = bufLen * 10;
for (let i = 0; i < fileSize; i++)
str += i % 10;
let fname = dataFileFilename();
let stream = open(assert, fname, true);
let i = 0;
while (i < str.length) {
// Use a chunk length that spans buffers.
let chunk = str.substr(i, bufLen + 1);
stream.write(chunk);
i += bufLen + 1;
}
stream.close();
stream = open(assert, fname);
let readStr = "";
bufLen = BUFFER_BYTE_LEN;
let readLen = bufLen + 1;
do {
var frag = stream.read(readLen);
readStr += frag;
} while (frag);
stream.close();
assert.equal(readStr, str,
"stream.write and read in chunks should work as expected");
file.remove(fname);
};
exports.testWriteRead = function (assert) {
let fname = dataFileFilename();
// Write a small string less than the stream's buffer size...
let str = "exports.testWriteRead data!";
let stream = open(assert, fname, true);
assert.ok(!stream.closed, "stream.closed after open should be false");
stream.write(str);
stream.close();
assert.ok(stream.closed, "Stream should be closed after stream.close");
assert.throws(() => stream.write("This shouldn't be written!"),
STREAM_CLOSED_ERROR,
"stream.write after close should raise error");
// ... and read it.
stream = open(assert, fname);
assert.equal(stream.read(), str,
"stream.read should return string written");
assert.equal(stream.read(), "",
"stream.read at EOS should return empty string");
stream.close();
assert.ok(stream.closed, "Stream should be closed after stream.close");
assert.throws(() => stream.read(),
STREAM_CLOSED_ERROR,
"stream.read after close should raise error");
file.remove(fname);
};
function migrateFromOlderVersion() {
const { pathFor } = require('sdk/system');
const path = require('sdk/fs/path');
const file = require('sdk/io/file');
var oldRedirectsFile = path.join(pathFor('ProfD'), 'Redirector.rjson');
if (!file.exists(oldRedirectsFile)) {
return;
}
var extensionId = require('sdk/self').id;
var newFolder = path.join(pathFor('ProfD'), 'browser-extension-data', extensionId);
file.mkpath(newFolder);
var newFile = path.join(newFolder, 'storage.js');
if (file.exists(newFile)) {
return;
}
var textReader = file.open(oldRedirectsFile, 'r');
var jsonData = JSON.parse(textReader.read());
textReader.close();
var Redirect = require('../redirect').Redirect;
var newData = {redirects:[]};
for (var r of jsonData.redirects) {
var redirect = new Redirect(r);
redirect.updateExampleResult();
newData.redirects.push(redirect.toObject());
}
Cu.import("resource://gre/modules/Services.jsm");
var enabled = true;
try {
enabled = Services.prefs.getBoolPref('extensions.redirector.enabled');
} catch(e) {}
newData.disabled = !enabled;
//Kill old prefs:
var oldPrefs = ['enabled', 'debugEnabled', 'enableShortcutKey', 'version', 'defaultDir'];
for (var p of oldPrefs) {
try {
Services.prefs.deleteBranch('extensions.redirector.' + p);
} catch(e) {
}
}
var textWriter = file.open(newFile, 'w');
textWriter.write(JSON.stringify(newData));
textWriter.close();
file.remove(oldRedirectsFile);
}
exports.deleteTemplate = function (data, emit) {
var profD = system.pathFor('ProfD'),
ec = file.join(profD, 'executable-creator'),
template = file.join(profD, 'executable-creator', data.fileName + '.html');
if (!file.exists(ec)) {
file.mkpath(ec);
}
if (!file.exists(template)) {
return {message: 'File file (' + template + ') + does not exist', fileName: data.fileName};
}
file.remove(template);
return {message: 'File removed!', fileName: data.fileName};
};
files.forEach(function(item, index, array){
// check if file or folder
if(io.isFile(path + "/" + item)){
// delete
io.remove(path + "/" + item);
}
else{
// call recursive
removeFolder(path + "/" + item);
}
});
exports.testWriteReadBig = function (assert) {
let str = "";
let bufLen = BUFFER_BYTE_LEN;
let fileSize = bufLen * 10;
for (let i = 0; i < fileSize; i++)
str += i % 10;
let fname = dataFileFilename();
let stream = open(assert, fname, true);
stream.write(str);
stream.close();
stream = open(assert, fname);
assert.equal(stream.read(), str,
"stream.read should return string written");
stream.close();
file.remove(fname);
};
removeAdguardDir: function () {
try {
var adguardDir = sdkFile.join(sdkPathFor(this.PROFILE_DIR), this.ADGUARD_DIR);
if (sdkFile.exists(adguardDir)) {
Log.info('Removing profile directory {0}', adguardDir);
var files = sdkFile.list(adguardDir);
for (var i = 0; i < files.length; i++) {
var filePath = sdkFile.join(sdkPathFor(this.PROFILE_DIR), this.ADGUARD_DIR, files[i]);
sdkFile.remove(filePath);
}
sdkFile.rmdir(adguardDir);
}
} catch (ex) {
//ignore
Log.error('Error remove profile directory, cause {0}', ex);
}
},
exports.testTruncate = function (assert) {
let fname = dataFileFilename();
let str = "exports.testReadLengths data!";
let stream = open(assert, fname, true);
stream.write(str);
stream.close();
stream = open(assert, fname);
assert.equal(stream.read(), str,
"stream.read should return string written");
stream.close();
stream = open(assert, fname, true);
stream.close();
stream = open(assert, fname);
assert.equal(stream.read(), "",
"stream.read after truncate should be empty");
stream.close();
file.remove(fname);
};
function removeFile(filename)
{
fileIO.remove(filename);
}
stdin], function() {
var output = fs.read(stdout);
fs.remove(stdin);
fs.remove(stdout);
callback(output, proc.exitValue === 0);
}
ws.writeAsync(data.content, function () {
if (lastTemplate) { // Currently not in use
file.remove(lastTemplate);
}
emit('saveTemplateResult', {templateName: data.fileName, message: 'Save successful! in (' + template + ')'});
});