chrome/browser/ash/crosapi/extension_printer_service_ash_browsertest.cc

// Copyright 2024 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/crosapi/extension_printer_service_ash.h"

#include <memory>
#include <utility>

#include "base/logging.h"
#include "base/test/metrics/histogram_tester.h"
#include "base/test/repeating_test_future.h"
#include "base/test/test_future.h"
#include "base/test/values_test_util.h"
#include "base/unguessable_token.h"
#include "base/values.h"
#include "chrome/browser/ash/crosapi/crosapi_ash.h"
#include "chrome/browser/ash/crosapi/crosapi_manager.h"
#include "chrome/test/base/in_process_browser_test.h"
#include "chromeos/crosapi/mojom/extension_printer.mojom.h"
#include "content/public/test/browser_test.h"
#include "testing/gmock/include/gmock/gmock.h"
#include "testing/gtest/include/gtest/gtest.h"

namespace crosapi {

namespace {

using ::testing::_;
using ::testing::Mock;

ExtensionPrinterServiceAsh* ExtensionPrinterService() {
  return CrosapiManager::Get()->crosapi_ash()->extension_printer_service_ash();
}

base::Value::List CreateTestPrintersSet1() {
  return base::test::ParseJsonList(R"(
    [ {
      "description": "A virtual printer for testing",
      "extensionId": "jbljdigmdjodgkcllikhggoepmmffba1",
      "extensionName": "Test Printer Provider",
      "id": "jbljdigmdjodgkcllikhggoepmmffba1:test-printer-01",
      "name": "Test Printer 01"
    }, {
      "description": "A virtual printer for testing",
      "extensionId": "jbljdigmdjodgkcllikhggoepmmffba1",
      "extensionName": "Test Printer Provider",
      "id": "jbljdigmdjodgkcllikhggoepmmffba1:test-printer-02",
      "name": "Test Printer 02"
    } ]
  )");
}

base::Value::List CreateTestPrintersSet2() {
  return base::test::ParseJsonList(R"(
    [ {
      "description": "A virtual printer for testing",
      "extensionId": "jbljdigmdjodgkcllikhggoepmmffba2",
      "extensionName": "Test Printer Provider",
      "id": "jbljdigmdjodgkcllikhggoepmmffba2:test-printer-03",
      "name": "Test Printer 03"
    }]
  )");
}

base::Value::Dict CreateTestCapability() {
  return base::test::ParseJsonDict(R"(
    {
      "version": "1.0",
      "printer": {
        "supported_content_type": [
          {"content_type": "application/pdf"}
        ]
      }
    })");
}

class MockExtensionPrinterServiceProvider
    : public crosapi::mojom::ExtensionPrinterServiceProvider {
 public:
  MOCK_METHOD(void,
              DispatchGetPrintersRequest,
              (const ::base::UnguessableToken& request_id),
              (override));
  MOCK_METHOD(void, DispatchResetRequest, (), (override));
  MOCK_METHOD(void,
              DispatchStartGetCapability,
              (const std::string& destination_id,
               DispatchStartGetCapabilityCallback callback),
              (override));
  MOCK_METHOD(void,
              DispatchStartPrint,
              (const ::std::u16string& job_title,
               ::base::Value::Dict settings,
               ::scoped_refptr<::base::RefCountedMemory> print_data,
               DispatchStartPrintCallback callback),
              (override));
  MOCK_METHOD(void,
              DispatchStartGrantPrinterAccess,
              (const std::string& printer_id,
               DispatchStartGrantPrinterAccessCallback callback),
              (override));

  mojo::Receiver<mojom::ExtensionPrinterServiceProvider> receiver_{this};
};

}  // namespace

class ExtensionPrinterServiceAshBrowserTest : public InProcessBrowserTest {
 public:
  ExtensionPrinterServiceAshBrowserTest() = default;

  void VerifyProvider() {
    ExtensionPrinterServiceAsh* service = ExtensionPrinterService();
    EXPECT_TRUE(service->HasProviderForTesting());
  }

 protected:
  MockExtensionPrinterServiceProvider& mock_provider() {
    return mock_provider_;
  }
  void FlushForTesting() {
    extension_printer_service_remote_.FlushForTesting();
  }

 private:
  void SetUpOnMainThread() override {
    InProcessBrowserTest::SetUpOnMainThread();

    ExtensionPrinterService()->BindReceiver(
        extension_printer_service_remote_.BindNewPipeAndPassReceiver());

    extension_printer_service_remote_->RegisterServiceProvider(
        mock_provider_.receiver_.BindNewPipeAndPassRemote());
    extension_printer_service_remote_.FlushForTesting();
  }

