cfacter 3.11.0.rc.20180314

data/ext/facter/facter/lib/tests/facts/linux/processor_fixture.hpp

@@ -0,0 +1,77 @@
+#pragma once
+
+#include <internal/facts/linux/processor_resolver.hpp>
+#include <map>
+#include <functional>
+#include <vector>
+#include <tuple>
+#include <memory>
+#include <boost/filesystem.hpp>
+#include <boost/optional.hpp>
+#include <boost/nowide/iostream.hpp>
+#include <boost/nowide/fstream.hpp>
+
+struct linux_cpu_fixture
+{
+    explicit linux_cpu_fixture(boost::filesystem::path const& sys_dir, int id, std::string const& model_name);
+
+    void set_logical_id(std::string const& logical_id);
+    virtual void set_physical_id(std::string const& physical_id);
+    virtual void set_speed(int64_t speed);
+    void set_info(std::string const& key, std::string const& value);
+    void erase_info(std::string const& key);
+    void erase_all_info();
+    std::string get_info();
+
+protected:
+    virtual void init_info(std::string const& model_name);
+
+    std::map<std::string, std::string, std::function<bool(std::string const&, std::string const&)>> _info;
+
+    boost::filesystem::path _cpuroot;
+    boost::filesystem::path _topology;
+    boost::filesystem::path _cpufreq;
+};
+
+struct linux_power_cpu_fixture : linux_cpu_fixture
+{
+    explicit linux_power_cpu_fixture(boost::filesystem::path const& sys_dir, int id, std::string const& model_name);
+
+    virtual void set_physical_id(std::string const& physical_id) override;
+    virtual void set_speed(int64_t speed) override;
+
+protected:
+    virtual void init_info(std::string const& model_name) override;
+};
+
+struct test_linux_processor_resolver : facter::facts::linux::processor_resolver
+{
+    using facter::facts::linux::processor_resolver::ArchitectureType;
+    struct test_linux_data : facter::facts::resolvers::processor_resolver::data {};
+    test_linux_data collect_cpu_data(std::string const& root);
+    ArchitectureType architecture_type(test_linux_data const& data, std::string const& root);
+};
+
+struct linux_processor_fixture
+{
+    explicit linux_processor_fixture(std::string const& root, test_linux_processor_resolver::ArchitectureType arch_type);
+    ~linux_processor_fixture();
+    int add_cpu(std::string const& model_name);
+    linux_cpu_fixture& get_cpu(int id);
+    void write_cpuinfo();
+    void add_to_sys_dir(std::string const& dir_name);
+    void clear_sys_dir();
+    void reset(test_linux_processor_resolver::ArchitectureType arch_type = test_linux_processor_resolver::ArchitectureType::X86);
+
+private:
+    std::vector<std::unique_ptr<linux_cpu_fixture>> _cpus;
+    std::function<linux_cpu_fixture*(boost::filesystem::path const&, int, std::string const&)> make_cpu;  
+    int _next_id;
+
+    boost::filesystem::path _root;
+    boost::filesystem::path _proc;
+    boost::filesystem::path _sys;
+};
+
+// a cpu is defined as (Model name, Logical id, Physical id, (Optional) Speed)
+std::vector<int> setup_linux_processor_fixture(linux_processor_fixture& fixture, std::vector<std::tuple<std::string, std::string, std::string, boost::optional<int64_t>>> const& cpu_params);

data/ext/facter/facter/lib/tests/facts/linux/processor_resolver.cc

