зеркало из https://github.com/mozilla/gecko-dev.git
726 строки
24 KiB
JavaScript
726 строки
24 KiB
JavaScript
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
|
/* vim: set ts=2 et sw=2 tw=80: */
|
|
/* Any copyright is dedicated to the Public Domain.
|
|
* http://creativecommons.org/publicdomain/zero/1.0/ */
|
|
|
|
/**
|
|
* This file tests components that implement nsIBackgroundFileSaver.
|
|
*/
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
//// Globals
|
|
|
|
Cu.import("resource://gre/modules/XPCOMUtils.jsm");
|
|
|
|
XPCOMUtils.defineLazyModuleGetter(this, "FileUtils",
|
|
"resource://gre/modules/FileUtils.jsm");
|
|
XPCOMUtils.defineLazyModuleGetter(this, "NetUtil",
|
|
"resource://gre/modules/NetUtil.jsm");
|
|
XPCOMUtils.defineLazyModuleGetter(this, "Promise",
|
|
"resource://gre/modules/Promise.jsm");
|
|
XPCOMUtils.defineLazyModuleGetter(this, "Task",
|
|
"resource://gre/modules/Task.jsm");
|
|
|
|
const BackgroundFileSaverOutputStream = Components.Constructor(
|
|
"@mozilla.org/network/background-file-saver;1?mode=outputstream",
|
|
"nsIBackgroundFileSaver");
|
|
|
|
const BackgroundFileSaverStreamListener = Components.Constructor(
|
|
"@mozilla.org/network/background-file-saver;1?mode=streamlistener",
|
|
"nsIBackgroundFileSaver");
|
|
|
|
const StringInputStream = Components.Constructor(
|
|
"@mozilla.org/io/string-input-stream;1",
|
|
"nsIStringInputStream",
|
|
"setData");
|
|
|
|
const REQUEST_SUSPEND_AT = 1024 * 1024 * 4;
|
|
const TEST_DATA_SHORT = "This test string is written to the file.";
|
|
const TEST_FILE_NAME_1 = "test-backgroundfilesaver-1.txt";
|
|
const TEST_FILE_NAME_2 = "test-backgroundfilesaver-2.txt";
|
|
const TEST_FILE_NAME_3 = "test-backgroundfilesaver-3.txt";
|
|
|
|
// A map of test data length to the expected SHA-256 hashes
|
|
const EXPECTED_HASHES = {
|
|
// No data
|
|
0 : "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
|
|
// TEST_DATA_SHORT
|
|
40 : "f37176b690e8744ee990a206c086cba54d1502aa2456c3b0c84ef6345d72a192",
|
|
// TEST_DATA_SHORT + TEST_DATA_SHORT
|
|
80 : "780c0e91f50bb7ec922cc11e16859e6d5df283c0d9470f61772e3d79f41eeb58",
|
|
// TEST_DATA_LONG
|
|
8388608 : "e3611a47714c42bdf326acfb2eb6ed9fa4cca65cb7d7be55217770a5bf5e7ff0",
|
|
// TEST_DATA_LONG + TEST_DATA_LONG
|
|
16777216 : "03a0db69a30140f307587ee746a539247c181bafd85b85c8516a3533c7d9ea1d"
|
|
};
|
|
|
|
const gTextDecoder = new TextDecoder();
|
|
|
|
// Generate a long string of data in a moderately fast way.
|
|
const TEST_256_CHARS = new Array(257).join("-");
|
|
const DESIRED_LENGTH = REQUEST_SUSPEND_AT * 2;
|
|
const TEST_DATA_LONG = new Array(1 + DESIRED_LENGTH / 256).join(TEST_256_CHARS);
|
|
do_check_eq(TEST_DATA_LONG.length, DESIRED_LENGTH);
|
|
|
|
/**
|
|
* Returns a reference to a temporary file. If the file is then created, it
|
|
* will be removed when tests in this file finish.
|
|
*/
|
|
function getTempFile(aLeafName) {
|
|
let file = FileUtils.getFile("TmpD", [aLeafName]);
|
|
do_register_cleanup(function GTF_cleanup() {
|
|
if (file.exists()) {
|
|
file.remove(false);
|
|
}
|
|
});
|
|
return file;
|
|
}
|
|
|
|
/**
|
|
* Helper function for converting a binary blob to its hex equivalent.
|
|
*
|
|
* @param str
|
|
* String possibly containing non-printable chars.
|
|
* @return A hex-encoded string.
|
|
*/
|
|
function toHex(str) {
|
|
var hex = '';
|
|
for (var i = 0; i < str.length; i++) {
|
|
hex += ('0' + str.charCodeAt(i).toString(16)).slice(-2);
|
|
}
|
|
return hex;
|
|
}
|
|
|
|
/**
|
|
* Ensures that the given file contents are equal to the given string.
|
|
*
|
|
* @param aFile
|
|
* nsIFile whose contents should be verified.
|
|
* @param aExpectedContents
|
|
* String containing the octets that are expected in the file.
|
|
*
|
|
* @return {Promise}
|
|
* @resolves When the operation completes.
|
|
* @rejects Never.
|
|
*/
|
|
function promiseVerifyContents(aFile, aExpectedContents) {
|
|
let deferred = Promise.defer();
|
|
NetUtil.asyncFetch(aFile, function(aInputStream, aStatus) {
|
|
do_check_true(Components.isSuccessCode(aStatus));
|
|
let contents = NetUtil.readInputStreamToString(aInputStream,
|
|
aInputStream.available());
|
|
if (contents.length <= TEST_DATA_SHORT.length * 2) {
|
|
do_check_eq(contents, aExpectedContents);
|
|
} else {
|
|
// Do not print the entire content string to the test log.
|
|
do_check_eq(contents.length, aExpectedContents.length);
|
|
do_check_true(contents == aExpectedContents);
|
|
}
|
|
deferred.resolve();
|
|
});
|
|
return deferred.promise;
|
|
}
|
|
|
|
/**
|
|
* Waits for the given saver object to complete.
|
|
*
|
|
* @param aSaver
|
|
* The saver, with the output stream or a stream listener implementation.
|
|
* @param aOnTargetChangeFn
|
|
* Optional callback invoked with the target file name when it changes.
|
|
*
|
|
* @return {Promise}
|
|
* @resolves When onSaveComplete is called with a success code.
|
|
* @rejects With an exception, if onSaveComplete is called with a failure code.
|
|
*/
|
|
function promiseSaverComplete(aSaver, aOnTargetChangeFn) {
|
|
let deferred = Promise.defer();
|
|
aSaver.observer = {
|
|
onTargetChange: function BFSO_onSaveComplete(aSaver, aTarget)
|
|
{
|
|
if (aOnTargetChangeFn) {
|
|
aOnTargetChangeFn(aTarget);
|
|
}
|
|
},
|
|
onSaveComplete: function BFSO_onSaveComplete(aSaver, aStatus)
|
|
{
|
|
if (Components.isSuccessCode(aStatus)) {
|
|
deferred.resolve();
|
|
} else {
|
|
deferred.reject(new Components.Exception("Saver failed.", aStatus));
|
|
}
|
|
},
|
|
};
|
|
return deferred.promise;
|
|
}
|
|
|
|
/**
|
|
* Feeds a string to a BackgroundFileSaverOutputStream.
|
|
*
|
|
* @param aSourceString
|
|
* The source data to copy.
|
|
* @param aSaverOutputStream
|
|
* The BackgroundFileSaverOutputStream to feed.
|
|
* @param aCloseWhenDone
|
|
* If true, the output stream will be closed when the copy finishes.
|
|
*
|
|
* @return {Promise}
|
|
* @resolves When the copy completes with a success code.
|
|
* @rejects With an exception, if the copy fails.
|
|
*/
|
|
function promiseCopyToSaver(aSourceString, aSaverOutputStream, aCloseWhenDone) {
|
|
let deferred = Promise.defer();
|
|
let inputStream = new StringInputStream(aSourceString, aSourceString.length);
|
|
let copier = Cc["@mozilla.org/network/async-stream-copier;1"]
|
|
.createInstance(Ci.nsIAsyncStreamCopier);
|
|
copier.init(inputStream, aSaverOutputStream, null, false, true, 0x8000, true,
|
|
aCloseWhenDone);
|
|
copier.asyncCopy({
|
|
onStartRequest: function () { },
|
|
onStopRequest: function (aRequest, aContext, aStatusCode)
|
|
{
|
|
if (Components.isSuccessCode(aStatusCode)) {
|
|
deferred.resolve();
|
|
} else {
|
|
deferred.reject(new Components.Exception(aResult));
|
|
}
|
|
},
|
|
}, null);
|
|
return deferred.promise;
|
|
}
|
|
|
|
/**
|
|
* Feeds a string to a BackgroundFileSaverStreamListener.
|
|
*
|
|
* @param aSourceString
|
|
* The source data to copy.
|
|
* @param aSaverStreamListener
|
|
* The BackgroundFileSaverStreamListener to feed.
|
|
* @param aCloseWhenDone
|
|
* If true, the output stream will be closed when the copy finishes.
|
|
*
|
|
* @return {Promise}
|
|
* @resolves When the operation completes with a success code.
|
|
* @rejects With an exception, if the operation fails.
|
|
*/
|
|
function promisePumpToSaver(aSourceString, aSaverStreamListener,
|
|
aCloseWhenDone) {
|
|
let deferred = Promise.defer();
|
|
aSaverStreamListener.QueryInterface(Ci.nsIStreamListener);
|
|
let inputStream = new StringInputStream(aSourceString, aSourceString.length);
|
|
let pump = Cc["@mozilla.org/network/input-stream-pump;1"]
|
|
.createInstance(Ci.nsIInputStreamPump);
|
|
pump.init(inputStream, -1, -1, 0, 0, true);
|
|
pump.asyncRead({
|
|
onStartRequest: function PPTS_onStartRequest(aRequest, aContext)
|
|
{
|
|
aSaverStreamListener.onStartRequest(aRequest, aContext);
|
|
},
|
|
onStopRequest: function PPTS_onStopRequest(aRequest, aContext, aStatusCode)
|
|
{
|
|
aSaverStreamListener.onStopRequest(aRequest, aContext, aStatusCode);
|
|
if (Components.isSuccessCode(aStatusCode)) {
|
|
deferred.resolve();
|
|
} else {
|
|
deferred.reject(new Components.Exception(aResult));
|
|
}
|
|
},
|
|
onDataAvailable: function PPTS_onDataAvailable(aRequest, aContext,
|
|
aInputStream, aOffset,
|
|
aCount)
|
|
{
|
|
aSaverStreamListener.onDataAvailable(aRequest, aContext, aInputStream,
|
|
aOffset, aCount);
|
|
},
|
|
}, null);
|
|
return deferred.promise;
|
|
}
|
|
|
|
let gStillRunning = true;
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
//// Tests
|
|
|
|
function run_test()
|
|
{
|
|
run_next_test();
|
|
}
|
|
|
|
add_task(function test_setup()
|
|
{
|
|
// Wait 10 minutes, that is half of the external xpcshell timeout.
|
|
do_timeout(10 * 60 * 1000, function() {
|
|
if (gStillRunning) {
|
|
do_throw("Test timed out.");
|
|
}
|
|
})
|
|
});
|
|
|
|
add_task(function test_normal()
|
|
{
|
|
// This test demonstrates the most basic use case.
|
|
let destFile = getTempFile(TEST_FILE_NAME_1);
|
|
|
|
// Create the object implementing the output stream.
|
|
let saver = new BackgroundFileSaverOutputStream();
|
|
|
|
// Set up callbacks for completion and target file name change.
|
|
let receivedOnTargetChange = false;
|
|
function onTargetChange(aTarget) {
|
|
do_check_true(destFile.equals(aTarget));
|
|
receivedOnTargetChange = true;
|
|
}
|
|
let completionPromise = promiseSaverComplete(saver, onTargetChange);
|
|
|
|
// Set the target file.
|
|
saver.setTarget(destFile, false);
|
|
|
|
// Write some data and close the output stream.
|
|
yield promiseCopyToSaver(TEST_DATA_SHORT, saver, true);
|
|
|
|
// Indicate that we are ready to finish, and wait for a successful callback.
|
|
saver.finish(Cr.NS_OK);
|
|
yield completionPromise;
|
|
|
|
// Only after we receive the completion notification, we can also be sure that
|
|
// we've received the target file name change notification before it.
|
|
do_check_true(receivedOnTargetChange);
|
|
|
|
// Clean up.
|
|
destFile.remove(false);
|
|
});
|
|
|
|
add_task(function test_combinations()
|
|
{
|
|
let initialFile = getTempFile(TEST_FILE_NAME_1);
|
|
let renamedFile = getTempFile(TEST_FILE_NAME_2);
|
|
|
|
// Keep track of the current file.
|
|
let currentFile = null;
|
|
function onTargetChange(aTarget) {
|
|
currentFile = null;
|
|
do_print("Target file changed to: " + aTarget.leafName);
|
|
currentFile = aTarget;
|
|
}
|
|
|
|
// Tests various combinations of events and behaviors for both the stream
|
|
// listener and the output stream implementations.
|
|
for (let testFlags = 0; testFlags < 32; testFlags++) {
|
|
let keepPartialOnFailure = !!(testFlags & 1);
|
|
let renameAtSomePoint = !!(testFlags & 2);
|
|
let cancelAtSomePoint = !!(testFlags & 4);
|
|
let useStreamListener = !!(testFlags & 8);
|
|
let useLongData = !!(testFlags & 16);
|
|
|
|
let startTime = Date.now();
|
|
do_print("Starting keepPartialOnFailure = " + keepPartialOnFailure +
|
|
", renameAtSomePoint = " + renameAtSomePoint +
|
|
", cancelAtSomePoint = " + cancelAtSomePoint +
|
|
", useStreamListener = " + useStreamListener +
|
|
", useLongData = " + useLongData);
|
|
|
|
// Create the object and register the observers.
|
|
currentFile = null;
|
|
let saver = useStreamListener
|
|
? new BackgroundFileSaverStreamListener()
|
|
: new BackgroundFileSaverOutputStream();
|
|
saver.enableSha256();
|
|
let completionPromise = promiseSaverComplete(saver, onTargetChange);
|
|
|
|
// Start feeding the first chunk of data to the saver. In case we are using
|
|
// the stream listener, we only write one chunk.
|
|
let testData = useLongData ? TEST_DATA_LONG : TEST_DATA_SHORT;
|
|
let feedPromise = useStreamListener
|
|
? promisePumpToSaver(testData + testData, saver)
|
|
: promiseCopyToSaver(testData, saver, false);
|
|
|
|
// Set a target output file.
|
|
saver.setTarget(initialFile, keepPartialOnFailure);
|
|
|
|
// Wait for the first chunk of data to be copied.
|
|
yield feedPromise;
|
|
|
|
if (renameAtSomePoint) {
|
|
saver.setTarget(renamedFile, keepPartialOnFailure);
|
|
}
|
|
|
|
if (cancelAtSomePoint) {
|
|
saver.finish(Cr.NS_ERROR_FAILURE);
|
|
}
|
|
|
|
// Feed the second chunk of data to the saver.
|
|
if (!useStreamListener) {
|
|
yield promiseCopyToSaver(testData, saver, true);
|
|
}
|
|
|
|
// Wait for completion, and ensure we succeeded or failed as expected.
|
|
if (!cancelAtSomePoint) {
|
|
saver.finish(Cr.NS_OK);
|
|
}
|
|
try {
|
|
yield completionPromise;
|
|
if (cancelAtSomePoint) {
|
|
do_throw("Failure expected.");
|
|
}
|
|
} catch (ex if cancelAtSomePoint && ex.result == Cr.NS_ERROR_FAILURE) { }
|
|
|
|
if (!cancelAtSomePoint) {
|
|
// In this case, the file must exist.
|
|
do_check_true(currentFile.exists());
|
|
let expectedContents = testData + testData;
|
|
yield promiseVerifyContents(currentFile, expectedContents);
|
|
do_check_eq(EXPECTED_HASHES[expectedContents.length],
|
|
toHex(saver.sha256Hash));
|
|
currentFile.remove(false);
|
|
|
|
// If the target was really renamed, the old file should not exist.
|
|
if (renamedFile.equals(currentFile)) {
|
|
do_check_false(initialFile.exists());
|
|
}
|
|
} else if (!keepPartialOnFailure) {
|
|
// In this case, the file must not exist.
|
|
do_check_false(initialFile.exists());
|
|
do_check_false(renamedFile.exists());
|
|
} else {
|
|
// In this case, the file may or may not exist, because canceling can
|
|
// interrupt the asynchronous operation at any point, even before the file
|
|
// has been created for the first time.
|
|
if (initialFile.exists()) {
|
|
initialFile.remove(false);
|
|
}
|
|
if (renamedFile.exists()) {
|
|
renamedFile.remove(false);
|
|
}
|
|
}
|
|
|
|
do_print("Test case completed in " + (Date.now() - startTime) + " ms.");
|
|
}
|
|
});
|
|
|
|
add_task(function test_setTarget_after_close_stream()
|
|
{
|
|
// This test checks the case where we close the output stream before we call
|
|
// the setTarget method. All the data should be buffered and written anyway.
|
|
let destFile = getTempFile(TEST_FILE_NAME_1);
|
|
|
|
// Test the case where the file does not already exists first, then the case
|
|
// where the file already exists.
|
|
for (let i = 0; i < 2; i++) {
|
|
let saver = new BackgroundFileSaverOutputStream();
|
|
saver.enableSha256();
|
|
let completionPromise = promiseSaverComplete(saver);
|
|
|
|
// Copy some data to the output stream of the file saver. This data must
|
|
// be shorter than the internal component's pipe buffer for the test to
|
|
// succeed, because otherwise the test would block waiting for the write to
|
|
// complete.
|
|
yield promiseCopyToSaver(TEST_DATA_SHORT, saver, true);
|
|
|
|
// Set the target file and wait for the output to finish.
|
|
saver.setTarget(destFile, false);
|
|
saver.finish(Cr.NS_OK);
|
|
yield completionPromise;
|
|
|
|
// Verify results.
|
|
yield promiseVerifyContents(destFile, TEST_DATA_SHORT);
|
|
do_check_eq(EXPECTED_HASHES[TEST_DATA_SHORT.length],
|
|
toHex(saver.sha256Hash));
|
|
}
|
|
|
|
// Clean up.
|
|
destFile.remove(false);
|
|
});
|
|
|
|
add_task(function test_setTarget_fast()
|
|
{
|
|
// This test checks a fast rename of the target file.
|
|
let destFile1 = getTempFile(TEST_FILE_NAME_1);
|
|
let destFile2 = getTempFile(TEST_FILE_NAME_2);
|
|
let saver = new BackgroundFileSaverOutputStream();
|
|
let completionPromise = promiseSaverComplete(saver);
|
|
|
|
// Set the initial name after the stream is closed, then rename immediately.
|
|
yield promiseCopyToSaver(TEST_DATA_SHORT, saver, true);
|
|
saver.setTarget(destFile1, false);
|
|
saver.setTarget(destFile2, false);
|
|
|
|
// Wait for all the operations to complete.
|
|
saver.finish(Cr.NS_OK);
|
|
yield completionPromise;
|
|
|
|
// Verify results and clean up.
|
|
do_check_false(destFile1.exists());
|
|
yield promiseVerifyContents(destFile2, TEST_DATA_SHORT);
|
|
destFile2.remove(false);
|
|
});
|
|
|
|
add_task(function test_setTarget_multiple()
|
|
{
|
|
// This test checks multiple renames of the target file.
|
|
let destFile = getTempFile(TEST_FILE_NAME_1);
|
|
let saver = new BackgroundFileSaverOutputStream();
|
|
let completionPromise = promiseSaverComplete(saver);
|
|
|
|
// Rename both before and after the stream is closed.
|
|
saver.setTarget(getTempFile(TEST_FILE_NAME_2), false);
|
|
saver.setTarget(getTempFile(TEST_FILE_NAME_3), false);
|
|
yield promiseCopyToSaver(TEST_DATA_SHORT, saver, true);
|
|
saver.setTarget(getTempFile(TEST_FILE_NAME_2), false);
|
|
saver.setTarget(destFile, false);
|
|
|
|
// Wait for all the operations to complete.
|
|
saver.finish(Cr.NS_OK);
|
|
yield completionPromise;
|
|
|
|
// Verify results and clean up.
|
|
do_check_false(getTempFile(TEST_FILE_NAME_2).exists());
|
|
do_check_false(getTempFile(TEST_FILE_NAME_3).exists());
|
|
yield promiseVerifyContents(destFile, TEST_DATA_SHORT);
|
|
destFile.remove(false);
|
|
});
|
|
|
|
add_task(function test_enableAppend()
|
|
{
|
|
// This test checks append mode with hashing disabled.
|
|
let destFile = getTempFile(TEST_FILE_NAME_1);
|
|
|
|
// Test the case where the file does not already exists first, then the case
|
|
// where the file already exists.
|
|
for (let i = 0; i < 2; i++) {
|
|
let saver = new BackgroundFileSaverOutputStream();
|
|
saver.enableAppend();
|
|
let completionPromise = promiseSaverComplete(saver);
|
|
|
|
saver.setTarget(destFile, false);
|
|
yield promiseCopyToSaver(TEST_DATA_LONG, saver, true);
|
|
|
|
saver.finish(Cr.NS_OK);
|
|
yield completionPromise;
|
|
|
|
// Verify results.
|
|
let expectedContents = (i == 0 ? TEST_DATA_LONG
|
|
: TEST_DATA_LONG + TEST_DATA_LONG);
|
|
yield promiseVerifyContents(destFile, expectedContents);
|
|
}
|
|
|
|
// Clean up.
|
|
destFile.remove(false);
|
|
});
|
|
|
|
add_task(function test_enableAppend_setTarget_fast()
|
|
{
|
|
// This test checks a fast rename of the target file in append mode.
|
|
let destFile1 = getTempFile(TEST_FILE_NAME_1);
|
|
let destFile2 = getTempFile(TEST_FILE_NAME_2);
|
|
|
|
// Test the case where the file does not already exists first, then the case
|
|
// where the file already exists.
|
|
for (let i = 0; i < 2; i++) {
|
|
let saver = new BackgroundFileSaverOutputStream();
|
|
saver.enableAppend();
|
|
let completionPromise = promiseSaverComplete(saver);
|
|
|
|
yield promiseCopyToSaver(TEST_DATA_SHORT, saver, true);
|
|
|
|
// The first time, we start appending to the first file and rename to the
|
|
// second file. The second time, we start appending to the second file,
|
|
// that was created the first time, and rename back to the first file.
|
|
let firstFile = (i == 0) ? destFile1 : destFile2;
|
|
let secondFile = (i == 0) ? destFile2 : destFile1;
|
|
saver.setTarget(firstFile, false);
|
|
saver.setTarget(secondFile, false);
|
|
|
|
saver.finish(Cr.NS_OK);
|
|
yield completionPromise;
|
|
|
|
// Verify results.
|
|
do_check_false(firstFile.exists());
|
|
let expectedContents = (i == 0 ? TEST_DATA_SHORT
|
|
: TEST_DATA_SHORT + TEST_DATA_SHORT);
|
|
yield promiseVerifyContents(secondFile, expectedContents);
|
|
}
|
|
|
|
// Clean up.
|
|
destFile1.remove(false);
|
|
});
|
|
|
|
add_task(function test_enableAppend_hash()
|
|
{
|
|
// This test checks append mode, also verifying that the computed hash
|
|
// includes the contents of the existing data.
|
|
let destFile = getTempFile(TEST_FILE_NAME_1);
|
|
|
|
// Test the case where the file does not already exists first, then the case
|
|
// where the file already exists.
|
|
for (let i = 0; i < 2; i++) {
|
|
let saver = new BackgroundFileSaverOutputStream();
|
|
saver.enableAppend();
|
|
saver.enableSha256();
|
|
let completionPromise = promiseSaverComplete(saver);
|
|
|
|
saver.setTarget(destFile, false);
|
|
yield promiseCopyToSaver(TEST_DATA_LONG, saver, true);
|
|
|
|
saver.finish(Cr.NS_OK);
|
|
yield completionPromise;
|
|
|
|
// Verify results.
|
|
let expectedContents = (i == 0 ? TEST_DATA_LONG
|
|
: TEST_DATA_LONG + TEST_DATA_LONG);
|
|
yield promiseVerifyContents(destFile, expectedContents);
|
|
do_check_eq(EXPECTED_HASHES[expectedContents.length],
|
|
toHex(saver.sha256Hash));
|
|
}
|
|
|
|
// Clean up.
|
|
destFile.remove(false);
|
|
});
|
|
|
|
add_task(function test_finish_only()
|
|
{
|
|
// This test checks creating the object and doing nothing.
|
|
let destFile = getTempFile(TEST_FILE_NAME_1);
|
|
let saver = new BackgroundFileSaverOutputStream();
|
|
function onTargetChange(aTarget) {
|
|
do_throw("Should not receive the onTargetChange notification.");
|
|
}
|
|
let completionPromise = promiseSaverComplete(saver, onTargetChange);
|
|
saver.finish(Cr.NS_OK);
|
|
yield completionPromise;
|
|
});
|
|
|
|
add_task(function test_empty()
|
|
{
|
|
// This test checks we still create an empty file when no data is fed.
|
|
let destFile = getTempFile(TEST_FILE_NAME_1);
|
|
|
|
let saver = new BackgroundFileSaverOutputStream();
|
|
let completionPromise = promiseSaverComplete(saver);
|
|
|
|
saver.setTarget(destFile, false);
|
|
yield promiseCopyToSaver("", saver, true);
|
|
|
|
saver.finish(Cr.NS_OK);
|
|
yield completionPromise;
|
|
|
|
// Verify results.
|
|
do_check_true(destFile.exists());
|
|
do_check_eq(destFile.fileSize, 0);
|
|
|
|
// Clean up.
|
|
destFile.remove(false);
|
|
});
|
|
|
|
add_task(function test_empty_hash()
|
|
{
|
|
// This test checks the hash of an empty file, both in normal and append mode.
|
|
let destFile = getTempFile(TEST_FILE_NAME_1);
|
|
|
|
// Test normal mode first, then append mode.
|
|
for (let i = 0; i < 2; i++) {
|
|
let saver = new BackgroundFileSaverOutputStream();
|
|
if (i == 1) {
|
|
saver.enableAppend();
|
|
}
|
|
saver.enableSha256();
|
|
let completionPromise = promiseSaverComplete(saver);
|
|
|
|
saver.setTarget(destFile, false);
|
|
yield promiseCopyToSaver("", saver, true);
|
|
|
|
saver.finish(Cr.NS_OK);
|
|
yield completionPromise;
|
|
|
|
// Verify results.
|
|
do_check_eq(destFile.fileSize, 0);
|
|
do_check_eq(EXPECTED_HASHES[0], toHex(saver.sha256Hash));
|
|
}
|
|
|
|
// Clean up.
|
|
destFile.remove(false);
|
|
});
|
|
|
|
add_task(function test_invalid_hash()
|
|
{
|
|
let saver = new BackgroundFileSaverStreamListener();
|
|
let completionPromise = promiseSaverComplete(saver);
|
|
// We shouldn't be able to get the hash if hashing hasn't been enabled
|
|
try {
|
|
let hash = saver.sha256Hash;
|
|
do_throw("Shouldn't be able to get hash if hashing not enabled");
|
|
} catch (ex if ex.result == Cr.NS_ERROR_NOT_AVAILABLE) { }
|
|
// Enable hashing, but don't feed any data to saver
|
|
saver.enableSha256();
|
|
let destFile = getTempFile(TEST_FILE_NAME_1);
|
|
saver.setTarget(destFile, false);
|
|
// We don't wait on promiseSaverComplete, so the hash getter can run before
|
|
// or after onSaveComplete is called. However, the expected behavior is the
|
|
// same in both cases since the hash is only valid when the save completes
|
|
// successfully.
|
|
saver.finish(Cr.NS_ERROR_FAILURE);
|
|
try {
|
|
let hash = saver.sha256Hash;
|
|
do_throw("Shouldn't be able to get hash if save did not succeed");
|
|
} catch (ex if ex.result == Cr.NS_ERROR_NOT_AVAILABLE) { }
|
|
// Wait for completion so that the worker thread finishes dealing with the
|
|
// target file. We expect it to fail.
|
|
try {
|
|
yield completionPromise;
|
|
do_throw("completionPromise should throw");
|
|
} catch (ex if ex.result == Cr.NS_ERROR_FAILURE) { }
|
|
});
|
|
|
|
add_task(function test_signature()
|
|
{
|
|
// Check that we get a signature if the saver is finished.
|
|
let destFile = getTempFile(TEST_FILE_NAME_1);
|
|
|
|
let saver = new BackgroundFileSaverOutputStream();
|
|
let completionPromise = promiseSaverComplete(saver);
|
|
|
|
try {
|
|
let signatureInfo = saver.signatureInfo;
|
|
do_throw("Can't get signature if saver is not complete");
|
|
} catch (ex if ex.result == Cr.NS_ERROR_NOT_AVAILABLE) { }
|
|
|
|
saver.enableSignatureInfo();
|
|
saver.setTarget(destFile, false);
|
|
yield promiseCopyToSaver(TEST_DATA_SHORT, saver, true);
|
|
|
|
saver.finish(Cr.NS_OK);
|
|
yield completionPromise;
|
|
yield promiseVerifyContents(destFile, TEST_DATA_SHORT);
|
|
|
|
// signatureInfo is an empty nsIArray
|
|
do_check_eq(0, saver.signatureInfo.length);
|
|
|
|
// Clean up.
|
|
destFile.remove(false);
|
|
});
|
|
|
|
add_task(function test_signature_not_enabled()
|
|
{
|
|
// Check that we get a signature if the saver is finished on Windows.
|
|
let destFile = getTempFile(TEST_FILE_NAME_1);
|
|
|
|
let saver = new BackgroundFileSaverOutputStream();
|
|
let completionPromise = promiseSaverComplete(saver);
|
|
saver.setTarget(destFile, false);
|
|
yield promiseCopyToSaver(TEST_DATA_SHORT, saver, true);
|
|
|
|
saver.finish(Cr.NS_OK);
|
|
yield completionPromise;
|
|
try {
|
|
let signatureInfo = saver.signatureInfo;
|
|
do_throw("Can't get signature if not enabled");
|
|
} catch (ex if ex.result == Cr.NS_ERROR_NOT_AVAILABLE) { }
|
|
|
|
// Clean up.
|
|
destFile.remove(false);
|
|
});
|
|
|
|
add_task(function test_teardown()
|
|
{
|
|
gStillRunning = false;
|
|
});
|