facter 3.12.2.cfacter.20181217 → 4.0.7.pre

data/ext/facter/facter/lib/tests/facts/resolvers/ssh_resolver.cc

@@ -1,103 +0,0 @@
-#include <catch.hpp>
-#include <internal/facts/resolvers/ssh_resolver.hpp>
-#include <facter/facts/collection.hpp>
-#include <facter/facts/fact.hpp>
-#include <facter/facts/scalar_value.hpp>
-#include <facter/facts/map_value.hpp>
-#include "../../collection_fixture.hpp"
-
-using namespace std;
-using namespace facter::facts;
-using namespace facter::facts::resolvers;
-using namespace facter::testing;
-
-struct empty_ssh_resolver : ssh_resolver
-{
- protected:
-    virtual data collect_data(collection& facts) override
-    {
-        return {};
-    }
-};
-
-struct test_ssh_resolver : ssh_resolver
-{
- protected:
-    virtual data collect_data(collection& facts) override
-    {
-        data result;
-        result.dsa.key = "dsa:key";
-        result.dsa.type = "dsa:type";
-        result.dsa.digest.sha1 = "dsa:sha1";
-        result.dsa.digest.sha256 = "dsa:sha256";
-        result.ecdsa.key = "ecdsa:key";
-        result.ecdsa.type = "ecdsa:type";
-        result.ecdsa.digest.sha1 = "ecdsa:sha1";
-        result.ecdsa.digest.sha256 = "ecdsa:sha256";
-        result.ed25519.key = "ed25519:key";
-        result.ed25519.type = "ed25519:type";
-        result.ed25519.digest.sha1 = "ed25519:sha1";
-        result.ed25519.digest.sha256 = "ed25519:sha256";
-        result.rsa.key = "rsa:key";
-        result.rsa.type = "rsa:type";
-        result.rsa.digest.sha1 = "rsa:sha1";
-        result.rsa.digest.sha256 = "rsa:sha256";
-        return result;
-    }
-};
-
-SCENARIO("using the ssh resolver") {
-    collection_fixture facts;
-    WHEN("data is not present") {
-        facts.add(make_shared<empty_ssh_resolver>());
-        THEN("facts should not be added") {
-            REQUIRE(facts.size() == 0u);
-        }
-    }
-    WHEN("data is present") {
-        static const vector<string> algorithms = {
-            "dsa",
-            "ecdsa",
-            "ed25519",
-            "rsa"
-        };
-        facts.add(make_shared<test_ssh_resolver>());
-        THEN("a structured fact is added") {
-            REQUIRE(facts.size() == 9u);
-            auto ssh = facts.get<map_value>(fact::ssh);
-            REQUIRE(ssh);
-            REQUIRE(ssh->size() == 4u);
-            for (auto const& algorithm : algorithms) {
-                auto entry = ssh->get<map_value>(algorithm);
-                REQUIRE(entry);
-                REQUIRE(entry->size() == 3u);
-                auto key = entry->get<string_value>("key");
-                REQUIRE(key);
-                REQUIRE(key->value() == algorithm + ":key");
-                auto type = entry->get<string_value>("type");
-                REQUIRE(type);
-                REQUIRE(type->value() == algorithm + ":type");
-                auto fingerprints = entry->get<map_value>("fingerprints");
-                REQUIRE(fingerprints);
-                REQUIRE(fingerprints->size() == 2u);
-                auto fingerprint = fingerprints->get<string_value>("sha1");
-                REQUIRE(fingerprint);
-                REQUIRE(fingerprint->value() == algorithm + ":sha1");
-                fingerprint = fingerprints->get<string_value>("sha256");
-                REQUIRE(fingerprint);
-                REQUIRE(fingerprint->value() == algorithm + ":sha256");
-            }
-        }
-        THEN("flat facts are added") {
-            REQUIRE(facts.size() == 9u);
-            for (auto const& algorithm : algorithms) {
-                auto key = facts.get<string_value>("ssh" + algorithm + "key");
-                REQUIRE(key);
-                REQUIRE(key->value() == algorithm + ":key");
-                auto fingerprint = facts.get<string_value>("sshfp_" + algorithm);
-                REQUIRE(fingerprint);
-                REQUIRE(fingerprint->value() == algorithm + ":sha1\n" + algorithm + ":sha256");
-            }
-        }
-    }
-}

