firmware_directory_test.cc

// Copyright 2017 The Chromium OS 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 "modemfwd/firmware_directory.h"

#include <memory>
#include <string>
#include <utility>
#include <vector>

#include <base/files/file_path.h>
#include <base/files/file_util.h>
#include <base/files/scoped_temp_dir.h>
#include <gtest/gtest.h>

namespace {

constexpr char kDeviceId[] = "device-id";

constexpr char kMainFirmwareFile1[] = "NAND_10.20.30.40.fls";
constexpr char kMainFirmwareVersion1[] = "10.20.30.40";

constexpr char kMainFirmwareFile2[] = "NAND_10.20.30.45.fls";
constexpr char kMainFirmwareVersion2[] = "10.20.30.45";

constexpr char kCarrierA[] = "CarrierA";
constexpr char kCarrierFirmwareFile1[] = "CarrierA_40.30.20.10.fls";
constexpr char kCarrierFirmwareVersion1[] = "40.30.20.10";

constexpr char kCarrierB[] = "CarrierB";
constexpr char kCarrierFirmwareFile2[] = "Custom_B_50_60.fls";
constexpr char kCarrierFirmwareVersion2[] = "50.60.70.80";

constexpr char kCarrierC[] = "CarrierC";

constexpr char kGenericCarrierFirmwareFile[] = "Generic_V1.59.3.fls";
constexpr char kGenericCarrierFirmwareVersion[] = "V1.59.3";

}  // namespace

namespace modemfwd {

class FirmwareDirectoryTest : public ::testing::Test {
 public:
  FirmwareDirectoryTest() { CHECK(temp_dir_.CreateUniqueTempDir()); }
  ~FirmwareDirectoryTest() override = default;

 protected:
  void SetUpDirectory(const base::FilePath& manifest,
                      bool manifest_is_valid = true) {
    base::FilePath manifest_in_dir =
        temp_dir_.GetPath().Append("firmware_manifest.prototxt");
    CHECK(base::CopyFile(manifest, manifest_in_dir));
    firmware_directory_ = CreateFirmwareDirectory(temp_dir_.GetPath());
    ASSERT_EQ(!!firmware_directory_, manifest_is_valid);
  }

  std::unique_ptr<FirmwareDirectory> firmware_directory_;

