Storage Framework

Merge lp:~michihenning/storage-framework/create-file into lp:storage-framework/devel

create-file
Merge into devel

Proposed by Michi Henning on 2016-10-13

Status:	Merged
Approved by:	James Henstridge on 2016-10-17
Approved revision:	112
Merged at revision:	81
Proposed branch:	lp:~michihenning/storage-framework/create-file
Merge into:	lp:storage-framework/devel
Diff against target:	534 lines (+364/-15) 7 files modified include/unity/storage/qt/Item.h (+4/-1) include/unity/storage/qt/internal/ItemImpl.h (+4/-0) src/qt/Item.cpp (+5/-2) src/qt/internal/ItemImpl.cpp (+45/-5) src/qt/internal/UploaderImpl.cpp (+1/-1) tests/remote-client/MockProvider.cpp (+7/-2) tests/remote-client/remote-client_test.cpp (+298/-4)
To merge this branch:	bzr merge lp:~michihenning/storage-framework/create-file
Related bugs:	Link a bug report

Reviewer	Review Type	Date Requested	Status
James Henstridge		2016-10-13	Approve on 2016-10-17
unity-api-1-bot	continuous-integration		Approve on 2016-10-17
Review via email: mp+308342@code.launchpad.net

Commit message

Added createFile().

Description of the change

Added createFile().

Revision history for this message

unity-api-1-bot (unity-api-1-bot) wrote on 2016-10-13:

Click here to trigger a rebuild:
https://jenkins.canonical.com/unity-api-1/job/lp-storage-framework-ci/155/rebuild

review: Approve (continuous-integration)

lp:~michihenning/storage-framework/create-file updated on 2016-10-17

112. By Michi Henning on 2016-10-17: Check policy for exists error.

Revision history for this message

unity-api-1-bot (unity-api-1-bot) wrote on 2016-10-17:

Click here to trigger a rebuild:
https://jenkins.canonical.com/unity-api-1/job/lp-storage-framework-ci/156/rebuild

review: Approve (continuous-integration)

Revision history for this message

unity-api-1-bot (unity-api-1-bot) wrote on 2016-10-17:

Click here to trigger a rebuild:
https://jenkins.canonical.com/unity-api-1/job/lp-storage-framework-ci/157/rebuild

review: Approve (continuous-integration)

Revision history for this message

James Henstridge (jamesh) wrote on 2016-10-17:

Looks good!

review: Approve

Preview Diff

[H/L] Next/Prev Comment, [J/K] Next/Prev File, [N/P] Next/Prev Hunk

Subscribers

People subscribed via source and target branches

to all changes:

Michi Henning

 === modified file 'include/unity/storage/qt/Item.h'
 --- include/unity/storage/qt/Item.h	2016-10-12 05:25:20 +0000
 +++ include/unity/storage/qt/Item.h	2016-10-17 13:01:35 +0000
@@ -108,7 +108,10 @@
      Q_INVOKABLE ItemListJob* list() const;
      Q_INVOKABLE ItemListJob* lookup(QString const& name) const;
      Q_INVOKABLE ItemJob* createFolder(QString const& name) const;
--    Q_INVOKABLE Uploader* createFile(QString const& name) const;
++    Q_INVOKABLE Uploader* createFile(QString const& name,
++                                     ConflictPolicy policy,
++                                     qint64 sizeInBytes,
++                                     QString const& contentType) const;
      Q_INVOKABLE IntJob* freeSpaceBytes() const;
      Q_INVOKABLE IntJob* usedSpaceBytes() const;
 === modified file 'include/unity/storage/qt/internal/ItemImpl.h'
 --- include/unity/storage/qt/internal/ItemImpl.h	2016-10-12 05:25:20 +0000
 +++ include/unity/storage/qt/internal/ItemImpl.h	2016-10-17 13:01:35 +0000
@@ -68,6 +68,10 @@
      ItemListJob* lookup(QString const& name) const;
      ItemJob* createFolder(QString const& name) const;
      Uploader* createFile(QString const& name) const;
++    Uploader* createFile(QString const& name,
++                         Item::ConflictPolicy policy,
++                         qint64 sizeInBytes,
++                         QString const& contentType) const;
      IntJob* freeSpaceBytes() const;
      IntJob* usedSpaceBytes() const;
 === modified file 'src/qt/Item.cpp'
 --- src/qt/Item.cpp	2016-10-10 06:27:12 +0000
 +++ src/qt/Item.cpp	2016-10-17 13:01:35 +0000