@@ -0,0 +1,312 @@
+#include <catch.hpp>
+#include <internal/facts/linux/filesystem_resolver.hpp>
+#include <boost/filesystem.hpp>
+#include <array>
+#include "processor_fixture.hpp"
+
+using namespace std;
+using namespace facter::facts::linux;
+using cpu_param = tuple<string, string, string, boost::optional<int64_t>>;
+using architecture_type = test_linux_processor_resolver::ArchitectureType;
+using test_data = test_linux_processor_resolver::test_linux_data;
+namespace fs = boost::filesystem;
+
+SCENARIO("determing the architecture of a linux machine") {
+    test_linux_processor_resolver resolver;
+    GIVEN("that the isa fact was successfully calculated") {
+        WHEN("it starts with ppc64") {
+            THEN("POWER is returned for the machine's architecture") {
+                test_data data;
+                array<string, 3> inputs{{"ppc64", "ppc64el", "ppc64le"}};
+                for (auto& input : inputs) {
+                    data.isa = input;
+                    REQUIRE(resolver.architecture_type(data, "non-existent-root") == architecture_type::POWER);
+                }
+            }
+        }
+        WHEN("it does not start with ppc64") {
+            THEN("X86 is returned for the machine's architecture") {
+                test_data data;
+                array<string, 3> inputs{{"x86_64", "i386", "amd64"}};
+                for (auto& input : inputs) {
+                    data.isa = input;
+                    REQUIRE(resolver.architecture_type(data, "non-existent-root") == architecture_type::X86);
+                }
+            }
+        }
+    }
+    GIVEN("that the isa fact was not successfully calculated") {
+        string root_dir = fs::unique_path("temp_processor_resolver_root%%%%-%%%%-%%%%-%%%%").string();
+        linux_processor_fixture fixture(root_dir, architecture_type::X86);
+        WHEN("the /proc/cpuinfo file has the x86 structure") {
+            THEN("X86 is returned for the machine's architecture") {
+                fixture.reset();
+                vector<cpu_param> cpu_params({
+                    make_tuple("Model A", "0", "0", 10),
+                    make_tuple("Model B", "1", "1", 15),
+                });
+                setup_linux_processor_fixture(fixture, cpu_params);
+                fixture.write_cpuinfo();
+
+                test_data data;
+                REQUIRE(resolver.architecture_type(data, "non-existent-root") == architecture_type::X86);
+            }
+        }
+        WHEN("the proc/cpu/info file almost has the power structure") {
+            THEN("X86 is returned for the machine's architecture") {
+                fixture.reset(architecture_type::POWER);
+                vector<cpu_param> cpu_params({
+                    make_tuple("Model A", "0", "0", 10),
+                    make_tuple("Model B", "1", "1", 15),
+                    make_tuple("Model C", "2", "2", 15),
+                    make_tuple("Model D", "3", "3", 15)
+                });
+
+                vector<int> ids = setup_linux_processor_fixture(fixture, cpu_params);
+                fixture.get_cpu(ids[0]).erase_info("processor");
+                fixture.get_cpu(ids[1]).erase_info("cpu");
+                fixture.get_cpu(ids[2]).erase_info("clock");
+                fixture.get_cpu(ids[3]).erase_info("revision");
+                fixture.write_cpuinfo();
+
+                test_data data;
+                REQUIRE(resolver.architecture_type(data, root_dir) == architecture_type::X86);
+            }
+        }
+        WHEN("the proc/cpu/info file has the power structure") {
+            THEN("POWER is returned for the machine's architecture") {
+                fixture.reset(architecture_type::POWER);
+                vector<cpu_param> cpu_params({
+                    make_tuple("Model A", "0", "0", 10),
+                    make_tuple("Model B", "1", "1", 15),
+                    make_tuple("Model C", "2", "2", 15),
+                    make_tuple("Model D", "3", "3", 15)
+                });
+                vector<int> ids = setup_linux_processor_fixture(fixture, cpu_params);
+                fixture.write_cpuinfo();
+
+                test_data data;
+                REQUIRE(resolver.architecture_type(data, root_dir) == architecture_type::POWER);
+            }
+        }
+    }
+}
+
+SCENARIO("resolving processor-specific facts for linux machines") {
+    string root_dir = fs::unique_path("temp_processor_resolver_root%%%%-%%%%-%%%%-%%%%").string();
+    linux_processor_fixture fixture(root_dir, architecture_type::X86);
+    test_linux_processor_resolver resolver;
+
+    GIVEN("an x86 architecture") {
+        WHEN("/sys/devices/system/cpu contains cpu information and /sys/devices/system/cpu/cpu0/cpufreq/cpuinfo_max_freq exists") {
+            THEN("the processor facts are correctly resolved, and the speed is set to cpu0's speed") {
+                fixture.reset();
+    
+                // here, speed is in KHz
+                vector<cpu_param> cpu_params({
+                    make_tuple("Model A", "0", "0", 10),
+                    // ensure that duplicate CPUs are not counted twice in the
+                    // physical count
+                    make_tuple("Model B", "1", "0", 15),
+                    make_tuple("Model C", "2", "1", 20),
+                    // ensure that some arbitrary string is also recognized as a valid physical cpu
+                    make_tuple("Model D", "3", "some physical id", 35), 
+                    // ensure that empty CPU ids are recognized as a valid physical cpu
+                    make_tuple("Model E", "4", "", 35) 
+                });
+                setup_linux_processor_fixture(fixture, cpu_params);
+                fixture.write_cpuinfo();
+                auto result = resolver.collect_cpu_data(root_dir);
+
+                REQUIRE(result.logical_count == 5);
+                REQUIRE(result.physical_count == 4);
+
+                array<string, 5> EXPECTED_MODELS{{"Model A", "Model B", "Model C", "Model D", "Model E"}};
+                REQUIRE(result.models.size() == EXPECTED_MODELS.size());
+                for (size_t i = 0; i < result.models.size(); ++i) {
+                    REQUIRE(result.models[i] == EXPECTED_MODELS[i]);
+                }
+    
+                REQUIRE(result.speed == 10000);
+            }
+        }
+    
+        WHEN("/sys/devices/system/cpu contains cpu information and /sys/devices/system/cpu/cpu0/cpufreq/cpuinfo_max_freq does not exist") {
+            THEN("the processor facts are correctly resolved, but the speed is not calculated") {
+                fixture.reset();
+                // here, speed is in KHz
+                vector<cpu_param> cpu_params({
+                    make_tuple("Model A", "0", "0", boost::optional<int64_t>()),
+                    // ensure that duplicate CPUs are not counted twice in the
+                    // physical count
+                    make_tuple("Model B", "1", "0", 15),
+                    make_tuple("Model C", "2", "1", 20),
+                    // ensure that some arbitrary string is also recognized as a valid physical cpu
+                    make_tuple("Model D", "3", "some physical id", 35), 
+                    // ensure that empty CPU ids are recognized as a valid physical cpu
+                    make_tuple("Model E", "4", "", 35) 
+                });
+
+                setup_linux_processor_fixture(fixture, cpu_params);
+                fixture.write_cpuinfo();
+                auto result = resolver.collect_cpu_data(root_dir);
+
+                REQUIRE(result.logical_count == 5);
+                REQUIRE(result.physical_count == 4);
+
+                array<string, 5> EXPECTED_MODELS{{"Model A", "Model B", "Model C", "Model D", "Model E"}};
+                REQUIRE(result.models.size() == EXPECTED_MODELS.size());
+                for (size_t i = 0; i < result.models.size(); ++i) {
+                    REQUIRE(result.models[i] == EXPECTED_MODELS[i]);
+                }
+
+                REQUIRE(result.speed == 0);
+            }
+        }
+    
+        WHEN("/sys/devices/system/cpu does not contain cpu information") {
+            THEN("the processor facts are correctly resolved, with the logical and physical counts are obtained from /proc/cpuinfo") {
+                fixture.reset();
+    
+                // here, speed is in KHz
+                vector<cpu_param> cpu_params({
+                    make_tuple("Model A", "0", "0", boost::optional<int64_t>()),
+                    // ensure that duplicate CPUs are not counted twice in the
+                    // physical count
+                    make_tuple("Model B", "1", "0", 15),
+                    make_tuple("Model C", "2", "1", 20),
+                    make_tuple("Model D", "3", "2", 35), 
+                    // ensure that a CPU with an empty logical ID's model name
+                    // is not collected
+                    make_tuple("Model E", "", "3", 35) 
+                });
+                setup_linux_processor_fixture(fixture, cpu_params);
+                fixture.write_cpuinfo();
+                fixture.clear_sys_dir();
+
+                // for this test, we want to ensure that the processor facts are obtained from
+                // /proc/cpuinfo only.
+                REQUIRE(fs::is_empty(fs::path(root_dir) / "sys" / "devices" / "system" / "cpu"));
+                auto result = resolver.collect_cpu_data(root_dir);
+
+                REQUIRE(result.logical_count == 5);
+                REQUIRE(result.physical_count == 4);
+
+                array<string, 4> EXPECTED_MODELS{{"Model A", "Model B", "Model C", "Model D"}};
+                REQUIRE(result.models.size() == EXPECTED_MODELS.size());
+                for (size_t i = 0; i < result.models.size(); ++i) {
+                    REQUIRE(result.models[i] == EXPECTED_MODELS[i]);
+                }
+
+                REQUIRE(result.speed == 0);
+            }
+        }
+    }
+    GIVEN("a power architecture") {
+        WHEN("/sys/devices/system/cpu contains cpu information and /sys/devices/system/cpu/cpu0/cpufreq/cpuinfo_max_freq exists") {
+            THEN("the processor facts are correctly resolved, with the speed being read from the 'clock' entry") {
+                fixture.reset(architecture_type::POWER);
+
+                // here, speed is in KHz
+                vector<cpu_param> cpu_params({
+                    // ensure that speed is read from the "clock" entry
+                    make_tuple("Model A", "0", "0", boost::optional<int64_t>()),
+                    // ensure that duplicate CPUs are not counted twice in the
+                    // physical count
+                    make_tuple("Model B", "1", "0", 15),
+                    make_tuple("Model C", "2", "1", 20),
+                    // ensure that some arbitrary string is also recognized as a valid physical cpu
+                    make_tuple("Model D", "3", "some physical id", 35), 
+                    // ensure that empty CPU ids are recognized as a valid physical cpu
+                    make_tuple("Model E", "4", "", 35),
+                    // ensure that negative ids are not included in the physical count
+                    // this entry simulates an invalid power cpu
+                    make_tuple("Invalid CPU", "5", "-1", 35),
+                });
+                vector<int> ids = setup_linux_processor_fixture(fixture, cpu_params);
+                fixture.get_cpu(ids.back()).erase_all_info();
+                fixture.write_cpuinfo();
+                auto result = resolver.collect_cpu_data(root_dir);
+
+                REQUIRE(result.logical_count == 5);
+                REQUIRE(result.physical_count == 4);
+
+                array<string, 5> EXPECTED_MODELS{{"Model A", "Model B", "Model C", "Model D", "Model E"}};
+                REQUIRE(result.models.size() == EXPECTED_MODELS.size());
+                for (size_t i = 0; i < result.models.size(); ++i) {
+                    REQUIRE(result.models[i] == EXPECTED_MODELS[i]);
+                }
+
+                REQUIRE(result.speed == 15000);
+            }
+        }
+
+        WHEN("/sys/devices/system/cpu contains cpu information but cpu0 is invalid") {
+            THEN("the processor facts are correctly resolved, but the speed is not calculated") {
+                fixture.reset(architecture_type::POWER);
+    
+                // here, speed is in KHz
+                vector<cpu_param> cpu_params({
+                    make_tuple("Model A", "0", "-1", 15),
+                    make_tuple("Model B", "0", "-1", -1)
+                });
+                vector<int> ids = setup_linux_processor_fixture(fixture, cpu_params);
+                fixture.get_cpu(ids.front()).erase_all_info();
+                fixture.write_cpuinfo();
+
+                auto result = resolver.collect_cpu_data(root_dir);
+
+                REQUIRE(result.logical_count == 1);
+                // /proc/cpuinfo does not have any "physical_id" entries for power architectures
+                REQUIRE(result.physical_count == 0);
+
+                array<string, 1> EXPECTED_MODELS{{"Model B"}};
+                REQUIRE(result.models.size() == EXPECTED_MODELS.size());
+                for (size_t i = 0; i < result.models.size(); ++i) {
+                  REQUIRE(result.models[i] == EXPECTED_MODELS[i]);
+                }
+
+                REQUIRE(result.speed == 0);
+            }
+        }
+    
+        WHEN("/sys/devices/system/cpu does not contain cpu information") {
+            THEN("the processor facts are correctly resolved, with the speed being read from the 'clock' entry, but the physical count is not computed") {
+                fixture.reset(architecture_type::POWER);
+    
+                // here, speed is in KHz
+                vector<cpu_param> cpu_params({
+                    make_tuple("Model A", "0", "0", boost::optional<int64_t>()),
+                    // ensure that duplicate CPUs are not counted twice in the
+                    // physical count
+                    make_tuple("Model B", "1", "0", 15),
+                    make_tuple("Model C", "2", "1", 20),
+                    make_tuple("Model D", "3", "2", 35), 
+                    // ensure that a CPU with an empty logical ID's model name
+                    // is not collected
+                    make_tuple("Model E", "", "3", 35)
+                });
+                setup_linux_processor_fixture(fixture, cpu_params);
+                fixture.write_cpuinfo();
+                fixture.clear_sys_dir();
+
+                // for this test, we want to ensure that the processor facts are obtained from
+                // /proc/cpuinfo only.
+                REQUIRE(fs::is_empty(fs::path(root_dir) / "sys" / "devices" / "system" / "cpu"));
+                auto result = resolver.collect_cpu_data(root_dir);
+
+                REQUIRE(result.logical_count == 5);
+                // /proc/cpuinfo does not have any "physical_id" entries for power architectures
+                REQUIRE(result.physical_count == 0);
+
+                array<string, 4> EXPECTED_MODELS{{"Model A", "Model B", "Model C", "Model D"}};
+                REQUIRE(result.models.size() == EXPECTED_MODELS.size());
+                for (size_t i = 0; i < result.models.size(); ++i) {
+                    REQUIRE(result.models[i] == EXPECTED_MODELS[i]);
+                }
+
+                REQUIRE(result.speed == 15000);
+            }
+        }
+    }
+}

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

