Replace AttachmentStore's StoreAttachments with UploadAttachments.

components/sync_driver/generic_change_processor_unittest.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "components/sync_driver/generic_change_processor.h"
 
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/message_loop/message_loop.h"
+#include "base/run_loop.h"
 #include "base/strings/stringprintf.h"
 #include "components/sync_driver/data_type_error_handler_mock.h"
 #include "components/sync_driver/sync_api_component_factory.h"
 #include "sync/api/attachments/fake_attachment_store.h"
 #include "sync/api/fake_syncable_service.h"
 #include "sync/api/sync_change.h"
 #include "sync/api/sync_merge_result.h"
 #include "sync/internal_api/public/attachments/attachment_service_impl.h"
 #include "sync/internal_api/public/attachments/fake_attachment_downloader.h"
 #include "sync/internal_api/public/attachments/fake_attachment_uploader.h"
 #include "sync/internal_api/public/base/model_type.h"
 #include "sync/internal_api/public/read_node.h"
 #include "sync/internal_api/public/read_transaction.h"
 #include "sync/internal_api/public/sync_encryption_handler.h"
 #include "sync/internal_api/public/test/test_user_share.h"
 #include "sync/internal_api/public/user_share.h"
 #include "sync/internal_api/public/write_node.h"
 #include "sync/internal_api/public/write_transaction.h"
