metadata_database_unittest.cc revision 3240926e260ce088908e02ac07a6cf7b0c0cbf44 
1// Copyright 2013 The Chromium Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5#include "chrome/browser/sync_file_system/drive_backend/metadata_database.h"
6
7#include "base/bind.h"
8#include "base/files/scoped_temp_dir.h"
9#include "base/message_loop/message_loop.h"
10#include "base/message_loop/message_loop_proxy.h"
11#include "base/strings/string_number_conversions.h"
12#include "chrome/browser/google_apis/drive_api_parser.h"
13#include "chrome/browser/sync_file_system/drive_backend/metadata_database.pb.h"
14#include "testing/gtest/include/gtest/gtest.h"
15#include "third_party/leveldatabase/src/include/leveldb/db.h"
16#include "third_party/leveldatabase/src/include/leveldb/write_batch.h"
17
18#define FPL(a) FILE_PATH_LITERAL(a)
19
20namespace sync_file_system {
21namespace drive_backend {
22
23namespace {
24
25const int64 kInitialChangeID = 1234;
26
27void SyncStatusResultCallback(SyncStatusCode* status_out,
28                              SyncStatusCode status) {
29  EXPECT_EQ(SYNC_STATUS_UNKNOWN, *status_out);
30  *status_out = status;
31}
32
33void DatabaseCreateResultCallback(SyncStatusCode* status_out,
34                                  scoped_ptr<MetadataDatabase>* database_out,
35                                  SyncStatusCode status,
36                                  scoped_ptr<MetadataDatabase> database) {
37  EXPECT_EQ(SYNC_STATUS_UNKNOWN, *status_out);
38  *status_out = status;
39  *database_out = database.Pass();
40}
41
42}  // namespace
43
44class MetadataDatabaseTest : public testing::Test {
45 public:
46  MetadataDatabaseTest()
47      : next_change_id_(kInitialChangeID + 1),
48        next_file_id_number_(1),
49        next_md5_sequence_number_(1) {}
50
51  virtual ~MetadataDatabaseTest() {}
52
53  virtual void SetUp() OVERRIDE {
54    ASSERT_TRUE(database_dir_.CreateUniqueTempDir());
55  }
56
57  virtual void TearDown() OVERRIDE { DropDatabase(); }
58
59 protected:
60  std::string GenerateFileID() {
61    return "file_id_" + base::Int64ToString(next_file_id_number_++);
62  }
63
64  SyncStatusCode InitializeMetadataDatabase() {
65    SyncStatusCode status = SYNC_STATUS_UNKNOWN;
66    MetadataDatabase::Create(base::MessageLoopProxy::current(),
67                             database_dir_.path(),
68                             base::Bind(&DatabaseCreateResultCallback,
69                                        &status, &metadata_database_));
70    message_loop_.RunUntilIdle();
71    return status;
72  }
73
74  void DropDatabase() {
75    metadata_database_.reset();
76    message_loop_.RunUntilIdle();
77  }
78
79  MetadataDatabase* metadata_database() { return metadata_database_.get(); }
80
81  leveldb::DB* db() {
82    if (!metadata_database_)
83      return NULL;
84    return metadata_database_->db_.get();
85  }
86
87  scoped_ptr<leveldb::DB> InitializeLevelDB() {
88    leveldb::DB* db = NULL;
89    leveldb::Options options;
90    options.create_if_missing = true;
91    options.max_open_files = 0;  // Use minimum.
92    leveldb::Status status =
93        leveldb::DB::Open(options, database_dir_.path().AsUTF8Unsafe(), &db);
94    EXPECT_TRUE(status.ok());
95
96    db->Put(leveldb::WriteOptions(), "VERSION", base::Int64ToString(3));
97    SetUpServiceMetadata(db);
98
99    return make_scoped_ptr(db);
100  }
101
102  void SetUpServiceMetadata(leveldb::DB* db) {
103    ServiceMetadata service_metadata;
104    service_metadata.set_largest_change_id(kInitialChangeID);
105    std::string value;
106    ASSERT_TRUE(service_metadata.SerializeToString(&value));
107    db->Put(leveldb::WriteOptions(), "SERVICE", value);
108  }
109
110  void PushToChangeList(scoped_ptr<google_apis::ChangeResource> change,
111                        ScopedVector<google_apis::ChangeResource>* changes) {
112    changes->push_back(change.release());
113  }
114
115  SyncStatusCode RegisterApp(const std::string& app_id,
116                             const std::string& folder_id) {
117    SyncStatusCode status = SYNC_STATUS_UNKNOWN;
118    metadata_database_->RegisterApp(
119        app_id, folder_id,
120        base::Bind(&SyncStatusResultCallback, &status));
121    message_loop_.RunUntilIdle();
122    return status;
123  }
124
125  SyncStatusCode DisableApp(const std::string& app_id) {
126    SyncStatusCode status = SYNC_STATUS_UNKNOWN;
127    metadata_database_->DisableApp(
128        app_id, base::Bind(&SyncStatusResultCallback, &status));
129    message_loop_.RunUntilIdle();
130    return status;
131  }
132
133  SyncStatusCode EnableApp(const std::string& app_id) {
134    SyncStatusCode status = SYNC_STATUS_UNKNOWN;
135    metadata_database_->EnableApp(
136        app_id, base::Bind(&SyncStatusResultCallback, &status));
137    message_loop_.RunUntilIdle();
138    return status;
139  }
140
141  SyncStatusCode UnregisterApp(const std::string& app_id) {
142    SyncStatusCode status = SYNC_STATUS_UNKNOWN;
143    metadata_database_->UnregisterApp(
144        app_id, base::Bind(&SyncStatusResultCallback, &status));
145    message_loop_.RunUntilIdle();
146    return status;
147  }
148
149  SyncStatusCode UpdateByChangeList(
150      ScopedVector<google_apis::ChangeResource> changes) {
151    SyncStatusCode status = SYNC_STATUS_UNKNOWN;
152    metadata_database_->UpdateByChangeList(
153        changes.Pass(), base::Bind(&SyncStatusResultCallback, &status));
154    message_loop_.RunUntilIdle();
155    return status;
156  }
157
158 private:
159
160  base::ScopedTempDir database_dir_;
161  base::MessageLoop message_loop_;
162
163  scoped_ptr<MetadataDatabase> metadata_database_;
164
165  int64 next_change_id_;
166  int64 next_file_id_number_;
167  int64 next_md5_sequence_number_;
168
169  DISALLOW_COPY_AND_ASSIGN(MetadataDatabaseTest);
170};
171
172}  // namespace drive_backend
173}  // namespace sync_file_system
174