data/ext/facter/facter/lib/tests/facts/resolvers/system_profiler_resolver.cc

@@ -1,135 +0,0 @@
-#include <catch.hpp>
-#include <internal/facts/resolvers/system_profiler_resolver.hpp>
-#include <facter/facts/collection.hpp>
-#include <facter/facts/fact.hpp>
-#include <facter/facts/scalar_value.hpp>
-#include <facter/facts/map_value.hpp>
-#include "../../collection_fixture.hpp"
-
-using namespace std;
-using namespace facter::facts;
-using namespace facter::facts::resolvers;
-using namespace facter::testing;
-
-struct empty_system_profiler_resolver : system_profiler_resolver
-{
- protected:
-    virtual data collect_data(collection& facts) override
-    {
-        return {};
-    }
-};
-
-struct test_system_profiler_resolver : system_profiler_resolver
-{
- protected:
-    virtual data collect_data(collection& facts) override
-    {
-        data result;
-        result.boot_mode = "boot_mode";
-        result.boot_rom_version = "boot_rom_version";
-        result.boot_volume = "boot_volume";
-        result.processor_name = "processor_name";
-        result.processor_speed = "processor_speed";
-        result.kernel_version = "kernel_version";
-        result.l2_cache_per_core = "l2_cache_per_core";
-        result.l3_cache = "l3_cache";
-        result.computer_name = "computer_name";
-        result.model_identifier = "model_identifier";
-        result.model_name = "model_name";
-        result.cores = "cores";
-        result.system_version = "system_version";
-        result.processors = "processors";
-        result.memory = "memory";
-        result.hardware_uuid = "hardware_uuid";
-        result.secure_virtual_memory = "secure_virtual_memory";
-        result.serial_number = "serial_number";
-        result.smc_version = "smc_version";
-        result.uptime = "uptime";
-        result.username = "username";
-        return result;
-    }
-};
-
-SCENARIO("using the system profiler resolver") {
-    collection_fixture facts;
-    WHEN("data is not present") {
-        facts.add(make_shared<empty_system_profiler_resolver>());
-        THEN("facts should not be added") {
-            REQUIRE(facts.size() == 0u);
-        }
-    }
-    WHEN("data is present") {
-        static const vector<string> algorithms = {
-            "dsa",
-            "ecdsa",
-            "ed25519",
-            "rsa"
-        };
-        facts.add(make_shared<test_system_profiler_resolver>());
-        THEN("a structured fact is added") {
-            auto system_profiler = facts.get<map_value>(fact::system_profiler);
-            REQUIRE(system_profiler);
-            REQUIRE(system_profiler->size() == 21u);
-            static const vector<string> names = {
-                "boot_mode",
-                "boot_rom_version",
-                "boot_volume",
-                "processor_name",
-                "processor_speed",
-                "kernel_version",
-                "l2_cache_per_core" ,
-                "l3_cache",
-                "computer_name",
-                "model_identifier",
-                "model_name",
-                "cores",
-                "system_version",
-                "processors",
-                "memory",
-                "hardware_uuid",
-                "secure_virtual_memory",
-                "serial_number",
-                "smc_version",
-                "uptime",
-                "username"
-            };
-            for (auto const& name : names) {
-                auto sval = system_profiler->get<string_value>(name);
-                REQUIRE(sval);
-                REQUIRE(sval->value() == name);
-            }
-        }
-        THEN("flat facts are added") {
-            REQUIRE(facts.size() == 22u);
-            static const map<string, string> check = {
-                { string(fact::sp_boot_mode), "boot_mode" },
-                { string(fact::sp_boot_rom_version), "boot_rom_version" },
-                { string(fact::sp_boot_volume), "boot_volume" },
-                { string(fact::sp_cpu_type), "processor_name" },
-                { string(fact::sp_current_processor_speed), "processor_speed" },
-                { string(fact::sp_kernel_version), "kernel_version" },
-                { string(fact::sp_l2_cache_core), "l2_cache_per_core" },
-                { string(fact::sp_l3_cache), "l3_cache" },
-                { string(fact::sp_local_host_name), "computer_name" },
-                { string(fact::sp_machine_model), "model_identifier" },
-                { string(fact::sp_machine_name), "model_name" },
-                { string(fact::sp_number_processors), "cores" },
-                { string(fact::sp_os_version), "system_version" },
-                { string(fact::sp_packages), "processors" },
-                { string(fact::sp_physical_memory), "memory" },
-                { string(fact::sp_platform_uuid), "hardware_uuid" },
-                { string(fact::sp_secure_vm), "secure_virtual_memory" },
-                { string(fact::sp_serial_number), "serial_number" },
-                { string(fact::sp_smc_version_system), "smc_version" },
-                { string(fact::sp_uptime), "uptime" },
-                { string(fact::sp_user_name), "username" }
-            };
-            for (auto const& kvp : check) {
-                auto sval = facts.get<string_value>(kvp.first);
-                REQUIRE(sval);
-                REQUIRE(sval->value() == kvp.second);
-            }
-        }
-    }
-}

