//
|
// Copyright (C) 2011 The Android Open Source Project
|
//
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
// you may not use this file except in compliance with the License.
|
// You may obtain a copy of the License at
|
//
|
// http://www.apache.org/licenses/LICENSE-2.0
|
//
|
// Unless required by applicable law or agreed to in writing, software
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
// See the License for the specific language governing permissions and
|
// limitations under the License.
|
//
|
|
#include "update_engine/payload_consumer/download_action.h"
|
|
#include <gmock/gmock.h>
|
#include <gtest/gtest.h>
|
|
#include <memory>
|
#include <string>
|
#include <utility>
|
#include <vector>
|
|
#include <base/bind.h>
|
#include <base/files/file_path.h>
|
#include <base/files/file_util.h>
|
#include <base/location.h>
|
#include <base/strings/stringprintf.h>
|
#include <brillo/message_loops/fake_message_loop.h>
|
#include <brillo/message_loops/message_loop.h>
|
|
#include "update_engine/common/action_pipe.h"
|
#include "update_engine/common/hash_calculator.h"
|
#include "update_engine/common/mock_http_fetcher.h"
|
#include "update_engine/common/mock_prefs.h"
|
#include "update_engine/common/test_utils.h"
|
#include "update_engine/common/utils.h"
|
#include "update_engine/fake_p2p_manager_configuration.h"
|
#include "update_engine/fake_system_state.h"
|
#include "update_engine/mock_file_writer.h"
|
#include "update_engine/payload_consumer/mock_download_action.h"
|
#include "update_engine/update_manager/fake_update_manager.h"
|
|
namespace chromeos_update_engine {
|
|
using base::FilePath;
|
using base::ReadFileToString;
|
using base::WriteFile;
|
using std::string;
|
using std::unique_ptr;
|
using test_utils::ScopedTempFile;
|
using testing::_;
|
using testing::AtLeast;
|
using testing::InSequence;
|
using testing::Return;
|
using testing::SetArgPointee;
|
|
class DownloadActionTest : public ::testing::Test {};
|
|
namespace {
|
|
class DownloadActionTestProcessorDelegate : public ActionProcessorDelegate {
|
public:
|
DownloadActionTestProcessorDelegate()
|
: processing_done_called_(false), expected_code_(ErrorCode::kSuccess) {}
|
~DownloadActionTestProcessorDelegate() override {
|
EXPECT_TRUE(processing_done_called_);
|
}
|
void ProcessingDone(const ActionProcessor* processor,
|
ErrorCode code) override {
|
brillo::MessageLoop::current()->BreakLoop();
|
brillo::Blob found_data;
|
ASSERT_TRUE(utils::ReadFile(path_, &found_data));
|
if (expected_code_ != ErrorCode::kDownloadWriteError) {
|
ASSERT_EQ(expected_data_.size(), found_data.size());
|
for (unsigned i = 0; i < expected_data_.size(); i++) {
|
EXPECT_EQ(expected_data_[i], found_data[i]);
|
}
|
}
|
processing_done_called_ = true;
|
}
|
|
void ActionCompleted(ActionProcessor* processor,
|
AbstractAction* action,
|
ErrorCode code) override {
|
const string type = action->Type();
|
if (type == DownloadAction::StaticType()) {
|
EXPECT_EQ(expected_code_, code);
|
p2p_file_id_ = static_cast<DownloadAction*>(action)->p2p_file_id();
|
} else {
|
EXPECT_EQ(ErrorCode::kSuccess, code);
|
}
|
}
|
|
string path_;
|
brillo::Blob expected_data_;
|
bool processing_done_called_;
|
ErrorCode expected_code_;
|
string p2p_file_id_;
|
};
|
|
class TestDirectFileWriter : public DirectFileWriter {
|
public:
|
TestDirectFileWriter() : fail_write_(0), current_write_(0) {}
|
void set_fail_write(int fail_write) { fail_write_ = fail_write; }
|
|
virtual bool Write(const void* bytes, size_t count) {
|
if (++current_write_ == fail_write_) {
|
return false;
|
}
|
return DirectFileWriter::Write(bytes, count);
|
}
|
|
private:
|
// If positive, fail on the |fail_write_| call to Write.
|
int fail_write_;
|
int current_write_;
|
};
|
|
void StartProcessorInRunLoop(ActionProcessor* processor,
|
MockHttpFetcher* http_fetcher) {
|
processor->StartProcessing();
|
http_fetcher->SetOffset(1);
|
}
|
|
void TestWithData(const brillo::Blob& data,
|
int fail_write,
|
bool use_download_delegate) {
|
brillo::FakeMessageLoop loop(nullptr);
|
loop.SetAsCurrent();
|
FakeSystemState fake_system_state;
|
|
// TODO(adlr): see if we need a different file for build bots
|
ScopedTempFile output_temp_file;
|
TestDirectFileWriter writer;
|
EXPECT_EQ(
|
0, writer.Open(output_temp_file.path().c_str(), O_WRONLY | O_CREAT, 0));
|
writer.set_fail_write(fail_write);
|
|
uint64_t size = data.size() - 1;
|
InstallPlan install_plan;
|
install_plan.payloads.push_back(
|
{.size = size, .type = InstallPayloadType::kDelta});
|
// We pull off the first byte from data and seek past it.
|
EXPECT_TRUE(HashCalculator::RawHashOfBytes(
|
&data[1], data.size() - 1, &install_plan.payloads[0].hash));
|
install_plan.source_slot = 0;
|
install_plan.target_slot = 1;
|
// We mark both slots as bootable. Only the target slot should be unbootable
|
// after the download starts.
|
fake_system_state.fake_boot_control()->SetSlotBootable(
|
install_plan.source_slot, true);
|
fake_system_state.fake_boot_control()->SetSlotBootable(
|
install_plan.target_slot, true);
|
auto feeder_action = std::make_unique<ObjectFeederAction<InstallPlan>>();
|
feeder_action->set_obj(install_plan);
|
MockPrefs prefs;
|
MockHttpFetcher* http_fetcher =
|
new MockHttpFetcher(data.data(), data.size(), nullptr);
|
// takes ownership of passed in HttpFetcher
|
auto download_action =
|
std::make_unique<DownloadAction>(&prefs,
|
fake_system_state.boot_control(),
|
fake_system_state.hardware(),
|
&fake_system_state,
|
http_fetcher,
|
false /* interactive */);
|
download_action->SetTestFileWriter(&writer);
|
BondActions(feeder_action.get(), download_action.get());
|
MockDownloadActionDelegate download_delegate;
|
if (use_download_delegate) {
|
InSequence s;
|
download_action->set_delegate(&download_delegate);
|
if (data.size() > kMockHttpFetcherChunkSize)
|
EXPECT_CALL(download_delegate,
|
BytesReceived(_, kMockHttpFetcherChunkSize, _));
|
EXPECT_CALL(download_delegate, BytesReceived(_, _, _)).Times(AtLeast(1));
|
EXPECT_CALL(download_delegate, DownloadComplete())
|
.Times(fail_write == 0 ? 1 : 0);
|
}
|
DownloadActionTestProcessorDelegate delegate;
|
delegate.expected_code_ =
|
(fail_write > 0) ? ErrorCode::kDownloadWriteError : ErrorCode::kSuccess;
|
delegate.expected_data_ = brillo::Blob(data.begin() + 1, data.end());
|
delegate.path_ = output_temp_file.path();
|
ActionProcessor processor;
|
processor.set_delegate(&delegate);
|
processor.EnqueueAction(std::move(feeder_action));
|
processor.EnqueueAction(std::move(download_action));
|
|
loop.PostTask(FROM_HERE,
|
base::Bind(&StartProcessorInRunLoop, &processor, http_fetcher));
|
loop.Run();
|
EXPECT_FALSE(loop.PendingTasks());
|
|
EXPECT_TRUE(fake_system_state.fake_boot_control()->IsSlotBootable(
|
install_plan.source_slot));
|
EXPECT_FALSE(fake_system_state.fake_boot_control()->IsSlotBootable(
|
install_plan.target_slot));
|
}
|
} // namespace
|
|
TEST(DownloadActionTest, SimpleTest) {
|
brillo::Blob small;
|
const char* foo = "foo";
|
small.insert(small.end(), foo, foo + strlen(foo));
|
TestWithData(small,
|
0, // fail_write
|
true); // use_download_delegate
|
}
|
|
TEST(DownloadActionTest, LargeTest) {
|
brillo::Blob big(5 * kMockHttpFetcherChunkSize);
|
char c = '0';
|
for (unsigned int i = 0; i < big.size(); i++) {
|
big[i] = c;
|
c = ('9' == c) ? '0' : c + 1;
|
}
|
TestWithData(big,
|
0, // fail_write
|
true); // use_download_delegate
|
}
|
|
TEST(DownloadActionTest, FailWriteTest) {
|
brillo::Blob big(5 * kMockHttpFetcherChunkSize);
|
char c = '0';
|
for (unsigned int i = 0; i < big.size(); i++) {
|
big[i] = c;
|
c = ('9' == c) ? '0' : c + 1;
|
}
|
TestWithData(big,
|
2, // fail_write
|
true); // use_download_delegate
|
}
|
|
TEST(DownloadActionTest, NoDownloadDelegateTest) {
|
brillo::Blob small;
|
const char* foo = "foofoo";
|
small.insert(small.end(), foo, foo + strlen(foo));
|
TestWithData(small,
|
0, // fail_write
|
false); // use_download_delegate
|
}
|
|
TEST(DownloadActionTest, MultiPayloadProgressTest) {
|
std::vector<brillo::Blob> payload_datas;
|
// the first payload must be the largest, as it's the actual payload used by
|
// the MockHttpFetcher for all downloaded data.
|
payload_datas.emplace_back(4 * kMockHttpFetcherChunkSize + 256);
|
payload_datas.emplace_back(2 * kMockHttpFetcherChunkSize);
|
brillo::FakeMessageLoop loop(nullptr);
|
loop.SetAsCurrent();
|
FakeSystemState fake_system_state;
|
EXPECT_CALL(*fake_system_state.mock_payload_state(), NextPayload())
|
.WillOnce(Return(true));
|
|
MockFileWriter mock_file_writer;
|
EXPECT_CALL(mock_file_writer, Close()).WillRepeatedly(Return(0));
|
EXPECT_CALL(mock_file_writer, Write(_, _, _))
|
.WillRepeatedly(
|
DoAll(SetArgPointee<2>(ErrorCode::kSuccess), Return(true)));
|
|
InstallPlan install_plan;
|
uint64_t total_expected_download_size{0};
|
for (const auto& data : payload_datas) {
|
uint64_t size = data.size();
|
install_plan.payloads.push_back(
|
{.size = size, .type = InstallPayloadType::kFull});
|
total_expected_download_size += size;
|
}
|
auto feeder_action = std::make_unique<ObjectFeederAction<InstallPlan>>();
|
feeder_action->set_obj(install_plan);
|
MockPrefs prefs;
|
MockHttpFetcher* http_fetcher = new MockHttpFetcher(
|
payload_datas[0].data(), payload_datas[0].size(), nullptr);
|
// takes ownership of passed in HttpFetcher
|
auto download_action =
|
std::make_unique<DownloadAction>(&prefs,
|
fake_system_state.boot_control(),
|
fake_system_state.hardware(),
|
&fake_system_state,
|
http_fetcher,
|
false /* interactive */);
|
download_action->SetTestFileWriter(&mock_file_writer);
|
BondActions(feeder_action.get(), download_action.get());
|
MockDownloadActionDelegate download_delegate;
|
{
|
InSequence s;
|
download_action->set_delegate(&download_delegate);
|
// these are hand-computed based on the payloads specified above
|
EXPECT_CALL(download_delegate,
|
BytesReceived(kMockHttpFetcherChunkSize,
|
kMockHttpFetcherChunkSize,
|
total_expected_download_size));
|
EXPECT_CALL(download_delegate,
|
BytesReceived(kMockHttpFetcherChunkSize,
|
kMockHttpFetcherChunkSize * 2,
|
total_expected_download_size));
|
EXPECT_CALL(download_delegate,
|
BytesReceived(kMockHttpFetcherChunkSize,
|
kMockHttpFetcherChunkSize * 3,
|
total_expected_download_size));
|
EXPECT_CALL(download_delegate,
|
BytesReceived(kMockHttpFetcherChunkSize,
|
kMockHttpFetcherChunkSize * 4,
|
total_expected_download_size));
|
EXPECT_CALL(download_delegate,
|
BytesReceived(256,
|
kMockHttpFetcherChunkSize * 4 + 256,
|
total_expected_download_size));
|
EXPECT_CALL(download_delegate,
|
BytesReceived(kMockHttpFetcherChunkSize,
|
kMockHttpFetcherChunkSize * 5 + 256,
|
total_expected_download_size));
|
EXPECT_CALL(download_delegate,
|
BytesReceived(kMockHttpFetcherChunkSize,
|
total_expected_download_size,
|
total_expected_download_size));
|
}
|
ActionProcessor processor;
|
processor.EnqueueAction(std::move(feeder_action));
|
processor.EnqueueAction(std::move(download_action));
|
|
loop.PostTask(
|
FROM_HERE,
|
base::Bind(
|
[](ActionProcessor* processor) { processor->StartProcessing(); },
|
base::Unretained(&processor)));
|
loop.Run();
|
EXPECT_FALSE(loop.PendingTasks());
|
}
|
|
namespace {
|
class TerminateEarlyTestProcessorDelegate : public ActionProcessorDelegate {
|
public:
|
void ProcessingStopped(const ActionProcessor* processor) {
|
brillo::MessageLoop::current()->BreakLoop();
|
}
|
};
|
|
void TerminateEarlyTestStarter(ActionProcessor* processor) {
|
processor->StartProcessing();
|
CHECK(processor->IsRunning());
|
processor->StopProcessing();
|
}
|
|
void TestTerminateEarly(bool use_download_delegate) {
|
brillo::FakeMessageLoop loop(nullptr);
|
loop.SetAsCurrent();
|
|
brillo::Blob data(kMockHttpFetcherChunkSize + kMockHttpFetcherChunkSize / 2);
|
memset(data.data(), 0, data.size());
|
|
ScopedTempFile temp_file;
|
{
|
DirectFileWriter writer;
|
EXPECT_EQ(0, writer.Open(temp_file.path().c_str(), O_WRONLY | O_CREAT, 0));
|
|
// takes ownership of passed in HttpFetcher
|
auto feeder_action = std::make_unique<ObjectFeederAction<InstallPlan>>();
|
InstallPlan install_plan;
|
install_plan.payloads.resize(1);
|
feeder_action->set_obj(install_plan);
|
FakeSystemState fake_system_state_;
|
MockPrefs prefs;
|
auto download_action = std::make_unique<DownloadAction>(
|
&prefs,
|
fake_system_state_.boot_control(),
|
fake_system_state_.hardware(),
|
&fake_system_state_,
|
new MockHttpFetcher(data.data(), data.size(), nullptr),
|
false /* interactive */);
|
download_action->SetTestFileWriter(&writer);
|
MockDownloadActionDelegate download_delegate;
|
if (use_download_delegate) {
|
download_action->set_delegate(&download_delegate);
|
EXPECT_CALL(download_delegate, BytesReceived(_, _, _)).Times(0);
|
}
|
TerminateEarlyTestProcessorDelegate delegate;
|
ActionProcessor processor;
|
processor.set_delegate(&delegate);
|
BondActions(feeder_action.get(), download_action.get());
|
processor.EnqueueAction(std::move(feeder_action));
|
processor.EnqueueAction(std::move(download_action));
|
|
loop.PostTask(FROM_HERE,
|
base::Bind(&TerminateEarlyTestStarter, &processor));
|
loop.Run();
|
EXPECT_FALSE(loop.PendingTasks());
|
}
|
|
// 1 or 0 chunks should have come through
|
const off_t resulting_file_size(utils::FileSize(temp_file.path()));
|
EXPECT_GE(resulting_file_size, 0);
|
if (resulting_file_size != 0)
|
EXPECT_EQ(kMockHttpFetcherChunkSize,
|
static_cast<size_t>(resulting_file_size));
|
}
|
|
} // namespace
|
|
TEST(DownloadActionTest, TerminateEarlyTest) {
|
TestTerminateEarly(true);
|
}
|
|
TEST(DownloadActionTest, TerminateEarlyNoDownloadDelegateTest) {
|
TestTerminateEarly(false);
|
}
|
|
class DownloadActionTestAction;
|
|
template <>
|
class ActionTraits<DownloadActionTestAction> {
|
public:
|
typedef InstallPlan OutputObjectType;
|
typedef InstallPlan InputObjectType;
|
};
|
|
// This is a simple Action class for testing.
|
class DownloadActionTestAction : public Action<DownloadActionTestAction> {
|
public:
|
DownloadActionTestAction() = default;
|
typedef InstallPlan InputObjectType;
|
typedef InstallPlan OutputObjectType;
|
ActionPipe<InstallPlan>* in_pipe() { return in_pipe_.get(); }
|
ActionPipe<InstallPlan>* out_pipe() { return out_pipe_.get(); }
|
ActionProcessor* processor() { return processor_; }
|
void PerformAction() {
|
ASSERT_TRUE(HasInputObject());
|
EXPECT_TRUE(expected_input_object_ == GetInputObject());
|
ASSERT_TRUE(processor());
|
processor()->ActionComplete(this, ErrorCode::kSuccess);
|
}
|
static std::string StaticType() { return "DownloadActionTestAction"; }
|
string Type() const { return StaticType(); }
|
InstallPlan expected_input_object_;
|
};
|
|
namespace {
|
// This class is an ActionProcessorDelegate that simply terminates the
|
// run loop when the ActionProcessor has completed processing. It's used
|
// only by the test PassObjectOutTest.
|
class PassObjectOutTestProcessorDelegate : public ActionProcessorDelegate {
|
public:
|
void ProcessingDone(const ActionProcessor* processor,
|
ErrorCode code) override {
|
brillo::MessageLoop::current()->BreakLoop();
|
}
|
void ActionCompleted(ActionProcessor* processor,
|
AbstractAction* action,
|
ErrorCode code) override {
|
if (action->Type() == DownloadActionTestAction::StaticType()) {
|
did_test_action_run_ = true;
|
}
|
}
|
|
bool did_test_action_run_ = false;
|
};
|
|
} // namespace
|
|
TEST(DownloadActionTest, PassObjectOutTest) {
|
brillo::FakeMessageLoop loop(nullptr);
|
loop.SetAsCurrent();
|
|
DirectFileWriter writer;
|
EXPECT_EQ(0, writer.Open("/dev/null", O_WRONLY | O_CREAT, 0));
|
|
// takes ownership of passed in HttpFetcher
|
InstallPlan install_plan;
|
install_plan.payloads.push_back({.size = 1});
|
EXPECT_TRUE(
|
HashCalculator::RawHashOfData({'x'}, &install_plan.payloads[0].hash));
|
auto feeder_action = std::make_unique<ObjectFeederAction<InstallPlan>>();
|
feeder_action->set_obj(install_plan);
|
MockPrefs prefs;
|
FakeSystemState fake_system_state_;
|
auto download_action =
|
std::make_unique<DownloadAction>(&prefs,
|
fake_system_state_.boot_control(),
|
fake_system_state_.hardware(),
|
&fake_system_state_,
|
new MockHttpFetcher("x", 1, nullptr),
|
false /* interactive */);
|
download_action->SetTestFileWriter(&writer);
|
|
auto test_action = std::make_unique<DownloadActionTestAction>();
|
test_action->expected_input_object_ = install_plan;
|
BondActions(feeder_action.get(), download_action.get());
|
BondActions(download_action.get(), test_action.get());
|
|
ActionProcessor processor;
|
PassObjectOutTestProcessorDelegate delegate;
|
processor.set_delegate(&delegate);
|
processor.EnqueueAction(std::move(feeder_action));
|
processor.EnqueueAction(std::move(download_action));
|
processor.EnqueueAction(std::move(test_action));
|
|
loop.PostTask(
|
FROM_HERE,
|
base::Bind(
|
[](ActionProcessor* processor) { processor->StartProcessing(); },
|
base::Unretained(&processor)));
|
loop.Run();
|
EXPECT_FALSE(loop.PendingTasks());
|
|
EXPECT_EQ(true, delegate.did_test_action_run_);
|
}
|
|
// Test fixture for P2P tests.
|
class P2PDownloadActionTest : public testing::Test {
|
protected:
|
P2PDownloadActionTest()
|
: start_at_offset_(0), fake_um_(fake_system_state_.fake_clock()) {}
|
|
~P2PDownloadActionTest() override {}
|
|
// Derived from testing::Test.
|
void SetUp() override { loop_.SetAsCurrent(); }
|
|
// Derived from testing::Test.
|
void TearDown() override { EXPECT_FALSE(loop_.PendingTasks()); }
|
|
// To be called by tests to setup the download. The
|
// |starting_offset| parameter is for where to resume.
|
void SetupDownload(off_t starting_offset) {
|
start_at_offset_ = starting_offset;
|
// Prepare data 10 kB of data.
|
data_.clear();
|
for (unsigned int i = 0; i < 10 * 1000; i++)
|
data_ += 'a' + (i % 25);
|
|
// Setup p2p.
|
FakeP2PManagerConfiguration* test_conf = new FakeP2PManagerConfiguration();
|
p2p_manager_.reset(P2PManager::Construct(test_conf,
|
nullptr,
|
&fake_um_,
|
"cros_au",
|
3,
|
base::TimeDelta::FromDays(5)));
|
fake_system_state_.set_p2p_manager(p2p_manager_.get());
|
}
|
|
// To be called by tests to perform the download. The
|
// |use_p2p_to_share| parameter is used to indicate whether the
|
// payload should be shared via p2p.
|
void StartDownload(bool use_p2p_to_share) {
|
EXPECT_CALL(*fake_system_state_.mock_payload_state(),
|
GetUsingP2PForSharing())
|
.WillRepeatedly(Return(use_p2p_to_share));
|
|
ScopedTempFile output_temp_file;
|
TestDirectFileWriter writer;
|
EXPECT_EQ(
|
0, writer.Open(output_temp_file.path().c_str(), O_WRONLY | O_CREAT, 0));
|
InstallPlan install_plan;
|
install_plan.payloads.push_back(
|
{.size = data_.length(),
|
.hash = {'1', '2', '3', '4', 'h', 'a', 's', 'h'}});
|
auto feeder_action = std::make_unique<ObjectFeederAction<InstallPlan>>();
|
feeder_action->set_obj(install_plan);
|
MockPrefs prefs;
|
// Note that DownloadAction takes ownership of the passed in HttpFetcher.
|
auto download_action = std::make_unique<DownloadAction>(
|
&prefs,
|
fake_system_state_.boot_control(),
|
fake_system_state_.hardware(),
|
&fake_system_state_,
|
new MockHttpFetcher(data_.c_str(), data_.length(), nullptr),
|
false /* interactive */);
|
auto http_fetcher = download_action->http_fetcher();
|
download_action->SetTestFileWriter(&writer);
|
BondActions(feeder_action.get(), download_action.get());
|
delegate_.expected_data_ =
|
brillo::Blob(data_.begin() + start_at_offset_, data_.end());
|
delegate_.path_ = output_temp_file.path();
|
processor_.set_delegate(&delegate_);
|
processor_.EnqueueAction(std::move(feeder_action));
|
processor_.EnqueueAction(std::move(download_action));
|
|
loop_.PostTask(
|
FROM_HERE,
|
base::Bind(
|
[](P2PDownloadActionTest* action_test, HttpFetcher* http_fetcher) {
|
action_test->processor_.StartProcessing();
|
http_fetcher->SetOffset(action_test->start_at_offset_);
|
},
|
base::Unretained(this),
|
base::Unretained(http_fetcher)));
|
loop_.Run();
|
}
|
|
// Mainloop used to make StartDownload() synchronous.
|
brillo::FakeMessageLoop loop_{nullptr};
|
|
// Delegate that is passed to the ActionProcessor.
|
DownloadActionTestProcessorDelegate delegate_;
|
|
// The P2PManager used in the test.
|
unique_ptr<P2PManager> p2p_manager_;
|
|
// The ActionProcessor used for running the actions.
|
ActionProcessor processor_;
|
|
// A fake system state.
|
FakeSystemState fake_system_state_;
|
|
// The data being downloaded.
|
string data_;
|
|
private:
|
// The requested starting offset passed to SetupDownload().
|
off_t start_at_offset_;
|
|
chromeos_update_manager::FakeUpdateManager fake_um_;
|
};
|
|
TEST_F(P2PDownloadActionTest, IsWrittenTo) {
|
SetupDownload(0); // starting_offset
|
StartDownload(true); // use_p2p_to_share
|
|
// Check the p2p file and its content matches what was sent.
|
string file_id = delegate_.p2p_file_id_;
|
EXPECT_NE("", file_id);
|
EXPECT_EQ(static_cast<int>(data_.length()),
|
p2p_manager_->FileGetSize(file_id));
|
EXPECT_EQ(static_cast<int>(data_.length()),
|
p2p_manager_->FileGetExpectedSize(file_id));
|
string p2p_file_contents;
|
EXPECT_TRUE(
|
ReadFileToString(p2p_manager_->FileGetPath(file_id), &p2p_file_contents));
|
EXPECT_EQ(data_, p2p_file_contents);
|
}
|
|
TEST_F(P2PDownloadActionTest, DeleteIfHoleExists) {
|
SetupDownload(1000); // starting_offset
|
StartDownload(true); // use_p2p_to_share
|
|
// DownloadAction should convey that the file is not being shared.
|
// and that we don't have any p2p files.
|
EXPECT_EQ(delegate_.p2p_file_id_, "");
|
EXPECT_EQ(p2p_manager_->CountSharedFiles(), 0);
|
}
|
|
TEST_F(P2PDownloadActionTest, CanAppend) {
|
SetupDownload(1000); // starting_offset
|
|
// Prepare the file with existing data before starting to write to
|
// it via DownloadAction.
|
string file_id = utils::CalculateP2PFileId(
|
{'1', '2', '3', '4', 'h', 'a', 's', 'h'}, data_.length());
|
ASSERT_TRUE(p2p_manager_->FileShare(file_id, data_.length()));
|
string existing_data;
|
for (unsigned int i = 0; i < 1000; i++)
|
existing_data += '0' + (i % 10);
|
ASSERT_EQ(
|
WriteFile(
|
p2p_manager_->FileGetPath(file_id), existing_data.c_str(), 1000),
|
1000);
|
|
StartDownload(true); // use_p2p_to_share
|
|
// DownloadAction should convey the same file_id and the file should
|
// have the expected size.
|
EXPECT_EQ(delegate_.p2p_file_id_, file_id);
|
EXPECT_EQ(static_cast<ssize_t>(data_.length()),
|
p2p_manager_->FileGetSize(file_id));
|
EXPECT_EQ(static_cast<ssize_t>(data_.length()),
|
p2p_manager_->FileGetExpectedSize(file_id));
|
string p2p_file_contents;
|
// Check that the first 1000 bytes wasn't touched and that we
|
// appended the remaining as appropriate.
|
EXPECT_TRUE(
|
ReadFileToString(p2p_manager_->FileGetPath(file_id), &p2p_file_contents));
|
EXPECT_EQ(existing_data, p2p_file_contents.substr(0, 1000));
|
EXPECT_EQ(data_.substr(1000), p2p_file_contents.substr(1000));
|
}
|
|
TEST_F(P2PDownloadActionTest, DeletePartialP2PFileIfResumingWithoutP2P) {
|
SetupDownload(1000); // starting_offset
|
|
// Prepare the file with all existing data before starting to write
|
// to it via DownloadAction.
|
string file_id = utils::CalculateP2PFileId(
|
{'1', '2', '3', '4', 'h', 'a', 's', 'h'}, data_.length());
|
ASSERT_TRUE(p2p_manager_->FileShare(file_id, data_.length()));
|
string existing_data;
|
for (unsigned int i = 0; i < 1000; i++)
|
existing_data += '0' + (i % 10);
|
ASSERT_EQ(
|
WriteFile(
|
p2p_manager_->FileGetPath(file_id), existing_data.c_str(), 1000),
|
1000);
|
|
// Check that the file is there.
|
EXPECT_EQ(1000, p2p_manager_->FileGetSize(file_id));
|
EXPECT_EQ(1, p2p_manager_->CountSharedFiles());
|
|
StartDownload(false); // use_p2p_to_share
|
|
// DownloadAction should have deleted the p2p file. Check that it's gone.
|
EXPECT_EQ(-1, p2p_manager_->FileGetSize(file_id));
|
EXPECT_EQ(0, p2p_manager_->CountSharedFiles());
|
}
|
|
} // namespace chromeos_update_engine
|