@@ -0,0 +1,48 @@
+#include <catch.hpp>
+#include <facter/util/string.hpp>
+#include <internal/facts/linux/virtualization_resolver.hpp>
+#include "../../fixtures.hpp"
+#include <iostream>
+
+using namespace std;
+using namespace facter::util;
+using namespace facter::facts;
+using namespace facter::facts::resolvers;
+using namespace facter::testing;
+
+struct peek_resolver : linux::virtualization_resolver
+{
+    using virtualization_resolver::get_azure;
+};
+
+SCENARIO("azure") {
+    collection_fixture facts;
+
+    WHEN("leases file does not exist") {
+        auto result = peek_resolver::get_azure(facts, "does-not-exist");
+        THEN("azure is empty") {
+            REQUIRE(result == "");
+        }
+    }
+
+    WHEN("leases file contains 'option 245'") {
+        auto result = peek_resolver::get_azure(facts, string(LIBFACTER_TESTS_DIRECTORY) + "/fixtures/facts/linux/cloud/azure");
+        THEN("it reports azure") {
+            REQUIRE(result == "azure");
+        }
+    }
+
+    WHEN("leases file contains 'option unknown-245'") {
+        auto result = peek_resolver::get_azure(facts, string(LIBFACTER_TESTS_DIRECTORY) + "/fixtures/facts/linux/cloud/azure-unknown");
+        THEN("it reports azure") {
+            REQUIRE(result == "azure");
+        }
+    }
+
+    WHEN("leases file does not contain correct option") {
+        auto result = peek_resolver::get_azure(facts, string(LIBFACTER_TESTS_DIRECTORY) + "/fixtures/facts/linux/cloud/not-azure");
+        THEN("it does not report azure") {
+            REQUIRE(result == "");
+        }
+    }
+}

