// Copyright 2022 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "chrome/browser/ash/file_system_provider/operation_request_manager.h"
#include <stddef.h>
#include <map>
#include <memory>
#include <string>
#include <utility>
#include <vector>
#include "base/files/file.h"
#include "base/files/file_path.h"
#include "base/functional/bind.h"
#include "base/functional/callback.h"
#include "base/memory/ptr_util.h"
#include "base/memory/weak_ptr.h"
#include "base/run_loop.h"
#include "base/scoped_observation.h"
#include "chrome/browser/ash/file_system_provider/notification_manager_interface.h"
#include "chrome/browser/ash/file_system_provider/request_manager.h"
#include "chrome/browser/ash/file_system_provider/request_value.h"
#include "chrome/test/base/testing_profile.h"
#include "content/public/test/browser_task_environment.h"
#include "testing/gtest/include/gtest/gtest.h"
namespace ash::file_system_provider {
namespace {
const RequestType kTestRequestType = RequestType::kGetMetadata;
std::optional<std::string> GetTestingParamFromResult(
const RequestValue& result) {
if (const std::string* testing_param = result.testing_params()) {
return *testing_param;
}
return std::nullopt;
}
// Fake implementation for the notification manager. Simulates user action on
// a notification.
class FakeNotificationManager : public NotificationManagerInterface {
public:
FakeNotificationManager() = default;
FakeNotificationManager(const FakeNotificationManager&) = delete;
FakeNotificationManager& operator=(const FakeNotificationManager&) = delete;
~FakeNotificationManager() override = default;
// NotificationManagerInterface overrides:
void ShowUnresponsiveNotification(int id,
NotificationCallback callback) override {
callbacks_[id] = std::move(callback);
}
void HideUnresponsiveNotification(int id) override { callbacks_.erase(id); }
// Aborts all of the virtually shown notifications.
void Abort() { OnNotificationResult(ABORT); }
// Discards all of the virtually shown notifications.
void Continue() { OnNotificationResult(CONTINUE); }
// Returns number of currently shown notifications.
size_t size() { return callbacks_.size(); }
private:
typedef std::map<int, NotificationCallback> CallbackMap;
// Handles a notification result by calling all registered callbacks and
// clearing the list.
void OnNotificationResult(NotificationResult result) {
CallbackMap::iterator it = callbacks_.begin();
while (it != callbacks_.end()) {
CallbackMap::iterator current_it = it++;
NotificationCallback callback = std::move(current_it->second);
callbacks_.erase(current_it);
std::move(callback).Run(result);
}
}
CallbackMap callbacks_;
};
class TimeoutWaiter : public RequestManager::Observer {
public:
explicit TimeoutWaiter(RequestManager* request_manager) {
scoped_observation_.Observe(request_manager);
}
void OnRequestCreated(int request_id, RequestType type) override {}
void OnRequestDestroyed(int request_id,
OperationCompletion completion) override {}
void OnRequestExecuted(int request_id) override {}
void OnRequestFulfilled(int request_id,
const RequestValue& result,
bool has_more) override {}
void OnRequestRejected(int request_id,
const RequestValue& result,
base::File::Error error) override {}
void OnRequestTimedOut(int request_id) override { run_loop_.Quit(); }
void Wait() { run_loop_.Run(); }
private:
base::RunLoop run_loop_;
base::ScopedObservation<RequestManager, RequestManager::Observer>
scoped_observation_{this};
};
// Logs calls of the success and error callbacks on requests.
class EventLogger {
public:
class ExecuteEvent {
public:
explicit ExecuteEvent(int request_id) : request_id_(request_id) {}
virtual ~ExecuteEvent() = default;
int request_id() { return request_id_; }
private:
int request_id_;
};
class SuccessEvent {
public:
SuccessEvent(int request_id, const RequestValue& result, bool has_more)
: request_id_(request_id),
testing_param_(GetTestingParamFromResult(result)),
result_is_valid_(result.is_valid()),
has_more_(has_more) {}
virtual ~SuccessEvent() = default;
int request_id() const { return request_id_; }
const std::optional<std::string>& testing_param() const {
return testing_param_;
}
bool has_more() const { return has_more_; }
bool result_is_valid() const { return result_is_valid_; }
private:
int request_id_;
std::optional<std::string> testing_param_;
bool result_is_valid_;
bool has_more_;
};
class ErrorEvent {
public:
ErrorEvent(int request_id, base::File::Error error)
: request_id_(request_id), error_(error) {}
virtual ~ErrorEvent() = default;
int request_id() { return request_id_; }
base::File::Error error() { return error_; }
private:
int request_id_;
base::File::Error error_;
};
class AbortEvent {
public:
explicit AbortEvent(int request_id) : request_id_(request_id) {}
virtual ~AbortEvent() = default;
int request_id() { return request_id_; }
private:
int request_id_;
};
EventLogger() = default;
EventLogger(const EventLogger&) = delete;
EventLogger& operator=(const EventLogger&) = delete;
virtual ~EventLogger() = default;
void OnExecute(int request_id) {
execute_events_.push_back(std::make_unique<ExecuteEvent>(request_id));
}
void OnSuccess(int request_id, const RequestValue& result, bool has_more) {
success_events_.push_back(
std::make_unique<SuccessEvent>(request_id, result, has_more));
}
void OnError(int request_id, base::File::Error error) {
error_events_.push_back(std::make_unique<ErrorEvent>(request_id, error));
}
void OnAbort(int request_id) {
abort_events_.push_back(std::make_unique<AbortEvent>(request_id));
}
std::vector<std::unique_ptr<ExecuteEvent>>& execute_events() {
return execute_events_;
}
std::vector<std::unique_ptr<SuccessEvent>>& success_events() {
return success_events_;
}
std::vector<std::unique_ptr<ErrorEvent>>& error_events() {
return error_events_;
}
std::vector<std::unique_ptr<AbortEvent>>& abort_events() {
return abort_events_;
}
base::WeakPtr<EventLogger> GetWeakPtr() {
return weak_ptr_factory_.GetWeakPtr();
}
private:
std::vector<std::unique_ptr<ExecuteEvent>> execute_events_;
std::vector<std::unique_ptr<SuccessEvent>> success_events_;
std::vector<std::unique_ptr<ErrorEvent>> error_events_;
std::vector<std::unique_ptr<AbortEvent>> abort_events_;
base::WeakPtrFactory<EventLogger> weak_ptr_factory_{this};
};
// Fake handler, which forwards callbacks to the logger. The handler is owned
// by a request manager, however the logger is owned by tests.
class FakeHandler : public RequestManager::HandlerInterface {
public:
// The handler can outlive the passed logger, so using a weak pointer. The
// |execute_reply| value will be returned for the Execute() call.
FakeHandler(base::WeakPtr<EventLogger> logger, bool execute_reply)
: logger_(logger), execute_reply_(execute_reply) {}
// RequestManager::Handler overrides.
bool Execute(int request_id) override {
if (logger_.get())
logger_->OnExecute(request_id);
return execute_reply_;
}
// RequestManager::Handler overrides.
void OnSuccess(int request_id,
const RequestValue& result,
bool has_more) override {
if (logger_.get())
logger_->OnSuccess(request_id, std::move(result), has_more);
}
// RequestManager::Handler overrides.
void OnError(int request_id,
const RequestValue& result,
base::File::Error error) override {
if (logger_.get())
logger_->OnError(request_id, error);
}
void OnAbort(int request_id) override {
if (logger_.get()) {
logger_->OnAbort(request_id);
}
}
FakeHandler(const FakeHandler&) = delete;
FakeHandler& operator=(const FakeHandler&) = delete;
~FakeHandler() override = default;
private:
base::WeakPtr<EventLogger> logger_;
bool execute_reply_;
};
// Observer the request manager for request events.
class RequestObserver : public RequestManager::Observer {
public:
class Event {
public:
explicit Event(int request_id) : request_id_(request_id) {}
virtual ~Event() = default;
int request_id() const { return request_id_; }
private:
int request_id_;
};
class CreatedEvent : public Event {
public:
CreatedEvent(int request_id, RequestType type)
: Event(request_id), type_(type) {}
~CreatedEvent() override = default;
RequestType type() const { return type_; }
private:
RequestType type_;
};
class FulfilledEvent : public Event {
public:
FulfilledEvent(int request_id, bool has_more)
: Event(request_id), has_more_(has_more) {}
~FulfilledEvent() override = default;
bool has_more() const { return has_more_; }
private:
bool has_more_;
};
class RejectedEvent : public Event {
public:
RejectedEvent(int request_id, base::File::Error error)
: Event(request_id), error_(error) {}
~RejectedEvent() override = default;
base::File::Error error() const { return error_; }
private:
base::File::Error error_;
};
class DestroyedEvent : public Event {
public:
DestroyedEvent(int request_id, OperationCompletion completion)
: Event(request_id), completion_(completion) {}
OperationCompletion completion() const { return completion_; }
private:
OperationCompletion completion_;
};
RequestObserver() = default;
RequestObserver(const RequestObserver&) = delete;
RequestObserver& operator=(const RequestObserver&) = delete;
~RequestObserver() override = default;
// RequestManager::Observer overrides.
void OnRequestCreated(int request_id, RequestType type) override {
created_.emplace_back(request_id, type);
}
// RequestManager::Observer overrides.
void OnRequestDestroyed(int request_id,
OperationCompletion completion) override {
destroyed_.emplace_back(request_id, completion);
}
// RequestManager::Observer overrides.
void OnRequestExecuted(int request_id) override {
executed_.emplace_back(request_id);
}
// RequestManager::Observer overrides.
void OnRequestFulfilled(int request_id,
const RequestValue& result,
bool has_more) override {
fulfilled_.emplace_back(request_id, has_more);
}
// RequestManager::Observer overrides.
void OnRequestRejected(int request_id,
const RequestValue& result,
base::File::Error error) override {
rejected_.emplace_back(request_id, error);
}
// RequestManager::Observer overrides.
void OnRequestTimedOut(int request_id) override {
timed_out_.emplace_back(request_id);
}
const std::vector<CreatedEvent>& created() const { return created_; }
const std::vector<DestroyedEvent>& destroyed() const { return destroyed_; }
const std::vector<Event>& executed() const { return executed_; }
const std::vector<FulfilledEvent>& fulfilled() const { return fulfilled_; }
const std::vector<RejectedEvent>& rejected() const { return rejected_; }
const std::vector<Event>& timed_out() const { return timed_out_; }
private:
std::vector<CreatedEvent> created_;
std::vector<DestroyedEvent> destroyed_;
std::vector<Event> executed_;
std::vector<FulfilledEvent> fulfilled_;
std::vector<RejectedEvent> rejected_;
std::vector<Event> timed_out_;
};
} // namespace
class FileSystemProviderRequestManagerTest : public testing::Test {
protected:
FileSystemProviderRequestManagerTest() = default;
~FileSystemProviderRequestManagerTest() override = default;
void SetUp() override {
profile_ = std::make_unique<TestingProfile>();
notification_manager_ = std::make_unique<FakeNotificationManager>();
request_manager_ = std::make_unique<OperationRequestManager>(
profile_.get(), /*provider_id=*/std::string(),
notification_manager_.get(), /*timeout=*/base::Seconds(10));
}
content::BrowserTaskEnvironment task_environment_;
std::unique_ptr<TestingProfile> profile_;
std::unique_ptr<FakeNotificationManager> notification_manager_;
std::unique_ptr<OperationRequestManager> request_manager_;
};
TEST_F(FileSystemProviderRequestManagerTest, CreateFailure) {
EventLogger logger;
RequestObserver observer;
request_manager_->AddObserver(&observer);
const int request_id = request_manager_->CreateRequest(
kTestRequestType,
base::WrapUnique<RequestManager::HandlerInterface>(
new FakeHandler(logger.GetWeakPtr(), /*execute_reply=*/false)));
EXPECT_EQ(0, request_id);
EXPECT_EQ(0u, logger.success_events().size());
EXPECT_EQ(0u, logger.error_events().size());
EXPECT_EQ(1u, observer.created().size());
EXPECT_EQ(kTestRequestType, observer.created()[0].type());
EXPECT_EQ(1u, observer.destroyed().size());
EXPECT_EQ(0u, observer.executed().size());
const std::vector<int> active_request_ids =
request_manager_->GetActiveRequestIds();
EXPECT_EQ(0u, active_request_ids.size());
request_manager_->RemoveObserver(&observer);
}
TEST_F(FileSystemProviderRequestManagerTest, CreateAndFulFill) {
EventLogger logger;
RequestObserver observer;
request_manager_->AddObserver(&observer);
const int request_id = request_manager_->CreateRequest(
kTestRequestType,
base::WrapUnique<RequestManager::HandlerInterface>(
new FakeHandler(logger.GetWeakPtr(), /*execute_reply=*/true)));
EXPECT_EQ(1, request_id);
EXPECT_EQ(0u, logger.success_events().size());
EXPECT_EQ(0u, logger.error_events().size());
ASSERT_EQ(1u, observer.created().size());
EXPECT_EQ(request_id, observer.created()[0].request_id());
EXPECT_EQ(kTestRequestType, observer.created()[0].type());
ASSERT_EQ(1u, observer.executed().size());
EXPECT_EQ(request_id, observer.executed()[0].request_id());
const std::vector<int> active_request_ids =
request_manager_->GetActiveRequestIds();
ASSERT_EQ(1u, active_request_ids.size());
EXPECT_EQ(request_id, active_request_ids[0]);
RequestValue response(RequestValue::CreateForTesting("i-like-vanilla"));
const bool has_more = false;
const base::File::Error result = request_manager_->FulfillRequest(
request_id, std::move(response), has_more);
EXPECT_EQ(base::File::FILE_OK, result);
ASSERT_EQ(1u, observer.fulfilled().size());
EXPECT_EQ(request_id, observer.fulfilled()[0].request_id());
EXPECT_FALSE(observer.fulfilled()[0].has_more());
// Validate if the callback has correct arguments.
ASSERT_EQ(1u, logger.success_events().size());
EXPECT_EQ(0u, logger.error_events().size());
EventLogger::SuccessEvent* event = logger.success_events()[0].get();
ASSERT_TRUE(event->testing_param());
EXPECT_EQ("i-like-vanilla", *event->testing_param());
EXPECT_FALSE(event->has_more());
// Confirm, that the request is removed. Basically, fulfilling again for the
// same request, should fail.
{
EXPECT_EQ(0u, request_manager_->GetActiveRequestIds().size());
const base::File::Error retry =
request_manager_->FulfillRequest(request_id, RequestValue(), has_more);
EXPECT_EQ(base::File::FILE_ERROR_NOT_FOUND, retry);
EXPECT_EQ(1u, observer.fulfilled().size());
}
// Rejecting should also fail.
{
const base::File::Error retry = request_manager_->RejectRequest(
request_id, RequestValue(), base::File::FILE_ERROR_FAILED);
EXPECT_EQ(base::File::FILE_ERROR_NOT_FOUND, retry);
EXPECT_EQ(0u, observer.rejected().size());
}
ASSERT_EQ(1u, observer.destroyed().size());
EXPECT_EQ(request_id, observer.destroyed()[0].request_id());
EXPECT_EQ(OperationCompletion::kCompletedNormally,
observer.destroyed()[0].completion());
EXPECT_EQ(0u, observer.timed_out().size());
request_manager_->RemoveObserver(&observer);
}
TEST_F(FileSystemProviderRequestManagerTest, CreateAndFulFill_WithHasNext) {
EventLogger logger;
RequestObserver observer;
request_manager_->AddObserver(&observer);
const int request_id = request_manager_->CreateRequest(
kTestRequestType,
base::WrapUnique<RequestManager::HandlerInterface>(
new FakeHandler(logger.GetWeakPtr(), /*execute_reply=*/true)));
EXPECT_EQ(1, request_id);
EXPECT_EQ(0u, logger.success_events().size());
EXPECT_EQ(0u, logger.error_events().size());
ASSERT_EQ(1u, observer.created().size());
EXPECT_EQ(request_id, observer.created()[0].request_id());
EXPECT_EQ(kTestRequestType, observer.created()[0].type());
ASSERT_EQ(1u, observer.executed().size());
EXPECT_EQ(request_id, observer.executed()[0].request_id());
const bool has_more = true;
const base::File::Error result =
request_manager_->FulfillRequest(request_id, RequestValue(), has_more);
EXPECT_EQ(base::File::FILE_OK, result);
// Validate if the callback has correct arguments.
ASSERT_EQ(1u, logger.success_events().size());
EXPECT_EQ(0u, logger.error_events().size());
EventLogger::SuccessEvent* event = logger.success_events()[0].get();
EXPECT_FALSE(event->result_is_valid());
EXPECT_TRUE(event->has_more());
ASSERT_EQ(1u, observer.fulfilled().size());
EXPECT_EQ(request_id, observer.fulfilled()[0].request_id());
EXPECT_TRUE(observer.fulfilled()[0].has_more());
// Confirm, that the request is not removed (since it has has_more == true).
// Basically, fulfilling again for the same request, should not fail.
{
const std::vector<int> active_request_ids =
request_manager_->GetActiveRequestIds();
ASSERT_EQ(1u, active_request_ids.size());
EXPECT_EQ(request_id, active_request_ids[0]);
const bool new_has_more = false;
const base::File::Error retry = request_manager_->FulfillRequest(
request_id, RequestValue(), new_has_more);
EXPECT_EQ(base::File::FILE_OK, retry);
ASSERT_EQ(2u, observer.fulfilled().size());
EXPECT_EQ(request_id, observer.fulfilled()[1].request_id());
EXPECT_FALSE(observer.fulfilled()[1].has_more());
}
// Since |new_has_more| is false, then the request should be removed. To check
// it, try to fulfill again, what should fail.
{
const std::vector<int> active_request_ids =
request_manager_->GetActiveRequestIds();
EXPECT_EQ(0u, active_request_ids.size());
const bool new_has_more = false;
const base::File::Error retry = request_manager_->FulfillRequest(
request_id, RequestValue(), new_has_more);
EXPECT_EQ(base::File::FILE_ERROR_NOT_FOUND, retry);
EXPECT_EQ(0u, observer.rejected().size());
}
ASSERT_EQ(1u, observer.destroyed().size());
EXPECT_EQ(request_id, observer.destroyed()[0].request_id());
EXPECT_EQ(0u, observer.timed_out().size());
request_manager_->RemoveObserver(&observer);
}
TEST_F(FileSystemProviderRequestManagerTest, CreateAndReject) {
EventLogger logger;
RequestObserver observer;
request_manager_->AddObserver(&observer);
const int request_id = request_manager_->CreateRequest(
kTestRequestType,
base::WrapUnique<RequestManager::HandlerInterface>(
new FakeHandler(logger.GetWeakPtr(), /*execute_reply=*/true)));
EXPECT_EQ(1, request_id);
EXPECT_EQ(0u, logger.success_events().size());
EXPECT_EQ(0u, logger.error_events().size());
ASSERT_EQ(1u, observer.created().size());
EXPECT_EQ(request_id, observer.created()[0].request_id());
EXPECT_EQ(kTestRequestType, observer.created()[0].type());
ASSERT_EQ(1u, observer.executed().size());
EXPECT_EQ(request_id, observer.executed()[0].request_id());
const base::File::Error error = base::File::FILE_ERROR_NO_MEMORY;
const base::File::Error result =
request_manager_->RejectRequest(request_id, RequestValue(), error);
EXPECT_EQ(base::File::FILE_OK, result);
// Validate if the callback has correct arguments.
ASSERT_EQ(1u, logger.error_events().size());
EXPECT_EQ(0u, logger.success_events().size());
EventLogger::ErrorEvent* event = logger.error_events()[0].get();
EXPECT_EQ(error, event->error());
ASSERT_EQ(1u, observer.rejected().size());
EXPECT_EQ(request_id, observer.rejected()[0].request_id());
EXPECT_EQ(error, observer.rejected()[0].error());
// Confirm, that the request is removed. Basically, fulfilling again for the
// same request, should fail.
{
const bool has_more = false;
const base::File::Error retry =
request_manager_->FulfillRequest(request_id, RequestValue(), has_more);
EXPECT_EQ(base::File::FILE_ERROR_NOT_FOUND, retry);
EXPECT_EQ(0u, observer.fulfilled().size());
}
// Rejecting should also fail.
{
const base::File::Error retry =
request_manager_->RejectRequest(request_id, RequestValue(), error);
EXPECT_EQ(base::File::FILE_ERROR_NOT_FOUND, retry);
EXPECT_EQ(1u, observer.rejected().size());
}
ASSERT_EQ(1u, observer.destroyed().size());
EXPECT_EQ(request_id, observer.destroyed()[0].request_id());
EXPECT_EQ(OperationCompletion::kCompletedNormally,
observer.destroyed()[0].completion());
EXPECT_EQ(0u, observer.timed_out().size());
request_manager_->RemoveObserver(&observer);
}
TEST_F(FileSystemProviderRequestManagerTest,
CreateAndFulfillWithWrongRequestId) {
EventLogger logger;
RequestObserver observer;
request_manager_->AddObserver(&observer);
const int request_id = request_manager_->CreateRequest(
kTestRequestType,
base::WrapUnique<RequestManager::HandlerInterface>(
new FakeHandler(logger.GetWeakPtr(), /*execute_reply=*/true)));
EXPECT_EQ(1, request_id);
EXPECT_EQ(0u, logger.success_events().size());
EXPECT_EQ(0u, logger.error_events().size());
ASSERT_EQ(1u, observer.created().size());
EXPECT_EQ(request_id, observer.created()[0].request_id());
EXPECT_EQ(kTestRequestType, observer.created()[0].type());
ASSERT_EQ(1u, observer.executed().size());
EXPECT_EQ(request_id, observer.executed()[0].request_id());
const bool has_more = true;
const base::File::Error result = request_manager_->FulfillRequest(
request_id + 1, RequestValue(), has_more);
EXPECT_EQ(base::File::FILE_ERROR_NOT_FOUND, result);
// Callbacks should not be called.
EXPECT_EQ(0u, logger.error_events().size());
EXPECT_EQ(0u, logger.success_events().size());
EXPECT_EQ(0u, observer.fulfilled().size());
EXPECT_EQ(request_id, observer.executed()[0].request_id());
// Confirm, that the request hasn't been removed, by fulfilling it correctly.
{
const base::File::Error retry =
request_manager_->FulfillRequest(request_id, RequestValue(), has_more);
EXPECT_EQ(base::File::FILE_OK, retry);
EXPECT_EQ(1u, observer.fulfilled().size());
}
request_manager_->RemoveObserver(&observer);
}
TEST_F(FileSystemProviderRequestManagerTest,
CreateAndRejectWithWrongRequestId) {
EventLogger logger;
RequestObserver observer;
request_manager_->AddObserver(&observer);
const int request_id = request_manager_->CreateRequest(
kTestRequestType,
base::WrapUnique<RequestManager::HandlerInterface>(
new FakeHandler(logger.GetWeakPtr(), /*execute_reply=*/true)));
EXPECT_EQ(1, request_id);
EXPECT_EQ(0u, logger.success_events().size());
EXPECT_EQ(0u, logger.error_events().size());
ASSERT_EQ(1u, observer.created().size());
EXPECT_EQ(request_id, observer.created()[0].request_id());
EXPECT_EQ(kTestRequestType, observer.created()[0].type());
ASSERT_EQ(1u, observer.executed().size());
EXPECT_EQ(request_id, observer.executed()[0].request_id());
const base::File::Error error = base::File::FILE_ERROR_NO_MEMORY;
const base::File::Error result =
request_manager_->RejectRequest(request_id + 1, RequestValue(), error);
EXPECT_EQ(base::File::FILE_ERROR_NOT_FOUND, result);
// Callbacks should not be called.
EXPECT_EQ(0u, logger.error_events().size());
EXPECT_EQ(0u, logger.success_events().size());
EXPECT_EQ(0u, observer.rejected().size());
// Confirm, that the request hasn't been removed, by rejecting it correctly.
{
const base::File::Error retry =
request_manager_->RejectRequest(request_id, RequestValue(), error);
EXPECT_EQ(base::File::FILE_OK, retry);
EXPECT_EQ(1u, observer.rejected().size());
}
request_manager_->RemoveObserver(&observer);
}
TEST_F(FileSystemProviderRequestManagerTest, UniqueIds) {
EventLogger logger;
const int first_request_id = request_manager_->CreateRequest(
kTestRequestType,
base::WrapUnique<RequestManager::HandlerInterface>(
new FakeHandler(logger.GetWeakPtr(), /*execute_reply=*/true)));
const int second_request_id = request_manager_->CreateRequest(
kTestRequestType,
base::WrapUnique<RequestManager::HandlerInterface>(
new FakeHandler(logger.GetWeakPtr(), /*execute_reply=*/true)));
EXPECT_EQ(1, first_request_id);
EXPECT_EQ(2, second_request_id);
}
TEST_F(FileSystemProviderRequestManagerTest, AbortOnDestroy) {
EventLogger logger;
RequestObserver observer;
int request_id;
{
OperationRequestManager request_manager(
profile_.get(), /*provider_id=*/std::string(),
/*notification_manager=*/nullptr, /*timeout=*/base::Seconds(10));
request_manager.AddObserver(&observer);
request_id = request_manager.CreateRequest(
kTestRequestType,
base::WrapUnique<RequestManager::HandlerInterface>(
new FakeHandler(logger.GetWeakPtr(), /*execute_reply=*/true)));
EXPECT_EQ(1, request_id);
EXPECT_EQ(0u, logger.success_events().size());
EXPECT_EQ(0u, logger.error_events().size());
EXPECT_EQ(0u, logger.abort_events().size());
ASSERT_EQ(1u, observer.created().size());
EXPECT_EQ(request_id, observer.created()[0].request_id());
EXPECT_EQ(kTestRequestType, observer.created()[0].type());
ASSERT_EQ(1u, observer.executed().size());
EXPECT_EQ(request_id, observer.executed()[0].request_id());
EXPECT_EQ(0u, observer.fulfilled().size());
EXPECT_EQ(0u, observer.rejected().size());
EXPECT_EQ(0u, observer.destroyed().size());
EXPECT_EQ(0u, observer.timed_out().size());
// Do not remove the observer, to catch events while destructing.
}
// All active requests should be aborted in the destructor of RequestManager.
ASSERT_EQ(1u, logger.error_events().size());
EventLogger::ErrorEvent* event = logger.error_events()[0].get();
EXPECT_EQ(base::File::FILE_ERROR_ABORT, event->error());
ASSERT_EQ(1u, logger.abort_events().size());
EXPECT_EQ(request_id, logger.abort_events()[0]->request_id());
EXPECT_EQ(0u, logger.success_events().size());
EXPECT_EQ(0u, observer.fulfilled().size());
EXPECT_EQ(0u, observer.timed_out().size());
ASSERT_EQ(1u, observer.rejected().size());
EXPECT_EQ(request_id, observer.rejected()[0].request_id());
EXPECT_EQ(base::File::FILE_ERROR_ABORT, observer.rejected()[0].error());
ASSERT_EQ(1u, observer.destroyed().size());
EXPECT_EQ(OperationCompletion::kAbortedInternally,
observer.destroyed()[0].completion());
}
TEST_F(FileSystemProviderRequestManagerTest, AbortOnTimeout) {
EventLogger logger;
RequestObserver observer;
request_manager_->AddObserver(&observer);
request_manager_->SetTimeoutForTesting(base::Seconds(0));
const int request_id = request_manager_->CreateRequest(
kTestRequestType,
base::WrapUnique<RequestManager::HandlerInterface>(
new FakeHandler(logger.GetWeakPtr(), /*execute_reply=*/true)));
EXPECT_EQ(1, request_id);
EXPECT_EQ(0u, logger.success_events().size());
EXPECT_EQ(0u, logger.error_events().size());
EXPECT_EQ(0u, notification_manager_->size());
ASSERT_EQ(1u, observer.created().size());
EXPECT_EQ(request_id, observer.created()[0].request_id());
EXPECT_EQ(kTestRequestType, observer.created()[0].type());
ASSERT_EQ(1u, observer.executed().size());
EXPECT_EQ(request_id, observer.executed()[0].request_id());
// Wait until the request is timed out.
base::RunLoop().RunUntilIdle();
// Abort the request.
EXPECT_EQ(1u, notification_manager_->size());
notification_manager_->Abort();
EXPECT_EQ(0u, notification_manager_->size());
ASSERT_EQ(1u, logger.error_events().size());
EventLogger::ErrorEvent* event = logger.error_events()[0].get();
EXPECT_EQ(base::File::FILE_ERROR_ABORT, event->error());
ASSERT_EQ(1u, logger.abort_events().size());
EXPECT_EQ(request_id, logger.abort_events()[0]->request_id());
ASSERT_EQ(1u, observer.rejected().size());
EXPECT_EQ(request_id, observer.rejected()[0].request_id());
EXPECT_EQ(base::File::FILE_ERROR_ABORT, observer.rejected()[0].error());
ASSERT_EQ(1u, observer.timed_out().size());
EXPECT_EQ(request_id, observer.timed_out()[0].request_id());
ASSERT_EQ(1u, observer.destroyed().size());
EXPECT_EQ(request_id, observer.destroyed()[0].request_id());
EXPECT_EQ(OperationCompletion::kAbortedFromNotification,
observer.destroyed()[0].completion());
request_manager_->RemoveObserver(&observer);
}
TEST_F(FileSystemProviderRequestManagerTest, ContinueOnTimeout) {
EventLogger logger;
RequestObserver observer;
request_manager_->AddObserver(&observer);
request_manager_->SetTimeoutForTesting(base::Seconds(0));
const int request_id = request_manager_->CreateRequest(
kTestRequestType,
base::WrapUnique<RequestManager::HandlerInterface>(
new FakeHandler(logger.GetWeakPtr(), /*execute_reply=*/true)));
EXPECT_EQ(1, request_id);
EXPECT_EQ(0u, logger.success_events().size());
EXPECT_EQ(0u, logger.error_events().size());
EXPECT_EQ(0u, logger.abort_events().size());
EXPECT_EQ(0u, notification_manager_->size());
ASSERT_EQ(1u, observer.created().size());
EXPECT_EQ(request_id, observer.created()[0].request_id());
EXPECT_EQ(kTestRequestType, observer.created()[0].type());
ASSERT_EQ(1u, observer.executed().size());
EXPECT_EQ(request_id, observer.executed()[0].request_id());
// Wait until the request is timed out.
base::RunLoop().RunUntilIdle();
// Let the provider have more time by closing the notification.
EXPECT_EQ(1u, notification_manager_->size());
notification_manager_->Continue();
EXPECT_EQ(0u, notification_manager_->size());
// The request is still active.
EXPECT_EQ(0u, logger.success_events().size());
EXPECT_EQ(0u, logger.error_events().size());
EXPECT_EQ(0u, logger.abort_events().size());
// Wait until the request is timed out again.
base::RunLoop().RunUntilIdle();
EXPECT_EQ(1u, notification_manager_->size());
// Fulfill and check that operation completion mode changes.
const base::File::Error result = request_manager_->FulfillRequest(
request_id,
RequestValue(RequestValue::CreateForTesting("i-like-vanilla")),
/*has_more=*/false);
EXPECT_EQ(base::File::FILE_OK, result);
ASSERT_EQ(1u, observer.fulfilled().size());
ASSERT_EQ(1u, observer.destroyed().size());
EXPECT_EQ(OperationCompletion::kCompletedAfterWarning,
observer.destroyed()[0].completion());
request_manager_->RemoveObserver(&observer);
}
TEST_F(FileSystemProviderRequestManagerTest, NoNotificationWhileInteractive) {
EventLogger logger;
RequestObserver observer;
base::ScopedObservation<RequestManager, RequestManager::Observer> observation(
&observer);
observation.Observe(request_manager_.get());
request_manager_->StartUserInteraction();
request_manager_->SetTimeoutForTesting(base::Seconds(0));
int request_id = request_manager_->CreateRequest(
kTestRequestType,
base::WrapUnique<RequestManager::HandlerInterface>(
new FakeHandler(logger.GetWeakPtr(), /*execute_reply=*/true)));
EXPECT_EQ(1, request_id);
EXPECT_EQ(0u, logger.success_events().size());
EXPECT_EQ(0u, logger.error_events().size());
EXPECT_EQ(0u, logger.abort_events().size());
EXPECT_EQ(0u, notification_manager_->size());
ASSERT_EQ(1u, observer.created().size());
EXPECT_EQ(request_id, observer.created()[0].request_id());
EXPECT_EQ(kTestRequestType, observer.created()[0].type());
ASSERT_EQ(1u, observer.executed().size());
EXPECT_EQ(request_id, observer.executed()[0].request_id());
// Wait until the request is timed out.
TimeoutWaiter(request_manager_.get()).Wait();
// Should not have shown a notification.
EXPECT_EQ(0u, notification_manager_->size());
// The request is still active.
EXPECT_EQ(0u, logger.success_events().size());
EXPECT_EQ(0u, logger.error_events().size());
EXPECT_EQ(0u, logger.abort_events().size());
// No longer interacting with the user.
request_manager_->EndUserInteraction();
// Wait until the request is timed out again.
TimeoutWaiter(request_manager_.get()).Wait();
// Shown a notification.
EXPECT_EQ(1u, notification_manager_->size());
}
} // namespace ash::file_system_provider
Codebase Browser
chromium