3party/crashpad
0
0
Fork 0
mirror of https://github.com/chromium/crashpad.git synced 2024-12-28 07:48:14 +08:00
Code Issues Projects Releases Wiki Activity
crashpad/client/crash_report_database_test.cc
Mark Mentovai 281be63d00 Standardize on static constexpr for arrays when possible 
This uses “static” at function scope to avoid making local copies, even
in cases where the compiler can’t see that the local copy is
unnecessary. “constexpr” adds additional safety in that it prevents
global state from being initialized from any runtime dependencies, which
would be undesirable.

At namespace scope, “constexpr” is also used where appropriate.

For the most part, this was a mechanical transformation for things
matching '(^| )const [^=]*\['.

Similar transformations could be applied to non-arrays in some cases,
but there’s limited practical impact in most non-array cases relative to
arrays, there are far more use sites, and much more manual intervention
would be required.

Change-Id: I3513b739ee8b0be026f8285475cddc5f9cc81152
Reviewed-on: https://chromium-review.googlesource.com/583997
Commit-Queue: Mark Mentovai <mark@chromium.org>
Reviewed-by: Leonard Mosescu <mosescu@chromium.org>
2017-07-25 17:40:51 +00:00

689 lines
24 KiB
C++
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

// Copyright 2015 The Crashpad Authors. All rights reserved.
//
// 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 "client/crash_report_database.h"
#include "build/build_config.h"
#include "client/settings.h"
#include "gtest/gtest.h"
#include "test/errors.h"
#include "test/file.h"
#include "test/scoped_temp_dir.h"
#include "util/file/file_io.h"
namespace crashpad {
namespace test {
namespace {
class CrashReportDatabaseTest : public testing::Test {
public:
CrashReportDatabaseTest() {
}
protected:
// testing::Test:
void SetUp() override {
db_ = CrashReportDatabase::Initialize(path());
ASSERT_TRUE(db_);
}
void ResetDatabase() {
db_.reset();
}
CrashReportDatabase* db() { return db_.get(); }
base::FilePath path() const {
return temp_dir_.path().Append(FILE_PATH_LITERAL("crashpad_test_database"));
}
void CreateCrashReport(CrashReportDatabase::Report* report) {
CrashReportDatabase::NewReport* new_report = nullptr;
ASSERT_EQ(db_->PrepareNewCrashReport(&new_report),
CrashReportDatabase::kNoError);
static constexpr char kTest[] = "test";
ASSERT_TRUE(LoggingWriteFile(new_report->handle, kTest, sizeof(kTest)));
UUID uuid;
EXPECT_EQ(db_->FinishedWritingCrashReport(new_report, &uuid),
CrashReportDatabase::kNoError);
EXPECT_EQ(db_->LookUpCrashReport(uuid, report),
CrashReportDatabase::kNoError);
ExpectPreparedCrashReport(*report);
ASSERT_TRUE(FileExists(report->file_path));
}
void UploadReport(const UUID& uuid, bool successful, const std::string& id) {
Settings* const settings = db_->GetSettings();
ASSERT_TRUE(settings);
time_t times[2];
ASSERT_TRUE(settings->GetLastUploadAttemptTime(&times[0]));
const CrashReportDatabase::Report* report = nullptr;
ASSERT_EQ(db_->GetReportForUploading(uuid, &report),
CrashReportDatabase::kNoError);
EXPECT_NE(report->uuid, UUID());
EXPECT_FALSE(report->file_path.empty());
EXPECT_TRUE(FileExists(report->file_path)) << report->file_path.value();
EXPECT_GT(report->creation_time, 0);
EXPECT_EQ(db_->RecordUploadAttempt(report, successful, id),
CrashReportDatabase::kNoError);
ASSERT_TRUE(settings->GetLastUploadAttemptTime(&times[1]));
EXPECT_NE(times[1], 0);
EXPECT_GE(times[1], times[0]);
}
void ExpectPreparedCrashReport(const CrashReportDatabase::Report& report) {
EXPECT_NE(report.uuid, UUID());
EXPECT_FALSE(report.file_path.empty());
EXPECT_TRUE(FileExists(report.file_path)) << report.file_path.value();
EXPECT_TRUE(report.id.empty());
EXPECT_GT(report.creation_time, 0);
EXPECT_FALSE(report.uploaded);
EXPECT_EQ(report.last_upload_attempt_time, 0);
EXPECT_EQ(report.upload_attempts, 0);
EXPECT_FALSE(report.upload_explicitly_requested);
}
void RelocateDatabase() {
ResetDatabase();
temp_dir_.Rename();
SetUp();
}
CrashReportDatabase::OperationStatus RequestUpload(const UUID& uuid) {
CrashReportDatabase::OperationStatus os = db()->RequestUpload(uuid);
CrashReportDatabase::Report report;
EXPECT_EQ(db_->LookUpCrashReport(uuid, &report),
CrashReportDatabase::kNoError);
return os;
}
private:
ScopedTempDir temp_dir_;
std::unique_ptr<CrashReportDatabase> db_;
DISALLOW_COPY_AND_ASSIGN(CrashReportDatabaseTest);
};
TEST_F(CrashReportDatabaseTest, Initialize) {
// Initialize the database for the first time, creating it.
ASSERT_TRUE(db());
Settings* settings = db()->GetSettings();
UUID client_ids[3];
ASSERT_TRUE(settings->GetClientID(&client_ids[0]));
EXPECT_NE(client_ids[0], UUID());
time_t last_upload_attempt_time;
ASSERT_TRUE(settings->GetLastUploadAttemptTime(&last_upload_attempt_time));
EXPECT_EQ(last_upload_attempt_time, 0);
// Close and reopen the database at the same path.
ResetDatabase();
EXPECT_FALSE(db());
auto db = CrashReportDatabase::InitializeWithoutCreating(path());
ASSERT_TRUE(db);
settings = db->GetSettings();
ASSERT_TRUE(settings->GetClientID(&client_ids[1]));
EXPECT_EQ(client_ids[1], client_ids[0]);
ASSERT_TRUE(settings->GetLastUploadAttemptTime(&last_upload_attempt_time));
EXPECT_EQ(last_upload_attempt_time, 0);
// Check that the database can also be opened by the method that is permitted
// to create it.
db = CrashReportDatabase::Initialize(path());
ASSERT_TRUE(db);
settings = db->GetSettings();
ASSERT_TRUE(settings->GetClientID(&client_ids[2]));
EXPECT_EQ(client_ids[2], client_ids[0]);
ASSERT_TRUE(settings->GetLastUploadAttemptTime(&last_upload_attempt_time));
EXPECT_EQ(last_upload_attempt_time, 0);
std::vector<CrashReportDatabase::Report> reports;
EXPECT_EQ(db->GetPendingReports(&reports), CrashReportDatabase::kNoError);
EXPECT_TRUE(reports.empty());
reports.clear();
EXPECT_EQ(db->GetCompletedReports(&reports), CrashReportDatabase::kNoError);
EXPECT_TRUE(reports.empty());
// InitializeWithoutCreating() shouldn’t create a nonexistent database.
base::FilePath non_database_path =
path().DirName().Append(FILE_PATH_LITERAL("not_a_database"));
db = CrashReportDatabase::InitializeWithoutCreating(non_database_path);
EXPECT_FALSE(db);
}
TEST_F(CrashReportDatabaseTest, NewCrashReport) {
CrashReportDatabase::NewReport* new_report;
EXPECT_EQ(db()->PrepareNewCrashReport(&new_report),
CrashReportDatabase::kNoError);
UUID expect_uuid = new_report->uuid;
EXPECT_TRUE(FileExists(new_report->path)) << new_report->path.value();
UUID uuid;
EXPECT_EQ(db()->FinishedWritingCrashReport(new_report, &uuid),
CrashReportDatabase::kNoError);
EXPECT_EQ(uuid, expect_uuid);
CrashReportDatabase::Report report;
EXPECT_EQ(db()->LookUpCrashReport(uuid, &report),
CrashReportDatabase::kNoError);
ExpectPreparedCrashReport(report);
std::vector<CrashReportDatabase::Report> reports;
EXPECT_EQ(db()->GetPendingReports(&reports), CrashReportDatabase::kNoError);
ASSERT_EQ(reports.size(), 1u);
EXPECT_EQ(reports[0].uuid, report.uuid);
reports.clear();
EXPECT_EQ(db()->GetCompletedReports(&reports), CrashReportDatabase::kNoError);
EXPECT_TRUE(reports.empty());
}
TEST_F(CrashReportDatabaseTest, ErrorWritingCrashReport) {
CrashReportDatabase::NewReport* new_report = nullptr;
ASSERT_EQ(db()->PrepareNewCrashReport(&new_report),
CrashReportDatabase::kNoError);
base::FilePath new_report_path = new_report->path;
EXPECT_TRUE(FileExists(new_report_path)) << new_report_path.value();
EXPECT_EQ(db()->ErrorWritingCrashReport(new_report),
CrashReportDatabase::kNoError);
EXPECT_FALSE(FileExists(new_report_path)) << new_report_path.value();
}
TEST_F(CrashReportDatabaseTest, LookUpCrashReport) {
UUID uuid;
{
CrashReportDatabase::Report report;
CreateCrashReport(&report);
uuid = report.uuid;
}
{
CrashReportDatabase::Report report;
EXPECT_EQ(db()->LookUpCrashReport(uuid, &report),
CrashReportDatabase::kNoError);
EXPECT_EQ(report.uuid, uuid);
EXPECT_NE(report.file_path.value().find(path().value()), std::string::npos);
EXPECT_EQ(report.id, std::string());
EXPECT_FALSE(report.uploaded);
EXPECT_EQ(report.last_upload_attempt_time, 0);
EXPECT_EQ(report.upload_attempts, 0);
EXPECT_FALSE(report.upload_explicitly_requested);
}
UploadReport(uuid, true, "test");
{
CrashReportDatabase::Report report;
EXPECT_EQ(db()->LookUpCrashReport(uuid, &report),
CrashReportDatabase::kNoError);
EXPECT_EQ(report.uuid, uuid);
EXPECT_NE(report.file_path.value().find(path().value()), std::string::npos);
EXPECT_EQ(report.id, "test");
EXPECT_TRUE(report.uploaded);
EXPECT_NE(report.last_upload_attempt_time, 0);
EXPECT_EQ(report.upload_attempts, 1);
EXPECT_FALSE(report.upload_explicitly_requested);
}
}
TEST_F(CrashReportDatabaseTest, RecordUploadAttempt) {
std::vector<CrashReportDatabase::Report> reports(3);
CreateCrashReport(&reports[0]);
CreateCrashReport(&reports[1]);
CreateCrashReport(&reports[2]);
// Record two attempts: one successful, one not.
UploadReport(reports[1].uuid, false, std::string());
UploadReport(reports[2].uuid, true, "abc123");
std::vector<CrashReportDatabase::Report> query(3);
EXPECT_EQ(db()->LookUpCrashReport(reports[0].uuid, &query[0]),
CrashReportDatabase::kNoError);
EXPECT_EQ(db()->LookUpCrashReport(reports[1].uuid, &query[1]),
CrashReportDatabase::kNoError);
EXPECT_EQ(db()->LookUpCrashReport(reports[2].uuid, &query[2]),
CrashReportDatabase::kNoError);
EXPECT_EQ(query[0].id, std::string());
EXPECT_EQ(query[1].id, std::string());
EXPECT_EQ(query[2].id, "abc123");
EXPECT_FALSE(query[0].uploaded);
EXPECT_FALSE(query[1].uploaded);
EXPECT_TRUE(query[2].uploaded);
EXPECT_EQ(query[0].last_upload_attempt_time, 0);
EXPECT_NE(query[1].last_upload_attempt_time, 0);
EXPECT_NE(query[2].last_upload_attempt_time, 0);
EXPECT_EQ(query[0].upload_attempts, 0);
EXPECT_EQ(query[1].upload_attempts, 1);
EXPECT_EQ(query[2].upload_attempts, 1);
// Attempt to upload and fail again.
UploadReport(reports[1].uuid, false, std::string());
time_t report_2_upload_time = query[2].last_upload_attempt_time;
EXPECT_EQ(db()->LookUpCrashReport(reports[0].uuid, &query[0]),
CrashReportDatabase::kNoError);
EXPECT_EQ(db()->LookUpCrashReport(reports[1].uuid, &query[1]),
CrashReportDatabase::kNoError);
EXPECT_EQ(db()->LookUpCrashReport(reports[2].uuid, &query[2]),
CrashReportDatabase::kNoError);
EXPECT_FALSE(query[0].uploaded);
EXPECT_FALSE(query[1].uploaded);
EXPECT_TRUE(query[2].uploaded);
EXPECT_EQ(query[0].last_upload_attempt_time, 0);
EXPECT_GE(query[1].last_upload_attempt_time, report_2_upload_time);
EXPECT_EQ(query[2].last_upload_attempt_time, report_2_upload_time);
EXPECT_EQ(query[0].upload_attempts, 0);
EXPECT_EQ(query[1].upload_attempts, 2);
EXPECT_EQ(query[2].upload_attempts, 1);
// Third time's the charm: upload and succeed.
UploadReport(reports[1].uuid, true, "666hahaha");
time_t report_1_upload_time = query[1].last_upload_attempt_time;
EXPECT_EQ(db()->LookUpCrashReport(reports[0].uuid, &query[0]),
CrashReportDatabase::kNoError);
EXPECT_EQ(db()->LookUpCrashReport(reports[1].uuid, &query[1]),
CrashReportDatabase::kNoError);
EXPECT_EQ(db()->LookUpCrashReport(reports[2].uuid, &query[2]),
CrashReportDatabase::kNoError);
EXPECT_FALSE(query[0].uploaded);
EXPECT_TRUE(query[1].uploaded);
EXPECT_TRUE(query[2].uploaded);
EXPECT_EQ(query[0].last_upload_attempt_time, 0);
EXPECT_GE(query[1].last_upload_attempt_time, report_1_upload_time);
EXPECT_EQ(query[2].last_upload_attempt_time, report_2_upload_time);
EXPECT_EQ(query[0].upload_attempts, 0);
EXPECT_EQ(query[1].upload_attempts, 3);
EXPECT_EQ(query[2].upload_attempts, 1);
}
// This test covers both query functions since they are related.
TEST_F(CrashReportDatabaseTest, GetCompletedAndNotUploadedReports) {
std::vector<CrashReportDatabase::Report> reports(5);
CreateCrashReport(&reports[0]);
CreateCrashReport(&reports[1]);
CreateCrashReport(&reports[2]);
CreateCrashReport(&reports[3]);
CreateCrashReport(&reports[4]);
const UUID& report_0_uuid = reports[0].uuid;
const UUID& report_1_uuid = reports[1].uuid;
const UUID& report_2_uuid = reports[2].uuid;
const UUID& report_3_uuid = reports[3].uuid;
const UUID& report_4_uuid = reports[4].uuid;
std::vector<CrashReportDatabase::Report> pending;
EXPECT_EQ(db()->GetPendingReports(&pending), CrashReportDatabase::kNoError);
std::vector<CrashReportDatabase::Report> completed;
EXPECT_EQ(db()->GetCompletedReports(&completed),
CrashReportDatabase::kNoError);
EXPECT_EQ(pending.size(), reports.size());
EXPECT_EQ(completed.size(), 0u);
// Upload one report successfully.
UploadReport(report_1_uuid, true, "report1");
pending.clear();
EXPECT_EQ(db()->GetPendingReports(&pending), CrashReportDatabase::kNoError);
completed.clear();
EXPECT_EQ(db()->GetCompletedReports(&completed),
CrashReportDatabase::kNoError);
EXPECT_EQ(pending.size(), 4u);
ASSERT_EQ(completed.size(), 1u);
for (const auto& report : pending) {
EXPECT_NE(report.uuid, report_1_uuid);
EXPECT_FALSE(report.file_path.empty());
}
EXPECT_EQ(completed[0].uuid, report_1_uuid);
EXPECT_EQ(completed[0].id, "report1");
EXPECT_EQ(completed[0].uploaded, true);
EXPECT_GT(completed[0].last_upload_attempt_time, 0);
EXPECT_EQ(completed[0].upload_attempts, 1);
// Fail to upload one report.
UploadReport(report_2_uuid, false, std::string());
pending.clear();
EXPECT_EQ(db()->GetPendingReports(&pending), CrashReportDatabase::kNoError);
completed.clear();
EXPECT_EQ(db()->GetCompletedReports(&completed),
CrashReportDatabase::kNoError);
EXPECT_EQ(pending.size(), 4u);
ASSERT_EQ(completed.size(), 1u);
for (const auto& report : pending) {
if (report.upload_attempts != 0) {
EXPECT_EQ(report.uuid, report_2_uuid);
EXPECT_GT(report.last_upload_attempt_time, 0);
EXPECT_FALSE(report.uploaded);
EXPECT_TRUE(report.id.empty());
}
EXPECT_FALSE(report.file_path.empty());
}
// Upload a second report.
UploadReport(report_4_uuid, true, "report_4");
pending.clear();
EXPECT_EQ(db()->GetPendingReports(&pending), CrashReportDatabase::kNoError);
completed.clear();
EXPECT_EQ(db()->GetCompletedReports(&completed),
CrashReportDatabase::kNoError);
EXPECT_EQ(pending.size(), 3u);
ASSERT_EQ(completed.size(), 2u);
// Succeed the failed report.
UploadReport(report_2_uuid, true, "report 2");
pending.clear();
EXPECT_EQ(db()->GetPendingReports(&pending), CrashReportDatabase::kNoError);
completed.clear();
EXPECT_EQ(db()->GetCompletedReports(&completed),
CrashReportDatabase::kNoError);
EXPECT_EQ(pending.size(), 2u);
ASSERT_EQ(completed.size(), 3u);
for (const auto& report : pending) {
EXPECT_TRUE(report.uuid == report_0_uuid || report.uuid == report_3_uuid);
EXPECT_FALSE(report.file_path.empty());
}
// Skip upload for one report.
EXPECT_EQ(db()->SkipReportUpload(
report_3_uuid, Metrics::CrashSkippedReason::kUploadsDisabled),
CrashReportDatabase::kNoError);
pending.clear();
EXPECT_EQ(db()->GetPendingReports(&pending), CrashReportDatabase::kNoError);
completed.clear();
EXPECT_EQ(db()->GetCompletedReports(&completed),
CrashReportDatabase::kNoError);
ASSERT_EQ(pending.size(), 1u);
ASSERT_EQ(completed.size(), 4u);
EXPECT_EQ(pending[0].uuid, report_0_uuid);
for (const auto& report : completed) {
if (report.uuid == report_3_uuid) {
EXPECT_FALSE(report.uploaded);
EXPECT_EQ(report.upload_attempts, 0);
EXPECT_EQ(report.last_upload_attempt_time, 0);
} else {
EXPECT_TRUE(report.uploaded);
EXPECT_GT(report.upload_attempts, 0);
EXPECT_GT(report.last_upload_attempt_time, 0);
}
EXPECT_FALSE(report.file_path.empty());
}
}
TEST_F(CrashReportDatabaseTest, DuelingUploads) {
CrashReportDatabase::Report report;
CreateCrashReport(&report);
const CrashReportDatabase::Report* upload_report;
EXPECT_EQ(db()->GetReportForUploading(report.uuid, &upload_report),
CrashReportDatabase::kNoError);
const CrashReportDatabase::Report* upload_report_2 = nullptr;
EXPECT_EQ(db()->GetReportForUploading(report.uuid, &upload_report_2),
CrashReportDatabase::kBusyError);
EXPECT_FALSE(upload_report_2);
EXPECT_EQ(db()->RecordUploadAttempt(upload_report, true, std::string()),
CrashReportDatabase::kNoError);
}
TEST_F(CrashReportDatabaseTest, UploadAlreadyUploaded) {
CrashReportDatabase::Report report;
CreateCrashReport(&report);
const CrashReportDatabase::Report* upload_report;
EXPECT_EQ(db()->GetReportForUploading(report.uuid, &upload_report),
CrashReportDatabase::kNoError);
EXPECT_EQ(db()->RecordUploadAttempt(upload_report, true, std::string()),
CrashReportDatabase::kNoError);
const CrashReportDatabase::Report* upload_report_2 = nullptr;
EXPECT_EQ(db()->GetReportForUploading(report.uuid, &upload_report_2),
CrashReportDatabase::kReportNotFound);
EXPECT_FALSE(upload_report_2);
}
TEST_F(CrashReportDatabaseTest, MoveDatabase) {
CrashReportDatabase::NewReport* new_report;
EXPECT_EQ(db()->PrepareNewCrashReport(&new_report),
CrashReportDatabase::kNoError);
EXPECT_TRUE(FileExists(new_report->path)) << new_report->path.value();
UUID uuid;
EXPECT_EQ(db()->FinishedWritingCrashReport(new_report, &uuid),
CrashReportDatabase::kNoError);
RelocateDatabase();
CrashReportDatabase::Report report;
EXPECT_EQ(db()->LookUpCrashReport(uuid, &report),
CrashReportDatabase::kNoError);
ExpectPreparedCrashReport(report);
EXPECT_TRUE(FileExists(report.file_path)) << report.file_path.value();
}
TEST_F(CrashReportDatabaseTest, ReportRemoved) {
CrashReportDatabase::NewReport* new_report;
EXPECT_EQ(db()->PrepareNewCrashReport(&new_report),
CrashReportDatabase::kNoError);
EXPECT_TRUE(FileExists(new_report->path)) << new_report->path.value();
UUID uuid;
EXPECT_EQ(db()->FinishedWritingCrashReport(new_report, &uuid),
CrashReportDatabase::kNoError);
CrashReportDatabase::Report report;
EXPECT_EQ(db()->LookUpCrashReport(uuid, &report),
CrashReportDatabase::kNoError);
#if defined(OS_WIN)
EXPECT_EQ(_wunlink(report.file_path.value().c_str()), 0);
#else
EXPECT_EQ(unlink(report.file_path.value().c_str()), 0)
<< ErrnoMessage("unlink");
#endif
EXPECT_EQ(db()->LookUpCrashReport(uuid, &report),
CrashReportDatabase::kReportNotFound);
}
TEST_F(CrashReportDatabaseTest, DeleteReport) {
CrashReportDatabase::Report keep_pending;
CrashReportDatabase::Report delete_pending;
CrashReportDatabase::Report keep_completed;
CrashReportDatabase::Report delete_completed;
CreateCrashReport(&keep_pending);
CreateCrashReport(&delete_pending);
CreateCrashReport(&keep_completed);
CreateCrashReport(&delete_completed);
EXPECT_TRUE(FileExists(keep_pending.file_path));
EXPECT_TRUE(FileExists(delete_pending.file_path));
EXPECT_TRUE(FileExists(keep_completed.file_path));
EXPECT_TRUE(FileExists(delete_completed.file_path));
UploadReport(keep_completed.uuid, true, "1");
UploadReport(delete_completed.uuid, true, "2");
EXPECT_EQ(db()->LookUpCrashReport(keep_completed.uuid, &keep_completed),
CrashReportDatabase::kNoError);
EXPECT_EQ(db()->LookUpCrashReport(delete_completed.uuid, &delete_completed),
CrashReportDatabase::kNoError);
EXPECT_TRUE(FileExists(keep_completed.file_path));
EXPECT_TRUE(FileExists(delete_completed.file_path));
EXPECT_EQ(db()->DeleteReport(delete_pending.uuid),
CrashReportDatabase::kNoError);
EXPECT_FALSE(FileExists(delete_pending.file_path));
EXPECT_EQ(db()->LookUpCrashReport(delete_pending.uuid, &delete_pending),
CrashReportDatabase::kReportNotFound);
EXPECT_EQ(db()->DeleteReport(delete_pending.uuid),
CrashReportDatabase::kReportNotFound);
EXPECT_EQ(db()->DeleteReport(delete_completed.uuid),
CrashReportDatabase::kNoError);
EXPECT_FALSE(FileExists(delete_completed.file_path));
EXPECT_EQ(db()->LookUpCrashReport(delete_completed.uuid, &delete_completed),
CrashReportDatabase::kReportNotFound);
EXPECT_EQ(db()->DeleteReport(delete_completed.uuid),
CrashReportDatabase::kReportNotFound);
EXPECT_EQ(db()->LookUpCrashReport(keep_pending.uuid, &keep_pending),
CrashReportDatabase::kNoError);
EXPECT_EQ(db()->LookUpCrashReport(keep_completed.uuid, &keep_completed),
CrashReportDatabase::kNoError);
}
TEST_F(CrashReportDatabaseTest, DeleteReportEmptyingDatabase) {
CrashReportDatabase::Report report;
CreateCrashReport(&report);
EXPECT_TRUE(FileExists(report.file_path));
UploadReport(report.uuid, true, "1");
EXPECT_EQ(db()->LookUpCrashReport(report.uuid, &report),
CrashReportDatabase::kNoError);
EXPECT_TRUE(FileExists(report.file_path));
// This causes an empty database to be written, make sure this is handled.
EXPECT_EQ(db()->DeleteReport(report.uuid), CrashReportDatabase::kNoError);
EXPECT_FALSE(FileExists(report.file_path));
}
TEST_F(CrashReportDatabaseTest, ReadEmptyDatabase) {
CrashReportDatabase::Report report;
CreateCrashReport(&report);
EXPECT_EQ(db()->DeleteReport(report.uuid), CrashReportDatabase::kNoError);
// Deleting and the creating another report causes an empty database to be
// loaded. Make sure this is handled.
CrashReportDatabase::Report report2;
CreateCrashReport(&report2);
}
TEST_F(CrashReportDatabaseTest, RequestUpload) {
std::vector<CrashReportDatabase::Report> reports(2);
CreateCrashReport(&reports[0]);
CreateCrashReport(&reports[1]);
const UUID& report_0_uuid = reports[0].uuid;
const UUID& report_1_uuid = reports[1].uuid;
// Skipped report gets back to pending state after RequestUpload is called.
EXPECT_EQ(db()->SkipReportUpload(
report_1_uuid, Metrics::CrashSkippedReason::kUploadsDisabled),
CrashReportDatabase::kNoError);
std::vector<CrashReportDatabase::Report> pending_reports;
CrashReportDatabase::OperationStatus os =
db()->GetPendingReports(&pending_reports);
EXPECT_EQ(os, CrashReportDatabase::kNoError);
ASSERT_EQ(pending_reports.size(), 1u);
EXPECT_EQ(report_0_uuid, pending_reports[0].uuid);
pending_reports.clear();
EXPECT_EQ(RequestUpload(report_1_uuid), CrashReportDatabase::kNoError);
os = db()->GetPendingReports(&pending_reports);
EXPECT_EQ(os, CrashReportDatabase::kNoError);
ASSERT_EQ(pending_reports.size(), 2u);
// Check individual reports.
const CrashReportDatabase::Report* expicitly_requested_report;
const CrashReportDatabase::Report* pending_report;
if (pending_reports[0].uuid == report_0_uuid) {
pending_report = &pending_reports[0];
expicitly_requested_report = &pending_reports[1];
} else {
pending_report = &pending_reports[1];
expicitly_requested_report = &pending_reports[0];
}
EXPECT_EQ(pending_report->uuid, report_0_uuid);
EXPECT_FALSE(pending_report->upload_explicitly_requested);
EXPECT_EQ(expicitly_requested_report->uuid, report_1_uuid);
EXPECT_TRUE(expicitly_requested_report->upload_explicitly_requested);
// Explicitly requested reports will not have upload_explicitly_requested bit
// after getting skipped.
EXPECT_EQ(db()->SkipReportUpload(
report_1_uuid, Metrics::CrashSkippedReason::kUploadsDisabled),
CrashReportDatabase::kNoError);
CrashReportDatabase::Report report;
EXPECT_EQ(db()->LookUpCrashReport(report_1_uuid, &report),
CrashReportDatabase::kNoError);
EXPECT_FALSE(report.upload_explicitly_requested);
// Pending report gets correctly affected after RequestUpload is called.
pending_reports.clear();
EXPECT_EQ(RequestUpload(report_0_uuid), CrashReportDatabase::kNoError);
os = db()->GetPendingReports(&pending_reports);
EXPECT_EQ(os, CrashReportDatabase::kNoError);
EXPECT_EQ(pending_reports.size(), 1u);
EXPECT_EQ(report_0_uuid, pending_reports[0].uuid);
EXPECT_TRUE(pending_reports[0].upload_explicitly_requested);
// Already uploaded report cannot be requested for the new upload.
UploadReport(report_0_uuid, true, "1");
EXPECT_EQ(RequestUpload(report_0_uuid),
CrashReportDatabase::kCannotRequestUpload);
}
} // namespace
} // namespace test
} // namespace crashpad
Reference in New Issue View Git Blame Copy Permalink