 private:
  base::ScopedTempDir temp_dir_;
};

TEST_F(FirmwareDirectoryTest, NoFirmwareForDevice) {
  const base::FilePath kManifest("/dev/null");
  SetUpDirectory(kManifest);

  std::string carrier_a(kCarrierA);
  FirmwareDirectory::Files res =
      firmware_directory_->FindFirmware(kDeviceId, &carrier_a);

  EXPECT_FALSE(res.main_firmware.has_value());
  EXPECT_FALSE(res.carrier_firmware.has_value());
}

// ----------------------- MANIFEST V1 TESTS ----------------------------------

TEST_F(FirmwareDirectoryTest, FindFirmware) {
  const base::FilePath kManifest("test_protos/find_firmware.prototxt");
  SetUpDirectory(kManifest);

  std::string carrier_a(kCarrierA);
  FirmwareDirectory::Files res =
      firmware_directory_->FindFirmware(kDeviceId, &carrier_a);

  EXPECT_TRUE(res.main_firmware.has_value());
  const FirmwareFileInfo& main_info = res.main_firmware.value();
  EXPECT_EQ(kMainFirmwareFile1, main_info.firmware_path.BaseName().value());
  EXPECT_EQ(kMainFirmwareVersion1, main_info.version);

  EXPECT_TRUE(res.carrier_firmware.has_value());
  const FirmwareFileInfo& carrier_info = res.carrier_firmware.value();
  EXPECT_EQ(kCarrierA, carrier_a);
  EXPECT_EQ(kCarrierFirmwareFile1,
            carrier_info.firmware_path.BaseName().value());
  EXPECT_EQ(kCarrierFirmwareVersion1, carrier_info.version);
}

TEST_F(FirmwareDirectoryTest, FirmwareForDifferentCarrier) {
  const base::FilePath kManifest(
      "test_protos/firmware_for_different_carrier.prototxt");
  SetUpDirectory(kManifest);

  std::string carrier_b(kCarrierB);
  FirmwareDirectory::Files res =
      firmware_directory_->FindFirmware(kDeviceId, &carrier_b);
  EXPECT_FALSE(res.carrier_firmware.has_value());
}

TEST_F(FirmwareDirectoryTest, FirmwareForDifferentDevice) {
  const base::FilePath kManifest(
      "test_protos/firmware_for_different_device.prototxt");
  SetUpDirectory(kManifest);

  FirmwareDirectory::Files res =
      firmware_directory_->FindFirmware(kDeviceId, nullptr);
  EXPECT_FALSE(res.main_firmware.has_value());
}

TEST_F(FirmwareDirectoryTest, MultipleCarrierFirmware) {
  const base::FilePath kManifest(
      "test_protos/multiple_carrier_firmware.prototxt");
  SetUpDirectory(kManifest);

  std::string carrier_a(kCarrierA);
  FirmwareDirectory::Files res =
      firmware_directory_->FindFirmware(kDeviceId, &carrier_a);
  EXPECT_TRUE(res.carrier_firmware.has_value());
  const FirmwareFileInfo& info_a = res.carrier_firmware.value();
  EXPECT_EQ(kCarrierA, carrier_a);
  EXPECT_EQ(kCarrierFirmwareFile1, info_a.firmware_path.BaseName().value());
  EXPECT_EQ(kCarrierFirmwareVersion1, info_a.version);

  std::string carrier_b(kCarrierB);
  res = firmware_directory_->FindFirmware(kDeviceId, &carrier_b);
  EXPECT_TRUE(res.carrier_firmware.has_value());
  const FirmwareFileInfo& info_b = res.carrier_firmware.value();
  EXPECT_EQ(kCarrierB, carrier_b);
  EXPECT_EQ(kCarrierFirmwareFile2, info_b.firmware_path.BaseName().value());
  EXPECT_EQ(kCarrierFirmwareVersion2, info_b.version);
}

TEST_F(FirmwareDirectoryTest, GenericFirmware) {
  const base::FilePath kManifest("test_protos/generic_firmware.prototxt");
  SetUpDirectory(kManifest);

  std::string carrier_a(kCarrierA);
  FirmwareDirectory::Files res =
      firmware_directory_->FindFirmware(kDeviceId, &carrier_a);
  EXPECT_TRUE(res.carrier_firmware.has_value());
  const FirmwareFileInfo& info = res.carrier_firmware.value();
  EXPECT_EQ(FirmwareDirectory::kGenericCarrierId, carrier_a);
  EXPECT_EQ(kGenericCarrierFirmwareFile, info.firmware_path.BaseName().value());
  EXPECT_EQ(kGenericCarrierFirmwareVersion, info.version);
}

TEST_F(FirmwareDirectoryTest, SpecificBeforeGeneric) {
  const base::FilePath kManifest(
      "test_protos/specific_before_generic.prototxt");
  SetUpDirectory(kManifest);

  std::string carrier_a(kCarrierA);
  FirmwareDirectory::Files res =
      firmware_directory_->FindFirmware(kDeviceId, &carrier_a);
  EXPECT_TRUE(res.carrier_firmware.has_value());
  const FirmwareFileInfo& info = res.carrier_firmware.value();
  EXPECT_EQ(kCarrierA, carrier_a);
  EXPECT_EQ(kCarrierFirmwareFile1, info.firmware_path.BaseName().value());
  EXPECT_EQ(kCarrierFirmwareVersion1, info.version);
}

TEST_F(FirmwareDirectoryTest, FirmwareSupportsTwoCarriers) {
  const base::FilePath kManifest("test_protos/two_carrier_firmware.prototxt");
  SetUpDirectory(kManifest);

  std::string carrier_a(kCarrierA);
  FirmwareDirectory::Files res =
      firmware_directory_->FindFirmware(kDeviceId, &carrier_a);
  EXPECT_TRUE(res.carrier_firmware.has_value());
  const FirmwareFileInfo& info_a = res.carrier_firmware.value();
  EXPECT_EQ(kCarrierA, carrier_a);
  EXPECT_EQ(kCarrierFirmwareFile1, info_a.firmware_path.BaseName().value());
  EXPECT_EQ(kCarrierFirmwareVersion1, info_a.version);

  std::string carrier_b(kCarrierB);
  res = firmware_directory_->FindFirmware(kDeviceId, &carrier_b);
  EXPECT_TRUE(res.carrier_firmware.has_value());
  const FirmwareFileInfo& info_b = res.carrier_firmware.value();
  EXPECT_EQ(kCarrierB, carrier_b);
  EXPECT_EQ(kCarrierFirmwareFile1, info_b.firmware_path.BaseName().value());
  EXPECT_EQ(kCarrierFirmwareVersion1, info_b.version);

  std::string carrier_c(kCarrierC);
  res = firmware_directory_->FindFirmware(kDeviceId, &carrier_c);
  EXPECT_FALSE(res.carrier_firmware.has_value());
}

TEST_F(FirmwareDirectoryTest, MalformedMainEntry) {
  const base::FilePath kManifest(
      "test_protos/malformed_main_firmware.prototxt");
  SetUpDirectory(kManifest, false);
}

TEST_F(FirmwareDirectoryTest, MalformedCarrierEntry) {
  const base::FilePath kManifest(
      "test_protos/malformed_carrier_firmware.prototxt");
  SetUpDirectory(kManifest, false);
}

// ----------------------- MANIFEST V2 TESTS ----------------------------------

TEST_F(FirmwareDirectoryTest, FindFirmwareV2) {
  const base::FilePath kManifest("test_protos/find_firmware_v2.prototxt");
  SetUpDirectory(kManifest);

  std::string carrier_a(kCarrierA);
  FirmwareDirectory::Files res =
      firmware_directory_->FindFirmware(kDeviceId, &carrier_a);

  EXPECT_TRUE(res.main_firmware.has_value());
  const FirmwareFileInfo& main_info = res.main_firmware.value();
  EXPECT_EQ(kMainFirmwareFile1, main_info.firmware_path.BaseName().value());
  EXPECT_EQ(kMainFirmwareVersion1, main_info.version);

  EXPECT_TRUE(res.carrier_firmware.has_value());
  const FirmwareFileInfo& carrier_info = res.carrier_firmware.value();
  EXPECT_EQ(kCarrierA, carrier_a);
  EXPECT_EQ(kCarrierFirmwareFile1,
            carrier_info.firmware_path.BaseName().value());
  EXPECT_EQ(kCarrierFirmwareVersion1, carrier_info.version);
}

TEST_F(FirmwareDirectoryTest, FirmwareForDifferentCarrierV2) {
  const base::FilePath kManifest("test_protos/find_firmware_v2.prototxt");
  SetUpDirectory(kManifest);

  std::string carrier_b(kCarrierB);
  FirmwareDirectory::Files res =
      firmware_directory_->FindFirmware(kDeviceId, &carrier_b);
  EXPECT_FALSE(res.carrier_firmware.has_value());
}

TEST_F(FirmwareDirectoryTest, FirmwareForDifferentDeviceV2) {
  const base::FilePath kManifest(
      "test_protos/firmware_for_different_device_v2.prototxt");
  SetUpDirectory(kManifest);

  FirmwareDirectory::Files res =
      firmware_directory_->FindFirmware(kDeviceId, nullptr);
  EXPECT_FALSE(res.main_firmware.has_value());
}

TEST_F(FirmwareDirectoryTest, MultipleCarrierFirmwareV2) {
  const base::FilePath kManifest(
      "test_protos/multiple_carrier_firmware_v2.prototxt");
  SetUpDirectory(kManifest);

  std::string carrier_a(kCarrierA);
  FirmwareDirectory::Files res =
      firmware_directory_->FindFirmware(kDeviceId, &carrier_a);
  EXPECT_TRUE(res.carrier_firmware.has_value());
  const FirmwareFileInfo& info_a = res.carrier_firmware.value();
  EXPECT_EQ(kCarrierA, carrier_a);
  EXPECT_EQ(kCarrierFirmwareFile1, info_a.firmware_path.BaseName().value());
  EXPECT_EQ(kCarrierFirmwareVersion1, info_a.version);

  std::string carrier_b(kCarrierB);
  res = firmware_directory_->FindFirmware(kDeviceId, &carrier_b);
  EXPECT_TRUE(res.carrier_firmware.has_value());
  const FirmwareFileInfo& info_b = res.carrier_firmware.value();
  EXPECT_EQ(kCarrierB, carrier_b);
  EXPECT_EQ(kCarrierFirmwareFile2, info_b.firmware_path.BaseName().value());
  EXPECT_EQ(kCarrierFirmwareVersion2, info_b.version);
}

TEST_F(FirmwareDirectoryTest, GenericFirmwareV2) {
  const base::FilePath kManifest("test_protos/generic_firmware_v2.prototxt");
  SetUpDirectory(kManifest);

  std::string carrier_a(kCarrierA);
  FirmwareDirectory::Files res =
      firmware_directory_->FindFirmware(kDeviceId, &carrier_a);
  EXPECT_TRUE(res.carrier_firmware.has_value());
  const FirmwareFileInfo& info = res.carrier_firmware.value();
  EXPECT_EQ(FirmwareDirectory::kGenericCarrierId, carrier_a);
  EXPECT_EQ(kGenericCarrierFirmwareFile, info.firmware_path.BaseName().value());
  EXPECT_EQ(kGenericCarrierFirmwareVersion, info.version);
}

TEST_F(FirmwareDirectoryTest, FirmwareSupportsTwoCarriersV2) {
  const base::FilePath kManifest(
      "test_protos/two_carrier_firmware_v2.prototxt");
  SetUpDirectory(kManifest);

  std::string carrier_a(kCarrierA);
  FirmwareDirectory::Files res =
      firmware_directory_->FindFirmware(kDeviceId, &carrier_a);
  EXPECT_TRUE(res.carrier_firmware.has_value());
  const FirmwareFileInfo& info_a = res.carrier_firmware.value();
  EXPECT_EQ(kCarrierA, carrier_a);
  EXPECT_EQ(kCarrierFirmwareFile1, info_a.firmware_path.BaseName().value());
  EXPECT_EQ(kCarrierFirmwareVersion1, info_a.version);

  std::string carrier_b(kCarrierB);
  res = firmware_directory_->FindFirmware(kDeviceId, &carrier_b);
  EXPECT_TRUE(res.carrier_firmware.has_value());
  const FirmwareFileInfo& info_b = res.carrier_firmware.value();
  EXPECT_EQ(kCarrierB, carrier_b);
  EXPECT_EQ(kCarrierFirmwareFile1, info_b.firmware_path.BaseName().value());
  EXPECT_EQ(kCarrierFirmwareVersion1, info_b.version);

  std::string carrier_c(kCarrierC);
  res = firmware_directory_->FindFirmware(kDeviceId, &carrier_c);
  EXPECT_FALSE(res.carrier_firmware.has_value());
}

TEST_F(FirmwareDirectoryTest, SpecificBeforeGenericV2) {
  const base::FilePath kManifest(
      "test_protos/specific_before_generic_v2.prototxt");
  SetUpDirectory(kManifest);

  std::string carrier_a(kCarrierA);
  FirmwareDirectory::Files res =
      firmware_directory_->FindFirmware(kDeviceId, &carrier_a);
  EXPECT_TRUE(res.carrier_firmware.has_value());
  const FirmwareFileInfo& info = res.carrier_firmware.value();
  EXPECT_EQ(kCarrierA, carrier_a);
  EXPECT_EQ(kCarrierFirmwareFile1, info.firmware_path.BaseName().value());
  EXPECT_EQ(kCarrierFirmwareVersion1, info.version);
}

TEST_F(FirmwareDirectoryTest, MainFirmwareDefault) {
  const base::FilePath kManifest("test_protos/main_firmware_default.prototxt");
  SetUpDirectory(kManifest);

  std::string carrier_a(kCarrierA);
  FirmwareDirectory::Files res =
      firmware_directory_->FindFirmware(kDeviceId, &carrier_a);

  EXPECT_TRUE(res.main_firmware.has_value());
  const FirmwareFileInfo& main_info = res.main_firmware.value();
  EXPECT_EQ(kMainFirmwareFile1, main_info.firmware_path.BaseName().value());
  EXPECT_EQ(kMainFirmwareVersion1, main_info.version);

  EXPECT_TRUE(res.carrier_firmware.has_value());
  const FirmwareFileInfo& info_a = res.carrier_firmware.value();
  EXPECT_EQ(kCarrierA, carrier_a);
  EXPECT_EQ(kCarrierFirmwareFile1, info_a.firmware_path.BaseName().value());
  EXPECT_EQ(kCarrierFirmwareVersion1, info_a.version);
}

TEST_F(FirmwareDirectoryTest, MainFirmwareDefaultForGeneric) {
  const base::FilePath kManifest("test_protos/main_firmware_default.prototxt");
  SetUpDirectory(kManifest);

  // The default main firmware should also apply to the generic/no carrier
  // case.
  FirmwareDirectory::Files res =
      firmware_directory_->FindFirmware(kDeviceId, nullptr);

  EXPECT_TRUE(res.main_firmware.has_value());
  const FirmwareFileInfo& main_info_2 = res.main_firmware.value();
  EXPECT_EQ(kMainFirmwareFile1, main_info_2.firmware_path.BaseName().value());
  EXPECT_EQ(kMainFirmwareVersion1, main_info_2.version);
}

TEST_F(FirmwareDirectoryTest, MainFirmwareSwitching) {
  const base::FilePath kManifest(
      "test_protos/main_firmware_switching.prototxt");
  SetUpDirectory(kManifest);

  std::string carrier_a(kCarrierA);
  FirmwareDirectory::Files res =
      firmware_directory_->FindFirmware(kDeviceId, &carrier_a);

  EXPECT_TRUE(res.main_firmware.has_value());
  const FirmwareFileInfo& main_info = res.main_firmware.value();
  EXPECT_EQ(kMainFirmwareFile1, main_info.firmware_path.BaseName().value());
  EXPECT_EQ(kMainFirmwareVersion1, main_info.version);

  EXPECT_TRUE(res.carrier_firmware.has_value());
  const FirmwareFileInfo& info_a = res.carrier_firmware.value();
  EXPECT_EQ(kCarrierA, carrier_a);
  EXPECT_EQ(kCarrierFirmwareFile1, info_a.firmware_path.BaseName().value());
  EXPECT_EQ(kCarrierFirmwareVersion1, info_a.version);

  // Carrier B calls for different main firmware. This can only be encoded
  // in manifest v2.
  std::string carrier_b(kCarrierB);
  res = firmware_directory_->FindFirmware(kDeviceId, &carrier_b);

  EXPECT_TRUE(res.main_firmware.has_value());
  const FirmwareFileInfo& main_info_2 = res.main_firmware.value();
  EXPECT_EQ(kMainFirmwareFile2, main_info_2.firmware_path.BaseName().value());
  EXPECT_EQ(kMainFirmwareVersion2, main_info_2.version);

  EXPECT_TRUE(res.carrier_firmware.has_value());
  const FirmwareFileInfo& info_b = res.carrier_firmware.value();
  EXPECT_EQ(kCarrierB, carrier_b);
  EXPECT_EQ(kCarrierFirmwareFile2, info_b.firmware_path.BaseName().value());
  EXPECT_EQ(kCarrierFirmwareVersion2, info_b.version);
}

TEST_F(FirmwareDirectoryTest, MainFirmwareFullySpecified) {
  const base::FilePath kManifest(
      "test_protos/main_firmware_specified.prototxt");
  SetUpDirectory(kManifest);

  std::string carrier_a(kCarrierA);
  FirmwareDirectory::Files res =
      firmware_directory_->FindFirmware(kDeviceId, &carrier_a);

  EXPECT_TRUE(res.main_firmware.has_value());
  const FirmwareFileInfo& main_info = res.main_firmware.value();
  EXPECT_EQ(kMainFirmwareFile1, main_info.firmware_path.BaseName().value());
  EXPECT_EQ(kMainFirmwareVersion1, main_info.version);

  EXPECT_TRUE(res.carrier_firmware.has_value());
  const FirmwareFileInfo& info_a = res.carrier_firmware.value();
  EXPECT_EQ(kCarrierA, carrier_a);
  EXPECT_EQ(kCarrierFirmwareFile1, info_a.firmware_path.BaseName().value());
  EXPECT_EQ(kCarrierFirmwareVersion1, info_a.version);

  // Carrier B uses the generic firmware, which specifies its own main firmware.
  std::string carrier_b(kCarrierB);
  res = firmware_directory_->FindFirmware(kDeviceId, &carrier_b);

  EXPECT_TRUE(res.main_firmware.has_value());
  const FirmwareFileInfo& main_info_2 = res.main_firmware.value();
  EXPECT_EQ(kMainFirmwareFile2, main_info_2.firmware_path.BaseName().value());
  EXPECT_EQ(kMainFirmwareVersion2, main_info_2.version);

  EXPECT_TRUE(res.carrier_firmware.has_value());
  const FirmwareFileInfo& info_b = res.carrier_firmware.value();
  EXPECT_EQ(FirmwareDirectory::kGenericCarrierId, carrier_b);
  EXPECT_EQ(kGenericCarrierFirmwareFile,
            info_b.firmware_path.BaseName().value());
  EXPECT_EQ(kGenericCarrierFirmwareVersion, info_b.version);
}

TEST_F(FirmwareDirectoryTest, MainFirmwareFullySpecifiedNoGeneric) {
  // If each carrier directly specifies a present main firmware but there's no
  // generic firmware, we can't flash anything for unknown carriers.
  const base::FilePath kManifest(
      "test_protos/main_firmware_specified_no_generic.prototxt");
  SetUpDirectory(kManifest, false);
}

TEST_F(FirmwareDirectoryTest, CarrierSpecifiesAbsentMainFirmware) {
  const base::FilePath kManifest(
      "test_protos/carrier_specifies_absent_main.prototxt");
  SetUpDirectory(kManifest, false);
}

TEST_F(FirmwareDirectoryTest, MalformedDeviceEntry) {
  const base::FilePath kManifest("test_protos/malformed_device_entry.prototxt");
  SetUpDirectory(kManifest, false);
}

TEST_F(FirmwareDirectoryTest, MalformedMainEntryV2) {
  const base::FilePath kManifest(
      "test_protos/malformed_main_firmware_v2.prototxt");
  SetUpDirectory(kManifest, false);
}

TEST_F(FirmwareDirectoryTest, MalformedCarrierEntryV2) {
  const base::FilePath kManifest(
      "test_protos/malformed_carrier_firmware_v2.prototxt");
  SetUpDirectory(kManifest, false);
}

}  // namespace modemfwd