data/ext/facter/facter/lib/tests/facts/map_value.cc

@@ -0,0 +1,116 @@
+#include <catch.hpp>
+#include <facter/facts/map_value.hpp>
+#include <facter/facts/array_value.hpp>
+#include <facter/facts/scalar_value.hpp>
+#include <rapidjson/document.h>
+#include <yaml-cpp/yaml.h>
+#include <sstream>
+
+using namespace std;
+using namespace facter::facts;
+using namespace rapidjson;
+using namespace YAML;
+
+SCENARIO("using a map fact value") {
+    map_value value;
+    REQUIRE(value.empty());
+    GIVEN("a null value to add") {
+        value.add("key", nullptr);
+        THEN("it should still be empty") {
+            REQUIRE(value.empty());
+        }
+    }
+    GIVEN("elements to insert") {
+        value.add("string", make_value<string_value>("hello"));
+        value.add("integer", make_value<integer_value>(5));
+        auto array_element = make_value<array_value>();
+        array_element->add(make_value<string_value>("1"));
+        array_element->add(make_value<integer_value>(2));
+        value.add("array", move(array_element));
+        auto map_element = make_value<map_value>();
+        map_element->add("foo", make_value<string_value>("bar"));
+        value.add("map", move(map_element));
+
+        THEN("it should contain the elements that were added") {
+            REQUIRE(value.size() == 4u);
+            auto str = value.get<string_value>("string");
+            REQUIRE(str);
+            REQUIRE(str->value() == "hello");
+
+            auto integer = value.get<integer_value>("integer");
+            REQUIRE(integer);
+            REQUIRE(integer->value() == 5);
+
+            auto array = value.get<array_value>("array");
+            REQUIRE(array);
+            REQUIRE(array->size() == 2u);
+            str = array->get<string_value>(0);
+            REQUIRE(str);
+            REQUIRE(str->value() == "1");
+            integer = array->get<integer_value>(1);
+            REQUIRE(integer);
+            REQUIRE(integer->value() == 2);
+
+            auto mapval = value.get<map_value>("map");
+            REQUIRE(mapval);
+            REQUIRE(mapval->size() == 1u);
+            str = mapval->get<string_value>("foo");
+            REQUIRE(str);
+            REQUIRE(str->value() == "bar");
+        }
+        THEN("elements should be in sort order") {
+            int index = 0;
+            value.each([&](string const& name, struct value const* val) {
+                if (index == 0) {
+                    REQUIRE(name == "array");
+                } else if (index == 1) {
+                    REQUIRE(name == "integer");
+                } else if (index == 2) {
+                    REQUIRE(name == "map");
+                } else if (index == 3) {
+                    REQUIRE(name == "string");
+                } else {
+                    FAIL("should not be reached");
+                    return false;
+                }
+                ++index;
+                return true;
+            });
+        }
+        WHEN("serialized to JSON") {
+            THEN("it should contain the same values") {
+                json_value json;
+                json_allocator allocator;
+                value.to_json(allocator, json);
+                REQUIRE(json.IsObject());
+                REQUIRE(json["string"].IsString());
+                REQUIRE(string(json["string"].GetString()) == "hello");
+                REQUIRE(json["integer"].IsNumber());
+                REQUIRE(json["integer"].GetInt64() == 5);
+                REQUIRE(json["array"].IsArray());
+                REQUIRE(json["array"].Size() == 2);
+                REQUIRE(json["array"][0u].IsString());
+                REQUIRE(string(json["array"][0u].GetString()) == "1");
+                REQUIRE(json["array"][1u].IsNumber());
+                REQUIRE(json["array"][1u].GetInt64() == 2);
+                REQUIRE(json["map"].IsObject());
+                REQUIRE(json["map"]["foo"].IsString());
+                REQUIRE(string(json["map"]["foo"].GetString()) == "bar");
+            }
+        }
+        WHEN("serialized to text") {
+            THEN("it should contain the same values") {
+                ostringstream stream;
+                value.write(stream);
+                REQUIRE(stream.str() == "{\n  array => [\n    \"1\",\n    2\n  ],\n  integer => 5,\n  map => {\n    foo => \"bar\"\n  },\n  string => \"hello\"\n}");
+            }
+        }
+        WHEN("serialized to text") {
+            THEN("it should contain the same values") {
+                Emitter emitter;
+                value.write(emitter);
+                REQUIRE(string(emitter.c_str()) == "array:\n  - \"1\"\n  - 2\ninteger: 5\nmap:\n  foo: bar\nstring: hello");
+            }
+        }
+    }
+}