@@ -162,9 +162,12 @@
      return p_->createFolder(name);
+ }
--Uploader* Item::createFile(QString const& name) const
++Uploader* Item::createFile(QString const& name,
++                           ConflictPolicy policy,
++                           qint64 sizeInBytes,
++                           QString const& contentType) const
+ {
--    return p_->createFile(name);
++    return p_->createFile(name, policy, sizeInBytes, contentType);
+ }
  IntJob* Item::freeSpaceBytes() const
 === modified file 'src/qt/internal/ItemImpl.cpp'
 --- src/qt/internal/ItemImpl.cpp	2016-10-13 06:48:11 +0000
 +++ src/qt/internal/ItemImpl.cpp	2016-10-17 13:01:35 +0000
@@ -243,7 +243,7 @@
+     }
      if (md_.type != storage::ItemType::file)
+     {
--        auto e = StorageErrorImpl::logic_error(method + ": cannot upload to a directory");
++        auto e = StorageErrorImpl::logic_error(method + ": cannot upload to a folder");
          return UploaderImpl::make_job(e);
+     }
      if (sizeInBytes < 0)
@@ -256,7 +256,7 @@
+     {
          if (md.type != storage::ItemType::file)
+         {
--            QString msg = method + ": impossible directory item returned by provider";
++            QString msg = method + ": impossible folder item returned by provider";
              qCritical().noquote() << msg;
              throw StorageErrorImpl::local_comms_error(msg);
+         }
@@ -279,7 +279,7 @@
+     }
      if (md_.type != storage::ItemType::file)
+     {
--        auto e = StorageErrorImpl::logic_error(method + ": cannot download a directory");
++        auto e = StorageErrorImpl::logic_error(method + ": cannot download a folder");
          return DownloaderImpl::make_job(e);
+     }
@@ -378,9 +378,49 @@
      return ItemJobImpl::make_job(This, method, reply, validate);
+ }
--Uploader* ItemImpl::createFile(QString const& name) const
++Uploader* ItemImpl::createFile(QString const& name,
++                               Item::ConflictPolicy policy,
++                               qint64 sizeInBytes,
++                               QString const& contentType) const
+ {
--    return nullptr;  // TODO
++    QString const method = "Item::createFile()";
++
++    auto invalid_job = check_invalid_or_destroyed<UploaderImpl>(method);
++    if (invalid_job)
++    {
++        return invalid_job;
++    }
++    if (md_.type == storage::ItemType::file)
++    {
++        auto e = StorageErrorImpl::logic_error(method + ": cannot create a file with a file as the parent");
++        return UploaderImpl::make_job(e);
++    }
++    if (sizeInBytes < 0)
++    {
++        auto e = StorageErrorImpl::invalid_argument_error(method + ": size must be >= 0");
++        return UploaderImpl::make_job(e);
++    }
++    if (name.isEmpty())
++    {
++        auto e = StorageErrorImpl::invalid_argument_error(method + ": name cannot be empty");
++        return UploaderImpl::make_job(e);
++    }
++    // contentType can be empty, so not checked here.
++
++    auto validate = [method](storage::internal::ItemMetadata const& md)
++    {
++        if (md.type != storage::ItemType::file)
++        {
++            QString msg = method + ": impossible folder item returned by provider";
++            qCritical().noquote() << msg;
++            throw StorageErrorImpl::local_comms_error(msg);
++        }
++    };
++
++    bool allow_overwrite = policy == Item::ConflictPolicy::Overwrite;
++    auto reply = account_impl_->provider()->CreateFile(md_.item_id, name, sizeInBytes, contentType, allow_overwrite);
++    auto This = const_pointer_cast<ItemImpl>(shared_from_this());
++    return UploaderImpl::make_job(This, method, reply, validate, policy, sizeInBytes);
+ }
  IntJob* ItemImpl::freeSpaceBytes() const
 === modified file 'src/qt/internal/UploaderImpl.cpp'
 --- src/qt/internal/UploaderImpl.cpp	2016-10-13 06:48:11 +0000
 +++ src/qt/internal/UploaderImpl.cpp	2016-10-17 13:01:35 +0000
@@ -158,7 +158,7 @@
  Item UploaderImpl::item() const
