// Copyright 2019 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/printing/printers_map.h"
#include "testing/gtest/include/gtest/gtest.h"
namespace ash {
namespace {
using ::chromeos::CupsPrinterStatus;
using ::chromeos::Printer;
using ::chromeos::PrinterClass;
using PrinterStatusReason = CupsPrinterStatus::CupsPrinterStatusReason;
bool IsPrinterInPrinters(const std::vector<Printer>& printers,
const Printer& printer) {
for (const auto& p : printers) {
if (p.id() == printer.id()) {
return true;
}
}
return false;
}
CupsPrinterStatus CreatePrinterStatus(
const std::string& printer_id,
const PrinterStatusReason::Reason reason =
PrinterStatusReason::Reason::kNoError) {
CupsPrinterStatus cups_printer_status(printer_id);
cups_printer_status.AddStatusReason(reason,
PrinterStatusReason::Severity::kReport);
return cups_printer_status;
}
void ExpectPrinterStatusesEqual(const CupsPrinterStatus expected_printer_status,
const CupsPrinterStatus actual_printer_status) {
EXPECT_EQ(expected_printer_status.GetPrinterId(),
actual_printer_status.GetPrinterId());
auto expected_status_reasons = expected_printer_status.GetStatusReasons();
auto actual_status_reasons = actual_printer_status.GetStatusReasons();
EXPECT_EQ(expected_status_reasons.size(), actual_status_reasons.size());
for (const auto& expected_status_reason : expected_status_reasons) {
for (const auto& actual_status_reason : actual_status_reasons) {
EXPECT_EQ(expected_status_reason.GetReason(),
actual_status_reason.GetReason());
EXPECT_EQ(expected_status_reason.GetSeverity(),
actual_status_reason.GetSeverity());
}
}
}
} // namespace
class PrintersMapTest : public testing::Test {
public:
PrintersMapTest() = default;
PrintersMapTest(const PrintersMapTest&) = delete;
PrintersMapTest& operator=(const PrintersMapTest&) = delete;
~PrintersMapTest() override = default;
};
TEST_F(PrintersMapTest, GetAllReturnsEmptyVector) {
PrintersMap printers_map;
std::vector<Printer> printers = printers_map.Get();
EXPECT_EQ(0u, printers.size());
}
TEST_F(PrintersMapTest, GetAllReturnsPrintersFromAllClasses) {
PrintersMap printers_map;
Printer discovered_printer = Printer("discovered_id");
Printer enterprise_printer = Printer("enterprise_id");
printers_map.Insert(PrinterClass::kEnterprise, enterprise_printer);
printers_map.Insert(PrinterClass::kDiscovered, discovered_printer);
auto printers = printers_map.Get();
EXPECT_EQ(2u, printers.size());
EXPECT_TRUE(IsPrinterInPrinters(printers, discovered_printer));
EXPECT_TRUE(IsPrinterInPrinters(printers, enterprise_printer));
}
TEST_F(PrintersMapTest, GetByIdReturnsEmptyOptionalWhenNonExistant) {
PrintersMap printers_map;
std::optional<Printer> printer = printers_map.Get("non_existant_id");
EXPECT_FALSE(printer);
}
TEST_F(PrintersMapTest, GetByIdReturnsPrinterWhenExistant) {
PrintersMap printers_map;
Printer expected_printer = Printer("printer_id");
expected_printer.set_display_name("123");
printers_map.Insert(PrinterClass::kEnterprise, expected_printer);
std::optional<Printer> actual_printer =
printers_map.Get(expected_printer.id());
EXPECT_TRUE(actual_printer);
EXPECT_EQ(expected_printer.id(), actual_printer->id());
EXPECT_EQ(expected_printer.display_name(), actual_printer->display_name());
}
TEST_F(PrintersMapTest, GetByClassReturnsEmptyVectorWhenNonExistant) {
PrintersMap printers_map;
auto printers = printers_map.Get(PrinterClass::kDiscovered);
EXPECT_EQ(0u, printers.size());
}
TEST_F(PrintersMapTest, GetByClassReturnsPrinters) {
PrintersMap printers_map;
Printer discovered_printer = Printer("discovered_id");
Printer enterprise_printer = Printer("enterprise_id");
printers_map.Insert(PrinterClass::kEnterprise, enterprise_printer);
printers_map.Insert(PrinterClass::kDiscovered, discovered_printer);
auto discovered_printers = printers_map.Get(PrinterClass::kDiscovered);
EXPECT_EQ(1u, discovered_printers.size());
EXPECT_EQ(discovered_printer.id(), discovered_printers[0].id());
auto enterprise_printers = printers_map.Get(PrinterClass::kEnterprise);
EXPECT_EQ(1u, enterprise_printers.size());
EXPECT_EQ(enterprise_printer.id(), enterprise_printers[0].id());
}
TEST_F(PrintersMapTest,
GetByClassAndIdOnlyReturnsEmptyOptionalWhenNonExistant) {
PrintersMap printers_map;
std::optional<Printer> found_printer =
printers_map.Get(PrinterClass::kDiscovered, "printer_id");
EXPECT_FALSE(found_printer);
}
TEST_F(PrintersMapTest, GetByClassAndIdOnlyReturnsFromCorrectClass) {
PrintersMap printers_map;
const std::string printer1_id = "1";
Printer printer1 = Printer(printer1_id);
Printer printer2 = Printer("2");
printers_map.Insert(PrinterClass::kEnterprise, printer1);
printers_map.Insert(PrinterClass::kDiscovered, printer2);
// No printer is found because |printer1| *is not* in kDiscovered.
std::optional<Printer> found_printer =
printers_map.Get(PrinterClass::kDiscovered, printer1_id);
EXPECT_FALSE(found_printer);
// Printer found because |printer1| *is* in kEnterprise.
found_printer = printers_map.Get(PrinterClass::kEnterprise, printer1_id);
EXPECT_TRUE(found_printer);
EXPECT_EQ(printer1_id, found_printer->id());
}
TEST_F(PrintersMapTest, InsertAddsPrinterToCorrectClass) {
PrintersMap printers_map;
Printer expected_printer = Printer("printer_id");
expected_printer.set_display_name("123");
EXPECT_EQ(0u, printers_map.Get(PrinterClass::kAutomatic).size());
printers_map.Insert(PrinterClass::kAutomatic, expected_printer);
EXPECT_EQ(1u, printers_map.Get(PrinterClass::kAutomatic).size());
}
TEST_F(PrintersMapTest, GetSecurePrintersReturnsEmptyVectorOnNonExistantClass) {
PrintersMap printers_map;
auto printers = printers_map.GetSecurePrinters();
EXPECT_EQ(0u, printers.size());
}
TEST_F(PrintersMapTest, GetSecurePrintersOnlyReturnsSecurePrinters) {
PrintersMap printers_map;
Printer ipp_printer = Printer("ipp");
ipp_printer.SetUri("ipp://printer");
printers_map.Insert(PrinterClass::kSaved, ipp_printer);
Printer ipps_printer = Printer("ipps");
ipps_printer.SetUri("ipps://printer");
printers_map.Insert(PrinterClass::kAutomatic, ipps_printer);
Printer usb_printer = Printer("usb");
usb_printer.SetUri("usb://printer/path");
printers_map.Insert(PrinterClass::kDiscovered, usb_printer);
Printer ippusb_printer = Printer("ippusb");
ippusb_printer.SetUri("ippusb://printer/path");
printers_map.Insert(PrinterClass::kEnterprise, ippusb_printer);
Printer http_printer = Printer("http");
http_printer.SetUri("http://printer");
printers_map.Insert(PrinterClass::kDiscovered, http_printer);
Printer https_printer = Printer("https");
https_printer.SetUri("https://printer");
printers_map.Insert(PrinterClass::kDiscovered, https_printer);
// Only HTTPS, IPPS, IPPUSB, and USB printers are returned.
auto printers = printers_map.GetSecurePrinters();
EXPECT_EQ(4u, printers.size());
EXPECT_TRUE(IsPrinterInPrinters(printers, ipps_printer));
EXPECT_TRUE(IsPrinterInPrinters(printers, usb_printer));
EXPECT_TRUE(IsPrinterInPrinters(printers, ippusb_printer));
EXPECT_TRUE(IsPrinterInPrinters(printers, https_printer));
EXPECT_FALSE(IsPrinterInPrinters(printers, ipp_printer));
EXPECT_FALSE(IsPrinterInPrinters(printers, http_printer));
}
TEST_F(PrintersMapTest,
GetSecurePrintersInClassReturnsEmptyVectorOnNonExistantClass) {
PrintersMap printers_map;
auto printers = printers_map.GetSecurePrinters(PrinterClass::kAutomatic);
EXPECT_EQ(0u, printers.size());
}
TEST_F(PrintersMapTest, GetSecurePrintersInClassOnlyReturnsSecurePrinters) {
PrintersMap printers_map;
Printer ipp_printer = Printer("ipp");
ipp_printer.SetUri("ipp://printer");
printers_map.Insert(PrinterClass::kSaved, ipp_printer);
Printer ipps_printer = Printer("ipps");
ipps_printer.SetUri("ipps://printer");
printers_map.Insert(PrinterClass::kSaved, ipps_printer);
Printer usb_printer = Printer("usb");
usb_printer.SetUri("usb://printer/path");
printers_map.Insert(PrinterClass::kSaved, usb_printer);
Printer ippusb_printer = Printer("ippusb");
ippusb_printer.SetUri("ippusb://printer/path");
printers_map.Insert(PrinterClass::kSaved, ippusb_printer);
Printer http_printer = Printer("http");
http_printer.SetUri("http://printer");
printers_map.Insert(PrinterClass::kSaved, http_printer);
// Only IPPS, IPPUSB, and USB printers are returned.
auto printers = printers_map.GetSecurePrinters(PrinterClass::kSaved);
EXPECT_EQ(3u, printers.size());
EXPECT_TRUE(IsPrinterInPrinters(printers, ipps_printer));
EXPECT_TRUE(IsPrinterInPrinters(printers, usb_printer));
EXPECT_TRUE(IsPrinterInPrinters(printers, ippusb_printer));
EXPECT_FALSE(IsPrinterInPrinters(printers, ipp_printer));
EXPECT_FALSE(IsPrinterInPrinters(printers, http_printer));
}
TEST_F(PrintersMapTest, ClearResetsClass) {
PrintersMap printers_map;
Printer printer1 = Printer("id1");
Printer printer2 = Printer("id2");
printers_map.Insert(PrinterClass::kEnterprise, printer1);
printers_map.Insert(PrinterClass::kEnterprise, printer2);
auto enterprise_printers = printers_map.Get(PrinterClass::kEnterprise);
EXPECT_EQ(2u, enterprise_printers.size());
// Calling clear erases the contents of the class.
printers_map.Clear(PrinterClass::kEnterprise);
auto empty_printers = printers_map.Get(PrinterClass::kEnterprise);
EXPECT_EQ(0u, empty_printers.size());
}
TEST_F(PrintersMapTest, ReplacePrintersInClassOverwritesPrinters) {
PrintersMap printers_map;
Printer printer1 = Printer("id1");
Printer printer2 = Printer("id2");
printers_map.Insert(PrinterClass::kEnterprise, printer1);
printers_map.Insert(PrinterClass::kEnterprise, printer2);
auto enterprise_printers = printers_map.Get(PrinterClass::kEnterprise);
EXPECT_EQ(2u, enterprise_printers.size());
// Overwriting the printer class with an empty vector should clear the
// printers.
printers_map.ReplacePrintersInClass(PrinterClass::kEnterprise,
std::vector<Printer>());
auto empty_printers = printers_map.Get(PrinterClass::kEnterprise);
EXPECT_EQ(0u, empty_printers.size());
// Replacing the printer class with the original enterprise printers restores
// them.
printers_map.ReplacePrintersInClass(PrinterClass::kEnterprise,
enterprise_printers);
auto restored_printers = printers_map.Get(PrinterClass::kEnterprise);
EXPECT_EQ(2u, restored_printers.size());
}
TEST_F(PrintersMapTest, RemoveSucceedsOnPrinterInClass) {
PrintersMap printers_map;
const std::string printer_id = "id1";
printers_map.Insert(PrinterClass::kEnterprise, Printer(printer_id));
auto printer = printers_map.Get(printer_id);
EXPECT_TRUE(printer);
EXPECT_EQ(printer_id, printer->id());
printers_map.Remove(PrinterClass::kEnterprise, printer_id);
printer = printers_map.Get(printer_id);
EXPECT_FALSE(printer);
}
TEST_F(PrintersMapTest, RemoveDoesNothingOnPrinterNotInClass) {
PrintersMap printers_map;
const std::string printer_id = "id1";
printers_map.Insert(PrinterClass::kEnterprise, Printer(printer_id));
auto printer = printers_map.Get(printer_id);
EXPECT_TRUE(printer);
EXPECT_EQ(printer_id, printer->id());
// Call remove using a different class, same printer_id and verify the printer
// is not rmemoved.
printers_map.Remove(PrinterClass::kDiscovered, printer_id);
printer = printers_map.Get(printer_id);
EXPECT_TRUE(printer);
EXPECT_EQ(printer_id, printer->id());
}
TEST_F(PrintersMapTest, RemoveDoesNothingOnUnknownPrinter) {
PrintersMap printers_map;
const std::string printer_id = "id";
printers_map.Insert(PrinterClass::kEnterprise, Printer(printer_id));
EXPECT_TRUE(printers_map.Get(printer_id));
// Call remove using a printer that does not exist in any class and verify the
// other printers are not changed.
printers_map.Remove(PrinterClass::kDiscovered, "random_id");
EXPECT_TRUE(printers_map.Get(printer_id));
}
TEST_F(PrintersMapTest, IsPrinterInClass) {
PrintersMap printers_map;
const std::string printer_id = "id";
// Returns false for non-existent printers.
EXPECT_FALSE(
printers_map.IsPrinterInClass(PrinterClass::kEnterprise, "random_id"));
// Add an enterprise printer. It can be found as an enterprise printer, but
// not as a discovered printer.
printers_map.Insert(PrinterClass::kEnterprise, Printer(printer_id));
EXPECT_TRUE(
printers_map.IsPrinterInClass(PrinterClass::kEnterprise, printer_id));
EXPECT_FALSE(
printers_map.IsPrinterInClass(PrinterClass::kDiscovered, printer_id));
}
TEST_F(PrintersMapTest, PrinterStatusMapSavePrinterStatus) {
PrintersMap printers_map;
const std::string printer_id = "id";
printers_map.Insert(PrinterClass::kDiscovered, Printer(printer_id));
printers_map.SavePrinterStatus(printer_id, CupsPrinterStatus(printer_id));
std::optional<Printer> printer = printers_map.Get(printer_id);
CupsPrinterStatus printer_status = printer->printer_status();
EXPECT_EQ(printer_id, printer_status.GetPrinterId());
}
TEST_F(PrintersMapTest, PrinterStatusMapMultipleStatuses) {
PrintersMap printers_map;
const std::string printer_id1 = "id1";
const std::string printer_id2 = "id2";
printers_map.Insert(PrinterClass::kDiscovered, Printer(printer_id1));
printers_map.Insert(PrinterClass::kEnterprise, Printer(printer_id2));
printers_map.SavePrinterStatus(printer_id1, CupsPrinterStatus(printer_id1));
printers_map.SavePrinterStatus(printer_id2, CupsPrinterStatus(printer_id2));
std::optional<Printer> printer1 = printers_map.Get(printer_id1);
CupsPrinterStatus printer_status1 = printer1->printer_status();
EXPECT_EQ(printer_id1, printer_status1.GetPrinterId());
std::optional<Printer> printer2 = printers_map.Get(printer_id2);
CupsPrinterStatus printer_status2 = printer2->printer_status();
EXPECT_EQ(printer_id2, printer_status2.GetPrinterId());
}
TEST_F(PrintersMapTest, PrinterStatusMapMissingRequestedPrinter) {
PrintersMap printers_map;
const std::string new_printer_id = "new_printer";
const std::string wrong_printer_id = "wrong_printer";
printers_map.Insert(PrinterClass::kDiscovered, Printer(new_printer_id));
printers_map.Insert(PrinterClass::kDiscovered, Printer(wrong_printer_id));
printers_map.SavePrinterStatus(new_printer_id, CupsPrinterStatus());
std::optional<Printer> wrong_printer = printers_map.Get(wrong_printer_id);
CupsPrinterStatus printer_status = wrong_printer->printer_status();
EXPECT_TRUE(printer_status.GetPrinterId().empty());
}
TEST_F(PrintersMapTest, PrinterStatusMapEmpty) {
PrintersMap printers_map;
const std::string printer_id = "id";
printers_map.Insert(PrinterClass::kDiscovered, Printer(printer_id));
std::optional<Printer> printer = printers_map.Get(printer_id);
CupsPrinterStatus printer_status = printer->printer_status();
EXPECT_TRUE(printer_status.GetPrinterId().empty());
}
TEST_F(PrintersMapTest, GetByIdWithStatus) {
PrintersMap printers_map;
const std::string printer_id = "id";
printers_map.Insert(PrinterClass::kDiscovered, Printer(printer_id));
CupsPrinterStatus saved_printer_status = CreatePrinterStatus(printer_id);
printers_map.SavePrinterStatus(printer_id, saved_printer_status);
std::optional<Printer> printer = printers_map.Get(printer_id);
EXPECT_TRUE(printer);
ExpectPrinterStatusesEqual(saved_printer_status, printer->printer_status());
}
TEST_F(PrintersMapTest, GetByIdAndClassWithStatus) {
PrintersMap printers_map;
const std::string printer_id = "id";
printers_map.Insert(PrinterClass::kDiscovered, Printer(printer_id));
CupsPrinterStatus saved_printer_status = CreatePrinterStatus(printer_id);
printers_map.SavePrinterStatus(printer_id, saved_printer_status);
std::optional<Printer> printer =
printers_map.Get(PrinterClass::kDiscovered, printer_id);
EXPECT_TRUE(printer);
ExpectPrinterStatusesEqual(saved_printer_status, printer->printer_status());
}
TEST_F(PrintersMapTest, GetByClassWithStatus) {
PrintersMap printers_map;
const std::string printer_id = "id";
printers_map.Insert(PrinterClass::kDiscovered, Printer(printer_id));
CupsPrinterStatus saved_printer_status = CreatePrinterStatus(printer_id);
printers_map.SavePrinterStatus(printer_id, saved_printer_status);
std::vector<Printer> printers = printers_map.Get(PrinterClass::kDiscovered);
EXPECT_EQ(1u, printers.size());
for (auto printer : printers) {
ExpectPrinterStatusesEqual(saved_printer_status, printer.printer_status());
}
}
TEST_F(PrintersMapTest, GetAllPrintersWithStatus) {
PrintersMap printers_map;
const std::string printer_id = "id";
printers_map.Insert(PrinterClass::kDiscovered, Printer(printer_id));
CupsPrinterStatus saved_printer_status = CreatePrinterStatus(printer_id);
printers_map.SavePrinterStatus(printer_id, saved_printer_status);
std::vector<Printer> printers = printers_map.Get();
EXPECT_EQ(1u, printers.size());
for (auto printer : printers) {
ExpectPrinterStatusesEqual(saved_printer_status, printer.printer_status());
}
}
TEST_F(PrintersMapTest, GetSecurePrintersWithStatus) {
PrintersMap printers_map;
const std::string printer_id = "id";
Printer ipps_printer = Printer(printer_id);
ipps_printer.SetUri("ipps://printer");
printers_map.Insert(PrinterClass::kDiscovered, ipps_printer);
CupsPrinterStatus saved_printer_status = CreatePrinterStatus(printer_id);
printers_map.SavePrinterStatus(printer_id, saved_printer_status);
std::vector<Printer> printers =
printers_map.GetSecurePrinters(PrinterClass::kDiscovered);
EXPECT_EQ(1u, printers.size());
for (auto printer : printers) {
ExpectPrinterStatusesEqual(saved_printer_status, printer.printer_status());
}
}
TEST_F(PrintersMapTest, ReplacePrintersInClassAddsStatus) {
PrintersMap printers_map;
const std::string printer_id1 = "id1";
const std::string printer_id2 = "id2";
std::vector<Printer> printers{Printer(printer_id1), Printer(printer_id2)};
CupsPrinterStatus saved_printer_status1 = CreatePrinterStatus(printer_id1);
CupsPrinterStatus saved_printer_status2 = CreatePrinterStatus(printer_id2);
printers_map.SavePrinterStatus(printer_id1, saved_printer_status1);
printers_map.SavePrinterStatus(printer_id2, saved_printer_status2);
printers_map.ReplacePrintersInClass(PrinterClass::kDiscovered, printers);
std::optional<Printer> printer1 = printers_map.Get(printer_id1);
ExpectPrinterStatusesEqual(saved_printer_status1, printer1->printer_status());
std::optional<Printer> printer2 = printers_map.Get(printer_id2);
ExpectPrinterStatusesEqual(saved_printer_status2, printer2->printer_status());
}
TEST_F(PrintersMapTest, ReplacePrintersInClassDeletesAllStatuses) {
PrintersMap printers_map;
const std::string printer_id1 = "id1";
const std::string printer_id2 = "id2";
printers_map.Insert(PrinterClass::kDiscovered, Printer(printer_id1));
printers_map.Insert(PrinterClass::kDiscovered, Printer(printer_id2));
CupsPrinterStatus saved_printer_status1 = CreatePrinterStatus(printer_id1);
CupsPrinterStatus saved_printer_status2 = CreatePrinterStatus(printer_id2);
printers_map.SavePrinterStatus(printer_id1, saved_printer_status1);
printers_map.SavePrinterStatus(printer_id2, saved_printer_status2);
// Only printer1 is part of printers vector so status for printer2 should be
// deleted.
std::vector<Printer> printer1_list{Printer(printer_id1)};
printers_map.ReplacePrintersInClass(PrinterClass::kDiscovered, printer1_list);
std::optional<Printer> printer1 = printers_map.Get(printer_id1);
ExpectPrinterStatusesEqual(saved_printer_status1, printer1->printer_status());
// Add printer2 back to the map so it can be fetched then confirm no status
// was leftover from the replace.
std::vector<Printer> printer2_list{Printer(printer_id2)};
printers_map.ReplacePrintersInClass(PrinterClass::kDiscovered, printer2_list);
std::optional<Printer> printer2 = printers_map.Get(printer_id2);
CupsPrinterStatus printer_status2 = printer2->printer_status();
EXPECT_TRUE(printer_status2.GetPrinterId().empty());
}
TEST_F(PrintersMapTest, ReplacePrintersOnlyDeletesStatusInSameClass) {
PrintersMap printers_map;
const std::string printer_id1 = "id1";
const std::string printer_id2 = "id2";
printers_map.Insert(PrinterClass::kDiscovered, Printer(printer_id1));
printers_map.Insert(PrinterClass::kEnterprise, Printer(printer_id2));
CupsPrinterStatus saved_printer_status1 = CreatePrinterStatus(printer_id1);
CupsPrinterStatus saved_printer_status2 = CreatePrinterStatus(printer_id2);
printers_map.SavePrinterStatus(printer_id1, saved_printer_status1);
printers_map.SavePrinterStatus(printer_id2, saved_printer_status2);
std::vector<Printer> printer1_list{Printer(printer_id1)};
printers_map.ReplacePrintersInClass(PrinterClass::kDiscovered, printer1_list);
std::optional<Printer> printer1 = printers_map.Get(printer_id1);
ExpectPrinterStatusesEqual(saved_printer_status1, printer1->printer_status());
std::optional<Printer> printer2 = printers_map.Get(printer_id2);
CupsPrinterStatus printer_status2 = printer2->printer_status();
ExpectPrinterStatusesEqual(saved_printer_status2, printer2->printer_status());
}
TEST_F(PrintersMapTest, RemovePrinterRemovesStatus) {
PrintersMap printers_map;
const std::string printer_id = "id";
printers_map.Insert(PrinterClass::kDiscovered, Printer(printer_id));
// Confirm the printer status is attached to the printer
CupsPrinterStatus saved_printer_status = CreatePrinterStatus(printer_id);
printers_map.SavePrinterStatus(printer_id, saved_printer_status);
std::optional<Printer> saved_printer = printers_map.Get(printer_id);
CupsPrinterStatus printer_status = saved_printer->printer_status();
EXPECT_EQ(printer_id, printer_status.GetPrinterId());
// Remove then resinsert the printer, retrieve that printer and confirm that
// the associated printer status was deleted.
printers_map.Remove(PrinterClass::kDiscovered, printer_id);
std::vector<Printer> printers{Printer(printer_id)};
printers_map.ReplacePrintersInClass(PrinterClass::kDiscovered, printers);
std::optional<Printer> printer = printers_map.Get(printer_id);
CupsPrinterStatus empty_printer_status = printer->printer_status();
EXPECT_TRUE(empty_printer_status.GetPrinterId().empty());
}
TEST_F(PrintersMapTest, DuplicatePrinterStatus) {
PrintersMap printers_map;
const std::string printer_id = "id";
printers_map.Insert(PrinterClass::kDiscovered, Printer(printer_id));
// Saving a new status should return true.
CupsPrinterStatus printer_status = CreatePrinterStatus(printer_id);
EXPECT_TRUE(printers_map.SavePrinterStatus(printer_id, printer_status));
// Saving the same status again should return false.
EXPECT_FALSE(printers_map.SavePrinterStatus(printer_id, printer_status));
// Saving a new status should return true again.
CupsPrinterStatus new_printer_status =
CreatePrinterStatus(printer_id, PrinterStatusReason::Reason::kOutOfInk);
EXPECT_TRUE(printers_map.SavePrinterStatus(printer_id, new_printer_status));
}
} // namespace ash
Codebase Browser
chromium