test/redfish-core/include/privileges_test.cpp

#include "privileges.hpp"

#include <array>

#include <gmock/gmock.h>  // IWYU pragma: keep
#include <gtest/gtest.h>  // IWYU pragma: keep
#include "boost/beast/http/verb.hpp"  // NOLINT

// IWYU pragma: no_include <gtest/gtest-message.h>
// IWYU pragma: no_include <gtest/gtest-test-part.h>
// IWYU pragma: no_include "gtest/gtest_pred_impl.h"
// IWYU pragma: no_include <gmock/gmock-matchers.h>
// IWYU pragma: no_include <gmock/gmock-more-matchers.h>

namespace redfish {
namespace {

using ::testing::IsEmpty;
using ::testing::UnorderedElementsAre;

TEST(PrivilegeTest, PrivilegeConstructor) {
  Privileges privileges{"Login", "ConfigureManager"};

  EXPECT_THAT(privileges.getActivePrivilegeNames(PrivilegeType::BASE),
              UnorderedElementsAre("Login", "ConfigureManager"));
}

TEST(PrivilegeTest, PrivilegeCheckForNoPrivilegesRequired) {
  Privileges user_privileges{"Login"};

  OperationMap entity_privileges{{boost::beast::http::verb::get, {{"Login"}}}};

  EXPECT_TRUE(isMethodAllowedWithPrivileges(
      boost::beast::http::verb::get, entity_privileges, user_privileges));
}

TEST(PrivilegeTest, PrivilegeCheckForSingleCaseSuccess) {
  auto user_privileges = Privileges{"Login"};
  OperationMap entity_privileges{{boost::beast::http::verb::get, {}}};

  EXPECT_TRUE(isMethodAllowedWithPrivileges(
      boost::beast::http::verb::get, entity_privileges, user_privileges));
}

TEST(PrivilegeTest, PrivilegeCheckForSingleCaseFailure) {
  auto user_privileges = Privileges{"Login"};
  OperationMap entity_privileges{
      {boost::beast::http::verb::get, {{"ConfigureManager"}}}};

  EXPECT_FALSE(isMethodAllowedWithPrivileges(
      boost::beast::http::verb::get, entity_privileges, user_privileges));
}

TEST(PrivilegeTest, PrivilegeCheckForANDCaseSuccess) {
  auto user_privileges =
      Privileges{"Login", "ConfigureManager", "ConfigureSelf"};
  OperationMap entity_privileges{
      {boost::beast::http::verb::get,
       {{"Login", "ConfigureManager", "ConfigureSelf"}}}};

  EXPECT_TRUE(isMethodAllowedWithPrivileges(
      boost::beast::http::verb::get, entity_privileges, user_privileges));
}

TEST(PrivilegeTest, PrivilegeCheckForANDCaseFailure) {
  auto user_privileges = Privileges{"Login", "ConfigureManager"};
  OperationMap entity_privileges{
      {boost::beast::http::verb::get,
       {{"Login", "ConfigureManager", "ConfigureSelf"}}}};

  EXPECT_FALSE(isMethodAllowedWithPrivileges(
      boost::beast::http::verb::get, entity_privileges, user_privileges));
}

TEST(PrivilegeTest, PrivilegeCheckForORPrivilegesCaseSuccess) {
  auto user_privileges = Privileges{"ConfigureManager"};
  OperationMap entity_privileges{
      {boost::beast::http::verb::get, {{"Login"}, {"ConfigureManager"}}}};

  EXPECT_TRUE(isMethodAllowedWithPrivileges(
      boost::beast::http::verb::get, entity_privileges, user_privileges));
}

TEST(PrivilegeTest, PrivilegeCheckForORPrivilegesCaseFailure) {
  auto user_privileges = Privileges{"ConfigureComponents"};
  OperationMap entity_privileges = OperationMap(
      {{boost::beast::http::verb::get, {{"Login"}, {"ConfigureManager"}}}});

  EXPECT_FALSE(isMethodAllowedWithPrivileges(
      boost::beast::http::verb::get, entity_privileges, user_privileges));
}

TEST(PrivilegeTest, DefaultPrivilegeBitsetsAreEmpty) {
  Privileges privileges;

  EXPECT_THAT(privileges.getActivePrivilegeNames(PrivilegeType::BASE),
              IsEmpty());

  EXPECT_THAT(privileges.getActivePrivilegeNames(PrivilegeType::OEM),
              IsEmpty());
}

TEST(PrivilegeTest, GetActivePrivilegeNames) {
  Privileges privileges;

  EXPECT_THAT(privileges.getActivePrivilegeNames(PrivilegeType::BASE),
              IsEmpty());

  std::array<const char*, 5> expected_privileges{
      "Login", "ConfigureManager", "ConfigureUsers", "ConfigureComponents",
      "ConfigureSelf"};

  for (const auto& privilege : expected_privileges) {
    EXPECT_TRUE(privileges.setSinglePrivilege(privilege));
  }

  EXPECT_THAT(
      privileges.getActivePrivilegeNames(PrivilegeType::BASE),
      UnorderedElementsAre(expected_privileges[0], expected_privileges[1],
                           expected_privileges[2], expected_privileges[3],
                           expected_privileges[4]));
}
}  // namespace
}  // namespace redfish