Merge lp:~mandel/ubuntu-download-manager/atomic-steps into lp:ubuntu-download-manager

[Manuel de la Peña]

Ensure that we do no have race issues between the diff downloads. This is fixed in two ways:

1. Use a temp file.
2. USe a mutex to decide the final path of the download.

Ensure that we do no have race issues between the diff downloads. This is fixed in two ways:

1. Use a temp file.
2. USe a mutex to decide the final path of the download.

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:240
http://jenkins.qa.ubuntu.com/job/ubuntu-download-manager-ci/357/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/ubuntu-download-manager-trusty-amd64-ci/246
    SUCCESS: http://jenkins.qa.ubuntu.com/job/ubuntu-download-manager-trusty-armhf-ci/246

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/ubuntu-download-manager-ci/357/rebuild

review: Approve (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:241
http://jenkins.qa.ubuntu.com/job/ubuntu-download-manager-ci/358/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/ubuntu-download-manager-trusty-amd64-ci/247
    SUCCESS: http://jenkins.qa.ubuntu.com/job/ubuntu-download-manager-trusty-armhf-ci/247

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/ubuntu-download-manager-ci/358/rebuild

review: Approve (continuous-integration)

[Diego Sarmentero (diegosarmentero)]

+1

review: Approve

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:246
http://jenkins.qa.ubuntu.com/job/ubuntu-download-manager-ci/359/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/ubuntu-download-manager-trusty-amd64-ci/248
    SUCCESS: http://jenkins.qa.ubuntu.com/job/ubuntu-download-manager-trusty-armhf-ci/248

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/ubuntu-download-manager-ci/359/rebuild

review: Approve (continuous-integration)

[lp:~mandel/ubuntu-download-manager/atomic-steps]

240. By Manuel de la Peña on 2014-02-20

Auth errs.

241. By Manuel de la Peña on 2014-02-20

Client auth errors.

242. By Manuel de la Peña on 2014-02-20

Group downloads.

243. By Manuel de la Peña on 2014-02-20

Use log

244. By Manuel de la Peña on 2014-02-20

better logging.

245. By Manuel de la Peña on 2014-02-20

Abstract classes.

246. By Manuel de la Peña on 2014-02-20

Fix merge issues.

247. By Manuel de la Peña on 2014-02-20

Small logging fix lost in the merge.

248. By Manuel de la Peña on 2014-02-20

Fixed merge issues.

249. By Manuel de la Peña on 2014-02-21

Merge fix logs.

250. By Manuel de la Peña on 2014-02-22

Better implementation for the unconfined apps.

=== modified file 'debian/libubuntu-download-manager-common-dev.install'
--- debian/libubuntu-download-manager-common-dev.install	2014-02-11 15:35:52 +0000
+++ debian/libubuntu-download-manager-common-dev.install	2014-02-22 10:42:10 +0000
@@ -6,5 +6,6 @@
 usr/include/ubuntu/download_manager/http_error_struct.h
 usr/include/ubuntu/download_manager/network_error_struct.h
 usr/include/ubuntu/download_manager/process_error_struct.h
+usr/include/ubuntu/download_manager/metadata.h
 usr/lib/*/pkgconfig/ubuntu-download-manager-common.pc
 usr/lib/*/libubuntu-download-manager-common.so

=== modified file 'download-manager.pro'
--- download-manager.pro	2014-01-09 15:21:14 +0000
+++ download-manager.pro	2014-02-22 10:42:10 +0000
@@ -10,8 +10,10 @@
     ubuntu-download-manager-client \
     ubuntu-download-manager-test-lib \
     ubuntu-download-manager-tests \
+    ubuntu-download-manager-common-tests \
     ubuntu-download-manager-test-daemon \
-    ubuntu-download-manager-client-tests \
+    ubuntu-download-manager-client-tests
+
 
 ubuntu-download-manager-priv.depends = ubuntu-download-manager-common
 
@@ -19,6 +21,10 @@
 
 ubuntu-download-manager-client.depends = ubuntu-download-manager-common
 
+ubuntu-download-manager-common-tests.depends += ubuntu-download-manager-test-daemon
+ubuntu-download-manager-common-tests.depends += ubuntu-download-manager-common
+ubuntu-download-manager-common-tests.depends += ubuntu-download-manager-test-lib
+
 ubuntu-download-manager-tests.depends += ubuntu-download-manager-test-lib
 ubuntu-download-manager-tests.depends += ubuntu-download-manager-priv
 

=== added directory 'ubuntu-download-manager-common-tests'
=== added file 'ubuntu-download-manager-common-tests/main.cpp'
--- ubuntu-download-manager-common-tests/main.cpp	1970-01-01 00:00:00 +0000
+++ ubuntu-download-manager-common-tests/main.cpp	2014-02-22 10:42:10 +0000
@@ -0,0 +1,25 @@
+/*
+ * Copyright 2014 Canonical Ltd.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of version 3 of the GNU Lesser General Public
+ * License as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#include <QCoreApplication>
+#include <ubuntu/download_manager/tests/test_runner.h>
+
+int main(int argc, char *argv[]) {
+    QCoreApplication a(argc, argv);
+    return RUN_ALL_QTESTS(argc, argv);
+}

=== added file 'ubuntu-download-manager-common-tests/test_metadata.cpp'
--- ubuntu-download-manager-common-tests/test_metadata.cpp	1970-01-01 00:00:00 +0000
+++ ubuntu-download-manager-common-tests/test_metadata.cpp	2014-02-22 10:42:10 +0000
@@ -0,0 +1,169 @@
+/*
+ * Copyright 2014 Canonical Ltd.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of version 3 of the GNU Lesser General Public
+ * License as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#include "test_metadata.h"
+
+using namespace Ubuntu::DownloadManager;
+
+TestMetadata::TestMetadata(QObject *parent)
+    : BaseTestCase("TestMetadata", parent) {
+}
+
+void
+TestMetadata::testCommnad_data() {
+    QTest::addColumn<QString>("command");
+
+    QTest::newRow("mkdir") << "mkdir test";
+    QTest::newRow("cd") << "cd test";
+    QTest::newRow("ls") << "ls -la";
+}
+
+void
+TestMetadata::testCommnad() {
+    QFETCH(QString, command);
+
+    Metadata metadata;
+    metadata[Metadata::COMMAND_KEY] = command;
+    QCOMPARE(command, metadata.command());
+}
+
+void
+TestMetadata::testSetCommnad_data() {
+    QTest::addColumn<QString>("command");
+
+    QTest::newRow("mkdir") << "mkdir test";
+    QTest::newRow("cd") << "cd test";
+    QTest::newRow("ls") << "ls -la";
+}
+
+void
+TestMetadata::testSetCommnad() {
+    QFETCH(QString, command);
+
+    Metadata metadata;
+    metadata.setCommand(command);
+    QCOMPARE(metadata[Metadata::COMMAND_KEY].toString(), command);
+}
+
+void
+TestMetadata::testHasCommnadTrue() {
+    Metadata metadata;
+    metadata.setCommand("command");
+
+    QVERIFY(metadata.hasCommand());
+}
+
+void
+TestMetadata::testHasCommnadFalse() {
+    Metadata metadata;
+    QVERIFY(!metadata.hasCommand());
+}
+
+void
+TestMetadata::testLocalPath_data() {
+    QTest::addColumn<QString>("path");
+
+    QTest::newRow("/home/test") << "/home/test";
+    QTest::newRow("second_file") << "second_file";
+    QTest::newRow("/tmp/data") << "/tmp/data";
+}
+
+void
+TestMetadata::testLocalPath() {
+    QFETCH(QString, path);
+
+    Metadata metadata;
+    metadata[Metadata::LOCAL_PATH_KEY] = path;
+    QCOMPARE(path, metadata.localPath());
+}
+
+void
+TestMetadata::testSetLocalPath_data() {
+    QTest::addColumn<QString>("path");
+
+    QTest::newRow("/home/test") << "/home/test";
+    QTest::newRow("second_file") << "second_file";
+    QTest::newRow("/tmp/data") << "/tmp/data";
+}
+
+void
+TestMetadata::testSetLocalPath() {
+    QFETCH(QString, path);
+
+    Metadata metadata;
+    metadata.setLocalPath(path);
+    QCOMPARE(metadata[Metadata::LOCAL_PATH_KEY].toString(), path);
+}
+
+void
+TestMetadata::testHasLocalPathTrue() {
+    Metadata metadata;
+    metadata.setLocalPath("command");
+
+    QVERIFY(metadata.hasLocalPath());
+}
+
+void
+TestMetadata::testHashLocalPathFalse() {
+    Metadata metadata;
+    QVERIFY(!metadata.hasLocalPath());
+}
+
+void TestMetadata::testObjectPath_data() {
+    QTest::addColumn<QString>("objectPath");
+
+    QTest::newRow("/com/canonica/si") << "/com/canonical/si";
+    QTest::newRow("/com/testing") << "/com/testing";
+    QTest::newRow("/com/data/download") << "/com/data/download";
+}
+
+void TestMetadata::testObjectPath() {
+    QFETCH(QString, objectPath);
+
+    Metadata metadata;
+    metadata[Metadata::OBJECT_PATH_KEY] = objectPath;
+    QCOMPARE(objectPath, metadata.objectPath());
+}
+
+void TestMetadata::testSetObjectPath_data() {
+    QTest::addColumn<QString>("objectPath");
+
+    QTest::newRow("/com/canonica/si") << "/com/canonical/si";
+    QTest::newRow("/com/testing") << "/com/testing";
+    QTest::newRow("/com/data/download") << "/com/data/download";
+}
+
+void TestMetadata::testSetObjectPath() {
+    QFETCH(QString, objectPath);
+
+    Metadata metadata;
+    metadata.setObjectPath(objectPath);
+    QCOMPARE(metadata[Metadata::OBJECT_PATH_KEY].toString(), objectPath);
+}
+
+void TestMetadata::testHasObjectPathTrue() {
+    Metadata metadata;
+    metadata.setObjectPath("command");
+
+    QVERIFY(metadata.hasObjectPath());
+}
+
+void TestMetadata::testHasObjectPathFalse() {
+    Metadata metadata;
+    QVERIFY(!metadata.hasObjectPath());
+}

=== added file 'ubuntu-download-manager-common-tests/test_metadata.h'
--- ubuntu-download-manager-common-tests/test_metadata.h	1970-01-01 00:00:00 +0000
+++ ubuntu-download-manager-common-tests/test_metadata.h	2014-02-22 10:42:10 +0000
@@ -0,0 +1,55 @@
+/*
+ * Copyright 2014 Canonical Ltd.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of version 3 of the GNU Lesser General Public
+ * License as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#ifndef TEST_METADATA_H
+#define TEST_METADATA_H
+
+#include <QObject>
+#include <ubuntu/download_manager/tests/base_testcase.h>
+#include <ubuntu/download_manager/tests/test_runner.h>
+#include <ubuntu/download_manager/metadata.h>
+
+class TestMetadata : public BaseTestCase {
+    Q_OBJECT
+
+ public:
+    explicit TestMetadata(QObject* parent = 0);
+
+ private slots:  // NOLINT(whitespace/indent)
+    void testCommnad_data();
+    void testCommnad();
+    void testSetCommnad_data();
+    void testSetCommnad();
+    void testHasCommnadTrue();
+    void testHasCommnadFalse();
+    void testLocalPath_data();
+    void testLocalPath();
+    void testSetLocalPath_data();
+    void testSetLocalPath();
+    void testHasLocalPathTrue();
+    void testHashLocalPathFalse();
+    void testObjectPath_data();
+    void testObjectPath();
+    void testSetObjectPath_data();
+    void testSetObjectPath();
+    void testHasObjectPathTrue();
+    void testHasObjectPathFalse();
+};
+
+DECLARE_TEST(TestMetadata)
+#endif // TEST_METADATA_H

=== added file 'ubuntu-download-manager-common-tests/ubuntu-download-manager-common-tests.pro'
--- ubuntu-download-manager-common-tests/ubuntu-download-manager-common-tests.pro	1970-01-01 00:00:00 +0000
+++ ubuntu-download-manager-common-tests/ubuntu-download-manager-common-tests.pro	2014-02-22 10:42:10 +0000
@@ -0,0 +1,36 @@
+include( ../common-project-config.pri )
+include( ../common-vars.pri )
+
+QT       += core testlib network
+QT       -= gui
+
+TARGET = ubuntu-download-manager-common-tests
+CONFIG   += console
+CONFIG   -= app_bundle
+
+TEMPLATE = app
+
+HEADERS += \
+    test_metadata.h
+
+SOURCES += main.cpp \
+    test_metadata.cpp
+
+LIBS += -L$$OUT_PWD/../ubuntu-download-manager-common/ -lubuntu-download-manager-common
+
+INCLUDEPATH += $$PWD/../ubuntu-download-manager-common
+DEPENDPATH += $$PWD/../ubuntu-download-manager-common
+
+LIBS += -L$$OUT_PWD/../ubuntu-download-manager-test-lib/ -lubuntu-download-manager-test-lib
+
+INCLUDEPATH += $$PWD/../ubuntu-download-manager-test-lib
+DEPENDPATH += $$PWD/../ubuntu-download-manager-test-lib
+
+LIBS += -L$$OUT_PWD/../ubuntu-download-manager-priv/ -lubuntu-download-manager-priv
+
+INCLUDEPATH += $$PWD/../ubuntu-download-manager-priv
+DEPENDPATH += $$PWD/../ubuntu-download-manager-priv
+
+check.depends = $${TARGET}
+check.commands = LD_LIBRARY_PATH=$$OUT_PWD/../ubuntu-download-manager-common:$$OUT_PWD/../ubuntu-download-manager-test-lib:$$OUT_PWD/../ubuntu-download-manager-priv ./$${TARGET}
+QMAKE_EXTRA_TARGETS += check

=== modified file 'ubuntu-download-manager-common/ubuntu-download-manager-common.pro'
--- ubuntu-download-manager-common/ubuntu-download-manager-common.pro	2014-02-11 15:35:52 +0000
+++ ubuntu-download-manager-common/ubuntu-download-manager-common.pro	2014-02-22 10:42:10 +0000
@@ -17,6 +17,7 @@
     ubuntu/download_manager/http_error_struct.cpp \
     ubuntu/download_manager/network_error_struct.cpp \
     ubuntu/download_manager/process_error_struct.cpp \
+    ubuntu/download_manager/metadata.cpp \
     ubuntu/download_manager/auth_error_struct.cpp
 
 public_headers = \
@@ -27,6 +28,7 @@
     ubuntu/download_manager/http_error_struct.h \
     ubuntu/download_manager/network_error_struct.h \
     ubuntu/download_manager/process_error_struct.h \
+    ubuntu/download_manager/metadata.h \
     ubuntu/download_manager/auth_error_struct.h
 
 private_headers = \

=== added file 'ubuntu-download-manager-common/ubuntu/download_manager/metadata.cpp'
--- ubuntu-download-manager-common/ubuntu/download_manager/metadata.cpp	1970-01-01 00:00:00 +0000
+++ ubuntu-download-manager-common/ubuntu/download_manager/metadata.cpp	2014-02-22 10:42:10 +0000
@@ -0,0 +1,80 @@
+/*
+ * Copyright 2014 Canonical Ltd.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of version 3 of the GNU Lesser General Public
+ * License as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#include "metadata.h"
+
+namespace Ubuntu {
+
+namespace DownloadManager {
+
+const QString Metadata::COMMAND_KEY = "post-download-command";
+const QString Metadata::COMMAND_FILE_KEY = "$file";
+const QString Metadata::LOCAL_PATH_KEY = "local-path";
+const QString Metadata::OBJECT_PATH_KEY = "objectpath";
+
+QString
+Metadata::command() const {
+    return (contains(Metadata::COMMAND_KEY))?
+        value(COMMAND_KEY).toString():"";
+}
+
+void
+Metadata::setCommand(const QString& command) {
+    insert(Metadata::COMMAND_KEY, command);
+}
+
+bool
+Metadata::hasCommand() const {
+    return contains(Metadata::COMMAND_KEY);
+}
+
+QString
+Metadata::localPath() const {
+    return (contains(Metadata::LOCAL_PATH_KEY))?
+        value(LOCAL_PATH_KEY).toString():"";
+}
+
+void
+Metadata::setLocalPath(const QString& localPath) {
+    insert(Metadata::LOCAL_PATH_KEY, localPath);
+}
+
+bool
+Metadata::hasLocalPath() const {
+    return contains(Metadata::LOCAL_PATH_KEY);
+}
+
+QString
+Metadata::objectPath() const {
+    return (contains(Metadata::OBJECT_PATH_KEY))?
+        value(OBJECT_PATH_KEY).toString():"";
+}
+
+void
+Metadata::setObjectPath(const QString& path) {
+    insert(Metadata::OBJECT_PATH_KEY, path);
+}
+
+bool
+Metadata::hasObjectPath() const {
+    return contains(Metadata::OBJECT_PATH_KEY);
+}
+
+}  // DownloadManager
+
+}  // Ubuntu

=== added file 'ubuntu-download-manager-common/ubuntu/download_manager/metadata.h'
--- ubuntu-download-manager-common/ubuntu/download_manager/metadata.h	1970-01-01 00:00:00 +0000
+++ ubuntu-download-manager-common/ubuntu/download_manager/metadata.h	2014-02-22 10:42:10 +0000
@@ -0,0 +1,56 @@
+/*
+ * Copyright 2014 Canonical Ltd.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of version 3 of the GNU Lesser General Public
+ * License as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#ifndef DOWNLOADER_LIB_METADATA_H
+#define DOWNLOADER_LIB_METADATA_H
+
+#include <QMap>
+#include <QVariant>
+
+namespace Ubuntu {
+
+namespace DownloadManager {
+
+class Metadata : public QVariantMap {
+
+ public:
+
+    static const QString COMMAND_KEY;
+    static const QString COMMAND_FILE_KEY;
+    static const QString LOCAL_PATH_KEY;
+    static const QString OBJECT_PATH_KEY;
+
+    // accessors to simplify the use of the metadata
+    QString command() const;
+    void setCommand(const QString& command);
+    bool hasCommand() const;
+
+    QString localPath() const;
+    void setLocalPath(const QString& localPath);
+    bool hasLocalPath() const;
+
+    QString objectPath() const;
+    void setObjectPath(const QString& path);
+    bool hasObjectPath() const;
+};
+
+}  // DownloadManager
+
+}  // Ubuntu
+
+#endif // METADATA_H

=== modified file 'ubuntu-download-manager-priv/downloads/daemon.cpp'
--- ubuntu-download-manager-priv/downloads/daemon.cpp	2014-02-13 11:01:48 +0000
+++ ubuntu-download-manager-priv/downloads/daemon.cpp	2014-02-22 10:42:10 +0000
@@ -170,11 +170,14 @@
             if (args.count() > index + 1) {
                 auto logPath = args[index + 1];
                 Logger::setupLogging(logPath);
-		LOG(INFO) << "Log path is" << logPath;
+                LOG(INFO) << "Log path is" << logPath;
             } else {
+                Logger::setupLogging();
                 LOG(ERROR) << "Missing log dir path.";
-                Logger::setupLogging();
             }
+        } else {
+            Logger::setupLogging();
+            LOG(INFO) << "Using default log path.";
         }
 
         if (args.contains(SELFSIGNED_CERT)) {

=== modified file 'ubuntu-download-manager-priv/downloads/factory.cpp'
--- ubuntu-download-manager-priv/downloads/factory.cpp	2014-02-01 08:46:28 +0000
+++ ubuntu-download-manager-priv/downloads/factory.cpp	2014-02-22 10:42:10 +0000
@@ -18,6 +18,7 @@
 
 #include <QNetworkProxy>
 #include <QPair>
+#include <ubuntu/download_manager/metadata.h>
 #include "downloads/download_adaptor.h"
 #include "downloads/group_download.h"
 #include "downloads/group_download_adaptor.h"
@@ -26,12 +27,6 @@
 #include "downloads/factory.h"
 #include "system/logger.h"
 
-namespace {
-
-    const QString OBJECT_PATH_KEY = "objectpath";
-
-}
-
 namespace Ubuntu {
 
 namespace DownloadManager {
@@ -61,9 +56,9 @@
                          QString& rootPath,
                          bool& isConfined) {
     TRACE << dbusOwner;
-    if (metadata.contains(OBJECT_PATH_KEY)) {
+    if (metadata.contains(Metadata::OBJECT_PATH_KEY)) {
         // create a uuid using the string value form the metadata
-        id = metadata[OBJECT_PATH_KEY].toString();
+        id = metadata[Metadata::OBJECT_PATH_KEY].toString();
         if (id.isEmpty()) {
             LOG(ERROR) << "Id sent by client is ''";
             id = _apparmor->getSecurePath(dbusOwner, dbusPath, rootPath,

=== modified file 'ubuntu-download-manager-priv/downloads/file_download.cpp'
--- ubuntu-download-manager-priv/downloads/file_download.cpp	2014-02-20 13:12:04 +0000
+++ ubuntu-download-manager-priv/downloads/file_download.cpp	2014-02-22 10:42:10 +0000
@@ -23,8 +23,10 @@
 #include <QFile>
 #include <QFileInfo>
 #include <QSslError>
+#include <ubuntu/download_manager/metadata.h>
 #include <ubuntu/download_manager/system/hash_algorithm.h>
 #include "downloads/file_download.h"
+#include "system/filename_mutex.h"
 #include "system/logger.h"
 #include "system/network_reply.h"
 
@@ -34,18 +36,15 @@
 namespace {
 
     const QString DATA_FILE_NAME = "data.download";
-    const QString METADATA_FILE_NAME = "metadata";
-    const QString METADATA_COMMAND_KEY = "post-download-command";
-    const QString METADATA_COMMAND_FILE_KEY = "$file";
     const QString NETWORK_ERROR = "NETWORK ERROR";
     const QString HASH_ERROR = "HASH ERROR";
     const QString COMMAND_ERROR = "COMMAND ERROR";
     const QString SSL_ERROR = "SSL ERROR";
     const QString FILE_SYSTEM_ERROR = "FILE SYSTEM ERROR: %1";
+    const QString TEMP_EXTENSION = ".tmp";
     const QString AUTH_ERROR = "AUTHENTICATION ERROR";
     const QString PROXY_AUTH_ERROR = "PROXY_AUTHENTICATION ERROR";
     const QString UNEXPECTED_ERROR = "UNEXPECTED_ERROR";
-
 }
 
 namespace Ubuntu {
@@ -116,6 +115,9 @@
 
     // remove current data and metadata
     cleanUpCurrentData();
+    // unlock the file name so that other downloads can use it it if is
+    // no used in the file system
+    _fileNameMutex->unlockFileName(_filePath);
     _downloading = false;
     emit canceled(true);
 }
@@ -197,7 +199,7 @@
 
     // create file that will be used to maintain the state of the
     // download when resumed.
-    _currentData = FileManager::instance()->createFile(_filePath);
+    _currentData = FileManager::instance()->createFile(_tempFilePath);
     bool canWrite = _currentData->open(QIODevice::ReadWrite | QFile::Append);
 
     if (!canWrite) {
@@ -326,11 +328,13 @@
     _reply->deleteLater();
     _reply = nullptr;
 
-    // clean the local file
+    // clean the local file without unlocking the file the reason for
+    // this is that the file pat is going to be reused to store the
+    // data from the redirect
     cleanUpCurrentData();
 
     // perform again the request but do not emit started signal
-    _currentData = FileManager::instance()->createFile(_filePath);
+    _currentData = FileManager::instance()->createFile(_tempFilePath);
     bool canWrite = _currentData->open(QIODevice::ReadWrite | QFile::Append);
 
     if (!canWrite) {
@@ -369,7 +373,7 @@
     // means we are done here else we execute the command AND raise the
     // finish signals once the command was done (or an error occurred in
     // the command execution.
-    if (metadata().contains(METADATA_COMMAND_KEY)) {
+    if (metadata().contains(Metadata::COMMAND_KEY)) {
         // just emit processing if we DO NOT have a hash because else we
         // already emitted it.
         if (_hash.isEmpty()) {
@@ -377,7 +381,7 @@
         }
         // toStringList will return an empty list if it cannot be converted
         QStringList commandData =
-            metadata()[METADATA_COMMAND_KEY].toStringList();
+            metadata()[Metadata::COMMAND_KEY].toStringList();
         if (commandData.count() == 0) {
             DOWN_LOG(ERROR) << "COMMAND DATA MISSING";
             emitError(COMMAND_ERROR);
@@ -390,7 +394,7 @@
             QStringList args;
 
             foreach(const QString& arg, commandData) {
-                if (arg == METADATA_COMMAND_FILE_KEY)
+                if (arg == Metadata::COMMAND_FILE_KEY)
                     args << filePath();
                 else
                     args << arg;
@@ -412,9 +416,7 @@
             return;
         }
     } else {
-        setState(Download::FINISH);
-        DOWN_LOG(INFO) << "EMIT finished" << filePath();
-        emit finished(filePath());
+        emitFinished();
     }
 
     // clean the reply
@@ -467,9 +469,20 @@
     if (exitCode == 0 && exitStatus == QProcess::NormalExit) {
         // remove the file since we are done with it
         cleanUpCurrentData();
-        setState(Download::FINISH);
-        DOWN_LOG(INFO) << "EMIT finished" << filePath();
-        emit finished(filePath());
+        emitFinished();
+        // remove the file because that is the contract that we have with
+        // the clients
+        auto fileMan = FileManager::instance();
+
+        if (fileMan->exists(_tempFilePath)) {
+            LOG(INFO) << "Removing '" << _tempFilePath << "'";
+            fileMan->remove(_tempFilePath);
+        }
+
+        if (fileMan->exists(_filePath)) {
+            LOG(INFO) << "Removing '" << _filePath << "'";
+            fileMan->remove(_filePath);
+        }
     } else {
         auto standardOut = p->readAllStandardOutput();
         auto standardErr = p->readAllStandardError();
@@ -507,6 +520,7 @@
 void
 FileDownload::init() {
     _requestFactory = RequestFactory::instance();
+    _fileNameMutex = System::FileNameMutex::instance();
     SystemNetworkInfo* networkInfo = SystemNetworkInfo::instance();
     _connected = networkInfo->isOnline();
     _downloading = false;
@@ -515,7 +529,7 @@
     connect(networkInfo, &SystemNetworkInfo::onlineStateChanged,
         this, &FileDownload::onOnlineStateChanged);
 
-    _filePath = getSaveFileName();
+    initFileNames();
 
     // ensure that the download is valid
     if (!_url.isValid()) {
@@ -563,66 +577,52 @@
     return flushed;
 }
 
-QString
-FileDownload::getSaveFileName() {
+void
+FileDownload::initFileNames() {
+    // the mutex will ensure that we do not have race conditions about
+    // the file names in the download manager
     QString path = _url.path();
     QString basename = QFileInfo(path).fileName();
 
     if (basename.isEmpty())
         basename = DATA_FILE_NAME;
 
-    QVariantMap metadataMap = metadata();
-    QString finalPath;
+    auto metadataMap = metadata();
 
-    if (!isConfined() && metadataMap.contains(LOCAL_PATH_KEY)) {
-        finalPath = metadataMap[LOCAL_PATH_KEY].toString();
+    if (!isConfined() && metadataMap.contains(Metadata::LOCAL_PATH_KEY)) {
+        _filePath = metadataMap[Metadata::LOCAL_PATH_KEY].toString();
+        _tempFilePath = _fileNameMutex->lockFileName(
+            _filePath + TEMP_EXTENSION);
 
         // in this case and because the app is not confined we are
         // going to check if the file exists, if it does we will
         // raise an error
-        if (QFile::exists(finalPath)) {
+        if (QFile::exists(_filePath)) {
             setIsValid(false);
             setLastError(QString("File already exists at: '%1'").arg(
-                finalPath));
+                _filePath));
         }
     } else {
-        finalPath = rootPath() + QDir::separator() + basename;
-        if (QFile::exists(finalPath)) {
-            finalPath = uniqueFilePath(finalPath);
-        }
-
+        auto desiredPath = rootPath() + QDir::separator() + basename;
+        _filePath = _fileNameMutex->lockFileName(desiredPath);
+        _tempFilePath = _filePath + TEMP_EXTENSION;
     }
-
-    return finalPath;
 }
 
-QString
-FileDownload::uniqueFilePath(QString path) {
-    QFileInfo fileInfo(path);
-
-    // Split the file into 2 parts - dot+extension, and everything else. For
-    // example, "path/file.tar.gz" becomes "path/file"+".tar.gz", while
-    // "path/file" (note lack of extension) becomes "path/file"+"".
-    auto secondPart = fileInfo.completeSuffix();
-    auto firstPart = path;
-
-    if (!secondPart.isEmpty()) {
-        secondPart = "." + secondPart;
-        firstPart = path.left(path.size() - secondPart.size());
+void
+FileDownload::emitFinished() {
+    auto fileMan = FileManager::instance();
+
+    LOG(INFO) << "EMIT finished" << filePath();
+    setState(Download::FINISH);
+
+    if (fileMan->exists(_tempFilePath)) {
+        LOG(INFO) << "Rename '" << _tempFilePath << "' to '"
+            << _filePath << "'";
+        fileMan->rename(_tempFilePath, _filePath);
     }
-
-    // Try with an ever-increasing number suffix, until we've reached a file
-    // that does not yet exist.
-    for (int ii = 1; ; ii++) {
-        // Construct the new file name by adding the unique number between the
-        // first and second part.
-        auto finalPath = QString("%1 (%2)%3").arg(firstPart).arg(ii).arg(secondPart);
-        // If no file exists with the new name, return it.
-        if (!QFile::exists(finalPath)) {
-            return finalPath;
-        }
-    }  // for
-    return path;
+    _fileNameMutex->unlockFileName(_filePath);
+    emit finished(_filePath);
 }
 
 void
@@ -638,7 +638,7 @@
         _currentData->deleteLater();
         _currentData = nullptr;
     } else {
-        QScopedPointer<QFile> tempFile(new QFile(_filePath));
+        QScopedPointer<QFile> tempFile(new QFile(_tempFilePath));
         success = tempFile->remove();
         if (!success)
             error = tempFile->error();
@@ -674,6 +674,8 @@
     _reply->deleteLater();
     _reply = nullptr;
     cleanUpCurrentData();
+    // let other downloads use the same file name
+    _fileNameMutex->unlockFileName(_filePath);
     Download::emitError(error);
 }
 

=== modified file 'ubuntu-download-manager-priv/downloads/file_download.h'
--- ubuntu-download-manager-priv/downloads/file_download.h	2014-02-11 15:35:52 +0000
+++ ubuntu-download-manager-priv/downloads/file_download.h	2014-02-22 10:42:10 +0000
@@ -30,8 +30,7 @@
 #include <ubuntu/download_manager/process_error_struct.h>
 #include "downloads/download.h"
 #include "system/file_manager.h"
-
-#define LOCAL_PATH_KEY "local-path"
+#include "system/filename_mutex.h"
 
 namespace Ubuntu {
 
@@ -121,8 +120,8 @@
     void onProcessFinished(int exitCode,
                            QProcess::ExitStatus exitStatus);
     void onOnlineStateChanged(bool);
-    QString getSaveFileName();
-    QString uniqueFilePath(QString path);
+    void initFileNames();
+    void emitFinished();
 
  private:
     bool _downloading = false;
@@ -130,10 +129,12 @@
     qulonglong _totalSize = 0;
     QUrl _url;
     QString _filePath;
+    QString _tempFilePath;
     QString _hash;
     QCryptographicHash::Algorithm _algo;
     NetworkReply* _reply = nullptr;
     File* _currentData = nullptr;
+    FileNameMutex* _fileNameMutex = nullptr;
     QList<QUrl> _visitedUrls;
 };
 

=== modified file 'ubuntu-download-manager-priv/downloads/group_download.cpp'
--- ubuntu-download-manager-priv/downloads/group_download.cpp	2014-02-20 13:12:04 +0000
+++ ubuntu-download-manager-priv/downloads/group_download.cpp	2014-02-22 10:42:10 +0000
@@ -16,6 +16,7 @@
  * boston, ma 02110-1301, usa.
  */
 
+#include <ubuntu/download_manager/metadata.h>
 #include <ubuntu/download_manager/system/hash_algorithm.h>
 #include "downloads/download_adaptor.h"
 #include "downloads/file_download.h"
@@ -95,7 +96,7 @@
 
         FileDownload* singleDownload;
         QVariantMap downloadMetadata = QVariantMap(metadataMap);
-        downloadMetadata[LOCAL_PATH_KEY] = download.getLocalFile();
+        downloadMetadata[Metadata::LOCAL_PATH_KEY] = download.getLocalFile();
 
         if (hash.isEmpty()) {
             singleDownload = qobject_cast<FileDownload*>(

=== modified file 'ubuntu-download-manager-priv/system/file_manager.cpp'
--- ubuntu-download-manager-priv/system/file_manager.cpp	2014-02-01 09:01:47 +0000
+++ ubuntu-download-manager-priv/system/file_manager.cpp	2014-02-22 10:42:10 +0000
@@ -107,6 +107,11 @@
     return QFile::exists(path);
 }
 
+bool
+FileManager::rename(const QString& oldName, const QString& newName) {
+    return QFile::rename(oldName, newName);
+}
+
 FileManager* FileManager::instance() {
     if(_instance == nullptr) {
         _mutex.lock();

=== modified file 'ubuntu-download-manager-priv/system/file_manager.h'
--- ubuntu-download-manager-priv/system/file_manager.h	2014-02-01 09:01:47 +0000
+++ ubuntu-download-manager-priv/system/file_manager.h	2014-02-22 10:42:10 +0000
@@ -66,6 +66,7 @@
     virtual File* createFile(const QString& name);
     virtual bool remove(const QString& path);
     virtual bool exists(const QString& path);
+    virtual bool rename(const QString& oldName, const QString& newName);
 
     static FileManager* instance();
 

=== added file 'ubuntu-download-manager-priv/system/filename_mutex.cpp'
--- ubuntu-download-manager-priv/system/filename_mutex.cpp	1970-01-01 00:00:00 +0000
+++ ubuntu-download-manager-priv/system/filename_mutex.cpp	2014-02-22 10:42:10 +0000
@@ -0,0 +1,133 @@
+/*
+ * Copyright 2014 Canonical Ltd.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of version 3 of the GNU Lesser General Public
+ * License as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#include <QFile>
+#include <QFileInfo>
+#include <ubuntu/download_manager/metadata.h>
+#include "logger.h"
+#include "filename_mutex.h"
+
+namespace Ubuntu {
+
+namespace DownloadManager {
+
+namespace System {
+
+FileNameMutex* FileNameMutex::_instance = nullptr;
+QMutex FileNameMutex::_singletonMutex;
+
+FileNameMutex::FileNameMutex(QObject* parent)
+    : QObject(parent) {
+}
+
+QString
+FileNameMutex::lockFileName(const QString& expectedName) {
+    auto path = expectedName;
+    _mutex.lock();
+    QFileInfo fileInfo(expectedName);
+    if (!_paths.contains(path) && !QFile::exists(path)) {
+        _paths.insert(path);
+        _mutex.unlock();
+        return path;
+    }
+    // Split the file into 2 parts - dot+extension, and everything
+    // else. For example, "path/file.tar.gz" becomes
+    // "path/file"+".tar.gz", while "path/file" (note lack of
+    // extension) becomes "path/file"+"".
+    auto secondPart = fileInfo.completeSuffix();
+    auto firstPart = expectedName;
+
+    if (!secondPart.isEmpty()) {
+        secondPart = "." + secondPart;
+        firstPart = expectedName.left(expectedName.size()
+            - secondPart.size());
+    }
+
+    // Try with an ever-increasing number suffix, until we've
+    // reached a file that does not yet exist.
+    for (int ii = 1; ; ii++) {
+        // Construct the new file name by adding the unique
+        // number between the first and second part.
+        path = QString("%1 (%2)%3").arg(firstPart
+            ).arg(ii).arg(secondPart);
+        // If no file exists with the new name, return it.
+        if (!_paths.contains(path) && !QFile::exists(path)) {
+            _paths.insert(path);
+            LOG(INFO) << "Locked path '" << path << "'";
+            break;
+        }
+    }  // for
+
+    _mutex.unlock();
+    return path;
+}
+
+void
+FileNameMutex::unlockFileName(const QString& filename) {
+    _mutex.lock();
+    auto removed = _paths.remove(filename);
+    if (!removed) {
+        LOG(WARNING) << "Tired to remove filename '" << filename
+            << "' when it was not owned by any object.";
+    } else {
+        LOG(INFO) << "Released path '" << filename << "'";
+    }
+    _mutex.unlock();
+}
+
+bool
+FileNameMutex::isLocked(const QString& filename) {
+    _mutex.lock();
+    auto present = _paths.contains(filename);
+    _mutex.unlock();
+    return present;
+}
+
+FileNameMutex*
+FileNameMutex::instance() {
+    if(_instance == nullptr) {
+        _singletonMutex.lock();
+        if(_instance == nullptr)
+            _instance = new FileNameMutex();
+        _singletonMutex.unlock();
+    }
+    return _instance;
+}
+
+void
+FileNameMutex::deleteInstance() {
+    if(_instance != nullptr) {
+        _singletonMutex.lock();
+        if(_instance != nullptr) {
+            delete _instance;
+            _instance = nullptr;
+        }
+        _singletonMutex.unlock();
+    }
+}
+
+void
+FileNameMutex::setInstance(FileNameMutex* instance) {
+    _instance = instance;
+}
+
+}  // System
+
+}  // DownloadManager
+
+}  // Ubuntu

=== added file 'ubuntu-download-manager-priv/system/filename_mutex.h'
--- ubuntu-download-manager-priv/system/filename_mutex.h	1970-01-01 00:00:00 +0000
+++ ubuntu-download-manager-priv/system/filename_mutex.h	2014-02-22 10:42:10 +0000
@@ -0,0 +1,64 @@
+/*
+ * Copyright 2014 Canonical Ltd.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of version 3 of the GNU Lesser General Public
+ * License as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#ifndef DOWNLOADER_LIB_FILENAME_MUTEX_H
+#define DOWNLOADER_LIB_FILENAME_MUTEX_H
+
+#include <QMutex>
+#include <QObject>
+#include <QVariant>
+#include <QSet>
+
+namespace Ubuntu {
+
+namespace DownloadManager {
+
+namespace System {
+
+class FileNameMutex : public QObject {
+    Q_OBJECT
+ public:
+    explicit FileNameMutex(QObject* parent = 0);
+    virtual QString lockFileName(const QString& expectedName);
+    virtual void unlockFileName(const QString& filename);
+    virtual bool isLocked(const QString& filename);
+
+    static FileNameMutex* instance();
+
+    // only used for testing so that we can inject a fake
+    static void setInstance(FileNameMutex* instance);
+    static void deleteInstance();
+
+ protected:
+    QSet<QString> _paths;
+
+ private:
+    // used for the singleton
+    static FileNameMutex* _instance;
+    static QMutex _singletonMutex;
+
+    QMutex _mutex;
+};
+
+}  // System
+
+}  // DownloadManager
+
+}  // Ubuntu
+
+#endif // FILENAME_MUTEX_H

=== modified file 'ubuntu-download-manager-priv/ubuntu-download-manager-priv.pro'
--- ubuntu-download-manager-priv/ubuntu-download-manager-priv.pro	2014-02-13 21:30:25 +0000
+++ ubuntu-download-manager-priv/ubuntu-download-manager-priv.pro	2014-02-22 10:42:10 +0000
@@ -41,7 +41,8 @@
     downloads/state_machines/final_state.cpp \
     system/apn_request_factory.cpp \
     downloads/mms_file_download.cpp \
-    system/apn_proxy.cpp
+    system/apn_proxy.cpp \
+    system/filename_mutex.cpp
 
 HEADERS +=\
     downloads/daemon.h \
@@ -74,7 +75,8 @@
     downloads/state_machines/final_state.h \
     system/apn_request_factory.h \
     downloads/mms_file_download.h \
-    system/apn_proxy.h
+    system/apn_proxy.h \
+    system/filename_mutex.h
 
 OTHER_FILES += \
     generate_adaptors.sh \

=== modified file 'ubuntu-download-manager-test-lib/ubuntu-download-manager-test-lib.pro'
--- ubuntu-download-manager-test-lib/ubuntu-download-manager-test-lib.pro	2014-02-13 13:21:14 +0000
+++ ubuntu-download-manager-test-lib/ubuntu-download-manager-test-lib.pro	2014-02-22 10:42:10 +0000
@@ -35,7 +35,8 @@
            ubuntu/download_manager/tests/client/testing_interface.cpp \
            ubuntu/download_manager/tests/client/testing_file_download.cpp \
            ubuntu/download_manager/tests/server/apn_request_factory.cpp \
-    ubuntu/download_manager/tests/server/group_download.cpp
+           ubuntu/download_manager/tests/server/filename_mutex.cpp \
+           ubuntu/download_manager/tests/server/group_download.cpp
 
 HEADERS += ubuntu/download_manager/tests/base_testcase.h \
            ubuntu/download_manager/tests/fake.h\
@@ -64,7 +65,8 @@
            ubuntu/download_manager/tests/client/testing_interface.h \
            ubuntu/download_manager/tests/client/testing_file_download.h \
            ubuntu/download_manager/tests/server/apn_request_factory.h \
-    ubuntu/download_manager/tests/server/group_download.h
+           ubuntu/download_manager/tests/server/filename_mutex.h \
+           ubuntu/download_manager/tests/server/group_download.h
 
 LIBS += -L$$OUT_PWD/../ubuntu-download-manager-common/ -lubuntu-download-manager-common
 

=== modified file 'ubuntu-download-manager-test-lib/ubuntu/download_manager/tests/base_testcase.cpp'
--- ubuntu-download-manager-test-lib/ubuntu/download_manager/tests/base_testcase.cpp	2014-01-24 11:24:40 +0000
+++ ubuntu-download-manager-test-lib/ubuntu/download_manager/tests/base_testcase.cpp	2014-02-22 10:42:10 +0000
@@ -46,7 +46,7 @@
     pathComponents << dataPath << objectName();
     QString path = pathComponents.join(QDir::separator());
 
-    if (!QDir().exists(path))
+    if (!QDir().exists(path)) 
         QDir().mkpath(path);
 
     return path;

=== modified file 'ubuntu-download-manager-test-lib/ubuntu/download_manager/tests/server/file_manager.cpp'
--- ubuntu-download-manager-test-lib/ubuntu/download_manager/tests/server/file_manager.cpp	2014-02-01 09:01:47 +0000
+++ ubuntu-download-manager-test-lib/ubuntu/download_manager/tests/server/file_manager.cpp	2014-02-22 10:42:10 +0000
@@ -76,5 +76,5 @@
         MethodData methodData("remove", params);
         _called.append(methodData);
     }
-    return true;
+    return QFile::remove(path);
 }

=== added file 'ubuntu-download-manager-test-lib/ubuntu/download_manager/tests/server/filename_mutex.cpp'
--- ubuntu-download-manager-test-lib/ubuntu/download_manager/tests/server/filename_mutex.cpp	1970-01-01 00:00:00 +0000
+++ ubuntu-download-manager-test-lib/ubuntu/download_manager/tests/server/filename_mutex.cpp	2014-02-22 10:42:10 +0000
@@ -0,0 +1,58 @@
+/*
+ * Copyright 2014 Canonical Ltd.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of version 3 of the GNU Lesser General Public
+ * License as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#include "filename_mutex.h"
+
+FakeFileNameMutex::FakeFileNameMutex(QObject* parent)
+    : FileNameMutex(parent),
+      Fake(){
+}
+
+QString
+FakeFileNameMutex::lockFileName(const QString& expectedName) {
+    if (_recording) {
+        QList<QObject*> inParams;
+        inParams.append(new StringWrapper(expectedName, this));
+        QList<QObject*> outParams;
+        MethodParams params(inParams, outParams);
+
+        MethodData methodData("lockFileName", params);
+        _called.append(methodData);
+    }
+
+    return FileNameMutex::lockFileName(expectedName);
+}
+
+void
+FakeFileNameMutex::unlockFileName(const QString& filename) {
+    if (_recording) {
+        QList<QObject*> inParams;
+        inParams.append(new StringWrapper(filename, this));
+        QList<QObject*> outParams;
+        MethodParams params(inParams, outParams);
+
+        MethodData methodData("unlockFileName", params);
+        _called.append(methodData);
+    }
+    FileNameMutex::unlockFileName(filename);
+}
+
+void
+FakeFileNameMutex::clearMutex() {
+    _paths.clear();
+}

=== added file 'ubuntu-download-manager-test-lib/ubuntu/download_manager/tests/server/filename_mutex.h'
--- ubuntu-download-manager-test-lib/ubuntu/download_manager/tests/server/filename_mutex.h	1970-01-01 00:00:00 +0000
+++ ubuntu-download-manager-test-lib/ubuntu/download_manager/tests/server/filename_mutex.h	2014-02-22 10:42:10 +0000
@@ -0,0 +1,43 @@
+/*
+ * Copyright 2014 Canonical Ltd.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of version 3 of the GNU Lesser General Public
+ * License as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#ifndef FILENAME_MUTEXT_H
+#define FILENAME_MUTEXT_H
+
+#include <QObject>
+#include <system/filename_mutex.h>
+#include "ubuntu/download_manager/tests/fake.h"
+
+using namespace Ubuntu::DownloadManager::System;
+
+class FakeFileNameMutex : public FileNameMutex, public Fake {
+    Q_OBJECT
+
+ public:
+    explicit FakeFileNameMutex(QObject *parent = 0);
+
+    /// override to keep track of the calls
+    QString lockFileName(const QString& expectedName) override;
+    void unlockFileName(const QString& filename) override;
+
+    // just for testing purposes
+    void clearMutex();
+
+};
+
+#endif // FILENAME_MUTEXT_H

=== modified file 'ubuntu-download-manager-tests/downloads/test_download.cpp'
--- ubuntu-download-manager-tests/downloads/test_download.cpp	2014-02-11 15:35:52 +0000
+++ ubuntu-download-manager-tests/downloads/test_download.cpp	2014-02-22 10:42:10 +0000
@@ -50,6 +50,8 @@
     ProcessFactory::setInstance(_processFactory);
     _fileManager = new FakeFileManager();
     FileManager::setInstance(_fileManager);
+    _fileNameMutex = new FakeFileNameMutex();
+    FileNameMutex::setInstance(_fileNameMutex);
 }
 
 void
@@ -60,6 +62,7 @@
     RequestFactory::deleteInstance();
     ProcessFactory::deleteInstance();
     FileManager::deleteInstance();
+    FileNameMutex::deleteInstance();
 }
 
 void
@@ -711,7 +714,9 @@
     QCOMPARE(spy.count(), 1);
 
     // assert that the files does exist in the system
-    QFileInfo info = QFileInfo(download->filePath());
+    QFileInfo info(download->filePath());
+    QVERIFY(!info.exists());
+    info = QFileInfo(download->filePath() + ".tmp");
     QVERIFY(info.exists());
 }
 
@@ -735,6 +740,8 @@
 
     // assert that the files does exist in the system
     QFileInfo info = QFileInfo(download->filePath());
+    QVERIFY(!info.exists());
+    info = QFileInfo(download->filePath() + ".tmp");
     QVERIFY(info.exists());
 }
 
@@ -1639,8 +1646,9 @@
 
     _processFactory->record();
     _reqFactory->record();
-    QScopedPointer<FileDownload> download(new FileDownload(_id, _path, _isConfined,
-        _rootPath, _url, metadata, _headers));
+    QScopedPointer<FileDownload> download(new FileDownload(_id, _path,
+        _isConfined, _rootPath, _url, metadata, _headers));
+    QSignalSpy finishedSpy(download.data(), SIGNAL(finished(QString)));
 
     // write something in the expected file
     QString fileName = download->filePath();
@@ -1668,6 +1676,7 @@
 
     // emit the finished signal with a result > 0 and ensure error is emitted
     process->emitFinished(0, QProcess::NormalExit);
+    QTRY_COMPARE(1, finishedSpy.count());
     // assert that the file does not longer exist in the system
     QVERIFY(!QFile::exists(fileName));
 }
@@ -1901,7 +1910,7 @@
 
     QTest::newRow("One") << 1;
     QTest::newRow("Some") << 3;
-    QTest::newRow("Several") << 10; 
+    QTest::newRow("Several") << 10;
     QTest::newRow("Plenti") << 100;
 }
 
@@ -1921,11 +1930,14 @@
 
     QFileInfo fileInfo(filePath);
     auto suffix = "." + fileInfo.completeSuffix();
+    qDebug() << "SUFIX" << suffix;
     auto prefix = filePath.left(filePath.size() - suffix.size());
+    qDebug() << "PREFIX" << prefix;
 
     // write the rest of the files
     for(int index=1; index < count; index++) {
         auto otherPath = QString("%1 (%2)%3").arg(prefix).arg(index).arg(suffix);
+        qDebug() << "Writing a new file" << otherPath;
         QScopedPointer<QFile> otherFile(new QFile(otherPath));
         otherFile->open(QIODevice::ReadWrite | QFile::Append);
         otherFile->write("data data data!");
@@ -2220,3 +2232,184 @@
     QTRY_COMPARE(finishedSpy.count(), 1);
     QCOMPARE(redirectCount, urls.count());
 }
+
+void
+TestDownload::testRedirectDoesNotUnlockPath() {
+    _fileNameMutex->record();
+
+    QUrl redirectUrl("http://redirect.example.com");
+    _reqFactory->record();
+    QScopedPointer<FileDownload> download(new FileDownload(_id, _path,
+        _isConfined, _rootPath, _url, _metadata, _headers));
+
+    download->start();  // change state
+    download->startDownload();
+
+    QList<MethodData> calledMethods = _reqFactory->calledMethods();
+    QCOMPARE(1, calledMethods.count());
+    FakeNetworkReply* reply = qobject_cast<FakeNetworkReply*>(
+        calledMethods[0].params().outParams()[0]);
+
+    // set the attr for a redirect to a new url
+    // makes the process to be executed
+    reply->setAttribute(QNetworkRequest::RedirectionTargetAttribute,
+        redirectUrl);
+    QSignalSpy replySpy(_reqFactory, SIGNAL(requestCreated(NetworkReply*)));
+
+    // use a spy to wait for the second reply
+    reply->emitFinished();
+
+    // ensure that a second request is performed
+    QTRY_COMPARE(1, replySpy.count());
+
+    reply = qobject_cast<FakeNetworkReply*>(
+        replySpy.takeFirst().at(0).value<NetworkReply*>());
+
+    download->pause();
+
+    QSignalSpy errorSpy(download.data(), SIGNAL(error(QString)));
+    QSignalSpy networkErrorSpy(download.data(),
+        SIGNAL(networkError(NetworkErrorStruct)));
+    QSignalSpy finishedSpy(download.data(), SIGNAL(finished(QString)));
+
+    reply->emitFinished();
+
+    QTRY_COMPARE(networkErrorSpy.count(), 0);
+    QTRY_COMPARE(errorSpy.count(), 0);
+    QTRY_COMPARE(finishedSpy.count(), 1);
+
+    // ensure that we only called lock and unlock once and not several times
+    calledMethods = _fileNameMutex->calledMethods();
+    QCOMPARE(2, calledMethods.count());
+    auto methodName = calledMethods[0].methodName();
+    QCOMPARE(QString("lockFileName"), methodName);
+    methodName = calledMethods[1].methodName();
+    QCOMPARE(QString("unlockFileName"), methodName);
+}
+
+void
+TestDownload::testCancelUnlocksPath() {
+    _fileNameMutex->record();
+    QScopedPointer<FileDownload> download(new FileDownload(_id, _path,
+        _isConfined, _rootPath, _url, _metadata, _headers));
+    QSignalSpy spy(download.data(),
+        SIGNAL(canceled(bool)));  // NOLINT(readability/function)
+
+    download->start();  // change state
+    download->startDownload();
+    download->cancel();  // change state
+    download->cancelDownload();  // method under test
+
+    // assert that the filename was correctly managed
+    auto calledMethods = _fileNameMutex->calledMethods();
+    QCOMPARE(2, calledMethods.count());
+    auto methodName = calledMethods[0].methodName();
+    QCOMPARE(QString("lockFileName"), methodName);
+    methodName = calledMethods[1].methodName();
+    QCOMPARE(QString("unlockFileName"), methodName);
+}
+
+void
+TestDownload::testFinishUnlocksPath() {
+    _fileNameMutex->record();
+    _reqFactory->record();
+    QScopedPointer<FileDownload> download(new FileDownload(_id, _path, _isConfined,
+        _rootPath, _url, _metadata, _headers));
+    QSignalSpy spy(download.data(), SIGNAL(finished(QString)));
+
+    download->start();  // change state
+    download->startDownload();
+
+    QList<MethodData> calledMethods = _reqFactory->calledMethods();
+    QCOMPARE(1, calledMethods.count());
+    FakeNetworkReply* reply = reinterpret_cast<FakeNetworkReply*>(
+        calledMethods[0].params().outParams()[0]);
+
+    // emit the finish signal and expect it to be raised
+    emit reply->finished();
+    QCOMPARE(spy.count(), 1);
+    QCOMPARE(download->state(), Download::FINISH);
+
+    calledMethods = _fileNameMutex->calledMethods();
+    QCOMPARE(2, calledMethods.count());
+    auto methodName = calledMethods[0].methodName();
+    QCOMPARE(QString("lockFileName"), methodName);
+    methodName = calledMethods[1].methodName();
+    QCOMPARE(QString("unlockFileName"), methodName);
+}
+
+void
+TestDownload::testProcessFinishUnlocksPath() {
+    _fileNameMutex->record();
+    _processFactory->record();
+    _reqFactory->record();
+
+    QString command = "cd";
+    QVariantMap metadata;
+    metadata["post-download-command"] = command;
+
+    QScopedPointer<FileDownload> download(new FileDownload(_id, _path,
+        _isConfined, _rootPath, _url, metadata, _headers));
+    QSignalSpy spy(download.data(), SIGNAL(finished(QString)));
+
+    download->start();  // change state
+    download->startDownload();
+
+    // we need to set the data before we pause!!!
+    QList<MethodData> calledMethods = _reqFactory->calledMethods();
+    QCOMPARE(1, calledMethods.count());
+    FakeNetworkReply* reply = reinterpret_cast<FakeNetworkReply*>(
+        calledMethods[0].params().outParams()[0]);
+
+    // makes the process to be executed
+    reply->emitFinished();
+
+    calledMethods = _processFactory->calledMethods();
+    QCOMPARE(1, calledMethods.count());
+    FakeProcess* process = reinterpret_cast<FakeProcess*>(
+        calledMethods[0].params().outParams()[0]);
+
+    process->emitFinished(0, QProcess::NormalExit);
+    QTRY_COMPARE(spy.count(), 1);
+
+    calledMethods = _fileNameMutex->calledMethods();
+    QCOMPARE(2, calledMethods.count());
+    auto methodName = calledMethods[0].methodName();
+    QCOMPARE(QString("lockFileName"), methodName);
+    methodName = calledMethods[1].methodName();
+    QCOMPARE(QString("unlockFileName"), methodName);
+}
+
+void
+TestDownload::testErrorUnlocksPath() {
+    // fake an error and make sure that unlock is called
+    _fileNameMutex->record();
+    _reqFactory->record();
+    QScopedPointer<FileDownload> download(new FileDownload(_id, _path,
+        _isConfined, _rootPath, _url, _metadata, _headers));
+    QSignalSpy errorSpy(download.data(), SIGNAL(error(QString)));
+
+    download->start();  // change state
+    download->startDownload();
+
+    // we need to set the data before we pause!!!
+    QList<MethodData> calledMethods = _reqFactory->calledMethods();
+    QCOMPARE(1, calledMethods.count());
+    FakeNetworkReply* reply = reinterpret_cast<FakeNetworkReply*>(
+        calledMethods[0].params().outParams()[0]);
+
+    // set the attrs in the reply so that we do raise two signals
+    reply->setAttribute(QNetworkRequest::HttpStatusCodeAttribute, 404);
+    reply->setAttribute(QNetworkRequest::HttpReasonPhraseAttribute, "");
+
+    // emit the error and esure that the signals are raised
+    reply->emitHttpError(QNetworkReply::ContentAccessDenied);
+    QCOMPARE(errorSpy.count(), 1);
+
+    calledMethods = _fileNameMutex->calledMethods();
+    QCOMPARE(2, calledMethods.count());
+    auto methodName = calledMethods[0].methodName();
+    QCOMPARE(QString("lockFileName"), methodName);
+    methodName = calledMethods[1].methodName();
+    QCOMPARE(QString("unlockFileName"), methodName);
+}

=== modified file 'ubuntu-download-manager-tests/downloads/test_download.h'
--- ubuntu-download-manager-tests/downloads/test_download.h	2014-02-11 15:35:52 +0000
+++ ubuntu-download-manager-tests/downloads/test_download.h	2014-02-22 10:42:10 +0000
@@ -24,6 +24,7 @@
 #include <downloads/file_download.h>
 #include <ubuntu/download_manager/metatypes.h>
 #include <ubuntu/download_manager/tests/server/file_manager.h>
+#include <ubuntu/download_manager/tests/server/filename_mutex.h>
 #include <ubuntu/download_manager/tests/server/system_network_info.h>
 #include <ubuntu/download_manager/tests/server/request_factory.h>
 #include <ubuntu/download_manager/tests/server/process_factory.h>
@@ -162,6 +163,13 @@
     void testSeveralRedirects_data();
     void testSeveralRedirects();
 
+    // test lock of files
+    void testRedirectDoesNotUnlockPath();
+    void testCancelUnlocksPath();
+    void testFinishUnlocksPath();
+    void testProcessFinishUnlocksPath();
+    void testErrorUnlocksPath();
+
  private:
     QString _id;
     bool _isConfined;
@@ -175,6 +183,7 @@
     FakeRequestFactory* _reqFactory;
     FakeProcessFactory* _processFactory;
     FakeFileManager* _fileManager;
+    FakeFileNameMutex* _fileNameMutex;
 };
 
 Q_DECLARE_METATYPE(QNetworkInfo::NetworkMode)

=== modified file 'ubuntu-download-manager-tests/downloads/test_downloads_db.cpp'
--- ubuntu-download-manager-tests/downloads/test_downloads_db.cpp	2014-02-10 09:54:01 +0000
+++ ubuntu-download-manager-tests/downloads/test_downloads_db.cpp	2014-02-22 10:42:10 +0000
@@ -47,6 +47,8 @@
 void
 TestDownloadsDb::init() {
     BaseTestCase::init();
+    _fileNameMutex = new FakeFileNameMutex();
+    FileNameMutex::setInstance(_fileNameMutex);
     _db = DownloadsDb::instance();
 }
 
@@ -62,6 +64,7 @@
     QFile::remove(dbFile);
     SystemNetworkInfo::deleteInstance();
     FileManager::deleteInstance();
+    FileNameMutex::deleteInstance();
 }
 
 void
@@ -244,8 +247,8 @@
 
     // create a second download with same id but a diff path to test is update
     QString newPath = path + path;
-    QScopedPointer<FakeDownload> secondDownload(new FakeDownload(id, newPath, true, "",
-        url, hash, hashAlgoString, metadata, headers));
+    QScopedPointer<FakeDownload> secondDownload(new FakeDownload(id,
+        newPath, true, "", url, hash, hashAlgoString, metadata, headers));
 
     _db->storeSingleDownload(secondDownload.data());
 
@@ -263,9 +266,6 @@
         QString dbDbusPath = query.value(1).toString();
         QCOMPARE(newPath, dbDbusPath);
 
-        QString dbLocalPath = query.value(2).toString();
-        QCOMPARE(dbLocalPath, download->filePath());
-
         QString dbHash = query.value(3).toString();
         QCOMPARE(hash, dbHash);
 

=== modified file 'ubuntu-download-manager-tests/downloads/test_downloads_db.h'
--- ubuntu-download-manager-tests/downloads/test_downloads_db.h	2014-02-10 09:51:58 +0000
+++ ubuntu-download-manager-tests/downloads/test_downloads_db.h	2014-02-22 10:42:10 +0000
@@ -24,6 +24,7 @@
 #include <downloads/downloads_db.h>
 #include <ubuntu/download_manager/tests/base_testcase.h>
 #include <ubuntu/download_manager/tests/test_runner.h>
+#include <ubuntu/download_manager/tests/server/filename_mutex.h>
 
 using namespace Ubuntu::DownloadManager::Daemon;
 
@@ -68,6 +69,7 @@
 
  private:
     DownloadsDb* _db;
+    FakeFileNameMutex* _fileNameMutex;
 };
 
 DECLARE_TEST(TestDownloadsDb)

=== modified file 'ubuntu-download-manager-tests/downloads/test_group_download.cpp'
--- ubuntu-download-manager-tests/downloads/test_group_download.cpp	2014-02-13 13:21:14 +0000
+++ ubuntu-download-manager-tests/downloads/test_group_download.cpp	2014-02-22 10:42:10 +0000
@@ -20,6 +20,7 @@
 #include <QSignalSpy>
 #include <downloads/group_download.h>
 #include <system/uuid_utils.h>
+#include <ubuntu/download_manager/metadata.h>
 #include <ubuntu/download_manager/tests/server/download.h>
 #include <ubuntu/download_manager/tests/server/group_download.h>
 #include "test_group_download.h"
@@ -667,18 +668,18 @@
 
     // assert that each metadata has the local file set
     QVariantMap downMeta = downloads[0]->metadata();
-    QVERIFY(downMeta.contains(LOCAL_PATH_KEY));
-    QCOMPARE(downMeta[LOCAL_PATH_KEY].toString(),
+    QVERIFY(downMeta.contains(Metadata::LOCAL_PATH_KEY));
+    QCOMPARE(downMeta[Metadata::LOCAL_PATH_KEY].toString(),
         downloadsStruct[0].getLocalFile());
 
     downMeta = downloads[1]->metadata();
-    QVERIFY(downMeta.contains(LOCAL_PATH_KEY));
-    QCOMPARE(downMeta[LOCAL_PATH_KEY].toString(),
+    QVERIFY(downMeta.contains(Metadata::LOCAL_PATH_KEY));
+    QCOMPARE(downMeta[Metadata::LOCAL_PATH_KEY].toString(),
         downloadsStruct[1].getLocalFile());
 
     downMeta = downloads[2]->metadata();
-    QVERIFY(downMeta.contains(LOCAL_PATH_KEY));
-    QCOMPARE(downMeta[LOCAL_PATH_KEY].toString(),
+    QVERIFY(downMeta.contains(Metadata::LOCAL_PATH_KEY));
+    QCOMPARE(downMeta[Metadata::LOCAL_PATH_KEY].toString(),
         downloadsStruct[2].getLocalFile());
 }
 

=== added file 'ubuntu-download-manager-tests/system/test_filename_mutex.cpp'
--- ubuntu-download-manager-tests/system/test_filename_mutex.cpp	1970-01-01 00:00:00 +0000
+++ ubuntu-download-manager-tests/system/test_filename_mutex.cpp	2014-02-22 10:42:10 +0000
@@ -0,0 +1,108 @@
+/*
+ * Copyright 2014 Canonical Ltd.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of version 3 of the GNU Lesser General Public
+ * License as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#include <QByteArray>
+#include <QDir>
+#include <QFile>
+#include <QScopedPointer>
+#include <system/filename_mutex.h>
+#include "test_filename_mutex.h"
+
+using namespace Ubuntu::DownloadManager::System;
+
+TestFileNameMutex::TestFileNameMutex(QObject *parent)
+    : BaseTestCase("TestFileNameMutex", parent) {
+}
+
+void
+TestFileNameMutex::testExpectedNameValid_data() {
+    QTest::addColumn<QString>("path");
+    auto dir = testDirectory();
+
+    QTest::newRow("First path") << dir + QDir::separator() + "first.zip";
+    QTest::newRow("Second path") << dir + QDir::separator() + "second.zip";
+    QTest::newRow("Last path") << dir + QDir::separator() + "last.zip";
+}
+
+void
+TestFileNameMutex::testExpectedNameValid() {
+    QFETCH(QString, path);
+
+    QScopedPointer<FileNameMutex> mutex(new FileNameMutex());
+    auto locked = mutex->lockFileName(path);
+    QCOMPARE(path, locked);
+    QVERIFY(mutex->isLocked(path));
+}
+
+void
+TestFileNameMutex::testExpectedNameLocked_data() {
+    QTest::addColumn<QString>("path");
+    auto dir = testDirectory();
+
+    QTest::newRow("First path") << dir + QDir::separator() + "first.zip";
+    QTest::newRow("Second path") << dir + QDir::separator() + "second.zip";
+    QTest::newRow("Last path") << dir + QDir::separator() + "last.zip";
+}
+
+void
+TestFileNameMutex::testExpectedNameLocked() {
+    QFETCH(QString, path);
+
+    QScopedPointer<FileNameMutex> mutex(new FileNameMutex());
+    mutex->lockFileName(path);  // ensure that we already locked the path
+    auto locked = mutex->lockFileName(path);
+    QVERIFY(path != locked);
+    QVERIFY(mutex->isLocked(locked));
+}
+
+void
+TestFileNameMutex::testExpectedNameInFileSystem_data() {
+    QTest::addColumn<QString>("path");
+    auto dir = testDirectory();
+
+    QTest::newRow("First path") << dir + QDir::separator() + "first.zip";
+    QTest::newRow("Second path") << dir + QDir::separator() + "second_zip";
+    QTest::newRow("Last path") << dir + QDir::separator() + "last_zip";
+}
+
+void
+TestFileNameMutex::testExpectedNameInFileSystem() {
+    QFETCH(QString, path);
+    testDirectory();  // build temp dir
+    QScopedPointer<FileNameMutex> mutex(new FileNameMutex());
+
+    QFile file(path);
+    file.open(QIODevice::ReadWrite | QFile::Append);
+    file.write(QByteArray(400, 'f'));
+    file.flush();
+    file.close();
+
+    auto locked = mutex->lockFileName(path);
+    QVERIFY(path != locked);
+    QVERIFY(!mutex->isLocked(path));
+}
+
+void
+TestFileNameMutex::testUnlockPresent() {
+    auto path = testDirectory() + QDir::separator() + "test.txt";
+    QScopedPointer<FileNameMutex> mutex(new FileNameMutex());
+    auto locked = mutex->lockFileName(path);
+    QVERIFY(mutex->isLocked(locked));
+    mutex->unlockFileName(path);
+    QVERIFY(!mutex->isLocked(locked));
+}

=== added file 'ubuntu-download-manager-tests/system/test_filename_mutex.h'
--- ubuntu-download-manager-tests/system/test_filename_mutex.h	1970-01-01 00:00:00 +0000
+++ ubuntu-download-manager-tests/system/test_filename_mutex.h	2014-02-22 10:42:10 +0000
@@ -0,0 +1,45 @@
+/*
+ * Copyright 2014 Canonical Ltd.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of version 3 of the GNU Lesser General Public
+ * License as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#ifndef TEST_FILENAME_MUTEX_H
+#define TEST_FILENAME_MUTEX_H
+
+#include <QObject>
+#include <ubuntu/download_manager/tests/base_testcase.h>
+#include <ubuntu/download_manager/tests/test_runner.h>
+
+class TestFileNameMutex : public BaseTestCase {
+    Q_OBJECT
+
+ public:
+    explicit TestFileNameMutex(QObject *parent = 0);
+
+ private slots:  // NOLINT(whitespace/indent)
+
+    void testExpectedNameValid_data();
+    void testExpectedNameValid();
+    void testExpectedNameLocked_data();
+    void testExpectedNameLocked();
+    void testExpectedNameInFileSystem_data();
+    void testExpectedNameInFileSystem();
+    void testUnlockPresent();
+};
+
+DECLARE_TEST(TestFileNameMutex)
+
+#endif // TEST_FILENAME_MUTEX_H

=== modified file 'ubuntu-download-manager-tests/ubuntu-download-manager-tests.pro'
--- ubuntu-download-manager-tests/ubuntu-download-manager-tests.pro	2014-02-03 17:50:07 +0000
+++ ubuntu-download-manager-tests/ubuntu-download-manager-tests.pro	2014-02-22 10:42:10 +0000
@@ -28,7 +28,8 @@
     downloads/state_machines/test_file_download_sm.cpp \
     system/test_apn_request_factory.cpp \
     downloads/test_mms_download.cpp \
-    downloads/test_base_download.cpp
+    downloads/test_base_download.cpp \
+    system/test_filename_mutex.cpp
 
 HEADERS += \
     downloads/test_download.h \
@@ -48,7 +49,8 @@
     downloads/state_machines/test_file_download_sm.h \
     system/test_apn_request_factory.h \
     downloads/test_mms_download.h \
-    downloads/test_base_download.h
+    downloads/test_base_download.h \
+    system/test_filename_mutex.h
 
 
 exists ($$OUT_PWD/data){