src/connectivity/weave/adaptation/tests/test_configuration_manager.h

// Copyright 2021 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#ifndef SRC_CONNECTIVITY_WEAVE_ADAPTATION_TESTS_TEST_CONFIGURATION_MANAGER_H_
#define SRC_CONNECTIVITY_WEAVE_ADAPTATION_TESTS_TEST_CONFIGURATION_MANAGER_H_

#include <gtest/gtest.h>

#include "configuration_manager_delegate_impl.h"

namespace weave::adaptation::testing {

class TestConfigurationManager final
    : public nl::Weave::DeviceLayer::ConfigurationManagerDelegateImpl {
 public:
  // Access underlying delegate implementation.
  using Impl = nl::Weave::DeviceLayer::ConfigurationManagerDelegateImpl;

  // Does the bare-minimum file initialization for tests. This should be used
  // instead of ConfigurationManager::Init() when tests invoke functions that
  // store data via ConfigurationManager but want to avoid accessing the
  // fuchsia.hwinfo and fuchsia.buildinfo FIDLs.
  void InitForTesting() {
    ASSERT_EQ(nl::Weave::DeviceLayer::Internal::EnvironmentConfig::Init(), WEAVE_NO_ERROR);
  }

  // Returns whether the device is thread-enabled.
  bool IsIPv6ForwardingEnabled() override {
    return is_ipv6_forwarding_enabled_.value_or(Impl::IsIPv6ForwardingEnabled());
  }

  // Returns whether the device is paired to an account.
  bool IsPairedToAccount() override {
    return is_paired_to_account_.value_or(Impl::IsPairedToAccount());
  }

  // Returns whether the device is a member of a fabric.
  bool IsMemberOfFabric() override {
    return is_member_of_fabric_.value_or(Impl::IsMemberOfFabric());
  }

  // Returns whether the device is thread-enabled.
  bool IsThreadEnabled() override { return is_thread_enabled_.value_or(Impl::IsThreadEnabled()); }

  // Returns the private key for signing.
  zx_status_t GetPrivateKeyForSigning(std::vector<uint8_t>* signing_key) override {
    if (use_signing_key_ && !use_signing_key_.value()) {
      return ZX_ERR_NOT_FOUND;
    }
    if (signing_key_) {
      std::copy(signing_key_.value().begin(), signing_key_.value().end(),
                std::back_inserter(*signing_key));
      return ZX_OK;
    }
    return Impl::GetPrivateKeyForSigning(signing_key);
  }

  // Returns the thread joinable duration.
  WEAVE_ERROR GetThreadJoinableDuration(uint32_t* duration) override {
    if (thread_joinable_duration_) {
      *duration = thread_joinable_duration_.value();
      return WEAVE_NO_ERROR;
    }
    return Impl::GetThreadJoinableDuration(duration);
  }

  // Returns the vendor-id description.
  WEAVE_ERROR GetVendorIdDescription(char* buf, size_t buf_size, size_t& out_len) override {
    if (vendor_id_description_) {
      return StringToBuffer(vendor_id_description_.value(), buf, buf_size, out_len);
    }
    return Impl::GetVendorIdDescription(buf, buf_size, out_len);
  }

  // Returns the product-id description.
  WEAVE_ERROR GetProductIdDescription(char* buf, size_t buf_size, size_t& out_len) override {
    if (product_id_description_) {
      return StringToBuffer(product_id_description_.value(), buf, buf_size, out_len);
    }
    return Impl::GetProductIdDescription(buf, buf_size, out_len);
  }

  // Returns the firmware revision.
  WEAVE_ERROR GetFirmwareRevision(char* buf, size_t buf_size, size_t& out_len) override {
    if (firmware_revision_) {
      return StringToBuffer(firmware_revision_.value(), buf, buf_size, out_len);
    }
    return Impl::GetFirmwareRevision(buf, buf_size, out_len);
  }

  // Set whether the device is a member of a fabric.
  TestConfigurationManager& set_is_ipv6_forwarding_enabled(
      std::optional<bool> is_ipv6_forwarding_enabled) {
    is_ipv6_forwarding_enabled_ = is_ipv6_forwarding_enabled;
    return *this;
  }

  // Set whether the device is paired to an account.
  TestConfigurationManager& set_is_paired_to_account(std::optional<bool> is_paired_to_account) {
    is_paired_to_account_ = is_paired_to_account;
    return *this;
  }

  // Set whether the device is a member of a fabric.
  TestConfigurationManager& set_is_member_of_fabric(std::optional<bool> is_member_of_fabric) {
    is_member_of_fabric_ = is_member_of_fabric;
    return *this;
  }

  // Set whether the device is thread-enabled.
  TestConfigurationManager& set_is_thread_enabled(std::optional<bool> is_thread_enabled) {
    is_thread_enabled_ = is_thread_enabled;
    return *this;
  }

  // Set whether or not to use the local private key.
  TestConfigurationManager& set_use_signing_key(std::optional<bool> use_signing_key) {
    use_signing_key_ = use_signing_key;
    return *this;
  }

  // Set the local private key when not using the fuchsia.weave.Signer protocol.
  TestConfigurationManager& set_signing_key(std::optional<std::vector<uint8_t>> signing_key) {
    signing_key_ = signing_key;
    return *this;
  }

  // Set the thread joinable duration.
  TestConfigurationManager& set_thread_joinable_duration(
      std::optional<uint32_t> thread_joinable_duration) {
    thread_joinable_duration_ = thread_joinable_duration;
    return *this;
  }

  // Set the vendor-id description.
  TestConfigurationManager& set_vendor_id_description(
      std::optional<std::string> vendor_id_description) {
    vendor_id_description_ = vendor_id_description;
    return *this;
  }

  // Set the product-id description.
  TestConfigurationManager& set_product_id_description(
      std::optional<std::string> product_id_description) {
    product_id_description_ = product_id_description;
    return *this;
  }

  // Set the firmware revision.
  TestConfigurationManager& set_firmware_revision(std::optional<std::string> firmware_revision) {
    firmware_revision_ = firmware_revision;
    return *this;
  }

 private:
  // Helper function to write string data into the provided buffer and return
  // appropriate WEAVE_ERROR types for insufficient space.
  WEAVE_ERROR StringToBuffer(std::string source, char* buf, size_t buf_size, size_t& out_len) {
    if (source.size() > buf_size) {
      return WEAVE_ERROR_BUFFER_TOO_SMALL;
    }
    std::memcpy(buf, source.data(), source.size());
    out_len = source.size();
    return WEAVE_NO_ERROR;
  }

  std::optional<bool> is_ipv6_forwarding_enabled_;
  std::optional<bool> is_paired_to_account_;
  std::optional<bool> is_member_of_fabric_;
  std::optional<bool> is_thread_enabled_;
  std::optional<bool> use_signing_key_;
  std::optional<std::vector<uint8_t>> signing_key_;
  std::optional<uint32_t> thread_joinable_duration_;
  std::optional<std::string> vendor_id_description_;
  std::optional<std::string> product_id_description_;
  std::optional<std::string> firmware_revision_;
};

}  // namespace weave::adaptation::testing

#endif  // SRC_CONNECTIVITY_WEAVE_ADAPTATION_TESTS_TEST_CONFIGURATION_MANAGER_H_