webkit/fileapi/local_file_writer_unittest.cc

// 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);
}