  MockExtensionPrinterServiceProvider mock_provider_;
  mojo::Remote<mojom::ExtensionPrinterService>
      extension_printer_service_remote_;
};

// Verifies that a service provider is registered.
IN_PROC_BROWSER_TEST_F(ExtensionPrinterServiceAshBrowserTest,
                       RegisterServiceProvider) {
  VerifyProvider();
}

// Verifies that StartGetPrinters can receive printers from multiple extensions.
IN_PROC_BROWSER_TEST_F(ExtensionPrinterServiceAshBrowserTest,
                       StartGetPrinters) {
  base::HistogramTester histogram_tester;

  constexpr char kNumberOfPrintersMetricName[] =
      "Printing.LacrosExtensions.FromAsh.NumberOfPrinters";

  EXPECT_CALL(mock_provider(), DispatchGetPrintersRequest(_))
      .WillOnce([](const ::base::UnguessableToken& requestId) {
        ExtensionPrinterServiceAsh* service = ExtensionPrinterService();
        // Simulates reporting printers from extension 1.
        service->PrintersAdded(requestId, CreateTestPrintersSet1(), false);
        // Simulates reporting printers from extension 2.
        service->PrintersAdded(requestId, CreateTestPrintersSet2(), false);
        // Simulates reporting printers is done.
        service->PrintersAdded(requestId, base::Value::List(), true);
      });

  base::test::RepeatingTestFuture<base::Value::List> printers_added_future;
  base::test::TestFuture<void> done_future;

  ExtensionPrinterService()->StartGetPrinters(
      printers_added_future.GetCallback(), done_future.GetCallback());

  // Verifies the first set of printers from extension 1.
  const base::Value::List& printers_set1 = printers_added_future.Take();
  EXPECT_EQ(printers_set1.size(), 2u);

  const base::Value::Dict& printer1 = printers_set1[0].GetDict();
  base::ExpectDictStringValue("A virtual printer for testing", printer1,
                              "description");
  base::ExpectDictStringValue("jbljdigmdjodgkcllikhggoepmmffba1", printer1,
                              "extensionId");
  base::ExpectDictStringValue("Test Printer Provider", printer1,
                              "extensionName");
  base::ExpectDictStringValue(
      "jbljdigmdjodgkcllikhggoepmmffba1:test-printer-01", printer1, "id");
  base::ExpectDictStringValue("Test Printer 01", printer1, "name");

  const base::Value::Dict& printer2 = printers_set1[1].GetDict();
  base::ExpectDictStringValue("A virtual printer for testing", printer2,
                              "description");
  base::ExpectDictStringValue("jbljdigmdjodgkcllikhggoepmmffba1", printer2,
                              "extensionId");
  base::ExpectDictStringValue("Test Printer Provider", printer2,
                              "extensionName");
  base::ExpectDictStringValue(
      "jbljdigmdjodgkcllikhggoepmmffba1:test-printer-02", printer2, "id");
  base::ExpectDictStringValue("Test Printer 02", printer2, "name");

  // Verifies the second set of printers from extension 2.
  const base::Value::List& printers_set2 = printers_added_future.Take();
  EXPECT_EQ(printers_set2.size(), 1u);

  const base::Value::Dict& printer3 = printers_set2[0].GetDict();
  base::ExpectDictStringValue("A virtual printer for testing", printer3,
                              "description");
  base::ExpectDictStringValue("jbljdigmdjodgkcllikhggoepmmffba2", printer3,
                              "extensionId");
  base::ExpectDictStringValue("Test Printer Provider", printer3,
                              "extensionName");
  base::ExpectDictStringValue(
      "jbljdigmdjodgkcllikhggoepmmffba2:test-printer-03", printer3, "id");
  base::ExpectDictStringValue("Test Printer 03", printer3, "name");

  // Verifies that the GetPrintersDoneCallback is invoked when no more printers
  // will be reported.
  EXPECT_TRUE(done_future.Wait());
  // The histogram is recorded once with a value of 3 (number of printers).
  histogram_tester.ExpectUniqueSample(kNumberOfPrintersMetricName, 3, 1);
}

// Verifies that StartGetCapability can receive capability.
IN_PROC_BROWSER_TEST_F(ExtensionPrinterServiceAshBrowserTest, Reset) {
  // Captures the request_id.
  base::UnguessableToken captured_request_id;
  // Simulates that a get printers request has been created but reporting
  // printers is not done yet, i.e., the service provider has not called
  // PrintersAdded.
  EXPECT_CALL(mock_provider(), DispatchGetPrintersRequest(_))
      .WillOnce(
          [&captured_request_id](const ::base::UnguessableToken& request_id) {
            captured_request_id = request_id;
          });
  // Verifies that the downstream's Reset has been called.
  EXPECT_CALL(mock_provider(), DispatchResetRequest()).Times(1);

  EXPECT_FALSE(ExtensionPrinterService()->HasAnyPendingGetPrintersRequests());

  // Starts a Get printers request.
  base::test::RepeatingTestFuture<base::Value::List> printers_added_future;
  base::test::TestFuture<void> done_future;
  ExtensionPrinterService()->StartGetPrinters(
      printers_added_future.GetCallback(), done_future.GetCallback());
  FlushForTesting();

  // A pending request with |captured_request_id| has been created.
  EXPECT_TRUE(ExtensionPrinterService()->HasPendingGetPrintersRequestForTesting(
      captured_request_id));

  ExtensionPrinterService()->Reset();
  // The pending request with |captured_request_id| has been cleared.
  EXPECT_FALSE(
      ExtensionPrinterService()->HasPendingGetPrintersRequestForTesting(
          captured_request_id));
  // And there are none pending requests with other ids.
  EXPECT_FALSE(ExtensionPrinterService()->HasAnyPendingGetPrintersRequests());
}

// Verifies that StartGetCapability can receive capability.
IN_PROC_BROWSER_TEST_F(ExtensionPrinterServiceAshBrowserTest,
                       StartGetCapability) {
  EXPECT_CALL(mock_provider(), DispatchStartGetCapability(_, _))
      .WillOnce([](const std::string& destination_id,
                   base::OnceCallback<void(::base::Value::Dict)> callback) {
        std::move(callback).Run(CreateTestCapability());
      });

  base::test::TestFuture<base::Value::Dict> get_capability_future;

  ExtensionPrinterService()->StartGetCapability(
      "jbljdigmdjodgkcllikhggoepmmffba1:test-printer-02",
      get_capability_future.GetCallback());

  const base::Value::Dict& capability = get_capability_future.Take();
  base::ExpectDictStringValue("1.0", capability, "version");

  const base::Value::List* supportedContentTypes =
      capability.FindListByDottedPath("printer.supported_content_type");
  ASSERT_TRUE(supportedContentTypes);
  EXPECT_EQ(supportedContentTypes->size(), 1u);

  const base::Value& contentType1 = (*supportedContentTypes)[0];
  EXPECT_TRUE(contentType1.is_dict());
  base::ExpectDictStringValue("application/pdf", contentType1.GetDict(),
                              "content_type");
}

// Verifies that StartPrint is dispatched correctly.
IN_PROC_BROWSER_TEST_F(ExtensionPrinterServiceAshBrowserTest, StartPrint) {
  // Test data for the print job.
  const std::u16string job_title = u"Test Print Job";
  base::Value::Dict settings = base::test::ParseJsonDict(R"(
    {
      "copies": 2,
      "color": "color"
    }
  )");
  scoped_refptr<base::RefCountedMemory> print_data =
      base::MakeRefCounted<base::RefCountedString>("Test print data");

  // Captures the arguments passed to DispatchStartPrint.
  std::u16string captured_job_title;
  base::Value::Dict captured_settings;
  scoped_refptr<base::RefCountedMemory> captured_print_data;

  // Sets up the expectation for DispatchStartPrint.
  EXPECT_CALL(mock_provider(), DispatchStartPrint(_, _, _, _))
      .WillOnce(
          [&](const std::u16string& job_title, base::Value::Dict settings,
              scoped_refptr<base::RefCountedMemory> print_data,
              MockExtensionPrinterServiceProvider::DispatchStartPrintCallback
                  callback) {
            // Capture the arguments.
            captured_job_title = job_title;
            captured_settings = std::move(settings);
            captured_print_data = print_data;

            // Simulate a successful print job.
            std::move(callback).Run(crosapi::mojom::StartPrintStatus::KOk);
          });

  // Calls the StartPrint method.
  base::test::TestFuture<crosapi::mojom::StartPrintStatus> print_future;
  ExtensionPrinterService()->StartPrint(job_title, std::move(settings),
                                        print_data, print_future.GetCallback());
  FlushForTesting();

  // Verifies the result of the print job.
  EXPECT_EQ(print_future.Get(), crosapi::mojom::StartPrintStatus::KOk);
  // Asserts the captured data matches the input.
  EXPECT_EQ(captured_job_title, job_title);
  EXPECT_EQ(captured_settings,
            base::test::ParseJsonDict(R"({"copies": 2, "color": "color"})"));
  EXPECT_TRUE(captured_print_data->Equals(print_data));
}

// Verifies that StartGrantPrinterAccess is dispatched correctly.
IN_PROC_BROWSER_TEST_F(ExtensionPrinterServiceAshBrowserTest,
                       StartGrantPrinterAccess) {
  const std::string test_printer_id = "test_printer_id_123";
  base::Value::Dict expected_printer_info = base::test::ParseJsonDict(R"(
    {
      "printerId": "test_printer_id_123",
      "name": "Test Printer"
    }
  )");

  EXPECT_CALL(mock_provider(),
              DispatchStartGrantPrinterAccess(test_printer_id, _))
      .WillOnce([&expected_printer_info](
                    const std::string& printer_id,
                    MockExtensionPrinterServiceProvider::
                        DispatchStartGrantPrinterAccessCallback callback) {
        // Calls the callback with the simulated printer info.
        std::move(callback).Run(expected_printer_info.Clone());
      });

  base::test::TestFuture<base::Value::Dict> grant_access_future;
  ExtensionPrinterService()->StartGrantPrinterAccess(
      test_printer_id, grant_access_future.GetCallback());

  const base::Value::Dict& printer_info = grant_access_future.Get();
  EXPECT_EQ(printer_info, expected_printer_info);
}

}  // namespace crosapi