#include "components/sync_driver/data_type_controller.h"
#include "components/sync_driver/data_type_encryption_handler.h"
#include "components/sync_driver/data_type_manager_observer.h"
-#include "components/sync_driver/failed_data_types_handler.h"
+#include "components/sync_driver/data_type_status_table.h"
#include "components/sync_driver/fake_data_type_controller.h"
#include "sync/internal_api/public/base/model_type.h"
#include "sync/internal_api/public/configure_reason.h"
-#include "testing/gmock/include/gmock/gmock.h"
#include "testing/gtest/include/gtest/gtest.h"
namespace sync_driver {
+using syncer::SyncError;
using syncer::ModelType;
using syncer::ModelTypeSet;
using syncer::ModelTypeToString;
using syncer::PASSWORDS;
using syncer::PREFERENCES;
using syncer::NIGORI;
-using testing::_;
-using testing::Mock;
-using testing::ResultOf;
namespace {
-// Used by SetConfigureDoneExpectation.
-DataTypeManager::ConfigureStatus GetStatus(
- const DataTypeManager::ConfigureResult& result) {
- return result.status;
-}
-
// Helper for unioning with priority types.
-syncer::ModelTypeSet AddHighPriorityTypesTo(syncer::ModelTypeSet types) {
- syncer::ModelTypeSet result = syncer::ControlTypes();
+ModelTypeSet AddHighPriorityTypesTo(ModelTypeSet types) {
+ ModelTypeSet result = syncer::ControlTypes();
result.PutAll(types);
return result;
}
+DataTypeStatusTable BuildStatusTable(ModelTypeSet crypto_errors,
+ ModelTypeSet association_errors,
+ ModelTypeSet unready_errors,
+ ModelTypeSet unrecoverable_errors) {
+ DataTypeStatusTable::TypeErrorMap error_map;
+ for (ModelTypeSet::Iterator iter = crypto_errors.First(); iter.Good();
+ iter.Inc()) {
+ error_map[iter.Get()] = SyncError(FROM_HERE,
+ SyncError::CRYPTO_ERROR,
+ "crypto error expected",
+ iter.Get());
+ }
+ for (ModelTypeSet::Iterator iter = association_errors.First(); iter.Good();
+ iter.Inc()) {
+ error_map[iter.Get()] = SyncError(FROM_HERE,
+ SyncError::DATATYPE_ERROR,
+ "association error expected",
+ iter.Get());
+ }
+ for (ModelTypeSet::Iterator iter = unready_errors.First(); iter.Good();
+ iter.Inc()) {
+ error_map[iter.Get()] = SyncError(FROM_HERE,
+ SyncError::UNREADY_ERROR,
+ "unready error expected",
+ iter.Get());
+ }
+ for (ModelTypeSet::Iterator iter = unrecoverable_errors.First(); iter.Good();
+ iter.Inc()) {
+ error_map[iter.Get()] = SyncError(FROM_HERE,
+ SyncError::UNRECOVERABLE_ERROR,
+ "unrecoverable error expected",
+ iter.Get());
+ }
+ DataTypeStatusTable status_table;
+ status_table.UpdateFailedDataTypes(error_map);
+ return status_table;
+}
+
// Fake BackendDataTypeConfigurer implementation that simply stores away the
// callback passed into ConfigureDataTypes.
class FakeBackendDataTypeConfigurer : public BackendDataTypeConfigurer {
public:
FakeBackendDataTypeConfigurer() {}
- virtual ~FakeBackendDataTypeConfigurer() {}
+ ~FakeBackendDataTypeConfigurer() override {}
- virtual void ConfigureDataTypes(
+ void ConfigureDataTypes(
syncer::ConfigureReason reason,
const DataTypeConfigStateMap& config_state_map,
- const base::Callback<void(ModelTypeSet,
- ModelTypeSet)>& ready_task,
- const base::Callback<void()>& retry_callback) OVERRIDE {
+ const base::Callback<void(ModelTypeSet, ModelTypeSet)>& ready_task,
+ const base::Callback<void()>& retry_callback) override {
last_ready_task_ = ready_task;
if (!expected_configure_types_.Empty()) {
EXPECT_TRUE(
expected_configure_types_.Equals(
GetDataTypesInState(CONFIGURE_ACTIVE, config_state_map)))
- << syncer::ModelTypeSetToString(expected_configure_types_)
+ << ModelTypeSetToString(expected_configure_types_)
<< " v.s. "
- << syncer::ModelTypeSetToString(
+ << ModelTypeSetToString(
GetDataTypesInState(CONFIGURE_ACTIVE, config_state_map));
}
}
- virtual void ActivateDataType(
- syncer::ModelType type, syncer::ModelSafeGroup group,
- ChangeProcessor* change_processor) OVERRIDE {
+ void ActivateDataType(syncer::ModelType type,
+ syncer::ModelSafeGroup group,
+ ChangeProcessor* change_processor) override {
activated_types_.Put(type);
}
- virtual void DeactivateDataType(syncer::ModelType type) OVERRIDE {
+ void DeactivateDataType(syncer::ModelType type) override {
activated_types_.Remove(type);
}
return last_ready_task_;
}
- void set_expected_configure_types(syncer::ModelTypeSet types) {
+ void set_expected_configure_types(ModelTypeSet types) {
expected_configure_types_ = types;
}
- const syncer::ModelTypeSet activated_types() { return activated_types_; }
+ const ModelTypeSet activated_types() { return activated_types_; }
private:
base::Callback<void(ModelTypeSet, ModelTypeSet)> last_ready_task_;
- syncer::ModelTypeSet expected_configure_types_;
- syncer::ModelTypeSet activated_types_;
+ ModelTypeSet expected_configure_types_;
+ ModelTypeSet activated_types_;
};
-// Mock DataTypeManagerObserver implementation.
-class DataTypeManagerObserverMock : public DataTypeManagerObserver {
+// DataTypeManagerObserver implementation.
+class FakeDataTypeManagerObserver : public DataTypeManagerObserver {
public:
- DataTypeManagerObserverMock() {}
- virtual ~DataTypeManagerObserverMock() {}
+ FakeDataTypeManagerObserver() { ResetExpectations(); }
+ ~FakeDataTypeManagerObserver() override {
+ EXPECT_FALSE(start_expected_);
+ DataTypeManager::ConfigureResult default_result;
+ EXPECT_EQ(done_expectation_.status, default_result.status);
+ EXPECT_TRUE(
+ done_expectation_.data_type_status_table.GetFailedTypes().Empty());
+ }
- MOCK_METHOD1(OnConfigureDone,
- void(const DataTypeManager::ConfigureResult&));
- MOCK_METHOD0(OnConfigureRetry, void());
- MOCK_METHOD0(OnConfigureStart, void());
+ void ExpectStart() {
+ start_expected_ = true;
+ }
+ void ExpectDone(const DataTypeManager::ConfigureResult& result) {
+ done_expectation_ = result;
+ }
+ void ResetExpectations() {
+ start_expected_ = false;
+ done_expectation_ = DataTypeManager::ConfigureResult();
+ }
+
+ void OnConfigureDone(
+ const DataTypeManager::ConfigureResult& result) override {
+ EXPECT_EQ(done_expectation_.status, result.status);
+ DataTypeStatusTable::TypeErrorMap errors =
+ result.data_type_status_table.GetAllErrors();
+ DataTypeStatusTable::TypeErrorMap expected_errors =
+ done_expectation_.data_type_status_table.GetAllErrors();
+ ASSERT_EQ(expected_errors.size(), errors.size());
+ for (DataTypeStatusTable::TypeErrorMap::const_iterator iter =
+ expected_errors.begin();
+ iter != expected_errors.end();
+ ++iter) {
+ ASSERT_TRUE(errors.find(iter->first) != errors.end());
+ ASSERT_EQ(iter->second.error_type(),
+ errors.find(iter->first)->second.error_type());
+ }
+ done_expectation_ = DataTypeManager::ConfigureResult();
+ }
+
+ void OnConfigureStart() override {
+ EXPECT_TRUE(start_expected_);
+ start_expected_ = false;
+ }
+
+ private:
+ bool start_expected_ = true;
+ DataTypeManager::ConfigureResult done_expectation_;
};
class FakeDataTypeEncryptionHandler : public DataTypeEncryptionHandler {
public:
FakeDataTypeEncryptionHandler();
- virtual ~FakeDataTypeEncryptionHandler();
+ ~FakeDataTypeEncryptionHandler() override;
- virtual bool IsPassphraseRequired() const OVERRIDE;
- virtual syncer::ModelTypeSet GetEncryptedDataTypes() const OVERRIDE;
+ bool IsPassphraseRequired() const override;
+ ModelTypeSet GetEncryptedDataTypes() const override;
void set_passphrase_required(bool passphrase_required) {
passphrase_required_ = passphrase_required;
}
- void set_encrypted_types(syncer::ModelTypeSet encrypted_types) {
+ void set_encrypted_types(ModelTypeSet encrypted_types) {
encrypted_types_ = encrypted_types;
}
private:
bool passphrase_required_;
- syncer::ModelTypeSet encrypted_types_;
+ ModelTypeSet encrypted_types_;
};
FakeDataTypeEncryptionHandler::FakeDataTypeEncryptionHandler()
return passphrase_required_;
}
-syncer::ModelTypeSet
+ModelTypeSet
FakeDataTypeEncryptionHandler::GetEncryptedDataTypes() const {
return encrypted_types_;
}
BackendDataTypeConfigurer* configurer,
const DataTypeController::TypeMap* controllers,
const DataTypeEncryptionHandler* encryption_handler,
- DataTypeManagerObserver* observer,
- FailedDataTypesHandler* failed_data_types_handler)
+ DataTypeManagerObserver* observer)
: DataTypeManagerImpl(base::Closure(),
debug_info_listener,
controllers,
encryption_handler,
configurer,
- observer,
- failed_data_types_handler),
+ observer),
custom_priority_types_(syncer::ControlTypes()) {}
- void set_priority_types(const syncer::ModelTypeSet& priority_types) {
+ void set_priority_types(const ModelTypeSet& priority_types) {
custom_priority_types_ = priority_types;
}
return configure_result_;
}
- virtual void OnModelAssociationDone(
- const DataTypeManager::ConfigureResult& result) OVERRIDE {
+ void OnModelAssociationDone(
+ const DataTypeManager::ConfigureResult& result) override {
configure_result_ = result;
DataTypeManagerImpl::OnModelAssociationDone(result);
}
private:
- virtual syncer::ModelTypeSet GetPriorityTypes() const OVERRIDE {
+ ModelTypeSet GetPriorityTypes() const override {
return custom_priority_types_;
}
- syncer::ModelTypeSet custom_priority_types_;
+ ModelTypeSet custom_priority_types_;
DataTypeManager::ConfigureResult configure_result_;
};
public:
SyncDataTypeManagerImplTest() {}
- virtual ~SyncDataTypeManagerImplTest() {
- }
+ ~SyncDataTypeManagerImplTest() override {}
protected:
- virtual void SetUp() {
+ void SetUp() override {
dtm_.reset(
new TestDataTypeManager(
syncer::WeakHandle<syncer::DataTypeDebugInfoListener>(),
&configurer_,
&controllers_,
&encryption_handler_,
- &observer_,
- &failed_data_types_handler_));
+ &observer_));
}
void SetConfigureStartExpectation() {
- EXPECT_CALL(observer_, OnConfigureStart());
+ observer_.ExpectStart();
}
- void SetConfigureDoneExpectation(DataTypeManager::ConfigureStatus status) {
- EXPECT_CALL(observer_, OnConfigureDone(ResultOf(&GetStatus, status)));
+ void SetConfigureDoneExpectation(DataTypeManager::ConfigureStatus status,
+ const DataTypeStatusTable& status_table) {
+ DataTypeManager::ConfigureResult result;
+ result.status = status;
+ result.data_type_status_table = status_table;
+ observer_.ExpectDone(result);
}
// Configure the given DTM with the given desired types.
void Configure(DataTypeManagerImpl* dtm,
- const syncer::ModelTypeSet& desired_types) {
+ const ModelTypeSet& desired_types) {
dtm->Configure(desired_types, syncer::CONFIGURE_REASON_RECONFIGURATION);
}
static_cast<FakeDataTypeController*>(it->second.get()));
}
- void FailEncryptionFor(syncer::ModelTypeSet encrypted_types) {
+ void FailEncryptionFor(ModelTypeSet encrypted_types) {
encryption_handler_.set_passphrase_required(true);
encryption_handler_.set_encrypted_types(encrypted_types);
}
base::MessageLoopForUI ui_loop_;
DataTypeController::TypeMap controllers_;
FakeBackendDataTypeConfigurer configurer_;
- DataTypeManagerObserverMock observer_;
+ FakeDataTypeManagerObserver observer_;
scoped_ptr<TestDataTypeManager> dtm_;
- FailedDataTypesHandler failed_data_types_handler_;
FakeDataTypeEncryptionHandler encryption_handler_;
};
// and then stop it.
TEST_F(SyncDataTypeManagerImplTest, NoControllers) {
SetConfigureStartExpectation();
- SetConfigureDoneExpectation(DataTypeManager::OK);
+ SetConfigureDoneExpectation(DataTypeManager::OK, DataTypeStatusTable());
Configure(dtm_.get(), ModelTypeSet());
EXPECT_EQ(DataTypeManager::DOWNLOAD_PENDING, dtm_->state());
AddController(BOOKMARKS);
SetConfigureStartExpectation();
- SetConfigureDoneExpectation(DataTypeManager::OK);
+ SetConfigureDoneExpectation(DataTypeManager::OK, DataTypeStatusTable());
Configure(dtm_.get(), ModelTypeSet(BOOKMARKS));
EXPECT_EQ(DataTypeManager::DOWNLOAD_PENDING, dtm_->state());
{
SetConfigureStartExpectation();
- SetConfigureDoneExpectation(DataTypeManager::ABORTED);
+ SetConfigureDoneExpectation(DataTypeManager::ABORTED,
+ DataTypeStatusTable());
Configure(dtm_.get(), ModelTypeSet(BOOKMARKS));
EXPECT_EQ(DataTypeManager::DOWNLOAD_PENDING, dtm_->state());
{
SetConfigureStartExpectation();
- SetConfigureDoneExpectation(DataTypeManager::ABORTED);
+ SetConfigureDoneExpectation(DataTypeManager::ABORTED,
+ DataTypeStatusTable());
Configure(dtm_.get(), ModelTypeSet(BOOKMARKS));
EXPECT_EQ(DataTypeManager::DOWNLOAD_PENDING, dtm_->state());
{
SetConfigureStartExpectation();
- SetConfigureDoneExpectation(DataTypeManager::ABORTED);
+ SetConfigureDoneExpectation(DataTypeManager::ABORTED,
+ DataTypeStatusTable());
Configure(dtm_.get(), ModelTypeSet(BOOKMARKS));
EXPECT_EQ(DataTypeManager::DOWNLOAD_PENDING, dtm_->state());
AddController(PASSWORDS);
SetConfigureStartExpectation();
- SetConfigureDoneExpectation(DataTypeManager::OK);
+ SetConfigureDoneExpectation(DataTypeManager::OK,
+ BuildStatusTable(ModelTypeSet(PASSWORDS),
+ ModelTypeSet(),
+ ModelTypeSet(),
+ ModelTypeSet()));
const ModelTypeSet types(PASSWORDS);
dtm_->set_priority_types(AddHighPriorityTypesTo(types));
AddController(PREFERENCES);
SetConfigureStartExpectation();
- SetConfigureDoneExpectation(DataTypeManager::OK);
+ SetConfigureDoneExpectation(DataTypeManager::OK, DataTypeStatusTable());
// Step 1.
Configure(dtm_.get(), ModelTypeSet(BOOKMARKS));
GetController(BOOKMARKS)->FinishStart(DataTypeController::OK);
EXPECT_EQ(DataTypeManager::CONFIGURED, dtm_->state());
- Mock::VerifyAndClearExpectations(&observer_);
+ observer_.ResetExpectations();
SetConfigureStartExpectation();
- SetConfigureDoneExpectation(DataTypeManager::OK);
+ SetConfigureDoneExpectation(DataTypeManager::OK, DataTypeStatusTable());
// Step 4.
Configure(dtm_.get(), ModelTypeSet(BOOKMARKS, PREFERENCES));
AddController(PREFERENCES);
SetConfigureStartExpectation();
- SetConfigureDoneExpectation(DataTypeManager::OK);
+ SetConfigureDoneExpectation(DataTypeManager::OK, DataTypeStatusTable());
// Step 1.
Configure(dtm_.get(), ModelTypeSet(BOOKMARKS));
GetController(BOOKMARKS)->FinishStart(DataTypeController::OK);
EXPECT_EQ(DataTypeManager::CONFIGURED, dtm_->state());
- Mock::VerifyAndClearExpectations(&observer_);
+ observer_.ResetExpectations();
SetConfigureStartExpectation();
- SetConfigureDoneExpectation(DataTypeManager::OK);
+ SetConfigureDoneExpectation(DataTypeManager::OK, DataTypeStatusTable());
// Step 4.
Configure(dtm_.get(), ModelTypeSet(PREFERENCES));
AddController(PREFERENCES);
SetConfigureStartExpectation();
- SetConfigureDoneExpectation(DataTypeManager::OK);
+ SetConfigureDoneExpectation(DataTypeManager::OK, DataTypeStatusTable());
// Step 1.
Configure(dtm_.get(), ModelTypeSet(BOOKMARKS));
AddController(BOOKMARKS);
SetConfigureStartExpectation();
- SetConfigureDoneExpectation(DataTypeManager::UNRECOVERABLE_ERROR);
+ SetConfigureDoneExpectation(DataTypeManager::UNRECOVERABLE_ERROR,
+ BuildStatusTable(ModelTypeSet(),
+ ModelTypeSet(),
+ ModelTypeSet(),
+ ModelTypeSet(BOOKMARKS)));
Configure(dtm_.get(), ModelTypeSet(BOOKMARKS));
EXPECT_EQ(DataTypeManager::DOWNLOAD_PENDING, dtm_->state());
AddController(PREFERENCES);
SetConfigureStartExpectation();
- SetConfigureDoneExpectation(DataTypeManager::UNRECOVERABLE_ERROR);
+ SetConfigureDoneExpectation(DataTypeManager::UNRECOVERABLE_ERROR,
+ BuildStatusTable(ModelTypeSet(),
+ ModelTypeSet(),
+ ModelTypeSet(),
+ ModelTypeSet(PREFERENCES)));
// Step 1.
Configure(dtm_.get(), ModelTypeSet(BOOKMARKS, PREFERENCES));
AddController(PREFERENCES);
SetConfigureStartExpectation();
- SetConfigureDoneExpectation(DataTypeManager::OK);
+ SetConfigureDoneExpectation(DataTypeManager::OK,
+ BuildStatusTable(ModelTypeSet(),
+ ModelTypeSet(PREFERENCES),
+ ModelTypeSet(),
+ ModelTypeSet()));
// Step 1.
Configure(dtm_.get(), ModelTypeSet(BOOKMARKS, PREFERENCES));
AddController(PREFERENCES);
SetConfigureStartExpectation();
- SetConfigureDoneExpectation(DataTypeManager::OK);
+ SetConfigureDoneExpectation(DataTypeManager::OK, DataTypeStatusTable());
// Step 1.
Configure(dtm_.get(), ModelTypeSet(BOOKMARKS));
AddController(PREFERENCES);
SetConfigureStartExpectation();
- SetConfigureDoneExpectation(DataTypeManager::OK);
+ SetConfigureDoneExpectation(DataTypeManager::OK, DataTypeStatusTable());
// Step 1.
Configure(dtm_.get(), ModelTypeSet(BOOKMARKS));
dtm_->set_priority_types(AddHighPriorityTypesTo(ModelTypeSet(BOOKMARKS)));
SetConfigureStartExpectation();
- SetConfigureDoneExpectation(DataTypeManager::OK);
+ SetConfigureDoneExpectation(DataTypeManager::OK, DataTypeStatusTable());
// Initial setup.
Configure(dtm_.get(), ModelTypeSet(BOOKMARKS));
// We've now configured bookmarks and (implicitly) the control types.
EXPECT_EQ(DataTypeManager::CONFIGURED, dtm_->state());
- Mock::VerifyAndClearExpectations(&observer_);
+ observer_.ResetExpectations();
// Pretend we were told to migrate all types.
ModelTypeSet to_migrate;
to_migrate.PutAll(syncer::ControlTypes());
SetConfigureStartExpectation();
- SetConfigureDoneExpectation(DataTypeManager::OK);
+ SetConfigureDoneExpectation(DataTypeManager::OK, DataTypeStatusTable());
dtm_->PurgeForMigration(to_migrate,
syncer::CONFIGURE_REASON_MIGRATION);
EXPECT_EQ(DataTypeManager::DOWNLOAD_PENDING, dtm_->state());
// The DTM will call ConfigureDataTypes(), even though it is unnecessary.
FinishDownload(*dtm_, ModelTypeSet(), ModelTypeSet());
EXPECT_EQ(DataTypeManager::CONFIGURED, dtm_->state());
- Mock::VerifyAndClearExpectations(&observer_);
+ observer_.ResetExpectations();
// Re-enable the migrated types.
SetConfigureStartExpectation();
- SetConfigureDoneExpectation(DataTypeManager::OK);
+ SetConfigureDoneExpectation(DataTypeManager::OK, DataTypeStatusTable());
Configure(dtm_.get(), to_migrate);
FinishDownload(*dtm_, to_migrate, ModelTypeSet());
GetController(BOOKMARKS)->FinishStart(DataTypeController::OK);
// Initial configure.
SetConfigureStartExpectation();
- SetConfigureDoneExpectation(DataTypeManager::OK);
+ SetConfigureDoneExpectation(DataTypeManager::OK, DataTypeStatusTable());
Configure(dtm_.get(), ModelTypeSet(BOOKMARKS));
FinishDownload(*dtm_, ModelTypeSet(), ModelTypeSet());
FinishDownload(*dtm_, ModelTypeSet(BOOKMARKS), ModelTypeSet());
GetController(BOOKMARKS)->FinishStart(DataTypeController::OK);
EXPECT_EQ(DataTypeManager::CONFIGURED, dtm_->state());
- Mock::VerifyAndClearExpectations(&observer_);
+ observer_.ResetExpectations();
// Purge the Nigori type.
SetConfigureStartExpectation();
dtm_->PurgeForMigration(ModelTypeSet(NIGORI),
syncer::CONFIGURE_REASON_MIGRATION);
EXPECT_EQ(DataTypeManager::DOWNLOAD_PENDING, dtm_->state());
- Mock::VerifyAndClearExpectations(&observer_);
+ observer_.ResetExpectations();
// Before the backend configuration completes, ask for a different
// set of types. This request asks for
// Invoke the callback we've been waiting for since we asked to purge NIGORI.
FinishDownload(*dtm_, ModelTypeSet(), ModelTypeSet());
- Mock::VerifyAndClearExpectations(&observer_);
+ observer_.ResetExpectations();
- SetConfigureDoneExpectation(DataTypeManager::OK);
+ SetConfigureDoneExpectation(DataTypeManager::OK, DataTypeStatusTable());
EXPECT_EQ(DataTypeManager::DOWNLOAD_PENDING, dtm_->state());
// Now invoke the callback for the second configure request.
AddController(PREFERENCES);
dtm_->set_priority_types(
- AddHighPriorityTypesTo(syncer::ModelTypeSet(PREFERENCES)));
+ AddHighPriorityTypesTo(ModelTypeSet(PREFERENCES)));
// Initial configure.
SetConfigureStartExpectation();
- SetConfigureDoneExpectation(DataTypeManager::OK);
+ SetConfigureDoneExpectation(DataTypeManager::OK, DataTypeStatusTable());
// Initially only PREFERENCES is configured.
configurer_.set_expected_configure_types(
AddController(APPS);
dtm_->set_priority_types(
- AddHighPriorityTypesTo(syncer::ModelTypeSet(PREFERENCES)));
+ AddHighPriorityTypesTo(ModelTypeSet(PREFERENCES)));
// Initial configure.
SetConfigureStartExpectation();
- SetConfigureDoneExpectation(DataTypeManager::OK);
+ SetConfigureDoneExpectation(DataTypeManager::OK, DataTypeStatusTable());
// Reconfigure while associating PREFERENCES and downloading BOOKMARKS.
configurer_.set_expected_configure_types(
AddController(PREFERENCES);
dtm_->set_priority_types(
- AddHighPriorityTypesTo(syncer::ModelTypeSet(PREFERENCES)));
+ AddHighPriorityTypesTo(ModelTypeSet(PREFERENCES)));
// Initial configure.
SetConfigureStartExpectation();
- SetConfigureDoneExpectation(DataTypeManager::ABORTED);
+ SetConfigureDoneExpectation(DataTypeManager::ABORTED, DataTypeStatusTable());
// Initially only PREFERENCES is configured.
configurer_.set_expected_configure_types(
AddController(PREFERENCES);
dtm_->set_priority_types(
- AddHighPriorityTypesTo(syncer::ModelTypeSet(PREFERENCES)));
+ AddHighPriorityTypesTo(ModelTypeSet(PREFERENCES)));
// Initial configure.
SetConfigureStartExpectation();
- SetConfigureDoneExpectation(DataTypeManager::UNRECOVERABLE_ERROR);
+ SetConfigureDoneExpectation(DataTypeManager::UNRECOVERABLE_ERROR,
+ BuildStatusTable(ModelTypeSet(),
+ ModelTypeSet(),
+ ModelTypeSet(),
+ ModelTypeSet(BOOKMARKS)));
// Initially only PREFERENCES is configured.
configurer_.set_expected_configure_types(
AddController(BOOKMARKS); // Will succeed.
dtm_->set_priority_types(
- AddHighPriorityTypesTo(syncer::ModelTypeSet(PREFERENCES)));
+ AddHighPriorityTypesTo(ModelTypeSet(PREFERENCES)));
// Initial configure.
SetConfigureStartExpectation();
- SetConfigureDoneExpectation(DataTypeManager::OK);
+ SetConfigureDoneExpectation(DataTypeManager::OK,
+ BuildStatusTable(ModelTypeSet(),
+ ModelTypeSet(PREFERENCES),
+ ModelTypeSet(),
+ ModelTypeSet()));
// Initially only PREFERENCES is configured.
configurer_.set_expected_configure_types(
AddController(BOOKMARKS); // Will fail.
dtm_->set_priority_types(
- AddHighPriorityTypesTo(syncer::ModelTypeSet(PREFERENCES)));
+ AddHighPriorityTypesTo(ModelTypeSet(PREFERENCES)));
// Initial configure.
SetConfigureStartExpectation();
- SetConfigureDoneExpectation(DataTypeManager::OK);
+ SetConfigureDoneExpectation(DataTypeManager::OK,
+ BuildStatusTable(ModelTypeSet(),
+ ModelTypeSet(BOOKMARKS),
+ ModelTypeSet(),
+ ModelTypeSet()));
// Initially only PREFERENCES is configured.
configurer_.set_expected_configure_types(
dtm_->set_priority_types(AddHighPriorityTypesTo(types));
SetConfigureStartExpectation();
- SetConfigureDoneExpectation(DataTypeManager::OK);
+ SetConfigureDoneExpectation(DataTypeManager::OK, DataTypeStatusTable());
- syncer::ModelTypeSet expected_types = syncer::ControlTypes();
+ ModelTypeSet expected_types = syncer::ControlTypes();
expected_types.Put(BOOKMARKS);
// APPS is filtered out because there's no controller for it.
configurer_.set_expected_configure_types(expected_types);
SetConfigureStartExpectation();
-
ModelTypeSet expected_types = syncer::ControlTypes();
expected_types.Put(BOOKMARKS);
configurer_.set_expected_configure_types(expected_types);
}
TEST_F(SyncDataTypeManagerImplTest, ReenableAfterDataTypeError) {
- syncer::SyncError error(FROM_HERE,
- syncer::SyncError::DATATYPE_ERROR,
- "Datatype disabled",
- syncer::BOOKMARKS);
- std::map<syncer::ModelType, syncer::SyncError> errors;
- errors[syncer::BOOKMARKS] = error;
- failed_data_types_handler_.UpdateFailedDataTypes(errors);
-
AddController(PREFERENCES); // Will succeed.
AddController(BOOKMARKS); // Will be disabled due to datatype error.
SetConfigureStartExpectation();
- SetConfigureDoneExpectation(DataTypeManager::OK);
+ SetConfigureDoneExpectation(DataTypeManager::OK,
+ BuildStatusTable(ModelTypeSet(),
+ ModelTypeSet(BOOKMARKS),
+ ModelTypeSet(),
+ ModelTypeSet()));
Configure(dtm_.get(), ModelTypeSet(BOOKMARKS, PREFERENCES));
FinishDownload(*dtm_, ModelTypeSet(), ModelTypeSet());
- FinishDownload(*dtm_, ModelTypeSet(PREFERENCES), ModelTypeSet());
+ FinishDownload(*dtm_, ModelTypeSet(PREFERENCES, BOOKMARKS), ModelTypeSet());
GetController(PREFERENCES)->FinishStart(DataTypeController::OK);
+ GetController(BOOKMARKS)
+ ->FinishStart(DataTypeController::ASSOCIATION_FAILED);
+ FinishDownload(*dtm_, ModelTypeSet(), ModelTypeSet()); // Reconfig for error.
+ FinishDownload(*dtm_, ModelTypeSet(), ModelTypeSet()); // Reconfig for error.
EXPECT_EQ(DataTypeManager::CONFIGURED, dtm_->state());
EXPECT_EQ(DataTypeController::RUNNING, GetController(PREFERENCES)->state());
EXPECT_EQ(DataTypeController::NOT_RUNNING, GetController(BOOKMARKS)->state());
- Mock::VerifyAndClearExpectations(&observer_);
+ observer_.ResetExpectations();
// Re-enable bookmarks.
- failed_data_types_handler_.ResetDataTypeErrorFor(syncer::BOOKMARKS);
-
- SetConfigureStartExpectation();
- SetConfigureDoneExpectation(DataTypeManager::OK);
+ SetConfigureDoneExpectation(DataTypeManager::OK, DataTypeStatusTable());
+ dtm_->ReenableType(syncer::BOOKMARKS);
- Configure(dtm_.get(), ModelTypeSet(BOOKMARKS, PREFERENCES));
EXPECT_EQ(DataTypeManager::DOWNLOAD_PENDING, dtm_->state());
FinishDownload(*dtm_, ModelTypeSet(), ModelTypeSet());
FinishDownload(*dtm_, ModelTypeSet(BOOKMARKS), ModelTypeSet());
EXPECT_EQ(DataTypeManager::CONFIGURED, dtm_->state());
EXPECT_EQ(DataTypeController::RUNNING, GetController(PREFERENCES)->state());
EXPECT_EQ(DataTypeController::RUNNING, GetController(BOOKMARKS)->state());
+
+ // Should do nothing.
+ dtm_->ReenableType(syncer::BOOKMARKS);
}
TEST_F(SyncDataTypeManagerImplTest, UnreadyType) {
// Bookmarks is never started due to being unready.
SetConfigureStartExpectation();
- SetConfigureDoneExpectation(DataTypeManager::OK);
+ SetConfigureDoneExpectation(DataTypeManager::OK,
+ BuildStatusTable(ModelTypeSet(),
+ ModelTypeSet(),
+ ModelTypeSet(BOOKMARKS),
+ ModelTypeSet()));
Configure(dtm_.get(), ModelTypeSet(BOOKMARKS));
FinishDownload(*dtm_, ModelTypeSet(), ModelTypeSet());
EXPECT_EQ(DataTypeController::NOT_RUNNING, GetController(BOOKMARKS)->state());
EXPECT_EQ(DataTypeManager::CONFIGURED, dtm_->state());
EXPECT_EQ(0U, configurer_.activated_types().Size());
- Mock::VerifyAndClearExpectations(&observer_);
+ observer_.ResetExpectations();
// Bookmarks should start normally now.
GetController(BOOKMARKS)->SetReadyForStart(true);
- SetConfigureStartExpectation();
- SetConfigureDoneExpectation(DataTypeManager::OK);
- Configure(dtm_.get(), ModelTypeSet(BOOKMARKS));
+ SetConfigureDoneExpectation(DataTypeManager::OK, DataTypeStatusTable());
+ dtm_->ReenableType(BOOKMARKS);
EXPECT_EQ(DataTypeManager::DOWNLOAD_PENDING, dtm_->state());
FinishDownload(*dtm_, ModelTypeSet(), ModelTypeSet());
EXPECT_EQ(DataTypeManager::CONFIGURED, dtm_->state());
EXPECT_EQ(1U, configurer_.activated_types().Size());
+ // Should do nothing.
+ observer_.ResetExpectations();
+ dtm_->ReenableType(BOOKMARKS);
+
dtm_->Stop();
EXPECT_EQ(DataTypeManager::STOPPED, dtm_->state());
EXPECT_TRUE(configurer_.activated_types().Empty());
}
+TEST_F(SyncDataTypeManagerImplTest, ModelLoadError) {
+ AddController(BOOKMARKS);
+ GetController(BOOKMARKS)->SetModelLoadError(syncer::SyncError(
+ FROM_HERE, SyncError::DATATYPE_ERROR, "load error", BOOKMARKS));
+
+ // Bookmarks is never started due to hitting a model load error.
+ SetConfigureStartExpectation();
+ SetConfigureDoneExpectation(DataTypeManager::OK,
+ BuildStatusTable(ModelTypeSet(),
+ ModelTypeSet(BOOKMARKS),
+ ModelTypeSet(),
+ ModelTypeSet()));
+ Configure(dtm_.get(), ModelTypeSet(BOOKMARKS));
+ FinishDownload(*dtm_, ModelTypeSet(), ModelTypeSet());
+ FinishDownload(*dtm_, ModelTypeSet(BOOKMARKS), ModelTypeSet());
+ EXPECT_EQ(DataTypeManager::CONFIGURED, dtm_->state());
+ EXPECT_EQ(DataTypeController::NOT_RUNNING, GetController(BOOKMARKS)->state());
+
+ EXPECT_EQ(0U, configurer_.activated_types().Size());
+}
+
+
+TEST_F(SyncDataTypeManagerImplTest, ErrorBeforeAssociation) {
+ AddController(BOOKMARKS);
+
+ // Bookmarks is never started due to hitting a datatype error while the DTM
+ // is still downloading types.
+ SetConfigureStartExpectation();
+ SetConfigureDoneExpectation(DataTypeManager::OK,
+ BuildStatusTable(ModelTypeSet(),
+ ModelTypeSet(BOOKMARKS),
+ ModelTypeSet(),
+ ModelTypeSet()));
+ Configure(dtm_.get(), ModelTypeSet(BOOKMARKS));
+ FinishDownload(*dtm_, ModelTypeSet(), ModelTypeSet());
+ GetController(BOOKMARKS)->OnSingleDataTypeUnrecoverableError(
+ syncer::SyncError(FROM_HERE,
+ SyncError::DATATYPE_ERROR,
+ "bookmarks error",
+ BOOKMARKS));
+ FinishDownload(*dtm_, ModelTypeSet(BOOKMARKS), ModelTypeSet());
+ FinishDownload(*dtm_, ModelTypeSet(), ModelTypeSet()); // Reconfig for error.
+ EXPECT_EQ(DataTypeManager::CONFIGURED, dtm_->state());
+ EXPECT_EQ(DataTypeController::NOT_RUNNING, GetController(BOOKMARKS)->state());
+
+ EXPECT_EQ(0U, configurer_.activated_types().Size());
+}
+
+TEST_F(SyncDataTypeManagerImplTest, AssociationNeverCompletes) {
+ AddController(BOOKMARKS);
+
+ // Bookmarks times out during association and so it's never started.
+ SetConfigureStartExpectation();
+ SetConfigureDoneExpectation(DataTypeManager::OK,
+ BuildStatusTable(ModelTypeSet(),
+ ModelTypeSet(BOOKMARKS),
+ ModelTypeSet(),
+ ModelTypeSet()));
+ Configure(dtm_.get(), ModelTypeSet(BOOKMARKS));
+
+ GetController(BOOKMARKS)->SetDelayModelLoad();
+ FinishDownload(*dtm_, ModelTypeSet(), ModelTypeSet());
+ FinishDownload(*dtm_, ModelTypeSet(BOOKMARKS), ModelTypeSet());
+
+ EXPECT_EQ(DataTypeManager::CONFIGURING, dtm_->state());
+
+ // Simulate timeout by firing the timer.
+ dtm_->GetModelAssociationManagerForTesting()
+ ->GetTimerForTesting()
+ ->user_task()
+ .Run();
+ EXPECT_EQ(DataTypeManager::DOWNLOAD_PENDING, dtm_->state());
+ EXPECT_EQ(DataTypeController::NOT_RUNNING, GetController(BOOKMARKS)->state());
+
+ FinishDownload(*dtm_, ModelTypeSet(), ModelTypeSet());
+
+ EXPECT_EQ(DataTypeManager::CONFIGURED, dtm_->state());
+ EXPECT_EQ(0U, configurer_.activated_types().Size());
+}
+
} // namespace sync_driver