data/ext/facter/facter/lib/tests/facts/resolvers/timezone_resolver.cc

@@ -1,49 +0,0 @@
-#include <catch.hpp>
-#include <internal/facts/resolvers/timezone_resolver.hpp>
-#include <facter/facts/collection.hpp>
-#include <facter/facts/fact.hpp>
-#include <facter/facts/scalar_value.hpp>
-#include "../../collection_fixture.hpp"
-
-using namespace std;
-using namespace facter::facts;
-using namespace facter::facts::resolvers;
-using namespace facter::testing;
-
-struct empty_timezone_resolver : timezone_resolver
-{
- protected:
-    virtual string get_timezone() override
-    {
-        return {};
-    }
-};
-
-struct test_timezone_resolver : timezone_resolver
-{
- protected:
-    virtual string get_timezone() override
-    {
-        return "PDT";
-    }
-};
-
-// TestRail C69635
-SCENARIO("using the timezone resolver") {
-    collection_fixture facts;
-    WHEN("data is not present") {
-        facts.add(make_shared<empty_timezone_resolver>());
-        THEN("facts should not be added") {
-            REQUIRE(facts.size() == 0u);
-        }
-    }
-    WHEN("data is present") {
-        facts.add(make_shared<test_timezone_resolver>());
-        THEN("a flat fact is added") {
-            REQUIRE(facts.size() == 1u);
-            auto timezone = facts.get<string_value>(fact::timezone);
-            REQUIRE(timezone);
-            REQUIRE(timezone->value() == "PDT");
-        }
-    }
-}

data/ext/facter/facter/lib/tests/facts/resolvers/uptime_resolver.cc