+ {
--    if (status_ == Uploader::Status::Error || status_ == Uploader::Status::Cancelled)
++    if (status_ != Uploader::Status::Finished)
+     {
          return Item();
+     }
 === modified file 'tests/remote-client/MockProvider.cpp'
 --- tests/remote-client/MockProvider.cpp	2016-10-13 06:48:11 +0000
 +++ tests/remote-client/MockProvider.cpp	2016-10-17 13:01:35 +0000
@@ -262,7 +262,7 @@
      string const&, string const&,
      int64_t, string const&, bool, Context const&)
+ {
--    return make_ready_future<unique_ptr<UploadJob>>(new MockUploadJob());
++    return make_ready_future<unique_ptr<UploadJob>>(new MockUploadJob(cmd_));
+ }
  boost::future<unique_ptr<UploadJob>> MockProvider::update(
@@ -403,6 +403,11 @@
+     {
          return make_exceptional_future<Item>(ResourceException("out of memory", 99));
+     }
++    if (cmd_ == "create_file_exists")
++    {
++        ExistsException e("file exists", "child_id", "Child");
++        return make_exceptional_future<Item>(e);
++    }
      if (cmd_ == "upload_returns_dir")
+     {
          Item metadata{"some_id", { "root_id" }, "some_upload", "etag", ItemType::folder, {}};
@@ -410,7 +415,7 @@
+     }
      Item metadata
+     {
--        "some_id", { "root_id" }, "some_upload", "etag", ItemType::file,
++        "child_id", { "root_id" }, "some_upload", "etag", ItemType::file,
          { { SIZE_IN_BYTES, 10 }, { LAST_MODIFIED_TIME, "2011-04-05T14:30:10.005Z" } }
      };
      return make_ready_future(metadata);
 === modified file 'tests/remote-client/remote-client_test.cpp'
 --- tests/remote-client/remote-client_test.cpp	2016-10-13 06:48:11 +0000
 +++ tests/remote-client/remote-client_test.cpp	2016-10-17 13:01:35 +0000
@@ -58,6 +58,7 @@
  class AccountTest : public RemoteClientTest {};
  class CopyTest : public RemoteClientTest {};
++class CreateFileTest : public RemoteClientTest {};
  class CreateFolderTest : public RemoteClientTest {};
  class DeleteTest : public RemoteClientTest {};
  class DownloadTest : public RemoteClientTest {};
@@ -2691,7 +2692,7 @@
      EXPECT_FALSE(downloader->isValid());
      EXPECT_EQ(Downloader::Status::Error, downloader->status());
      EXPECT_EQ(StorageError::Type::LogicError, downloader->error().type());
--    EXPECT_EQ("Item::createDownloader(): cannot download a directory", downloader->error().message());
++    EXPECT_EQ("Item::createDownloader(): cannot download a folder", downloader->error().message());
+     {
          QSignalSpy spy(downloader.get(), &Downloader::statusChanged);
@@ -2826,7 +2827,7 @@
      EXPECT_TRUE(uploader->isValid());
      EXPECT_EQ(Uploader::Status::Loading, uploader->status());
      EXPECT_EQ(StorageError::NoError, uploader->error().type());
--    EXPECT_EQ(child, uploader->item());
++    EXPECT_EQ(Item(), uploader->item());
      EXPECT_EQ(Item::ConflictPolicy::Overwrite, uploader->policy());
      EXPECT_EQ(contents.size(), uploader->sizeInBytes());
@@ -2846,6 +2847,7 @@
      EXPECT_EQ(Uploader::Status::Finished, qvariant_cast<Uploader::Status>(arg.at(0)));
      EXPECT_EQ(Uploader::Status::Finished, uploader->status());
++    EXPECT_EQ(child, uploader->item());
+ }
  TEST_F(UploadTest, abandoned)
@@ -3237,7 +3239,7 @@
      EXPECT_FALSE(uploader->isValid());
      EXPECT_EQ(Uploader::Status::Error, uploader->status());
      EXPECT_EQ(StorageError::Type::LogicError, uploader->error().type());
--    EXPECT_EQ("Item::createUploader(): cannot upload to a directory", uploader->error().message());
++    EXPECT_EQ("Item::createUploader(): cannot upload to a folder", uploader->error().message());
+     {
          QSignalSpy spy(uploader.get(), &Uploader::statusChanged);
@@ -3319,7 +3321,7 @@
      EXPECT_EQ(Uploader::Status::Error, uploader->status());
      EXPECT_EQ(StorageError::Type::LocalCommsError, uploader->error().type());
--    EXPECT_EQ("Item::createUploader(): impossible directory item returned by provider", uploader->error().message());
++    EXPECT_EQ("Item::createUploader(): impossible folder item returned by provider", uploader->error().message());
+ }
  TEST_F(UploadTest, cancel_success)
@@ -3467,6 +3469,298 @@
      EXPECT_EQ("Uploader::cancel(): Runtime was destroyed previously", uploader->error().message());
+ }
++TEST_F(CreateFileTest, basic)
++{
++    set_provider(unique_ptr<provider::ProviderBase>(new MockProvider()));
++
++    Item root;
++    {
++        unique_ptr<ItemJob> j(acc_.get("root_id"));
++        QSignalSpy spy(j.get(), &ItemJob::statusChanged);
++        spy.wait(SIGNAL_WAIT_TIME);
++        root = j->item();
++    }
++
++    Item child;
++    {
++        unique_ptr<ItemJob> j(acc_.get("child_id"));
++        QSignalSpy spy(j.get(), &ItemJob::statusChanged);
++        spy.wait(SIGNAL_WAIT_TIME);
++        child = j->item();
++    }
++
++    QByteArray contents("Hello world", -1);
++    unique_ptr<Uploader> uploader(root.createFile("Child",
++                                                  Item::ConflictPolicy::Overwrite,
++                                                  contents.size(),
++                                                  ""));
++    EXPECT_TRUE(uploader->isValid());
++    EXPECT_EQ(Uploader::Status::Loading, uploader->status());
++    EXPECT_EQ(StorageError::NoError, uploader->error().type());
++    EXPECT_EQ(Item(), uploader->item());
++    EXPECT_EQ(Item::ConflictPolicy::Overwrite, uploader->policy());
++    EXPECT_EQ(contents.size(), uploader->sizeInBytes());
++
++    {
++        QSignalSpy spy(uploader.get(), &Uploader::statusChanged);
++        ASSERT_TRUE(spy.wait(SIGNAL_WAIT_TIME));
++        auto arg = spy.takeFirst();
++        EXPECT_EQ(Uploader::Status::Ready, qvariant_cast<Uploader::Status>(arg.at(0)));
++    }
++
++    EXPECT_EQ(contents.size(), uploader->write(contents));
++
++    QSignalSpy spy(uploader.get(), &Uploader::statusChanged);
++    uploader->finishUpload();
++    ASSERT_TRUE(spy.wait(SIGNAL_WAIT_TIME));
++    auto arg = spy.takeFirst();
++    EXPECT_EQ(Uploader::Status::Finished, qvariant_cast<Uploader::Status>(arg.at(0)));
++
++    EXPECT_EQ(Uploader::Status::Finished, uploader->status());
++    EXPECT_EQ(child, uploader->item());
++}
++
++TEST_F(CreateFileTest, runtime_destroyed)
++{
++    set_provider(unique_ptr<provider::ProviderBase>(new MockProvider()));
++
++    Item root;
++    {
++        unique_ptr<ItemJob> j(acc_.get("root_id"));
++        QSignalSpy spy(j.get(), &ItemJob::statusChanged);
++        spy.wait(SIGNAL_WAIT_TIME);
++        root = j->item();
++    }
++
++    Item child;
++    {
++        unique_ptr<ItemJob> j(acc_.get("child_id"));
++        QSignalSpy spy(j.get(), &ItemJob::statusChanged);
++        spy.wait(SIGNAL_WAIT_TIME);
++        child = j->item();
++    }
++
++    EXPECT_EQ(StorageError::Type::NoError, runtime_->shutdown().type());  // Destroy runtime
++
++    QByteArray contents("Hello world", -1);
++    unique_ptr<Uploader> uploader(root.createFile("Child",
++                                                  Item::ConflictPolicy::Overwrite,
++                                                  contents.size(),
++                                                  ""));
++    EXPECT_FALSE(uploader->isValid());
++    EXPECT_EQ(Uploader::Status::Error, uploader->status());
++    EXPECT_EQ(StorageError::Type::RuntimeDestroyed, uploader->error().type());
++    EXPECT_EQ("Item::createFile(): Runtime was destroyed previously", uploader->error().message());
++
++    // Signal must be received.
++    QSignalSpy spy(uploader.get(), &Uploader::statusChanged);
++    spy.wait(SIGNAL_WAIT_TIME);
++    ASSERT_EQ(1, spy.count());
++    auto arg = spy.takeFirst();
++    EXPECT_EQ(Uploader::Status::Error, qvariant_cast<Uploader::Status>(arg.at(0)));
++}
++
++TEST_F(CreateFileTest, wrong_type)
++{
++    set_provider(unique_ptr<provider::ProviderBase>(new MockProvider()));
++
++    Item root;
++    {
++        unique_ptr<ItemJob> j(acc_.get("root_id"));
++        QSignalSpy spy(j.get(), &ItemJob::statusChanged);
++        spy.wait(SIGNAL_WAIT_TIME);
++        root = j->item();
++    }
++
++    Item child;
++    {
++        unique_ptr<ItemJob> j(acc_.get("child_id"));
++        QSignalSpy spy(j.get(), &ItemJob::statusChanged);
++        spy.wait(SIGNAL_WAIT_TIME);
++        child = j->item();
++    }
++
++    QByteArray contents("Hello world", -1);
++    unique_ptr<Uploader> uploader(child.createFile("somefile",
++                                                   Item::ConflictPolicy::Overwrite,
++                                                   contents.size(),
++                                                   ""));
++    EXPECT_FALSE(uploader->isValid());
++    EXPECT_EQ(Uploader::Status::Error, uploader->status());
++    EXPECT_EQ(StorageError::Type::LogicError, uploader->error().type());
++    EXPECT_EQ("Item::createFile(): cannot create a file with a file as the parent", uploader->error().message());
++
++    // Signal must be received.
++    QSignalSpy spy(uploader.get(), &Uploader::statusChanged);
++    spy.wait(SIGNAL_WAIT_TIME);
++    ASSERT_EQ(1, spy.count());
++    auto arg = spy.takeFirst();
++    EXPECT_EQ(Uploader::Status::Error, qvariant_cast<Uploader::Status>(arg.at(0)));
++}
++
++TEST_F(CreateFileTest, bad_name)
++{
++    set_provider(unique_ptr<provider::ProviderBase>(new MockProvider()));
++
++    Item root;
++    {
++        unique_ptr<ItemJob> j(acc_.get("root_id"));
++        QSignalSpy spy(j.get(), &ItemJob::statusChanged);
++        spy.wait(SIGNAL_WAIT_TIME);
++        root = j->item();
++    }
++
++    Item child;
++    {
++        unique_ptr<ItemJob> j(acc_.get("child_id"));
++        QSignalSpy spy(j.get(), &ItemJob::statusChanged);
++        spy.wait(SIGNAL_WAIT_TIME);
++        child = j->item();
++    }
++
++    QByteArray contents("Hello world", -1);
++    unique_ptr<Uploader> uploader(root.createFile("",
++                                                   Item::ConflictPolicy::Overwrite,
++                                                   contents.size(),
++                                                   ""));
++    EXPECT_FALSE(uploader->isValid());
++    EXPECT_EQ(Uploader::Status::Error, uploader->status());
++    EXPECT_EQ(StorageError::Type::InvalidArgument, uploader->error().type());
++    EXPECT_EQ("Item::createFile(): name cannot be empty", uploader->error().message());
++
++    // Signal must be received.
++    QSignalSpy spy(uploader.get(), &Uploader::statusChanged);
++    spy.wait(SIGNAL_WAIT_TIME);
++    ASSERT_EQ(1, spy.count());
++    auto arg = spy.takeFirst();
++    EXPECT_EQ(Uploader::Status::Error, qvariant_cast<Uploader::Status>(arg.at(0)));
++}
++
++TEST_F(CreateFileTest, bad_size)
++{
++    set_provider(unique_ptr<provider::ProviderBase>(new MockProvider()));
++
++    Item root;
++    {
++        unique_ptr<ItemJob> j(acc_.get("root_id"));
++        QSignalSpy spy(j.get(), &ItemJob::statusChanged);
++        spy.wait(SIGNAL_WAIT_TIME);
++        root = j->item();
++    }
++
++    Item child;
++    {
++        unique_ptr<ItemJob> j(acc_.get("child_id"));
++        QSignalSpy spy(j.get(), &ItemJob::statusChanged);
++        spy.wait(SIGNAL_WAIT_TIME);
++        child = j->item();
++    }
++
++    QByteArray contents("Hello world", -1);
++    unique_ptr<Uploader> uploader(root.createFile("some_file",
++                                                   Item::ConflictPolicy::Overwrite,
++                                                   -1,
++                                                   ""));
++    EXPECT_FALSE(uploader->isValid());
++    EXPECT_EQ(Uploader::Status::Error, uploader->status());
++    EXPECT_EQ(StorageError::Type::InvalidArgument, uploader->error().type());
++    EXPECT_EQ("Item::createFile(): size must be >= 0", uploader->error().message());
++
++    // Signal must be received.
++    QSignalSpy spy(uploader.get(), &Uploader::statusChanged);
++    spy.wait(SIGNAL_WAIT_TIME);
++    ASSERT_EQ(1, spy.count());
++    auto arg = spy.takeFirst();
++    EXPECT_EQ(Uploader::Status::Error, qvariant_cast<Uploader::Status>(arg.at(0)));
++}
++
++TEST_F(CreateFileTest, bad_return_type)
++{
++    set_provider(unique_ptr<provider::ProviderBase>(new MockProvider("upload_returns_dir")));
++
++    Item root;
++    {
++        unique_ptr<ItemJob> j(acc_.get("root_id"));
++        QSignalSpy spy(j.get(), &ItemJob::statusChanged);
++        spy.wait(SIGNAL_WAIT_TIME);
++        root = j->item();
++    }
++
++    Item child;
++    {
++        unique_ptr<ItemJob> j(acc_.get("child_id"));
++        QSignalSpy spy(j.get(), &ItemJob::statusChanged);
++        spy.wait(SIGNAL_WAIT_TIME);
++        child = j->item();
++    }
++
++    QByteArray contents("Hello world", -1);
++    unique_ptr<Uploader> uploader(root.createFile("some_file",
++                                                   Item::ConflictPolicy::Overwrite,
++                                                   contents.size(),
++                                                   ""));
++    EXPECT_TRUE(uploader->isValid());
++
++    {
++        QSignalSpy spy(uploader.get(), &Uploader::statusChanged);
++        ASSERT_TRUE(spy.wait(SIGNAL_WAIT_TIME));
++        auto arg = spy.takeFirst();
++        EXPECT_EQ(Uploader::Status::Ready, qvariant_cast<Uploader::Status>(arg.at(0)));
++    }
++
++    EXPECT_EQ(contents.size(), uploader->write(contents));
++
++    QSignalSpy spy(uploader.get(), &Uploader::statusChanged);
++    uploader->finishUpload();
++    ASSERT_TRUE(spy.wait(SIGNAL_WAIT_TIME));
++    auto arg = spy.takeFirst();
++    EXPECT_EQ(Uploader::Status::Error, qvariant_cast<Uploader::Status>(arg.at(0)));
++
++    EXPECT_EQ(StorageError::Type::LocalCommsError, uploader->error().type());
++    EXPECT_EQ("Item::createFile(): impossible folder item returned by provider", uploader->error().message());
++}
++
++TEST_F(CreateFileTest, exists)
++{
++    set_provider(unique_ptr<provider::ProviderBase>(new MockProvider("create_file_exists")));
++
++    Item root;
++    {
++        unique_ptr<ItemJob> j(acc_.get("root_id"));
++        QSignalSpy spy(j.get(), &ItemJob::statusChanged);
++        spy.wait(SIGNAL_WAIT_TIME);
++        root = j->item();
++    }
++
++    QByteArray contents("Hello world", -1);
++    unique_ptr<Uploader> uploader(root.createFile("Child",
++                                                   Item::ConflictPolicy::ErrorIfConflict,
++                                                   contents.size(),
++                                                   ""));
++    EXPECT_TRUE(uploader->isValid());
++
++    {
++        QSignalSpy spy(uploader.get(), &Uploader::statusChanged);
++        ASSERT_TRUE(spy.wait(SIGNAL_WAIT_TIME));
++        auto arg = spy.takeFirst();
++        EXPECT_EQ(Uploader::Status::Ready, qvariant_cast<Uploader::Status>(arg.at(0)));
++    }
++
++    EXPECT_EQ(contents.size(), uploader->write(contents));
++
++    QSignalSpy spy(uploader.get(), &Uploader::statusChanged);
++    uploader->finishUpload();
++    ASSERT_TRUE(spy.wait(SIGNAL_WAIT_TIME));
++    auto arg = spy.takeFirst();
++    EXPECT_EQ(Uploader::Status::Error, qvariant_cast<Uploader::Status>(arg.at(0)));
++
++    EXPECT_EQ(StorageError::Type::Exists, uploader->error().type());
++    EXPECT_EQ("file exists", uploader->error().message());
++    EXPECT_EQ("child_id", uploader->error().itemId());
++    EXPECT_EQ("Child", uploader->error().itemName());
++    EXPECT_EQ(Item::ConflictPolicy::ErrorIfConflict, uploader->policy());
++}
++
  int main(int argc, char** argv)
+ {
      QCoreApplication app(argc, argv);