| // Copyright 2018 The Chromium Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "chrome/browser/chromeos/printing/zeroconf_printer_detector.h" |
| |
| #include <algorithm> |
| #include <functional> |
| #include <random> |
| #include <set> |
| #include <string> |
| #include <utility> |
| #include <vector> |
| |
| #include "base/bind.h" |
| #include "base/stl_util.h" |
| #include "base/strings/strcat.h" |
| #include "base/strings/stringprintf.h" |
| #include "base/test/scoped_task_environment.h" |
| #include "base/time/time.h" |
| #include "chrome/browser/local_discovery/service_discovery_device_lister.h" |
| #include "testing/gtest/include/gtest/gtest.h" |
| |
| namespace chromeos { |
| namespace { |
| |
| using local_discovery::ServiceDescription; |
| using local_discovery::ServiceDiscoveryDeviceLister; |
| |
| // Determine basic printer attributes deterministically but pseudorandomly based |
| // on the printer name. The exact values returned here are not really |
| // important, the important parts are that there's variety based on the name, |
| // and it's deterministic. |
| |
| // Should this printer provide usb_MFG and usb_MDL fields? |
| bool GetUsbFor(const std::string& name) { |
| return std::hash<std::string>()(name) & 1; |
| } |
| |
| // Get an IP address for this printer. The returned address may be IPv4 or IPv6 |
| net::IPAddress GetIPAddressFor(const std::string& name) { |
| std::mt19937 rng(std::hash<std::string>()(name)); |
| if (rng() & 1) { |
| // Give an IPv4 address. |
| return net::IPAddress(rng(), rng(), rng(), rng()); |
| } else { |
| // Give an IPv6 address. |
| return net::IPAddress(rng(), rng(), rng(), rng(), rng(), rng(), rng(), |
| rng(), rng(), rng(), rng(), rng(), rng(), rng(), |
| rng(), rng()); |
| } |
| } |
| |
| int GetPortFor(const std::string& name) { |
| return (std::hash<std::string>()(name) % 1000) + 1; |
| } |
| |
| // Bitfield flags for MakeExpectedPrinter() |
| int kFlagSSL = 0x1; // Use ipps, not ipp. |
| int kFlagIPPE = 0x2; // Printer can be autoconfigured with IPP-Everywhere |
| |
| // This corresponds to FakeServiceDeviceLister::MakeServiceDescription. Given |
| // the same name (and the correct ssl/ippe flags based on the service type) this |
| // generates the DetectedPrinter record we expect from ZeroconfPrinterDectector |
| // when it gets that ServiceDescription. This needs to be kept in sync with |
| // FakeServiceDeviceLister::MakeServiceDescription. |
| PrinterDetector::DetectedPrinter MakeExpectedPrinter(const std::string& name, |
| int flags) { |
| PrinterDetector::DetectedPrinter detected; |
| Printer& printer = detected.printer; |
| net::IPAddress ip_address = GetIPAddressFor(name); |
| int port = GetPortFor(name); |
| bool ssl = flags & kFlagSSL; |
| printer.set_effective_uri( |
| base::StringPrintf("ipp%s://%s:%d/%s_rp", ssl ? "s" : "", |
| ip_address.ToString().c_str(), port, name.c_str())); |
| printer.set_uri(base::StringPrintf("ipp%s://%s.local:%d/%s_rp", |
| ssl ? "s" : "", name.c_str(), port, |
| name.c_str())); |
| |
| printer.set_uuid(base::StrCat({name, "_UUID"})); |
| printer.set_display_name(base::StrCat({name, "_ty"})); |
| printer.set_description(base::StrCat({name, "_note"})); |
| printer.set_make_and_model(base::StrCat({name, "_product"})); |
| detected.ppd_search_data.make_and_model.push_back(printer.display_name()); |
| detected.ppd_search_data.make_and_model.push_back(printer.make_and_model()); |
| if (GetUsbFor(name)) { |
| // We should get an effective make and model guess from the usb fields |
| // if they exist. |
| detected.ppd_search_data.make_and_model.push_back( |
| base::StrCat({name, "_usb_MFG ", name, "_usb_MDL"})); |
| } |
| |
| if (flags & kFlagIPPE) { |
| printer.mutable_ppd_reference()->autoconf = true; |
| } |
| return detected; |
| } |
| |
| // This is a thin wrapper around Delegate that defers callbacks until |
| // the actual delegate is initialized, then calls all deferred callbacks. Once |
| // the actual delegate is initialized, this just becomes a simple passthrough. |
| class DeferringDelegate : public ServiceDiscoveryDeviceLister::Delegate { |
| public: |
| void OnDeviceChanged(const std::string& service_type, |
| bool added, |
| const ServiceDescription& service_description) override { |
| if (actual_) { |
| actual_->OnDeviceChanged(service_type, added, service_description); |
| } else { |
| deferred_callbacks_.push_back(base::BindOnce( |
| &DeferringDelegate::OnDeviceChanged, base::Unretained(this), |
| service_type, added, service_description)); |
| } |
| } |
| // Not guaranteed to be called after OnDeviceChanged. |
| void OnDeviceRemoved(const std::string& service_type, |
| const std::string& service_name) override { |
| if (actual_) { |
| actual_->OnDeviceRemoved(service_type, service_name); |
| } else { |
| deferred_callbacks_.push_back( |
| base::BindOnce(&DeferringDelegate::OnDeviceRemoved, |
| base::Unretained(this), service_type, service_name)); |
| } |
| } |
| |
| void OnDeviceCacheFlushed(const std::string& service_type) override { |
| if (actual_) { |
| actual_->OnDeviceCacheFlushed(service_type); |
| } else { |
| deferred_callbacks_.push_back( |
| base::BindOnce(&DeferringDelegate::OnDeviceCacheFlushed, |
| base::Unretained(this), service_type)); |
| } |
| } |
| |
| void SetActual(ServiceDiscoveryDeviceLister::Delegate* actual) { |
| CHECK(!actual_); |
| actual_ = actual; |
| for (auto& cb : deferred_callbacks_) { |
| std::move(cb).Run(); |
| } |
| deferred_callbacks_.clear(); |
| } |
| |
| private: |
| std::vector<base::OnceCallback<void()>> deferred_callbacks_; |
| ServiceDiscoveryDeviceLister::Delegate* actual_ = nullptr; |
| }; |
| |
| // A fake ServiceDiscoveryDeviceLister. This provides an implementation |
| // of ServiceDiscoveryDeviceLister that tests can use to trigger addition |
| // and removal of devices. |
| // |
| // There's some hackery here to handle constructor order constraints. There's a |
| // circular dependency in that ZeroconfPrinterDetector (which is a device lister |
| // delegate) needs its device lister set to be supplied at construction time, |
| // and each device lister needs to know about its delegate for callbacks. Thus |
| // we use DeferringDelegate to queue callbacks triggered before we have the |
| // delegate reference in this class, and invoke those queued callbacks when the |
| // Delegate is set. |
| class FakeServiceDiscoveryDeviceLister : public ServiceDiscoveryDeviceLister { |
| public: |
| FakeServiceDiscoveryDeviceLister(base::TaskRunner* task_runner, |
| const std::string& service_type) |
| : task_runner_(task_runner), service_type_(service_type) {} |
| |
| ~FakeServiceDiscoveryDeviceLister() override = default; |
| |
| // The only thing we care about with Start() is that it's called before |
| // DiscoverNewDevices. |
| void Start() override { |
| if (start_called_) { |
| ADD_FAILURE() << "Start called multiple times"; |
| } |
| start_called_ = true; |
| } |
| |
| // When DiscoverNewDevices is called, all updates we've queued up until this |
| // point are invoked. |
| void DiscoverNewDevices() override { |
| if (!start_called_) { |
| ADD_FAILURE() << "DiscoverNewDevices called before Start"; |
| } |
| discovery_started_ = true; |
| for (const auto& update : queued_updates_) { |
| SendUpdate(update); |
| } |
| queued_updates_.clear(); |
| } |
| |
| const std::string& service_type() const override { return service_type_; } |
| |
| void SetDelegate(ServiceDiscoveryDeviceLister::Delegate* delegate) { |
| deferring_delegate_.SetActual(delegate); |
| } |
| |
| // Announce a new service or update it if we've seen it before and already |
| // announced it. If discovery hasn't started yet, queue the description |
| // to be sent when discovery is started. |
| void Announce(const std::string& name) { |
| ServiceDescription description = MakeServiceDescription(name); |
| if (!discovery_started_) { |
| queued_updates_.push_back(description); |
| } else { |
| SendUpdate(description); |
| } |
| } |
| |
| void Remove(const std::string& name) { |
| std::string service_name = base::StrCat({name, ".", service_type_}); |
| announced_services_.erase(service_name); |
| CHECK(task_runner_->PostTask( |
| FROM_HERE, |
| base::BindOnce(&ServiceDiscoveryDeviceLister::Delegate::OnDeviceRemoved, |
| base::Unretained(&deferring_delegate_), service_type_, |
| service_name))); |
| } |
| |
| // Simulate an event that clears downstream caches and the lister. |
| void Clear() { |
| announced_services_.clear(); |
| discovery_started_ = false; |
| CHECK(task_runner_->PostTask( |
| FROM_HERE, |
| base::BindOnce( |
| &ServiceDiscoveryDeviceLister::Delegate::OnDeviceCacheFlushed, |
| base::Unretained(&deferring_delegate_), service_type_))); |
| } |
| |
| // Create a deterministic ServiceDescription based on the name and this |
| // lister's service_type. See the note on MakeExpectedPrinter, above. This |
| // is a member function instead of a free function because the service_type_ |
| // impacts some of the fields. This must be kept in sync with |
| // MakeExpectedPrinter. |
| ServiceDescription MakeServiceDescription(const std::string& name) { |
| ServiceDescription sd; |
| sd.service_name = base::StrCat({name, ".", service_type_}); |
| sd.metadata.push_back(base::StrCat({"ty=", name, "_ty"})); |
| sd.metadata.push_back(base::StrCat({"product=(", name, "_product)"})); |
| if (GetUsbFor(name)) { |
| sd.metadata.push_back(base::StrCat({"usb_MFG=", name, "_usb_MFG"})); |
| sd.metadata.push_back(base::StrCat({"usb_MDL=", name, "_usb_MDL"})); |
| } |
| sd.metadata.push_back(base::StrCat({"rp=", name, "_rp"})); |
| sd.metadata.push_back(base::StrCat({"note=", name, "_note"})); |
| sd.metadata.push_back(base::StrCat({"UUID=", name, "_UUID"})); |
| sd.address.set_host(base::StrCat({name, ".local"})); |
| sd.ip_address = GetIPAddressFor(name); |
| sd.address.set_port(GetPortFor(name)); |
| return sd; |
| } |
| |
| bool discovery_started() { return discovery_started_; } |
| |
| private: |
| void SendUpdate(const ServiceDescription& description) { |
| bool is_new; |
| if (!base::ContainsKey(announced_services_, description.service_name)) { |
| is_new = true; |
| announced_services_.insert(description.service_name); |
| } else { |
| is_new = false; |
| } |
| CHECK(task_runner_->PostTask( |
| FROM_HERE, |
| base::BindOnce(&ServiceDiscoveryDeviceLister::Delegate::OnDeviceChanged, |
| base::Unretained(&deferring_delegate_), service_type_, |
| is_new, description))); |
| } |
| base::TaskRunner* task_runner_; |
| |
| // Services which have previously posted an update, and therefore are no |
| // longer 'new' for the purposes of the OnDeviceChanged callback. |
| std::set<std::string> announced_services_; |
| |
| // Updates added to the class before discovery started. |
| std::vector<ServiceDescription> queued_updates_; |
| |
| // Has Start() been called? |
| bool start_called_ = false; |
| |
| // Has DiscoverNewDevices been called? |
| bool discovery_started_ = false; |
| |
| std::string service_type_; |
| DeferringDelegate deferring_delegate_; |
| }; |
| |
| class ZeroconfPrinterDetectorTest : public testing::Test, |
| public PrinterDetector::Observer { |
| public: |
| ZeroconfPrinterDetectorTest() { |
| auto* runner = scoped_task_environment_.GetMainThreadTaskRunner().get(); |
| auto ipp_lister = std::make_unique<FakeServiceDiscoveryDeviceLister>( |
| runner, ZeroconfPrinterDetector::kIppServiceName); |
| ipp_lister_ = ipp_lister.get(); |
| auto ipps_lister = std::make_unique<FakeServiceDiscoveryDeviceLister>( |
| runner, ZeroconfPrinterDetector::kIppsServiceName); |
| ipps_lister_ = ipps_lister.get(); |
| auto ippe_lister = std::make_unique<FakeServiceDiscoveryDeviceLister>( |
| runner, ZeroconfPrinterDetector::kIppEverywhereServiceName); |
| ippe_lister_ = ippe_lister.get(); |
| auto ippse_lister = std::make_unique<FakeServiceDiscoveryDeviceLister>( |
| runner, ZeroconfPrinterDetector::kIppsEverywhereServiceName); |
| ippse_lister_ = ippse_lister.get(); |
| |
| listers_[ZeroconfPrinterDetector::kIppServiceName] = std::move(ipp_lister); |
| listers_[ZeroconfPrinterDetector::kIppsServiceName] = |
| std::move(ipps_lister); |
| listers_[ZeroconfPrinterDetector::kIppEverywhereServiceName] = |
| std::move(ippe_lister); |
| listers_[ZeroconfPrinterDetector::kIppsEverywhereServiceName] = |
| std::move(ippse_lister); |
| } |
| ~ZeroconfPrinterDetectorTest() override = default; |
| |
| void CreateDetector() { |
| detector_ = ZeroconfPrinterDetector::CreateForTesting(&listers_); |
| // The previously allocated listers_ are swapped into the detector_, and so |
| // the unique_ptr values of the listers_ map are no longer valid at this |
| // point. The ipp[se]_lister_ raw pointers are kept as seperate members to |
| // keep the lister fakes accessible after ownership is transferred into the |
| // detector. |
| listers_.clear(); |
| detector_->AddObserver(this); |
| ipp_lister_->SetDelegate(detector_.get()); |
| ipps_lister_->SetDelegate(detector_.get()); |
| ippe_lister_->SetDelegate(detector_.get()); |
| ippse_lister_->SetDelegate(detector_.get()); |
| } |
| |
| // Expect that the most up-to-date results from the detector match those |
| // in printers. |
| void ExpectPrintersAre( |
| const std::vector<PrinterDetector::DetectedPrinter>& printers) { |
| // The last observer callback should tell us the same thing as the querying |
| // the detector manually. |
| ASSERT_GE(printers_found_callbacks_.size(), 1U); |
| ExpectPrintersEq(printers, printers_found_callbacks_.back()); |
| ExpectPrintersEq(printers, detector_->GetPrinters()); |
| } |
| |
| // Expect that the given vectors have the same contents. The ordering |
| // may be different. |
| void ExpectPrintersEq( |
| const std::vector<PrinterDetector::DetectedPrinter>& expected, |
| const std::vector<PrinterDetector::DetectedPrinter>& actual) { |
| if (expected.size() != actual.size()) { |
| ADD_FAILURE() << "Printers size mismatch, found " << actual.size() |
| << " expected " << expected.size(); |
| return; |
| } |
| std::vector<PrinterDetector::DetectedPrinter> sorted_expected = expected; |
| std::vector<PrinterDetector::DetectedPrinter> sorted_actual = actual; |
| |
| std::sort(sorted_expected.begin(), sorted_expected.end(), |
| [](const PrinterDetector::DetectedPrinter& a, |
| const PrinterDetector::DetectedPrinter& b) -> bool { |
| return a.printer.uuid() < b.printer.uuid(); |
| }); |
| std::sort(sorted_actual.begin(), sorted_actual.end(), |
| [](const PrinterDetector::DetectedPrinter& a, |
| const PrinterDetector::DetectedPrinter& b) -> bool { |
| return a.printer.uuid() < b.printer.uuid(); |
| }); |
| for (size_t i = 0; i < sorted_expected.size(); ++i) { |
| ExpectPrinterEq(sorted_expected[i], sorted_actual[i]); |
| } |
| } |
| |
| void ExpectPrinterEq(const PrinterDetector::DetectedPrinter& expected, |
| const PrinterDetector::DetectedPrinter& actual) { |
| EXPECT_EQ(expected.printer.effective_uri(), actual.printer.effective_uri()); |
| EXPECT_EQ(expected.printer.uri(), actual.printer.uri()); |
| // We don't have a good way to directly check for an expected id. |
| EXPECT_EQ(expected.printer.uuid(), actual.printer.uuid()); |
| EXPECT_EQ(expected.printer.display_name(), actual.printer.display_name()); |
| EXPECT_EQ(expected.printer.description(), actual.printer.description()); |
| EXPECT_EQ(expected.printer.IsIppEverywhere(), |
| actual.printer.IsIppEverywhere()); |
| EXPECT_EQ(expected.printer.make_and_model(), |
| actual.printer.make_and_model()); |
| EXPECT_EQ(expected.ppd_search_data.usb_vendor_id, |
| actual.ppd_search_data.usb_vendor_id); |
| EXPECT_EQ(expected.ppd_search_data.usb_product_id, |
| actual.ppd_search_data.usb_product_id); |
| EXPECT_EQ(expected.ppd_search_data.make_and_model, |
| actual.ppd_search_data.make_and_model); |
| } |
| |
| // PrinterDetector::Observer callback. |
| void OnPrintersFound( |
| const std::vector<PrinterDetector::DetectedPrinter>& printers) override { |
| printers_found_callbacks_.push_back(printers); |
| } |
| |
| protected: |
| base::test::ScopedTaskEnvironment scoped_task_environment_; |
| |
| // Device listers fakes. These are initialized when the test is constructed. |
| // These pointers don't involve ownership; ownership of the listers starts |
| // with this class in listers_ when the test starts, and is transferred to |
| // detector_ when the detector is created. Throughout, the listers remain |
| // available to the test via these pointers. |
| FakeServiceDiscoveryDeviceLister* ipp_lister_; |
| FakeServiceDiscoveryDeviceLister* ipps_lister_; |
| FakeServiceDiscoveryDeviceLister* ippe_lister_; |
| FakeServiceDiscoveryDeviceLister* ippse_lister_; |
| |
| // Detector under test. |
| std::unique_ptr<ZeroconfPrinterDetector> detector_; |
| |
| // Saved copies of all the things given to OnPrintersFound. |
| std::vector<std::vector<PrinterDetector::DetectedPrinter>> |
| printers_found_callbacks_; |
| |
| private: |
| // Temporary storage for the device listers, between the time the test is |
| // constructed and the detector is created. Tests shouldn't access this |
| // directly, use the ipp*_lister_ variables instead. |
| std::map<std::string, std::unique_ptr<ServiceDiscoveryDeviceLister>> listers_; |
| }; |
| |
| // Very basic stuff, one printer of each protocol we support. |
| TEST_F(ZeroconfPrinterDetectorTest, SingleIppPrinter) { |
| ipp_lister_->Announce("Printer1"); |
| CreateDetector(); |
| scoped_task_environment_.RunUntilIdle(); |
| ExpectPrintersAre({MakeExpectedPrinter("Printer1", 0)}); |
| } |
| |
| TEST_F(ZeroconfPrinterDetectorTest, SingleIppsPrinter) { |
| ipps_lister_->Announce("Printer2"); |
| CreateDetector(); |
| scoped_task_environment_.RunUntilIdle(); |
| ExpectPrintersAre({MakeExpectedPrinter("Printer2", kFlagSSL)}); |
| } |
| |
| TEST_F(ZeroconfPrinterDetectorTest, SingleIppEverywherePrinter) { |
| ippe_lister_->Announce("Printer3"); |
| CreateDetector(); |
| scoped_task_environment_.RunUntilIdle(); |
| ExpectPrintersAre({MakeExpectedPrinter("Printer3", kFlagIPPE)}); |
| } |
| |
| TEST_F(ZeroconfPrinterDetectorTest, SingleIppsEverywherePrinter) { |
| ippse_lister_->Announce("Printer4"); |
| CreateDetector(); |
| scoped_task_environment_.RunUntilIdle(); |
| ExpectPrintersAre({MakeExpectedPrinter("Printer4", kFlagSSL | kFlagIPPE)}); |
| } |
| |
| // Test that an announce after the detector creation shows up as a printer. |
| TEST_F(ZeroconfPrinterDetectorTest, AnnounceAfterDetectorCreation) { |
| CreateDetector(); |
| scoped_task_environment_.RunUntilIdle(); |
| ippse_lister_->Announce("Printer4"); |
| scoped_task_environment_.RunUntilIdle(); |
| ExpectPrintersAre({MakeExpectedPrinter("Printer4", kFlagSSL | kFlagIPPE)}); |
| } |
| |
| // Test that we use the same printer ID regardless of which service type it |
| // comes to us from. |
| TEST_F(ZeroconfPrinterDetectorTest, StableIds) { |
| ipp_lister_->Announce("Printer1"); |
| CreateDetector(); |
| scoped_task_environment_.RunUntilIdle(); |
| ASSERT_FALSE(printers_found_callbacks_.empty()); |
| ASSERT_EQ(1U, printers_found_callbacks_.back().size()); |
| // Grab the id when it's an IPPS printer We should continue to get the same id |
| // regardless of service type. |
| std::string id = printers_found_callbacks_.back()[0].printer.id(); |
| |
| // Remove it as an IPP printer, add it as an IPPS printer. |
| ipp_lister_->Remove("Printer1"); |
| scoped_task_environment_.RunUntilIdle(); |
| ASSERT_TRUE(printers_found_callbacks_.back().empty()); |
| ipps_lister_->Announce("Printer1"); |
| scoped_task_environment_.RunUntilIdle(); |
| ASSERT_FALSE(printers_found_callbacks_.back().empty()); |
| // Id should be the same. |
| ASSERT_EQ(id, printers_found_callbacks_.back()[0].printer.id()); |
| |
| // Remove it as an IPPS printer, add it as an IPP-Everywhere printer. |
| ipps_lister_->Remove("Printer1"); |
| scoped_task_environment_.RunUntilIdle(); |
| ASSERT_TRUE(printers_found_callbacks_.back().empty()); |
| ippe_lister_->Announce("Printer1"); |
| scoped_task_environment_.RunUntilIdle(); |
| ASSERT_FALSE(printers_found_callbacks_.back().empty()); |
| // Id should be the same. |
| ASSERT_EQ(id, printers_found_callbacks_.back()[0].printer.id()); |
| |
| // Remove it as an IPP-Everywhere printer, add it as an IPPS-Everywhere |
| // printer. |
| ippe_lister_->Remove("Printer1"); |
| scoped_task_environment_.RunUntilIdle(); |
| ASSERT_TRUE(printers_found_callbacks_.back().empty()); |
| ippse_lister_->Announce("Printer1"); |
| scoped_task_environment_.RunUntilIdle(); |
| ASSERT_FALSE(printers_found_callbacks_.back().empty()); |
| // Id should be the same. |
| ASSERT_EQ(id, printers_found_callbacks_.back()[0].printer.id()); |
| } |
| |
| // Test a basic removal. |
| TEST_F(ZeroconfPrinterDetectorTest, Removal) { |
| ipp_lister_->Announce("Printer5"); |
| ipp_lister_->Announce("Printer6"); |
| ipp_lister_->Announce("Printer7"); |
| ipp_lister_->Announce("Printer8"); |
| ipp_lister_->Announce("Printer9"); |
| CreateDetector(); |
| scoped_task_environment_.RunUntilIdle(); |
| ExpectPrintersAre( |
| {MakeExpectedPrinter("Printer5", 0), MakeExpectedPrinter("Printer6", 0), |
| MakeExpectedPrinter("Printer7", 0), MakeExpectedPrinter("Printer8", 0), |
| MakeExpectedPrinter("Printer9", 0)}); |
| ipp_lister_->Remove("Printer7"); |
| scoped_task_environment_.RunUntilIdle(); |
| ExpectPrintersAre( |
| {MakeExpectedPrinter("Printer5", 0), MakeExpectedPrinter("Printer6", 0), |
| MakeExpectedPrinter("Printer8", 0), MakeExpectedPrinter("Printer9", 0)}); |
| } |
| |
| // Test that, when the same printer appears in multiple services, we |
| // use the highest priority one. Priorities, from highest to lowest |
| // are IPPS-E, IPP-E, IPPS, IPP. |
| TEST_F(ZeroconfPrinterDetectorTest, ServiceTypePriorities) { |
| // Advertise on all 4 services. |
| ipp_lister_->Announce("Printer5"); |
| ipps_lister_->Announce("Printer5"); |
| ippe_lister_->Announce("Printer5"); |
| ippse_lister_->Announce("Printer5"); |
| CreateDetector(); |
| scoped_task_environment_.RunUntilIdle(); |
| // IPPS-E is highest priority. |
| ExpectPrintersAre({MakeExpectedPrinter("Printer5", kFlagSSL | kFlagIPPE)}); |
| ippse_lister_->Remove("Printer5"); |
| scoped_task_environment_.RunUntilIdle(); |
| // IPP-E is highest remaining priority. |
| ExpectPrintersAre({MakeExpectedPrinter("Printer5", kFlagIPPE)}); |
| |
| ippe_lister_->Remove("Printer5"); |
| scoped_task_environment_.RunUntilIdle(); |
| // IPPS is highest remaining priority. |
| ExpectPrintersAre({MakeExpectedPrinter("Printer5", kFlagSSL)}); |
| |
| ipps_lister_->Remove("Printer5"); |
| scoped_task_environment_.RunUntilIdle(); |
| // IPP is only remaining entry. |
| ExpectPrintersAre({MakeExpectedPrinter("Printer5", 0)}); |
| |
| ipp_lister_->Remove("Printer5"); |
| scoped_task_environment_.RunUntilIdle(); |
| // No entries left. |
| ExpectPrintersAre({}); |
| } |
| |
| // Test that cache flushes appropriately remove entries. |
| TEST_F(ZeroconfPrinterDetectorTest, CacheFlushes) { |
| ipp_lister_->Announce("Printer6"); |
| ipp_lister_->Announce("Printer7"); |
| ipps_lister_->Announce("Printer7"); |
| ipps_lister_->Announce("Printer8"); |
| ippe_lister_->Announce("Printer8"); |
| ippe_lister_->Announce("Printer9"); |
| ippse_lister_->Announce("Printer9"); |
| ippse_lister_->Announce("Printer10"); |
| |
| CreateDetector(); |
| scoped_task_environment_.RunUntilIdle(); |
| ExpectPrintersAre({MakeExpectedPrinter("Printer6", 0), |
| MakeExpectedPrinter("Printer7", kFlagSSL), |
| MakeExpectedPrinter("Printer8", kFlagIPPE), |
| MakeExpectedPrinter("Printer9", kFlagSSL | kFlagIPPE), |
| MakeExpectedPrinter("Printer10", kFlagSSL | kFlagIPPE)}); |
| |
| ipps_lister_->Clear(); |
| |
| scoped_task_environment_.RunUntilIdle(); |
| // With the IPPS lister cleared, Printer7 should fall back to the IPP listing. |
| ExpectPrintersAre({MakeExpectedPrinter("Printer6", 0), |
| MakeExpectedPrinter("Printer7", 0), |
| MakeExpectedPrinter("Printer8", kFlagIPPE), |
| MakeExpectedPrinter("Printer9", kFlagSSL | kFlagIPPE), |
| MakeExpectedPrinter("Printer10", kFlagSSL | kFlagIPPE)}); |
| |
| // We should have restarted discovery after dealing with the cache flush. |
| EXPECT_TRUE(ipps_lister_->discovery_started()); |
| |
| ipp_lister_->Clear(); |
| scoped_task_environment_.RunUntilIdle(); |
| // With the IPP lister cleared, Printers 6 and 7 no longer should appear. |
| ExpectPrintersAre({MakeExpectedPrinter("Printer8", kFlagIPPE), |
| MakeExpectedPrinter("Printer9", kFlagSSL | kFlagIPPE), |
| MakeExpectedPrinter("Printer10", kFlagSSL | kFlagIPPE)}); |
| EXPECT_TRUE(ipps_lister_->discovery_started()); |
| |
| ippse_lister_->Clear(); |
| scoped_task_environment_.RunUntilIdle(); |
| // With the IPPSE lister cleared, Printer10 should disappear, and Printer9 |
| // should fall back to the IPPE. |
| ExpectPrintersAre({MakeExpectedPrinter("Printer8", kFlagIPPE), |
| MakeExpectedPrinter("Printer9", kFlagIPPE)}); |
| EXPECT_TRUE(ippse_lister_->discovery_started()); |
| |
| // Just for kicks, announce something new at this point. |
| ipps_lister_->Announce("Printer11"); |
| scoped_task_environment_.RunUntilIdle(); |
| ExpectPrintersAre({MakeExpectedPrinter("Printer8", kFlagIPPE), |
| MakeExpectedPrinter("Printer9", kFlagIPPE), |
| MakeExpectedPrinter("Printer11", kFlagSSL)}); |
| |
| // Clear out the IPPE lister, leaving only the new printer we announced |
| // on the IPPS lister. |
| ippe_lister_->Clear(); |
| scoped_task_environment_.RunUntilIdle(); |
| // With the IPPSE lister cleared, Printer10 should disappear, and Printer9 |
| // should fall back to the IPPE entry. |
| ExpectPrintersAre({MakeExpectedPrinter("Printer11", kFlagSSL)}); |
| EXPECT_TRUE(ippe_lister_->discovery_started()); |
| } |
| |
| // Test some general traffic with a mix of everything we expect to handle. |
| TEST_F(ZeroconfPrinterDetectorTest, GeneralMixedTraffic) { |
| ipp_lister_->Announce("Printer12"); |
| ipps_lister_->Announce("Printer12"); |
| ipps_lister_->Announce("Printer13"); |
| ippse_lister_->Announce("Printer14"); |
| ipps_lister_->Announce("Printer15"); |
| |
| CreateDetector(); |
| scoped_task_environment_.RunUntilIdle(); |
| ExpectPrintersAre({MakeExpectedPrinter("Printer12", kFlagSSL), |
| MakeExpectedPrinter("Printer13", kFlagSSL), |
| MakeExpectedPrinter("Printer14", kFlagSSL | kFlagIPPE), |
| MakeExpectedPrinter("Printer15", kFlagSSL)}); |
| |
| ippe_lister_->Announce("Printer13"); |
| ipp_lister_->Announce("Printer16"); |
| scoped_task_environment_.RunUntilIdle(); |
| ExpectPrintersAre({MakeExpectedPrinter("Printer12", kFlagSSL), |
| MakeExpectedPrinter("Printer13", kFlagIPPE), |
| MakeExpectedPrinter("Printer14", kFlagSSL | kFlagIPPE), |
| MakeExpectedPrinter("Printer15", kFlagSSL), |
| MakeExpectedPrinter("Printer16", 0)}); |
| |
| ipp_lister_->Remove("NonexistantPrinter"); |
| ipps_lister_->Remove("Printer12"); |
| ipps_lister_->Clear(); |
| ipp_lister_->Announce("Printer17"); |
| scoped_task_environment_.RunUntilIdle(); |
| ExpectPrintersAre({MakeExpectedPrinter("Printer12", 0), |
| MakeExpectedPrinter("Printer13", kFlagIPPE), |
| MakeExpectedPrinter("Printer14", kFlagSSL | kFlagIPPE), |
| MakeExpectedPrinter("Printer16", 0), |
| MakeExpectedPrinter("Printer17", 0)}); |
| ipp_lister_->Clear(); |
| ippse_lister_->Clear(); |
| ippe_lister_->Clear(); |
| scoped_task_environment_.RunUntilIdle(); |
| ExpectPrintersAre({}); |
| } |
| |
| } // namespace |
| } // namespace chromeos |
