Index: net/http/http_cache_writers_unittest.cc |
diff --git a/net/http/http_cache_writers_unittest.cc b/net/http/http_cache_writers_unittest.cc |
new file mode 100644 |
index 0000000000000000000000000000000000000000..3b7c107ff5d3a790bd2d3ee5c8d0452f4746daa5 |
--- /dev/null |
+++ b/net/http/http_cache_writers_unittest.cc |
@@ -0,0 +1,726 @@ |
+// Copyright (c) 2017 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. |
+ |
+#include "net/http/http_cache_writers.h" |
+ |
+#include <memory> |
+#include <string> |
+#include <vector> |
+ |
+#include "base/run_loop.h" |
+#include "net/http/http_cache.h" |
+#include "net/http/http_cache_transaction.h" |
+#include "net/http/http_transaction.h" |
+#include "net/http/http_transaction_test_util.h" |
+#include "net/http/mock_http_cache.h" |
+#include "net/test/gtest_util.h" |
+ |
+using net::test::IsError; |
+using net::test::IsOk; |
+ |
+namespace net { |
+ |
+class WritersTest : public testing::Test { |
+ public: |
+ WritersTest() : disk_entry_(nullptr), request_(kSimpleGET_Transaction) {} |
+ |
+ ~WritersTest() override { |
+ if (disk_entry_) |
+ disk_entry_->Close(); |
+ } |
+ |
+ void CreateWriters(const std::string& url) { |
+ cache_.CreateBackendEntry(kSimpleGET_Transaction.url, &disk_entry_, |
+ nullptr); |
+ writers_ = base::MakeUnique<HttpCache::Writers>(disk_entry_); |
+ } |
+ |
+ std::unique_ptr<HttpTransaction> CreateNetworkTransaction() { |
+ std::unique_ptr<HttpTransaction> transaction; |
+ MockNetworkLayer* network_layer = cache_.network_layer(); |
+ network_layer->CreateTransaction(DEFAULT_PRIORITY, &transaction); |
+ return transaction; |
+ } |
+ |
+ void CreateWritersAddTransaction(bool is_exclusive = false) { |
+ std::unique_ptr<HttpTransaction> transaction; |
+ int rv = cache_.CreateTransaction(&transaction); |
+ EXPECT_EQ(rv, OK); |
+ EXPECT_TRUE(transaction); |
+ |
+ TestCompletionCallback callback; |
+ |
+ CreateWriters(kSimpleGET_Transaction.url); |
+ |
+ // Create and Start a mock network transaction. |
+ std::unique_ptr<HttpTransaction> network_transaction; |
+ network_transaction = CreateNetworkTransaction(); |
+ network_transaction->Start(&request_, callback.callback(), |
+ NetLogWithSource()); |
+ base::RunLoop().RunUntilIdle(); |
+ |
+ EXPECT_TRUE(writers_->IsEmpty()); |
+ writers_->AddTransaction( |
+ static_cast<HttpCache::Transaction*>(transaction.get()), |
+ std::move(network_transaction), is_exclusive); |
+ EXPECT_TRUE(writers_->HasTransaction( |
+ static_cast<HttpCache::Transaction*>(transaction.get()))); |
+ transactions_.push_back(std::move(transaction)); |
+ } |
+ |
+ void CreateWritersAddTransactionPriority(net::RequestPriority priority, |
+ bool is_exclusive = false) { |
+ CreateWritersAddTransaction(is_exclusive); |
+ HttpCache::Transaction* transaction = |
+ static_cast<HttpCache::Transaction*>(transactions_.begin()->get()); |
+ transaction->SetPriority(priority); |
+ } |
+ |
+ void AddTransactionToExistingWriters() { |
+ std::unique_ptr<HttpTransaction> transaction; |
+ int rv = cache_.CreateTransaction(&transaction); |
+ EXPECT_EQ(rv, OK); |
+ EXPECT_TRUE(transaction); |
+ |
+ EXPECT_TRUE(writers_); |
+ writers_->AddTransaction( |
+ static_cast<HttpCache::Transaction*>(transaction.get()), nullptr, |
+ false); |
+ transactions_.push_back(std::move(transaction)); |
+ } |
+ |
+ int Read(std::string* result) { |
+ EXPECT_TRUE(transactions_.size() >= (size_t)1); |
+ HttpCache::Transaction* transaction = |
+ static_cast<HttpCache::Transaction*>(transactions_.begin()->get()); |
+ TestCompletionCallback callback; |
+ |
+ std::string content; |
+ int rv = 0; |
+ do { |
+ scoped_refptr<IOBuffer> buf(new IOBuffer(256)); |
+ rv = writers_->Read(buf.get(), 256, callback.callback(), transaction); |
+ if (rv == ERR_IO_PENDING) { |
+ rv = callback.WaitForResult(); |
+ base::RunLoop().RunUntilIdle(); |
+ } |
+ |
+ if (rv > 0) |
+ content.append(buf->data(), rv); |
+ else if (rv < 0) |
+ return rv; |
+ } while (rv > 0); |
+ |
+ result->swap(content); |
+ return OK; |
+ } |
+ |
+ int ReadAll(std::vector<std::string>* results) { |
+ int rv = 0; |
+ do { |
+ std::vector<scoped_refptr<IOBuffer>> bufs; |
+ std::vector<TestCompletionCallback> callbacks(results->size()); |
+ |
+ // Multiple transactions should be able to read. |
+ for (size_t i = 0; i < transactions_.size(); i++) { |
+ bufs.push_back(new IOBuffer(256)); |
+ rv = writers_->Read( |
+ bufs[i].get(), 256, callbacks[i].callback(), |
+ static_cast<HttpCache::Transaction*>(transactions_[i].get())); |
+ EXPECT_EQ(rv, ERR_IO_PENDING); // Since the default is asynchronous. |
+ } |
+ |
+ int prev_rv = callbacks[0].WaitForResult(); |
+ rv = prev_rv; |
+ for (size_t i = 1; i < callbacks.size(); i++) { |
jkarlin
2017/07/06 18:50:04
Really qequires at least 2 transactions, can you A
shivanisha
2017/07/11 02:10:27
done
|
+ rv = callbacks[i].WaitForResult(); |
+ EXPECT_EQ(rv, prev_rv); |
+ prev_rv = rv; |
+ } |
+ |
+ if (rv > 0) { |
+ for (size_t i = 0; i < results->size(); i++) |
+ results->at(i).append(bufs[i]->data(), rv); |
+ } else if (rv <= 0) { |
+ return rv; |
+ } |
+ } while (rv > 0); |
+ |
+ return OK; |
+ } |
+ |
+ void ReadVerifyTwoDifferentBufferLengths( |
+ const std::vector<int>& buffer_lengths) { |
+ EXPECT_EQ(2u, buffer_lengths.size()); |
+ EXPECT_EQ(2u, transactions_.size()); |
+ |
+ std::vector<std::string> results(buffer_lengths.size()); |
+ |
+ // Check only the 1st Read and not the complete response because the smaller |
+ // buffer transaction will need to read the remaining response from the |
+ // cache which will be tested when integrated with HttpCache::Transaction |
+ // layer. |
+ |
+ int rv = 0; |
+ |
+ std::vector<scoped_refptr<IOBuffer>> bufs; |
+ for (auto buffer_length : buffer_lengths) |
+ bufs.push_back(new IOBuffer(buffer_length)); |
+ |
+ std::vector<TestCompletionCallback> callbacks(buffer_lengths.size()); |
+ |
+ // Multiple transactions should be able to read with different sized |
+ // buffers. |
+ for (size_t i = 0; i < transactions_.size(); i++) { |
+ rv = writers_->Read( |
+ bufs[i].get(), buffer_lengths[i], callbacks[i].callback(), |
+ static_cast<HttpCache::Transaction*>(transactions_[i].get())); |
+ EXPECT_EQ(rv, ERR_IO_PENDING); // Since the default is asynchronous. |
jkarlin
2017/07/06 18:50:04
In expect/assert/dcheck/check macros the argument
shivanisha
2017/07/11 02:10:26
done
|
+ } |
+ |
+ size_t larger = 0; |
+ size_t smaller = 1; |
+ bool same_length = false; |
+ if (buffer_lengths[1] > buffer_lengths[0]) { |
+ larger = 1; |
+ smaller = 0; |
+ // If first buffer is smaller, then the second one will only read the |
+ // smaller length as well. |
+ same_length = true; |
+ } |
jkarlin
2017/07/06 18:50:04
How about:
std::vector<size_t> expected_lengths =
shivanisha
2017/07/11 02:10:26
Much nicer, thanks.
|
+ |
+ for (size_t i = 0; i < callbacks.size(); i++) { |
+ rv = callbacks[i].WaitForResult(); |
+ |
+ if (same_length) { |
+ EXPECT_EQ(rv, buffer_lengths[smaller]); |
+ results.at(i).append(bufs[i]->data(), buffer_lengths[smaller]); |
+ if (i == 1) |
+ EXPECT_EQ(results[larger], results[smaller]); |
+ } else { |
+ EXPECT_EQ(rv, buffer_lengths[i]); |
+ results.at(i).append(bufs[i]->data(), buffer_lengths[i]); |
+ if (i == 1) { |
+ EXPECT_EQ(results[larger].substr(0, buffer_lengths[smaller]), |
+ results[smaller]); |
+ } |
+ } |
+ } |
+ } |
+ |
+ int ReadAllDeleteActiveTransaction(std::vector<std::string>* results) { |
jkarlin
2017/07/06 18:50:04
Seems like the ReadAllDeleteXTransaction functions
shivanisha
2017/07/11 02:10:26
Done. Happy to remove all the other functions.
|
+ int rv = 0; |
+ bool first_iter = true; |
+ do { |
+ std::vector<scoped_refptr<IOBuffer>> bufs; |
+ std::vector<TestCompletionCallback> callbacks(results->size()); |
+ |
+ // Multiple transactions should be able to read. |
+ for (size_t i = 0; i < transactions_.size(); i++) { |
+ bufs.push_back(new IOBuffer(256)); |
+ if (!first_iter && i == 0) |
+ continue; |
+ |
+ rv = writers_->Read( |
+ bufs[i].get(), 256, callbacks[i].callback(), |
+ static_cast<HttpCache::Transaction*>(transactions_[i].get())); |
+ EXPECT_EQ(rv, ERR_IO_PENDING); // Since the default is asynchronous. |
+ } |
+ |
+ if (first_iter) { |
+ // Delete active transaction. |
+ RemoveFirstTransaction(); |
+ } |
+ int prev_rv = callbacks[1].WaitForResult(); |
+ rv = prev_rv; |
+ for (size_t i = 2; i < callbacks.size(); i++) { |
jkarlin
2017/07/06 18:50:04
This really requires at least 3 transactions, can
shivanisha
2017/07/11 02:10:26
done
|
+ rv = callbacks[i].WaitForResult(); |
+ EXPECT_EQ(rv, prev_rv); |
+ prev_rv = rv; |
+ } |
+ |
+ if (rv > 0) { |
+ for (size_t i = 0; i < results->size(); i++) |
+ results->at(i).append(bufs[i]->data(), rv); |
+ } |
+ first_iter = false; |
+ } while (rv > 0); |
+ |
+ return rv; |
+ } |
+ |
+ int ReadAllDeleteWaitingTransaction(size_t waiting_index, |
+ std::vector<std::string>* results) { |
+ int rv = 0; |
+ bool first_iter = true; |
+ do { |
+ std::vector<scoped_refptr<IOBuffer>> bufs; |
+ std::vector<TestCompletionCallback> callbacks(results->size()); |
+ |
+ // Multiple transactions should be able to read. |
+ for (size_t i = 0; i < transactions_.size(); i++) { |
+ bufs.push_back(new IOBuffer(256)); |
+ if (!first_iter && i == waiting_index) |
+ continue; |
+ |
+ rv = writers_->Read( |
+ bufs[i].get(), 256, callbacks[i].callback(), |
+ static_cast<HttpCache::Transaction*>(transactions_[i].get())); |
+ EXPECT_EQ(rv, ERR_IO_PENDING); // Since the default is asynchronous. |
+ } |
+ |
+ if (first_iter) { |
+ // Delete waiting transaction. |
+ writers_->RemoveTransaction(static_cast<HttpCache::Transaction*>( |
+ transactions_.at(waiting_index).get())); |
+ } |
+ int prev_rv = callbacks[0].WaitForResult(); |
+ rv = prev_rv; |
+ for (size_t i = 1; i < callbacks.size(); i++) { |
+ if (i == waiting_index) |
+ continue; |
+ rv = callbacks[i].WaitForResult(); |
+ EXPECT_EQ(rv, prev_rv); |
+ prev_rv = rv; |
+ } |
+ |
+ if (rv > 0) { |
+ for (size_t i = 0; i < results->size(); i++) { |
+ if (i == waiting_index) |
+ continue; |
+ results->at(i).append(bufs[i]->data(), rv); |
+ } |
+ } |
+ first_iter = false; |
+ } while (rv > 0); |
+ |
+ return rv; |
+ } |
+ |
+ int ReadAllDeleteIdleTransaction(size_t idle_index, |
+ std::vector<std::string>* results) { |
+ int rv = 0; |
+ bool first_iter = true; |
+ do { |
+ std::vector<scoped_refptr<IOBuffer>> bufs; |
+ std::vector<TestCompletionCallback> callbacks(results->size()); |
+ |
+ // Multiple transactions should be able to read. |
+ for (size_t i = 0; i < transactions_.size(); i++) { |
+ bufs.push_back(new IOBuffer(256)); |
+ if (i == idle_index) |
+ continue; |
+ |
+ rv = writers_->Read( |
+ bufs[i].get(), 256, callbacks[i].callback(), |
+ static_cast<HttpCache::Transaction*>(transactions_[i].get())); |
+ EXPECT_EQ(rv, ERR_IO_PENDING); // Since the default is asynchronous. |
+ } |
+ |
+ if (first_iter) { |
+ // Delete idle transaction. |
+ writers_->RemoveTransaction(static_cast<HttpCache::Transaction*>( |
+ transactions_.at(idle_index).get())); |
+ } |
+ int prev_rv = callbacks[0].WaitForResult(); |
+ rv = prev_rv; |
+ for (size_t i = 1; i < callbacks.size(); i++) { |
+ if (i == idle_index) |
+ continue; |
+ rv = callbacks[i].WaitForResult(); |
+ EXPECT_EQ(rv, prev_rv); |
+ prev_rv = rv; |
+ } |
+ |
+ if (rv > 0) { |
+ for (size_t i = 0; i < results->size(); i++) { |
+ if (i == idle_index) |
+ continue; |
+ results->at(i).append(bufs[i]->data(), rv); |
+ } |
+ } |
+ first_iter = false; |
+ } while (rv > 0); |
+ |
+ return rv; |
+ } |
+ |
+ int ReadCacheWriteFailure(std::vector<std::string>* results) { |
+ int rv = 0; |
+ int active_transaction_rv = 0; |
+ bool first_iter = true; |
+ do { |
+ std::vector<scoped_refptr<IOBuffer>> bufs; |
+ std::vector<TestCompletionCallback> callbacks(results->size()); |
+ |
+ // Fail the request. |
+ cache_.disk_cache()->set_soft_failures(true); |
+ |
+ // We have to open the entry again to propagate the failure flag. |
+ disk_cache::Entry* en; |
+ cache_.OpenBackendEntry(kSimpleGET_Transaction.url, &en); |
+ en->Close(); |
+ |
+ for (size_t i = 0; i < transactions_.size(); i++) { |
+ bufs.push_back(new IOBuffer(30)); |
+ |
+ if (!first_iter && i > 0) |
+ break; |
+ rv = writers_->Read( |
+ bufs[i].get(), 30, callbacks[i].callback(), |
+ static_cast<HttpCache::Transaction*>(transactions_[i].get())); |
+ EXPECT_EQ(rv, ERR_IO_PENDING); // Since the default is asynchronous. |
+ } |
+ |
+ for (size_t i = 0; i < callbacks.size(); i++) { |
+ // Only active transaction should succeed. |
+ if (i == 0) { |
+ active_transaction_rv = callbacks[i].WaitForResult(); |
+ EXPECT_TRUE(active_transaction_rv >= 0); |
+ results->at(0).append(bufs[i]->data(), active_transaction_rv); |
+ } else if (first_iter) { |
+ rv = callbacks[i].WaitForResult(); |
+ EXPECT_EQ(ERR_CACHE_WRITE_FAILURE, rv); |
+ } |
+ } |
+ |
+ first_iter = false; |
+ } while (active_transaction_rv > 0); |
+ |
+ return active_transaction_rv; |
+ } |
+ |
+ int ReadNetworkFailure(std::vector<std::string>* results, Error error) { |
+ int rv = 0; |
+ std::vector<scoped_refptr<IOBuffer>> bufs; |
+ std::vector<TestCompletionCallback> callbacks(results->size()); |
+ |
+ for (size_t i = 0; i < transactions_.size(); i++) { |
+ bufs.push_back(new IOBuffer(30)); |
+ |
+ rv = writers_->Read( |
+ bufs[i].get(), 30, callbacks[i].callback(), |
+ static_cast<HttpCache::Transaction*>(transactions_[i].get())); |
+ EXPECT_EQ(rv, ERR_IO_PENDING); // Since the default is asynchronous. |
+ } |
+ |
+ for (auto& callback : callbacks) { |
+ rv = callback.WaitForResult(); |
+ EXPECT_EQ(error, rv); |
+ } |
+ |
+ return error; |
+ } |
+ |
+ bool StopCaching() { |
+ HttpCache::Transaction* transaction = |
+ static_cast<HttpCache::Transaction*>(transactions_.begin()->get()); |
+ EXPECT_TRUE(transaction); |
+ return writers_->StopCaching(transaction); |
+ } |
+ |
+ void RemoveFirstTransaction() { |
+ HttpCache::Transaction* transaction = |
+ static_cast<HttpCache::Transaction*>(transactions_.begin()->get()); |
+ EXPECT_TRUE(transaction); |
+ writers_->RemoveTransaction(transaction); |
+ } |
+ |
+ void UpdateAndVerifyPriority(RequestPriority priority) { |
+ writers_->UpdatePriority(); |
+ EXPECT_EQ(writers_->priority_, priority); |
+ } |
+ |
+ MockHttpCache cache_; |
+ std::unique_ptr<HttpCache::Writers> writers_; |
+ disk_cache::Entry* disk_entry_; |
+ |
+ // Should be before transactions_ since it is accessed in the network |
+ // transaction's destructor. |
+ MockHttpRequest request_; |
+ |
+ std::vector<std::unique_ptr<HttpTransaction>> transactions_; |
+}; |
+ |
+// Tests successful addition of a transaction. |
+TEST_F(WritersTest, AddTransaction) { |
+ CreateWritersAddTransaction(); |
+ EXPECT_FALSE(writers_->IsEmpty()); |
+} |
+ |
+// Tests successful addition of multiple transaction. |
jkarlin
2017/07/06 18:50:04
s/transaction/transactions/
shivanisha
2017/07/11 02:10:26
done
|
+TEST_F(WritersTest, AddManyTransactions) { |
+ CreateWritersAddTransaction(); |
+ EXPECT_FALSE(writers_->IsEmpty()); |
+ |
+ for (int i = 0; i < 5; i++) |
+ AddTransactionToExistingWriters(); |
+ |
+ EXPECT_EQ(writers_->CountTransactionsForTesting(), 6); |
+} |
+ |
+// Tests that CanAddWriters should return false if it is exclusive writing. |
jkarlin
2017/07/06 18:50:04
s/exclusive writing/writing exclusively/
shivanisha
2017/07/11 02:10:26
done
|
+TEST_F(WritersTest, AddTransactionsExclusive) { |
+ CreateWritersAddTransaction(true /* is_exclusive */); |
+ EXPECT_FALSE(writers_->IsEmpty()); |
+ |
+ EXPECT_FALSE(writers_->CanAddWriters()); |
+} |
+ |
+// Tests StopCaching should not stop caching if there are multiple writers. |
+TEST_F(WritersTest, StopCachingMultipleWriters) { |
+ CreateWritersAddTransaction(); |
+ EXPECT_FALSE(writers_->IsEmpty()); |
+ |
+ EXPECT_TRUE(writers_->CanAddWriters()); |
+ AddTransactionToExistingWriters(); |
+ |
+ EXPECT_FALSE(StopCaching()); |
+ EXPECT_TRUE(writers_->CanAddWriters()); |
+} |
+ |
+// Tests StopCaching should stop caching if there is a single writer. |
+TEST_F(WritersTest, StopCaching) { |
+ CreateWritersAddTransaction(); |
+ EXPECT_FALSE(writers_->IsEmpty()); |
+ |
+ EXPECT_TRUE(StopCaching()); |
+ EXPECT_FALSE(writers_->CanAddWriters()); |
+} |
+ |
+// Tests removing of an idle transaction and change in priority. |
+TEST_F(WritersTest, RemoveIdleTransaction) { |
+ CreateWritersAddTransactionPriority(HIGHEST); |
+ UpdateAndVerifyPriority(HIGHEST); |
+ |
+ AddTransactionToExistingWriters(); |
+ UpdateAndVerifyPriority(HIGHEST); |
+ |
+ EXPECT_FALSE(writers_->IsEmpty()); |
+ EXPECT_EQ(2, writers_->CountTransactionsForTesting()); |
+ |
+ RemoveFirstTransaction(); |
+ EXPECT_EQ(1, writers_->CountTransactionsForTesting()); |
+ |
+ UpdateAndVerifyPriority(DEFAULT_PRIORITY); |
+} |
+ |
+// Tests that Read is successful. |
+TEST_F(WritersTest, Read) { |
+ CreateWritersAddTransaction(); |
+ EXPECT_FALSE(writers_->IsEmpty()); |
+ |
+ std::string content; |
+ int rv = Read(&content); |
+ |
+ EXPECT_THAT(rv, IsOk()); |
+ std::string expected(kSimpleGET_Transaction.data); |
+ EXPECT_EQ(expected, content); |
+} |
+ |
+// Tests that multiple transactions can read the same data simultaneously. |
+TEST_F(WritersTest, ReadMultiple) { |
+ CreateWritersAddTransaction(); |
+ EXPECT_FALSE(writers_->IsEmpty()); |
+ |
+ EXPECT_TRUE(writers_->CanAddWriters()); |
+ AddTransactionToExistingWriters(); |
+ |
+ std::vector<std::string> contents(2); |
+ int rv = ReadAll(&contents); |
+ |
+ EXPECT_THAT(rv, IsOk()); |
+ std::string expected(kSimpleGET_Transaction.data); |
+ |
+ for (auto content : contents) |
+ EXPECT_EQ(expected, content); |
+} |
+ |
+// Tests that multiple transactions can read the same data simultaneously. |
+TEST_F(WritersTest, ReadMultipleDifferentBufferSizes) { |
+ CreateWritersAddTransaction(); |
+ EXPECT_FALSE(writers_->IsEmpty()); |
+ |
+ EXPECT_TRUE(writers_->CanAddWriters()); |
+ AddTransactionToExistingWriters(); |
+ |
+ std::vector<int> buffer_lengths; |
jkarlin
2017/07/06 18:50:04
std::vector<int> buffer_lengths {20, 10};
shivanisha
2017/07/11 02:10:26
done
|
+ buffer_lengths.push_back(20); |
+ buffer_lengths.push_back(10); |
+ ReadVerifyTwoDifferentBufferLengths(buffer_lengths); |
+} |
+ |
+// Same as above but tests the first transaction having smaller buffer size |
+// than the next. |
+TEST_F(WritersTest, ReadMultipleDifferentBufferSizes1) { |
+ CreateWritersAddTransaction(); |
+ EXPECT_FALSE(writers_->IsEmpty()); |
+ |
+ EXPECT_TRUE(writers_->CanAddWriters()); |
+ AddTransactionToExistingWriters(); |
+ |
+ std::vector<int> buffer_lengths; |
jkarlin
2017/07/06 18:50:04
std::vector<int> buffer_lengths {10, 20};
shivanisha
2017/07/11 02:10:26
done
|
+ buffer_lengths.push_back(10); |
+ buffer_lengths.push_back(20); |
+ ReadVerifyTwoDifferentBufferLengths(buffer_lengths); |
+} |
+ |
+// Tests that ongoing Read completes even when active transaction is deleted |
+// mid-read. Any transactions waiting should be able to get the read buffer. |
+TEST_F(WritersTest, ReadMultipleDeleteActiveTransaction) { |
+ CreateWritersAddTransaction(); |
+ EXPECT_FALSE(writers_->IsEmpty()); |
+ |
+ EXPECT_TRUE(writers_->CanAddWriters()); |
+ AddTransactionToExistingWriters(); |
+ AddTransactionToExistingWriters(); |
+ |
+ std::vector<std::string> contents(3); |
+ int rv = ReadAllDeleteActiveTransaction(&contents); |
+ |
+ EXPECT_THAT(rv, IsOk()); |
+ std::string expected(kSimpleGET_Transaction.data); |
+ |
+ for (auto content : contents) |
+ EXPECT_EQ(expected, content); |
+} |
+ |
+// Tests that removing a waiting for read transaction does not impact other |
+// transactions. |
+TEST_F(WritersTest, ReadMultipleDeleteWaitingTransaction) { |
+ CreateWritersAddTransaction(); |
+ EXPECT_FALSE(writers_->IsEmpty()); |
+ |
+ EXPECT_TRUE(writers_->CanAddWriters()); |
+ AddTransactionToExistingWriters(); |
+ AddTransactionToExistingWriters(); |
+ AddTransactionToExistingWriters(); |
+ |
+ std::vector<std::string> contents(4); |
+ size_t waiting_index = 1; |
+ int rv = ReadAllDeleteWaitingTransaction(waiting_index, &contents); |
+ |
+ EXPECT_THAT(rv, IsOk()); |
+ std::string expected(kSimpleGET_Transaction.data); |
+ |
+ size_t i = 0; |
+ for (auto content : contents) { |
+ if (i == waiting_index) |
+ EXPECT_EQ("", content); |
+ else |
+ EXPECT_EQ(expected, content); |
+ i++; |
+ } |
+} |
+ |
+// Tests that removing an idle transaction does not impact other transactions. |
+TEST_F(WritersTest, ReadMultipleDeleteIdleTransaction) { |
+ CreateWritersAddTransaction(); |
+ EXPECT_FALSE(writers_->IsEmpty()); |
+ |
+ EXPECT_TRUE(writers_->CanAddWriters()); |
+ AddTransactionToExistingWriters(); |
+ AddTransactionToExistingWriters(); |
+ |
+ std::vector<std::string> contents(3); |
+ size_t idle_index = 1; |
+ int rv = ReadAllDeleteIdleTransaction(idle_index, &contents); |
+ |
+ EXPECT_THAT(rv, IsOk()); |
+ std::string expected(kSimpleGET_Transaction.data); |
+ |
+ size_t i = 0; |
+ for (auto content : contents) { |
+ if (i == idle_index) { |
+ i++; |
+ continue; |
+ } |
+ EXPECT_EQ(expected, content); |
+ i++; |
+ } |
+} |
+ |
+// Tests cache write failure. |
+TEST_F(WritersTest, ReadMultipleCacheWriteFailed) { |
+ CreateWritersAddTransaction(); |
+ EXPECT_FALSE(writers_->IsEmpty()); |
+ |
+ EXPECT_TRUE(writers_->CanAddWriters()); |
+ AddTransactionToExistingWriters(); |
+ AddTransactionToExistingWriters(); |
+ |
+ std::vector<std::string> contents(3); |
+ int rv = ReadCacheWriteFailure(&contents); |
+ |
+ EXPECT_THAT(rv, IsOk()); |
+ std::string expected(kSimpleGET_Transaction.data); |
+ |
+ // Only active_transaction_ should succeed. |
+ EXPECT_EQ(expected, contents.at(0)); |
+ |
+ // No new transactions should now be added. |
+ EXPECT_FALSE(writers_->CanAddWriters()); |
+} |
+ |
+// Tests that network read failure fails all transactions: active, waiting and |
+// idle. |
+TEST_F(WritersTest, ReadMultipleNetworkReadFailed) { |
+ ScopedMockTransaction transaction(kSimpleGET_Transaction); |
+ transaction.read_return_code = ERR_INTERNET_DISCONNECTED; |
+ MockHttpRequest request(transaction); |
+ request_ = request; |
+ |
+ CreateWritersAddTransaction(); |
+ EXPECT_FALSE(writers_->IsEmpty()); |
+ |
+ EXPECT_TRUE(writers_->CanAddWriters()); |
+ AddTransactionToExistingWriters(); |
+ AddTransactionToExistingWriters(); |
+ |
+ std::vector<std::string> contents(3); |
+ int rv = ReadNetworkFailure(&contents, ERR_INTERNET_DISCONNECTED); |
+ |
+ EXPECT_EQ(rv, ERR_INTERNET_DISCONNECTED); |
+} |
+ |
+// Tests moving idle writers to readers. |
+TEST_F(WritersTest, MoveIdleWritersToReaders) { |
+ CreateWritersAddTransaction(); |
+ EXPECT_FALSE(writers_->IsEmpty()); |
+ |
+ EXPECT_TRUE(writers_->CanAddWriters()); |
+ AddTransactionToExistingWriters(); |
+ AddTransactionToExistingWriters(); |
+ |
+ EXPECT_FALSE(writers_->IsEmpty()); |
+ writers_->RemoveAllIdleWriters(); |
+ EXPECT_TRUE(writers_->IsEmpty()); |
+} |
+ |
+// Tests GetWriterLoadState. |
+TEST_F(WritersTest, GetWriterLoadState) { |
+ CreateWritersAddTransaction(); |
+ EXPECT_FALSE(writers_->IsEmpty()); |
+ |
+ EXPECT_EQ(LOAD_STATE_IDLE, writers_->GetWriterLoadState()); |
+} |
+ |
+// Tests truncating the entry via Writers. |
+TEST_F(WritersTest, TruncateEntry) { |
+ CreateWritersAddTransaction(); |
+ EXPECT_FALSE(writers_->IsEmpty()); |
+ |
+ std::string content; |
+ int rv = Read(&content); |
+ |
+ EXPECT_THAT(rv, IsOk()); |
+ std::string expected(kSimpleGET_Transaction.data); |
+ EXPECT_EQ(expected, content); |
+ |
+ writers_->TruncateEntry(); |
+ base::RunLoop().RunUntilIdle(); |
+ EXPECT_TRUE(writers_->IsTruncatedForTesting()); |
+} |
+ |
+} // namespace net |