@@ -1,151 +0,0 @@
-#include <catch.hpp>
-#include <internal/facts/resolvers/uptime_resolver.hpp>
-#include <facter/facts/collection.hpp>
-#include <facter/facts/fact.hpp>
-#include <facter/facts/scalar_value.hpp>
-#include <facter/facts/map_value.hpp>
-#include "../../collection_fixture.hpp"
-
-using namespace std;
-using namespace facter::facts;
-using namespace facter::facts::resolvers;
-using namespace facter::testing;
-
-struct test_less_than_day_resolver : uptime_resolver
-{
- protected:
-    virtual int64_t get_uptime() override
-    {
-        // 13 hours, 35 minutes, 6 seconds
-        return (13 * 60 * 60) + (35 * 60) + 6;
-    }
-};
-
-struct test_one_day_resolver : uptime_resolver
-{
- protected:
-    virtual int64_t get_uptime() override
-    {
-        // 1 day, 2 hours, 12 minutes, 22 seconds
-        return (1 * 24 * 60 * 60) + (2 * 60 * 60) + (12 * 60) + 22;
-    }
-};
-
-struct test_more_than_day_resolver : uptime_resolver
-{
- protected:
-    virtual int64_t get_uptime() override
-    {
-        // 3 day, 4 hours, 19 minutes, 45 seconds
-        return (3 * 24 * 60 * 60) + (4 * 60 * 60) + (19 * 60) + 45;
-    }
-};
-
-SCENARIO("using the uptime resolver") {
-    collection_fixture facts;
-    WHEN("the uptime is less than one day") {
-        facts.add(make_shared<test_less_than_day_resolver>());
-        THEN("a structured fact with 'hours' uptime is added") {
-            auto system_uptime = facts.get<map_value>(fact::system_uptime);
-            REQUIRE(system_uptime);
-            REQUIRE(system_uptime->size() == 4u);
-            auto time = system_uptime->get<integer_value>("seconds");
-            REQUIRE(time);
-            REQUIRE(time->value() == 48906);
-            time = system_uptime->get<integer_value>("hours");
-            REQUIRE(time);
-            REQUIRE(time->value() == 13);
-            time = system_uptime->get<integer_value>("days");
-            REQUIRE(time);
-            REQUIRE(time->value() == 0);
-            auto uptime = system_uptime->get<string_value>("uptime");
-            REQUIRE(uptime);
-            REQUIRE(uptime->value() == "13:35 hours");
-        }
-        THEN("flat facts with 'hours' uptime is added") {
-            REQUIRE(facts.size() == 5u);
-            auto time = facts.get<integer_value>(fact::uptime_seconds);
-            REQUIRE(time);
-            REQUIRE(time->value() == 48906);
-            time = facts.get<integer_value>(fact::uptime_hours);
-            REQUIRE(time);
-            REQUIRE(time->value() == 13);
-            time = facts.get<integer_value>(fact::uptime_days);
-            REQUIRE(time);
-            REQUIRE(time->value() == 0);
-            auto uptime = facts.get<string_value>(fact::uptime);
-            REQUIRE(uptime);
-            REQUIRE(uptime->value() == "13:35 hours");
-        }
-    }
-    WHEN("the uptime is one day") {
-        facts.add(make_shared<test_one_day_resolver>());
-        THEN("a structured fact with '1 day' uptime is added") {
-            auto system_uptime = facts.get<map_value>(fact::system_uptime);
-            REQUIRE(system_uptime);
-            REQUIRE(system_uptime->size() == 4u);
-            auto time = system_uptime->get<integer_value>("seconds");
-            REQUIRE(time);
-            REQUIRE(time->value() == 94342);
-            time = system_uptime->get<integer_value>("hours");
-            REQUIRE(time);
-            REQUIRE(time->value() == 26);
-            time = system_uptime->get<integer_value>("days");
-            REQUIRE(time);
-            REQUIRE(time->value() == 1);
-            auto uptime = system_uptime->get<string_value>("uptime");
-            REQUIRE(uptime);
-            REQUIRE(uptime->value() == "1 day");
-        }
-        THEN("flat facts with '1 day' uptime is added") {
-            REQUIRE(facts.size() == 5u);
-            auto time = facts.get<integer_value>(fact::uptime_seconds);
-            REQUIRE(time);
-            REQUIRE(time->value() == 94342);
-            time = facts.get<integer_value>(fact::uptime_hours);
-            REQUIRE(time);
-            REQUIRE(time->value() == 26);
-            time = facts.get<integer_value>(fact::uptime_days);
-            REQUIRE(time);
-            REQUIRE(time->value() == 1);
-            auto uptime = facts.get<string_value>(fact::uptime);
-            REQUIRE(uptime);
-            REQUIRE(uptime->value() == "1 day");
-        }
-    }
-    WHEN("the uptime is more than one day") {
-        facts.add(make_shared<test_more_than_day_resolver>());
-        THEN("a structured fact with 'x days' uptime is added") {
-            auto system_uptime = facts.get<map_value>(fact::system_uptime);
-            REQUIRE(system_uptime);
-            REQUIRE(system_uptime->size() == 4u);
-            auto time = system_uptime->get<integer_value>("seconds");
-            REQUIRE(time);
-            REQUIRE(time->value() == 274785);
-            time = system_uptime->get<integer_value>("hours");
-            REQUIRE(time);
-            REQUIRE(time->value() == 76);
-            time = system_uptime->get<integer_value>("days");
-            REQUIRE(time);
-            REQUIRE(time->value() == 3);
-            auto uptime = system_uptime->get<string_value>("uptime");
-            REQUIRE(uptime);
-            REQUIRE(uptime->value() == "3 days");
-        }
-        THEN("flat facts with 'x days' uptime is added") {
-            REQUIRE(facts.size() == 5u);
-            auto time = facts.get<integer_value>(fact::uptime_seconds);
-            REQUIRE(time);
-            REQUIRE(time->value() == 274785);
-            time = facts.get<integer_value>(fact::uptime_hours);
-            REQUIRE(time);
-            REQUIRE(time->value() == 76);
-            time = facts.get<integer_value>(fact::uptime_days);
-            REQUIRE(time);
-            REQUIRE(time->value() == 3);
-            auto uptime = facts.get<string_value>(fact::uptime);
-            REQUIRE(uptime);
-            REQUIRE(uptime->value() == "3 days");
-        }
-    }
-}

