winget-cli

Unnamed repository; edit this file 'description' to name the repository.
Log | Files | Refs | README | LICENSE

TestOverrideTests.cpp (4397B)

      1 // Copyright (c) Microsoft Corporation.
      2 // Licensed under the MIT License.
      3 
      4 #include "Env.h"
      5 #include "TestOverride.h"
      6 
      7 #include <catch2/catch_test_macros.hpp>
      8 
      9 #define TEST(...) TEST_CASE("[TestOverrideTests] " __VA_ARGS__)
     10 
     11 using namespace SFS::test;
     12 using namespace SFS::details::env;
     13 
     14 TEST("Testing AreTestOverridesAllowed()")
     15 {
     16     bool areTestOverridesAllowed = AreTestOverridesAllowed();
     17 #ifdef SFS_ENABLE_TEST_OVERRIDES
     18     REQUIRE(areTestOverridesAllowed);
     19 #else
     20     REQUIRE_FALSE(areTestOverridesAllowed);
     21 #endif
     22 }
     23 
     24 TEST("Testing GetEnvVarNameFromOverride")
     25 {
     26     REQUIRE(GetEnvVarNameFromOverride(TestOverride::BaseUrl) == "SFS_TEST_OVERRIDE_BASE_URL");
     27 }
     28 
     29 TEST("Testing GetTestOverride()")
     30 {
     31     if (AreTestOverridesAllowed())
     32     {
     33         SECTION("Testing GetTestOverride() on a non-existing environment variable")
     34         {
     35             auto env = GetTestOverride(TestOverride::BaseUrl);
     36             REQUIRE(!env.has_value());
     37 
     38             SECTION("Testing GetTestOverride() on an existing environment variable")
     39             {
     40                 const std::string varName = GetEnvVarNameFromOverride(TestOverride::BaseUrl);
     41                 REQUIRE(SetEnv(varName, "override"));
     42 
     43                 env = GetTestOverride(TestOverride::BaseUrl);
     44                 REQUIRE(env.has_value());
     45                 REQUIRE(*env == "override");
     46 
     47                 INFO("Unsetting the environment variable");
     48                 REQUIRE(UnsetEnv(varName));
     49             }
     50         }
     51     }
     52     else
     53     {
     54         SECTION("GetTestOverride() returns std::nullopt when test overrides are not allowed")
     55         {
     56             auto env = GetTestOverride(TestOverride::BaseUrl);
     57             REQUIRE(!env.has_value());
     58         }
     59     }
     60 }
     61 
     62 TEST("Testing ScopedTestOverride")
     63 {
     64     SECTION("Testing ScopedTestOverride on a non-existing override")
     65     {
     66         const std::string varName = GetEnvVarNameFromOverride(TestOverride::BaseUrl);
     67         auto env = GetTestOverride(TestOverride::BaseUrl);
     68         REQUIRE(!env.has_value());
     69 
     70         {
     71             ScopedTestOverride scopedOverride(TestOverride::BaseUrl, "dummyValue");
     72 
     73             INFO("Variable exists within scope");
     74             env = GetEnv(varName);
     75             REQUIRE(env.has_value());
     76             REQUIRE(*env == "dummyValue");
     77 
     78             if (AreTestOverridesAllowed())
     79             {
     80                 INFO("Checking test override within scope");
     81                 env = GetTestOverride(TestOverride::BaseUrl);
     82                 REQUIRE(env.has_value());
     83                 REQUIRE(*env == "dummyValue");
     84             }
     85 
     86             SECTION("Testing ScopedEnv on an existing variable overwrites it")
     87             {
     88                 {
     89                     ScopedTestOverride scopedOverride2(TestOverride::BaseUrl, "dummyValue2");
     90 
     91                     INFO("Variable has value overwritten within scope");
     92                     env = GetEnv(varName);
     93                     REQUIRE(env.has_value());
     94                     REQUIRE(*env == "dummyValue2");
     95 
     96                     if (AreTestOverridesAllowed())
     97                     {
     98                         INFO("Checking test override has been overwritten within scope");
     99                         env = GetTestOverride(TestOverride::BaseUrl);
    100                         REQUIRE(env.has_value());
    101                         REQUIRE(*env == "dummyValue2");
    102                     }
    103                 }
    104 
    105                 INFO("Variable goes back to previous value");
    106                 env = GetEnv(varName);
    107                 REQUIRE(env.has_value());
    108                 REQUIRE(*env == "dummyValue");
    109 
    110                 if (AreTestOverridesAllowed())
    111                 {
    112                     INFO("Checking test override has gone back to previous value");
    113                     env = GetTestOverride(TestOverride::BaseUrl);
    114                     REQUIRE(env.has_value());
    115                     REQUIRE(*env == "dummyValue");
    116                 }
    117             }
    118         }
    119 
    120         INFO("Variable should be unset after the scope ends");
    121         env = GetEnv(varName);
    122         REQUIRE(!env.has_value());
    123 
    124         if (AreTestOverridesAllowed())
    125         {
    126             INFO("Test override should be unset after the scope ends");
    127             env = GetTestOverride(TestOverride::BaseUrl);
    128             REQUIRE(!env.has_value());
    129         }
    130     }
    131 }