Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(90)

Side by Side Diff: trunk/src/chrome/browser/extensions/api/image_writer_private/operation_unittest.cc

Issue 175423004: Revert 252466 "In order to support writing on windows we need to..." (Closed) Base URL: svn://svn.chromium.org/chrome/
Patch Set: Created 6 years, 10 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch | Annotate | Revision Log
OLDNEW
1 // Copyright 2013 The Chromium Authors. All rights reserved. 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 2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file. 3 // found in the LICENSE file.
4 4
5 #include "base/file_util.h" 5 #include "base/file_util.h"
6 #include "base/files/scoped_temp_dir.h" 6 #include "base/files/scoped_temp_dir.h"
7 #include "base/message_loop/message_loop.h" 7 #include "base/message_loop/message_loop.h"
8 #include "base/run_loop.h" 8 #include "base/run_loop.h"
9 #include "chrome/browser/extensions/api/image_writer_private/error_messages.h" 9 #include "chrome/browser/extensions/api/image_writer_private/error_messages.h"
10 #include "chrome/browser/extensions/api/image_writer_private/operation.h" 10 #include "chrome/browser/extensions/api/image_writer_private/operation.h"
(...skipping 59 matching lines...) Expand 10 before | Expand all | Expand 10 after
70 70
71 // Create the zip file. 71 // Create the zip file.
72 base::FilePath image_dir = temp_dir_.path().AppendASCII("zip"); 72 base::FilePath image_dir = temp_dir_.path().AppendASCII("zip");
73 ASSERT_TRUE(base::CreateDirectory(image_dir)); 73 ASSERT_TRUE(base::CreateDirectory(image_dir));
74 ASSERT_TRUE(base::CreateTemporaryFileInDir(image_dir, &image_path_)); 74 ASSERT_TRUE(base::CreateTemporaryFileInDir(image_dir, &image_path_));
75 75
76 FillFile(image_path_, kImagePattern, kTestFileSize); 76 FillFile(image_path_, kImagePattern, kTestFileSize);
77 77
78 zip_file_ = temp_dir_.path().AppendASCII("test_image.zip"); 78 zip_file_ = temp_dir_.path().AppendASCII("test_image.zip");
79 ASSERT_TRUE(zip::Zip(image_dir, zip_file_, true)); 79 ASSERT_TRUE(zip::Zip(image_dir, zip_file_, true));
80
81 // Operation setup.
82 operation_ = new OperationForTest(manager_.AsWeakPtr(),
83 kDummyExtensionId,
84 test_device_path_.AsUTF8Unsafe());
85 client_ = FakeImageWriterClient::Create();
86 operation_->SetImagePath(test_image_path_);
87 } 80 }
88 81
89 virtual void TearDown() OVERRIDE { 82 virtual void TearDown() OVERRIDE {
90 // Ensure all callbacks have been destroyed and cleanup occurs.
91 client_->Shutdown();
92 operation_->Cancel();
93
94 ImageWriterUnitTestBase::TearDown(); 83 ImageWriterUnitTestBase::TearDown();
95 } 84 }
96 85
97 base::FilePath image_path_; 86 base::FilePath image_path_;
98 base::FilePath zip_file_; 87 base::FilePath zip_file_;
99 88
100 MockOperationManager manager_; 89 MockOperationManager manager_;
101 scoped_refptr<FakeImageWriterClient> client_;
102 scoped_refptr<OperationForTest> operation_;
103 }; 90 };
104 91
105 } // namespace 92 } // namespace
106 93
107 // Unizpping a non-zip should do nothing.
108 TEST_F(ImageWriterOperationTest, UnzipNonZipFile) { 94 TEST_F(ImageWriterOperationTest, UnzipNonZipFile) {
95 scoped_refptr<OperationForTest> operation(
96 new OperationForTest(manager_.AsWeakPtr(),
97 kDummyExtensionId,
98 test_device_path_.AsUTF8Unsafe()));
99
109 EXPECT_CALL(manager_, OnProgress(kDummyExtensionId, _, _)).Times(0); 100 EXPECT_CALL(manager_, OnProgress(kDummyExtensionId, _, _)).Times(0);
110 101
111 EXPECT_CALL(manager_, OnError(kDummyExtensionId, _, _, _)).Times(0); 102 operation->SetImagePath(test_image_path_);
112 EXPECT_CALL(manager_, OnProgress(kDummyExtensionId, _, _)).Times(0);
113 EXPECT_CALL(manager_, OnComplete(kDummyExtensionId)).Times(0);
114 103
115 operation_->Start(); 104 operation->Start();
116 content::BrowserThread::PostTask( 105 content::BrowserThread::PostTask(
117 content::BrowserThread::FILE, 106 content::BrowserThread::FILE,
118 FROM_HERE, 107 FROM_HERE,
119 base::Bind( 108 base::Bind(
120 &OperationForTest::Unzip, operation_, base::Bind(&base::DoNothing))); 109 &OperationForTest::Unzip, operation, base::Bind(&base::DoNothing)));
121 110
122 base::RunLoop().RunUntilIdle(); 111 base::RunLoop().RunUntilIdle();
123 } 112 }
124 113
125 TEST_F(ImageWriterOperationTest, UnzipZipFile) { 114 TEST_F(ImageWriterOperationTest, UnzipZipFile) {
115 scoped_refptr<OperationForTest> operation(
116 new OperationForTest(manager_.AsWeakPtr(),
117 kDummyExtensionId,
118 test_device_path_.AsUTF8Unsafe()));
119
126 EXPECT_CALL(manager_, OnError(kDummyExtensionId, _, _, _)).Times(0); 120 EXPECT_CALL(manager_, OnError(kDummyExtensionId, _, _, _)).Times(0);
127 EXPECT_CALL(manager_, 121 EXPECT_CALL(manager_,
128 OnProgress(kDummyExtensionId, image_writer_api::STAGE_UNZIP, _)) 122 OnProgress(kDummyExtensionId, image_writer_api::STAGE_UNZIP, _))
129 .Times(AtLeast(1)); 123 .Times(AtLeast(1));
130 EXPECT_CALL(manager_, 124 EXPECT_CALL(manager_,
131 OnProgress(kDummyExtensionId, image_writer_api::STAGE_UNZIP, 0)) 125 OnProgress(kDummyExtensionId, image_writer_api::STAGE_UNZIP, 0))
132 .Times(AtLeast(1)); 126 .Times(AtLeast(1));
133 EXPECT_CALL(manager_, 127 EXPECT_CALL(manager_,
134 OnProgress(kDummyExtensionId, image_writer_api::STAGE_UNZIP, 100)) 128 OnProgress(kDummyExtensionId, image_writer_api::STAGE_UNZIP, 100))
135 .Times(AtLeast(1)); 129 .Times(AtLeast(1));
136 130
137 operation_->SetImagePath(zip_file_); 131 operation->SetImagePath(zip_file_);
138 132
139 operation_->Start(); 133 operation->Start();
140 content::BrowserThread::PostTask( 134 content::BrowserThread::PostTask(
141 content::BrowserThread::FILE, 135 content::BrowserThread::FILE,
142 FROM_HERE, 136 FROM_HERE,
143 base::Bind( 137 base::Bind(
144 &OperationForTest::Unzip, operation_, base::Bind(&base::DoNothing))); 138 &OperationForTest::Unzip, operation, base::Bind(&base::DoNothing)));
145 139
146 base::RunLoop().RunUntilIdle(); 140 base::RunLoop().RunUntilIdle();
147 141
148 EXPECT_TRUE(base::ContentsEqual(image_path_, operation_->GetImagePath())); 142 EXPECT_TRUE(base::ContentsEqual(image_path_, operation->GetImagePath()));
149 } 143 }
150 144
151 #if defined(OS_LINUX) 145 #if defined(OS_LINUX)
152 TEST_F(ImageWriterOperationTest, WriteImageToDevice) { 146 TEST_F(ImageWriterOperationTest, WriteImageToDevice) {
153 #if !defined(OS_CHROMEOS) 147
154 operation_->SetUtilityClientForTesting(client_); 148 scoped_refptr<OperationForTest> operation(
155 #endif 149 new OperationForTest(manager_.AsWeakPtr(),
150 kDummyExtensionId,
151 test_device_path_.AsUTF8Unsafe()));
156 152
157 EXPECT_CALL(manager_, OnError(kDummyExtensionId, _, _, _)).Times(0); 153 EXPECT_CALL(manager_, OnError(kDummyExtensionId, _, _, _)).Times(0);
158 EXPECT_CALL(manager_, 154 EXPECT_CALL(manager_,
159 OnProgress(kDummyExtensionId, image_writer_api::STAGE_WRITE, _)) 155 OnProgress(kDummyExtensionId, image_writer_api::STAGE_WRITE, _))
160 .Times(AtLeast(1)); 156 .Times(AtLeast(1));
161 EXPECT_CALL(manager_, 157 EXPECT_CALL(manager_,
162 OnProgress(kDummyExtensionId, image_writer_api::STAGE_WRITE, 0)) 158 OnProgress(kDummyExtensionId, image_writer_api::STAGE_WRITE, 0))
163 .Times(AtLeast(1)); 159 .Times(AtLeast(1));
164 EXPECT_CALL(manager_, 160 EXPECT_CALL(manager_,
165 OnProgress(kDummyExtensionId, image_writer_api::STAGE_WRITE, 100)) 161 OnProgress(kDummyExtensionId, image_writer_api::STAGE_WRITE, 100))
166 .Times(AtLeast(1)); 162 .Times(AtLeast(1));
167 163
168 operation_->Start(); 164 operation->SetImagePath(test_image_path_);
165
166 operation->Start();
169 content::BrowserThread::PostTask( 167 content::BrowserThread::PostTask(
170 content::BrowserThread::FILE, 168 content::BrowserThread::FILE,
171 FROM_HERE, 169 FROM_HERE,
172 base::Bind( 170 base::Bind(
173 &OperationForTest::Write, operation_, base::Bind(&base::DoNothing))); 171 &OperationForTest::Write, operation, base::Bind(&base::DoNothing)));
174 172
175 base::RunLoop().RunUntilIdle(); 173 base::RunLoop().RunUntilIdle();
176 174
177 #if !defined(OS_CHROMEOS) 175 #if !defined(OS_CHROMEOS)
178 client_->Progress(0); 176 // Chrome OS tests don't actually write to the disk because that's handled by
179 client_->Progress(kTestFileSize / 2); 177 // the DBUS process.
180 client_->Progress(kTestFileSize); 178 EXPECT_TRUE(base::ContentsEqual(test_image_path_, test_device_path_));
181 client_->Success();
182
183 base::RunLoop().RunUntilIdle();
184 #endif 179 #endif
185 } 180 }
186 #endif 181 #endif
187 182
188 #if !defined(OS_CHROMEOS) 183 #if defined(OS_LINUX) && !defined(OS_CHROMEOS)
189 // Chrome OS doesn't support verification in the ImageBurner, so these two tests 184 // Chrome OS doesn't support verification in the ImageBurner, so these two tests
190 // are skipped. 185 // are skipped.
191 186
192 TEST_F(ImageWriterOperationTest, VerifyFileSuccess) { 187 TEST_F(ImageWriterOperationTest, VerifyFileSuccess) {
193 operation_->SetUtilityClientForTesting(client_); 188 scoped_refptr<OperationForTest> operation(
189 new OperationForTest(manager_.AsWeakPtr(),
190 kDummyExtensionId,
191 test_device_path_.AsUTF8Unsafe()));
194 192
195 EXPECT_CALL(manager_, OnError(kDummyExtensionId, _, _, _)).Times(0); 193 EXPECT_CALL(manager_, OnError(kDummyExtensionId, _, _, _)).Times(0);
196 EXPECT_CALL( 194 EXPECT_CALL(
197 manager_, 195 manager_,
198 OnProgress(kDummyExtensionId, image_writer_api::STAGE_VERIFYWRITE, _)) 196 OnProgress(kDummyExtensionId, image_writer_api::STAGE_VERIFYWRITE, _))
199 .Times(AtLeast(1)); 197 .Times(AtLeast(1));
200 EXPECT_CALL( 198 EXPECT_CALL(
201 manager_, 199 manager_,
202 OnProgress(kDummyExtensionId, image_writer_api::STAGE_VERIFYWRITE, 0)) 200 OnProgress(kDummyExtensionId, image_writer_api::STAGE_VERIFYWRITE, 0))
203 .Times(AtLeast(1)); 201 .Times(AtLeast(1));
204 EXPECT_CALL( 202 EXPECT_CALL(
205 manager_, 203 manager_,
206 OnProgress(kDummyExtensionId, image_writer_api::STAGE_VERIFYWRITE, 100)) 204 OnProgress(kDummyExtensionId, image_writer_api::STAGE_VERIFYWRITE, 100))
207 .Times(AtLeast(1)); 205 .Times(AtLeast(1));
208 206
209 FillFile(test_device_path_, kImagePattern, kTestFileSize); 207 FillFile(test_device_path_, kImagePattern, kTestFileSize);
208 operation->SetImagePath(test_image_path_);
210 209
211 operation_->Start(); 210 operation->Start();
212 content::BrowserThread::PostTask(content::BrowserThread::FILE, 211 content::BrowserThread::PostTask(content::BrowserThread::FILE,
213 FROM_HERE, 212 FROM_HERE,
214 base::Bind(&OperationForTest::VerifyWrite, 213 base::Bind(&OperationForTest::VerifyWrite,
215 operation_, 214 operation,
216 base::Bind(&base::DoNothing))); 215 base::Bind(&base::DoNothing)));
217 216
218 base::RunLoop().RunUntilIdle(); 217 base::RunLoop().RunUntilIdle();
219
220 client_->Progress(0);
221 client_->Progress(kTestFileSize / 2);
222 client_->Progress(kTestFileSize);
223 client_->Success();
224
225 base::RunLoop().RunUntilIdle();
226 } 218 }
227 219
228 TEST_F(ImageWriterOperationTest, VerifyFileFailure) { 220 TEST_F(ImageWriterOperationTest, VerifyFileFailure) {
229 operation_->SetUtilityClientForTesting(client_); 221 scoped_refptr<OperationForTest> operation(
222 new OperationForTest(manager_.AsWeakPtr(),
223 kDummyExtensionId,
224 test_device_path_.AsUTF8Unsafe()));
230 225
231 EXPECT_CALL( 226 EXPECT_CALL(
232 manager_, 227 manager_,
228 OnError(kDummyExtensionId, image_writer_api::STAGE_VERIFYWRITE, _, _))
229 .Times(1);
230 EXPECT_CALL(
231 manager_,
233 OnProgress(kDummyExtensionId, image_writer_api::STAGE_VERIFYWRITE, _)) 232 OnProgress(kDummyExtensionId, image_writer_api::STAGE_VERIFYWRITE, _))
234 .Times(AnyNumber()); 233 .Times(AnyNumber());
235 EXPECT_CALL( 234 EXPECT_CALL(
236 manager_, 235 manager_,
237 OnProgress(kDummyExtensionId, image_writer_api::STAGE_VERIFYWRITE, 100)) 236 OnProgress(kDummyExtensionId, image_writer_api::STAGE_VERIFYWRITE, 100))
238 .Times(0); 237 .Times(0);
239 EXPECT_CALL(manager_, OnComplete(kDummyExtensionId)).Times(0);
240 EXPECT_CALL(
241 manager_,
242 OnError(kDummyExtensionId, image_writer_api::STAGE_VERIFYWRITE, _, _))
243 .Times(1);
244 238
245 FillFile(test_device_path_, kDevicePattern, kTestFileSize); 239 FillFile(test_device_path_, kDevicePattern, kTestFileSize);
240 operation->SetImagePath(test_image_path_);
246 241
247 operation_->Start(); 242 operation->Start();
248 content::BrowserThread::PostTask(content::BrowserThread::FILE, 243 content::BrowserThread::PostTask(content::BrowserThread::FILE,
249 FROM_HERE, 244 FROM_HERE,
250 base::Bind(&OperationForTest::VerifyWrite, 245 base::Bind(&OperationForTest::VerifyWrite,
251 operation_, 246 operation,
252 base::Bind(&base::DoNothing))); 247 base::Bind(&base::DoNothing)));
253 248
254 base::RunLoop().RunUntilIdle(); 249 base::RunLoop().RunUntilIdle();
255
256 client_->Progress(0);
257 client_->Progress(kTestFileSize / 2);
258 client_->Error(error::kVerificationFailed);
259
260 base::RunLoop().RunUntilIdle();
261 } 250 }
262 #endif 251 #endif
263 252
264 // Tests that on creation the operation_ has the expected state. 253 // Tests that on creation the operation has the expected state.
265 TEST_F(ImageWriterOperationTest, Creation) { 254 TEST_F(ImageWriterOperationTest, Creation) {
266 EXPECT_EQ(0, operation_->GetProgress()); 255 scoped_refptr<Operation> op(
267 EXPECT_EQ(image_writer_api::STAGE_UNKNOWN, operation_->GetStage()); 256 new OperationForTest(manager_.AsWeakPtr(),
257 kDummyExtensionId,
258 test_device_path_.AsUTF8Unsafe()));
259
260 EXPECT_EQ(0, op->GetProgress());
261 EXPECT_EQ(image_writer_api::STAGE_UNKNOWN, op->GetStage());
268 } 262 }
269 263
270 } // namespace image_writer 264 } // namespace image_writer
271 } // namespace extensions 265 } // namespace extensions
OLDNEW

Powered by Google App Engine
This is Rietveld 408576698