+#include "testing/gmock/include/gmock/gmock-matchers.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace sync_driver {
 
 namespace {
 
 const char kTestData[] = "some data";
 
-// A mock that keeps track of attachments passed to StoreAttachments.
+// A mock that keeps track of attachments passed to UploadAttachments.
 class MockAttachmentService : public syncer::AttachmentServiceImpl {
  public:
   MockAttachmentService();
   virtual ~MockAttachmentService();
-  virtual void StoreAttachments(const syncer::AttachmentList& attachments,
-                                const StoreCallback& callback) OVERRIDE;
-  std::vector<syncer::AttachmentList>* attachment_lists();
+  virtual void UploadAttachments(
+      const syncer::AttachmentIdSet& attachment_ids) OVERRIDE;
+  std::vector<syncer::AttachmentIdSet>* attachment_id_sets();
 
  private:
-  std::vector<syncer::AttachmentList> attachment_lists_;
+  std::vector<syncer::AttachmentIdSet> attachment_id_sets_;
 };
 
 MockAttachmentService::MockAttachmentService()
     : AttachmentServiceImpl(
           scoped_ptr<syncer::AttachmentStore>(new syncer::FakeAttachmentStore(
               base::MessageLoopProxy::current())),
           scoped_ptr<syncer::AttachmentUploader>(
               new syncer::FakeAttachmentUploader),
           scoped_ptr<syncer::AttachmentDownloader>(
               new syncer::FakeAttachmentDownloader),
           NULL) {
 }
 
 MockAttachmentService::~MockAttachmentService() {
 }
 
-void MockAttachmentService::StoreAttachments(
-    const syncer::AttachmentList& attachments,
-    const StoreCallback& callback) {
-  attachment_lists_.push_back(attachments);
-  AttachmentServiceImpl::StoreAttachments(attachments, callback);
+void MockAttachmentService::UploadAttachments(
+    const syncer::AttachmentIdSet& attachment_ids) {
+  attachment_id_sets_.push_back(attachment_ids);
+  AttachmentServiceImpl::UploadAttachments(attachment_ids);
 }
 
-std::vector<syncer::AttachmentList>* MockAttachmentService::attachment_lists() {
-  return &attachment_lists_;
+std::vector<syncer::AttachmentIdSet>*
+MockAttachmentService::attachment_id_sets() {
+  return &attachment_id_sets_;
 }
 
 // MockSyncApiComponentFactory needed to initialize GenericChangeProcessor and
 // pass MockAttachmentService to it.
 class MockSyncApiComponentFactory : public SyncApiComponentFactory {
  public:
   MockSyncApiComponentFactory(
       scoped_ptr<syncer::AttachmentService> attachment_service)
       : attachment_service_(attachment_service.Pass()) {}
 
@@ skipping 72 matching lines @@
   }
 
   syncer::UserShare* user_share() {
     return test_user_share_.user_share();
   }
 
   MockAttachmentService* mock_attachment_service() {
     return mock_attachment_service_;
   }
 
+  void RunLoop() {
+    base::RunLoop run_loop;
+    run_loop.RunUntilIdle();
+  }
+
  private:
   base::MessageLoopForUI loop_;
 
   syncer::SyncMergeResult sync_merge_result_;
   base::WeakPtrFactory<syncer::SyncMergeResult> merge_result_ptr_factory_;
 
   syncer::FakeSyncableService fake_syncable_service_;
   base::WeakPtrFactory<syncer::FakeSyncableService>
       syncable_service_ptr_factory_;
 
@@ skipping 168 matching lines @@
 
   // Add a SyncData with two attachments.
   syncer::SyncChangeList change_list;
   change_list.push_back(
       syncer::SyncChange(FROM_HERE,
                          syncer::SyncChange::ACTION_ADD,
                          syncer::SyncData::CreateLocalDataWithAttachments(
                              tag, title, specifics, attachments)));
   ASSERT_FALSE(
       change_processor()->ProcessSyncChanges(FROM_HERE, change_list).IsSet());
+  RunLoop();
 
   // Check that the AttachmentService received the new attachments.
-  ASSERT_EQ(mock_attachment_service()->attachment_lists()->size(), 1U);
-  const syncer::AttachmentList& attachments_added =
-      mock_attachment_service()->attachment_lists()->front();
+  ASSERT_EQ(mock_attachment_service()->attachment_id_sets()->size(), 1U);
+  const syncer::AttachmentIdSet& attachments_added =
+      mock_attachment_service()->attachment_id_sets()->front();
   ASSERT_EQ(attachments_added.size(), 2U);
-  ASSERT_EQ(attachments_added[0].GetId(), attachments[0].GetId());
-  ASSERT_EQ(attachments_added[1].GetId(), attachments[1].GetId());
+  EXPECT_THAT(attachments_added, testing::Contains(attachments[0].GetId()));

[pavely, 2014/09/04 17:44:37]

(not asking to change): I learned today about UnorderedElementsAre matcher.

[maniscalco, 2014/09/04 22:39:38]

Neat.  I hadn't heard of UnorderedElementsAre.  It seems like a better fit here
(no need to check size) so I'll switch.

+  EXPECT_THAT(attachments_added, testing::Contains(attachments[1].GetId()));
 
   // Update the SyncData, replacing its two attachments with one new attachment.
   syncer::AttachmentList new_attachments;
   new_attachments.push_back(syncer::Attachment::Create(attachment_data));
-  mock_attachment_service()->attachment_lists()->clear();
+  mock_attachment_service()->attachment_id_sets()->clear();
   change_list.clear();
   change_list.push_back(
       syncer::SyncChange(FROM_HERE,
                          syncer::SyncChange::ACTION_UPDATE,
                          syncer::SyncData::CreateLocalDataWithAttachments(
                              tag, title, specifics, new_attachments)));
   ASSERT_FALSE(
       change_processor()->ProcessSyncChanges(FROM_HERE, change_list).IsSet());
+  RunLoop();
 
   // Check that the AttachmentService received it.
-  ASSERT_EQ(mock_attachment_service()->attachment_lists()->size(), 1U);
-  const syncer::AttachmentList& new_attachments_added =
-      mock_attachment_service()->attachment_lists()->front();
+  ASSERT_EQ(mock_attachment_service()->attachment_id_sets()->size(), 1U);
+  const syncer::AttachmentIdSet& new_attachments_added =
+      mock_attachment_service()->attachment_id_sets()->front();
   ASSERT_EQ(new_attachments_added.size(), 1U);
-  ASSERT_EQ(new_attachments_added[0].GetId(), new_attachments[0].GetId());
+  EXPECT_THAT(new_attachments_added,
+              testing::Contains(new_attachments[0].GetId()));
 }
 
 // Verify that after attachment is uploaded GenericChangeProcessor updates
 // corresponding entries
 TEST_F(SyncGenericChangeProcessorTest, AttachmentUploaded) {
   std::string tag = "client_tag";
   std::string title = "client_title";
   sync_pb::EntitySpecifics specifics;
   sync_pb::PreferenceSpecifics* pref_specifics = specifics.mutable_preference();
   pref_specifics->set_name("test");
@@ skipping 23 matching lines @@
   syncer::ReadNode node(&read_transaction);
   ASSERT_EQ(node.InitByClientTagLookup(syncer::PREFERENCES, tag),
             syncer::BaseNode::INIT_OK);
   syncer::AttachmentIdList attachment_ids = node.GetAttachmentIds();
   EXPECT_EQ(1U, attachment_ids.size());
 }
 
 }  // namespace
 
 }  // namespace sync_driver