fileapi: FileWriter and LocalFileWriter.

webkit/fileapi/local_file_writer_unittest.cc

Index: webkit/fileapi/local_file_writer_unittest.cc
diff --git a/webkit/fileapi/local_file_writer_unittest.cc b/webkit/fileapi/local_file_writer_unittest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..a8ff7bb20ea89f5e128b21a97a81914c2d217075
--- /dev/null
+++ b/webkit/fileapi/local_file_writer_unittest.cc
@@ -0,0 +1,160 @@
+// Copyright (c) 2012 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.
+
+// NOTE: These tests are run as part of "unit_tests" (in chrome/test) rather
+// than as part of test_shell_tests because they rely on being able to
+// instantiate a MessageLoop of type TYPE_IO.  test_shell_tests uses TYPE_UI,
+// which net::TestCompletionCallback doesn't allow.
+
+#include "webkit/fileapi/local_file_writer.h"
+
+#include <string>
+
+#include "base/callback.h"
+#include "base/file_util.h"
+#include "base/logging.h"
+#include "base/message_loop.h"
+#include "base/scoped_temp_dir.h"
+#include "base/memory/scoped_ptr.h"
+#include "net/base/io_buffer.h"
+#include "net/base/test_completion_callback.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace {
+
+using fileapi::LocalFileWriter;
+
+class LocalFileWriterTest : public testing::Test {
+ public:
+  LocalFileWriterTest() : message_loop_(MessageLoop::TYPE_IO) {}
+
+  virtual void SetUp() OVERRIDE {
+    ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
+  }
+
+ protected:
+  FilePath Path(const std::string& name) {
+    return temp_dir_.path().AppendASCII(name);
+  }
+
+  int WriteStringToWriter(LocalFileWriter* writer, const std::string& data) {
+    scoped_refptr<net::StringIOBuffer> buffer(new net::StringIOBuffer(data));
+    scoped_refptr<net::DrainableIOBuffer> drainable(
+        new net::DrainableIOBuffer(buffer, buffer->size()));
+
+    while (drainable->BytesRemaining() > 0) {
+      net::TestCompletionCallback callback;
+      int result = writer->Write(drainable, drainable->BytesRemaining(),
+                                 callback.callback());
+      if (result == net::ERR_IO_PENDING)
+        result = callback.WaitForResult();
+      if (result <= 0)
+        return result;
+      drainable->DidConsume(result);
+    }
+    return net::OK;
+  }
+
+  std::string GetFileContent(const FilePath& path) {
+    std::string content;
+    file_util::ReadFileToString(path, &content);
+    return content;
+  }
+
+  FilePath CreateFileWithContent(const std::string& name,
+                                 const std::string& data) {
+    FilePath path = Path(name);
+    file_util::WriteFile(path, data.c_str(), data.size());
+    return path;
+  }
+
+ private:
+  MessageLoop message_loop_;
+  ScopedTempDir temp_dir_;
+};
+
+void NeverCalled(int) {
+  ADD_FAILURE();
+}
+
+}  // namespace
+
+TEST_F(LocalFileWriterTest, Write) {
+  FilePath path = CreateFileWithContent("file_a", "");
+  scoped_ptr<LocalFileWriter> writer(new LocalFileWriter(path, 0));
+  EXPECT_EQ(net::OK, WriteStringToWriter(writer.get(), "foo"));
+  EXPECT_EQ(net::OK, WriteStringToWriter(writer.get(), "bar"));
+  writer.reset();
+  MessageLoop::current()->RunAllPending();
+  EXPECT_TRUE(file_util::PathExists(path));
+  EXPECT_EQ("foobar", GetFileContent(path));
+}
+
+TEST_F(LocalFileWriterTest, WriteMiddle) {
+  FilePath path = CreateFileWithContent("file_a", "foobar");
+  scoped_ptr<LocalFileWriter> writer(new LocalFileWriter(path, 2));
+  EXPECT_EQ(net::OK, WriteStringToWriter(writer.get(), "xxx"));
+  writer.reset();
+  MessageLoop::current()->RunAllPending();
+  EXPECT_TRUE(file_util::PathExists(path));
+  EXPECT_EQ("foxxxr", GetFileContent(path));
+}
+
+TEST_F(LocalFileWriterTest, WriteEnd) {
+  FilePath path = CreateFileWithContent("file_a", "foobar");
+  scoped_ptr<LocalFileWriter> writer(new LocalFileWriter(path, 6));
+  EXPECT_EQ(net::OK, WriteStringToWriter(writer.get(), "xxx"));
+  writer.reset();
+  MessageLoop::current()->RunAllPending();
+  EXPECT_TRUE(file_util::PathExists(path));
+  EXPECT_EQ("foobarxxx", GetFileContent(path));
+}
+
+TEST_F(LocalFileWriterTest, WriteFailForNonexistingFile) {
+  FilePath path = Path("file_a");
+  ASSERT_FALSE(file_util::PathExists(path));
+  scoped_ptr<LocalFileWriter> writer(new LocalFileWriter(path, 0));
+  EXPECT_EQ(net::ERR_FILE_NOT_FOUND, WriteStringToWriter(writer.get(), "foo"));
+  writer.reset();
+  MessageLoop::current()->RunAllPending();
+  EXPECT_FALSE(file_util::PathExists(path));
+}
+
+TEST_F(LocalFileWriterTest, CancelBeforeOperation) {
+  FilePath path = Path("file_a");
+  scoped_ptr<LocalFileWriter> writer(new LocalFileWriter(path, 0));
+  // Cancel immediately fails when there's no in-flight operation.
+  int cancel_result = writer->Cancel(base::Bind(&NeverCalled));
+  EXPECT_EQ(net::ERR_UNEXPECTED, cancel_result);
+}
+
+TEST_F(LocalFileWriterTest, CancelAfterFinishedOperation) {
+  FilePath path = CreateFileWithContent("file_a", "");
+  scoped_ptr<LocalFileWriter> writer(new LocalFileWriter(path, 0));
+  EXPECT_EQ(net::OK, WriteStringToWriter(writer.get(), "foo"));
+
+  // Cancel immediately fails when there's no in-flight operation.
+  int cancel_result = writer->Cancel(base::Bind(&NeverCalled));
+  EXPECT_EQ(net::ERR_UNEXPECTED, cancel_result);
+
+  writer.reset();
+  MessageLoop::current()->RunAllPending();
+  // Write operation is already completed.
+  EXPECT_TRUE(file_util::PathExists(path));
+  EXPECT_EQ("foo", GetFileContent(path));
+}
+
+TEST_F(LocalFileWriterTest, CancelWrite) {
+  FilePath path = CreateFileWithContent("file_a", "foobar");
+  scoped_ptr<LocalFileWriter> writer(new LocalFileWriter(path, 0));
+
+  scoped_refptr<net::StringIOBuffer> buffer(new net::StringIOBuffer("xxx"));
+  int result = writer->Write(buffer, buffer->size(), base::Bind(&NeverCalled));
+  ASSERT_EQ(net::ERR_IO_PENDING, result);
+
+  net::TestCompletionCallback callback;
+  writer->Cancel(callback.callback());
+  int cancel_result = callback.WaitForResult();
+  EXPECT_EQ(net::OK, cancel_result);
+}