data/ext/facter/facter/lib/tests/facts/resolvers/virtualization_resolver.cc

@@ -1,175 +0,0 @@
-#include <catch.hpp>
-#include <internal/facts/resolvers/virtualization_resolver.hpp>
-#include <facter/facts/collection.hpp>
-#include <facter/facts/fact.hpp>
-#include <facter/facts/scalar_value.hpp>
-#include <facter/facts/vm.hpp>
-#include "../../collection_fixture.hpp"
-
-using namespace std;
-using namespace facter::facts;
-using namespace facter::facts::resolvers;
-using namespace facter::testing;
-
-struct empty_virtualization_resolver : virtualization_resolver
-{
- protected:
-    string get_hypervisor(collection& facts) override
-    {
-        return "";
-    }
-    string get_cloud_provider(collection& facts) override
-    {
-        return "";
-    }
-};
-
-struct unknown_hypervisor_resolver : virtualization_resolver
-{
- protected:
-    string get_hypervisor(collection& facts) override
-    {
-        return "foobar";
-    }
-    string get_cloud_provider(collection& facts) override
-    {
-        return "provider";
-    }
-};
-
-struct unknown_non_virtual_hypervisor_resolver : virtualization_resolver
-{
- protected:
-    string get_hypervisor(collection& facts) override
-    {
-        return "foobar";
-    }
-    string get_cloud_provider(collection& facts) override
-    {
-        return "provider";
-    }
-
-    bool is_virtual(string const& hypervisor) override
-    {
-        return hypervisor != "foobar";
-    }
-};
-
-struct known_hypervisor_resolver : virtualization_resolver
-{
- protected:
-    string get_hypervisor(collection& facts) override
-    {
-        return vm::docker;
-    }
-    string get_cloud_provider(collection& facts) override
-    {
-        return "provider";
-    }
-};
-
-struct matched_product_hypervisor_resolver : virtualization_resolver
-{
- protected:
-    string get_hypervisor(collection& facts) override
-    {
-        facts.add(fact::product_name, make_value<string_value>("VMware"));
-        auto result = get_fact_vm(facts);
-        facts.remove(fact::product_name);
-        return result;
-    }
-    string get_cloud_provider(collection& facts) override
-    {
-        return "provider";
-    }
-};
-
-struct matched_vendor_hypervisor_resolver : virtualization_resolver
-{
- protected:
-    string get_hypervisor(collection& facts) override
-    {
-        facts.add(fact::bios_vendor, make_value<string_value>("Amazon EC2"));
-        auto result = get_fact_vm(facts);
-        facts.remove(fact::bios_vendor);
-        return result;
-    }
-    string get_cloud_provider(collection& facts) override
-    {
-        return "provider";
-    }
-};
-
-SCENARIO("using the virtualization resolver") {
-    collection_fixture facts;
-    WHEN("no hypervisor is returned") {
-        facts.add(make_shared<empty_virtualization_resolver>());
-        THEN("the system is reported as physical") {
-            REQUIRE(facts.size() == 2u);
-            auto is_virt = facts.get<boolean_value>(fact::is_virtual);
-            REQUIRE(is_virt);
-            REQUIRE_FALSE(is_virt->value());
-            auto hypervisor = facts.get<string_value>(fact::virtualization);
-            REQUIRE(hypervisor);
-            REQUIRE(hypervisor->value() == "physical");
-        }
-    }
-    WHEN("an unknown virtual hypervisor is returned") {
-        facts.add(make_shared<unknown_hypervisor_resolver>());
-        THEN("the system is reported as virtual") {
-            REQUIRE(facts.size() == 3u);
-            auto is_virt = facts.get<boolean_value>(fact::is_virtual);
-            REQUIRE(is_virt);
-            REQUIRE(is_virt->value());
-            auto hypervisor = facts.get<string_value>(fact::virtualization);
-            REQUIRE(hypervisor);
-            REQUIRE(hypervisor->value() == "foobar");
-        }
-    }
-    WHEN("an unknown physical hypervisor is returned") {
-        facts.add(make_shared<unknown_non_virtual_hypervisor_resolver>());
-        THEN("the system is reported as virtual") {
-            REQUIRE(facts.size() == 3u);
-            auto is_virt = facts.get<boolean_value>(fact::is_virtual);
-            REQUIRE(is_virt);
-            REQUIRE_FALSE(is_virt->value());
-            auto hypervisor = facts.get<string_value>(fact::virtualization);
-            REQUIRE(hypervisor);
-            REQUIRE(hypervisor->value() == "foobar");
-        }
-    }
-    WHEN("a known hypervisor is returned") {
-        facts.add(make_shared<known_hypervisor_resolver>());
-        THEN("the system is reported as virtual") {
-            REQUIRE(facts.size() == 3u);
-            auto is_virt = facts.get<boolean_value>(fact::is_virtual);
-            REQUIRE(is_virt);
-            REQUIRE(is_virt->value());
-            auto hypervisor = facts.get<string_value>(fact::virtualization);
-            REQUIRE(hypervisor);
-            REQUIRE(hypervisor->value() == string(vm::docker));
-        }
-    }
-
-    WHEN("a hypervisor is matched from product name") {
-        facts.add(make_shared<matched_product_hypervisor_resolver>());
-        THEN("the system is reported as virtual") {
-            REQUIRE(facts.size() == 3u);
-            auto is_virt = facts.get<boolean_value>(fact::is_virtual);
-            REQUIRE(is_virt);
-            REQUIRE(is_virt->value());
-            auto hypervisor = facts.get<string_value>(fact::virtualization);
-            REQUIRE(hypervisor);
-            REQUIRE(hypervisor->value() == string(vm::vmware));
-        }
-    }
-    WHEN("a hypervisor is matched from the vendor name") {
-        facts.add(make_shared<matched_vendor_hypervisor_resolver>());
-        auto is_virt = facts.get<boolean_value>(fact::is_virtual);
-        REQUIRE(is_virt);
-        REQUIRE(is_virt->value());
-        auto hypervisor = facts.get<string_value>(fact::virtualization);
-        REQUIRE(hypervisor);
-        REQUIRE(hypervisor->value() == string(vm::kvm));
-    }
-}