cfacter 3.11.0.rc.20180314

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

@@ -0,0 +1,247 @@
+#include <catch.hpp>
+#include <internal/facts/resolvers/operating_system_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_os_resolver : operating_system_resolver
+{
+ protected:
+    virtual data collect_data(collection& facts) override
+    {
+        return {};
+    }
+};
+
+struct test_os_resolver : operating_system_resolver
+{
+ protected:
+    virtual data collect_data(collection& facts) override
+    {
+        data result;
+        result.name = "Archlinux";
+        result.family = "Archlinux";
+        result.release = "1.2.3";
+        result.specification_version = "1.4";
+        result.distro.id = "Arch";
+        result.distro.release = "1.2.3";
+        result.distro.codename = "awesomesauce";
+        result.distro.description = "best distro ever";
+        result.osx.product = "Mac OS X";
+        result.osx.build = "14A388b";
+        result.osx.version = "10.10";
+        result.win.system32 = "C:\\WINDOWS\\sysnative";
+        result.architecture = "amd64";
+        result.hardware = "x86-64";
+        result.selinux.supported = true;
+        result.selinux.enabled = true;
+        result.selinux.enforced = true;
+        result.selinux.current_mode = "current mode";
+        result.selinux.config_mode = "config mode";
+        result.selinux.config_policy = "config policy";
+        result.selinux.policy_version = "policy version";
+        return result;
+    }
+};
+
+SCENARIO("using the operating system resolver") {
+    collection_fixture facts;
+    WHEN("data is not present") {
+        facts.add(make_shared<empty_os_resolver>());
+        THEN("facts should not be added") {
+            REQUIRE(facts.size() == 0u);
+        }
+    }
+    WHEN("data is present") {
+        facts.add(make_shared<test_os_resolver>());
+        REQUIRE(facts.size() == 26u);
+        THEN("a structured fact is added") {
+            auto os = facts.get<map_value>(fact::os);
+            REQUIRE(os);
+            REQUIRE(os->size() == 9u);
+            auto distro = os->get<map_value>("distro");
+            REQUIRE(distro);
+            REQUIRE(distro->size() == 5u);
+            auto codename = distro->get<string_value>("codename");
+            REQUIRE(codename);
+            REQUIRE(codename->value() == "awesomesauce");
+            auto description = distro->get<string_value>("description");
+            REQUIRE(description);
+            REQUIRE(description->value() == "best distro ever");
+            auto id = distro->get<string_value>("id");
+            REQUIRE(description);
+            REQUIRE(id->value() == "Arch");
+            auto lsbrelease = distro->get<string_value>("specification");
+            REQUIRE(lsbrelease);
+            REQUIRE(lsbrelease->value() == "1.4");
+            auto release_attribute = distro->get<map_value>("release");
+            REQUIRE(release_attribute);
+            REQUIRE(release_attribute->size() == 3u);
+            auto release = release_attribute->get<string_value>("full");
+            REQUIRE(release);
+            REQUIRE(release->value() == "1.2.3");
+            auto major = release_attribute->get<string_value>("major");
+            REQUIRE(major);
+            REQUIRE(major->value() == "1");
+            auto minor = release_attribute->get<string_value>("minor");
+            REQUIRE(minor);
+            REQUIRE(minor->value() == "2");
+            auto family = os->get<string_value>("family");
+            REQUIRE(family);
+            REQUIRE(family->value() == "Archlinux");
+            auto name = os->get<string_value>("name");
+            REQUIRE(name);
+            REQUIRE(name->value() == "Archlinux");
+            auto architecture = os->get<string_value>("architecture");
+            REQUIRE(architecture);
+            REQUIRE(architecture->value() == "amd64");
+            auto hardware = os->get<string_value>("hardware");
+            REQUIRE(hardware);
+            REQUIRE(hardware->value() == "x86-64");
+            release_attribute = os->get<map_value>("release");
+            REQUIRE(release_attribute);
+            REQUIRE(release_attribute->size() == 3u);
+            release = release_attribute->get<string_value>("full");
+            REQUIRE(release);
+            REQUIRE(release->value() == "1.2.3");
+            major = release_attribute->get<string_value>("major");
+            REQUIRE(major);
+            REQUIRE(major->value() == "1");
+            minor = release_attribute->get<string_value>("minor");
+            REQUIRE(minor);
+            REQUIRE(minor->value() == "2");
+            auto macosx = os->get<map_value>("macosx");
+            REQUIRE(macosx);
+            REQUIRE(macosx->size() == 3u);
+            auto product = macosx->get<string_value>("product");
+            REQUIRE(product);
+            REQUIRE(product->value() == "Mac OS X");
+            auto build = macosx->get<string_value>("build");
+            REQUIRE(build);
+            REQUIRE(build->value() == "14A388b");
+            release_attribute = macosx->get<map_value>("version");
+            REQUIRE(release_attribute);
+            REQUIRE(release_attribute->size() == 3u);
+            release = release_attribute->get<string_value>("full");
+            REQUIRE(release);
+            REQUIRE(release->value() == "10.10");
+            major = release_attribute->get<string_value>("major");
+            REQUIRE(major);
+            REQUIRE(major->value() == "10.10");
+            minor = release_attribute->get<string_value>("minor");
+            REQUIRE(minor);
+            REQUIRE(minor->value() == "0");
+            auto windows = os->get<map_value>("windows");
+            REQUIRE(windows);
+            REQUIRE(windows->size() == 1u);
+            auto system32 = windows->get<string_value>("system32");
+            REQUIRE(system32);
+            REQUIRE(system32->value() == "C:\\WINDOWS\\sysnative");
+            auto selinux = os->get<map_value>("selinux");
+            REQUIRE(selinux);
+            REQUIRE(selinux->size() == 6u);
+            auto bval = selinux->get<boolean_value>("enabled");
+            REQUIRE(bval);
+            REQUIRE(bval->value());
+            bval = selinux->get<boolean_value>("enforced");
+            REQUIRE(bval);
+            REQUIRE(bval->value());
+            auto sval = selinux->get<string_value>("policy_version");
+            REQUIRE(sval);
+            REQUIRE(sval->value() == "policy version");
+            sval = selinux->get<string_value>("current_mode");
+            REQUIRE(sval);
+            REQUIRE(sval->value() == "current mode");
+            sval = selinux->get<string_value>("config_mode");
+            REQUIRE(sval);
+            REQUIRE(sval->value() == "config mode");
+            sval = selinux->get<string_value>("config_policy");
+            REQUIRE(sval);
+            REQUIRE(sval->value() == "config policy");
+        }
+        THEN("flat facts are added") {
+            auto name = facts.get<string_value>(fact::operating_system);
+            REQUIRE(name);
+            REQUIRE(name->value() == "Archlinux");
+            auto architecture = facts.get<string_value>(fact::architecture);
+            REQUIRE(architecture);
+            REQUIRE(architecture->value() == "amd64");
+            auto hardware = facts.get<string_value>(fact::hardware_model);
+            REQUIRE(hardware);
+            REQUIRE(hardware->value() == "x86-64");
+            auto release = facts.get<string_value>(fact::operating_system_release);
+            REQUIRE(release);
+            REQUIRE(release->value() == "1.2.3");
+            auto major = facts.get<string_value>(fact::operating_system_major_release);
+            REQUIRE(major);
+            REQUIRE(major->value() == "1");
+            auto family = facts.get<string_value>(fact::os_family);
+            REQUIRE(family);
+            REQUIRE(family->value() == "Archlinux");
+            auto codename = facts.get<string_value>(fact::lsb_dist_codename);
+            REQUIRE(codename);
+            REQUIRE(codename->value() == "awesomesauce");
+            auto description = facts.get<string_value>(fact::lsb_dist_description);
+            REQUIRE(description);
+            REQUIRE(description->value() == "best distro ever");
+            auto id = facts.get<string_value>(fact::lsb_dist_id);
+            REQUIRE(id);
+            REQUIRE(id->value() == "Arch");
+            release = facts.get<string_value>(fact::lsb_dist_release);
+            REQUIRE(release);
+            REQUIRE(release->value() == "1.2.3");
+            major = facts.get<string_value>(fact::lsb_dist_major_release);
+            REQUIRE(major);
+            REQUIRE(major->value() == "1");
+            auto minor = facts.get<string_value>(fact::lsb_dist_minor_release);
+            REQUIRE(minor);
+            REQUIRE(minor->value() == "2");
+            auto lsbrelease = facts.get<string_value>(fact::lsb_release);
+            REQUIRE(lsbrelease);
+            REQUIRE(lsbrelease->value() == "1.4");
+            auto build = facts.get<string_value>(fact::macosx_buildversion);
+            REQUIRE(build);
+            REQUIRE(build->value() == "14A388b");
+            auto product = facts.get<string_value>(fact::macosx_productname);
+            REQUIRE(product);
+            REQUIRE(product->value() == "Mac OS X");
+            release = facts.get<string_value>(fact::macosx_productversion);
+            REQUIRE(release);
+            REQUIRE(release->value() == "10.10");
+            major = facts.get<string_value>(fact::macosx_productversion_major);
+            REQUIRE(major);
+            REQUIRE(major->value() == "10.10");
+            minor = facts.get<string_value>(fact::macosx_productversion_minor);
+            REQUIRE(minor);
+            REQUIRE(minor->value() == "0");
+            auto system32 = facts.get<string_value>(fact::windows_system32);
+            REQUIRE(system32);
+            REQUIRE(system32->value() == "C:\\WINDOWS\\sysnative");
+            auto bval = facts.get<boolean_value>(fact::selinux);
+            REQUIRE(bval);
+            REQUIRE(bval->value());
+            bval = facts.get<boolean_value>(fact::selinux_enforced);
+            REQUIRE(bval);
+            REQUIRE(bval->value());
+            auto sval = facts.get<string_value>(fact::selinux_policyversion);
+            REQUIRE(sval);
+            REQUIRE(sval->value() == "policy version");
+            sval = facts.get<string_value>(fact::selinux_current_mode);
+            REQUIRE(sval);
+            REQUIRE(sval->value() == "current mode");
+            sval = facts.get<string_value>(fact::selinux_config_mode);
+            REQUIRE(sval);
+            REQUIRE(sval->value() == "config mode");
+            sval = facts.get<string_value>(fact::selinux_config_policy);
+            REQUIRE(sval);
+            REQUIRE(sval->value() == "config policy");
+        }
+    }
+}

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

@@ -0,0 +1,157 @@
+#include <catch.hpp>
+#include <internal/facts/resolvers/processor_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 <facter/facts/array_value.hpp>
+#include "../../collection_fixture.hpp"
+
+using namespace std;
+using namespace facter::facts;
+using namespace facter::facts::resolvers;
+using namespace facter::testing;
+
+struct empty_processor_resolver : processor_resolver
+{
+ protected:
+    virtual data collect_data(collection& facts) override
+    {
+        return {};
+    }
+};
+
+struct test_processor_resolver : processor_resolver
+{
+ protected:
+    virtual data collect_data(collection& facts) override
+    {
+        data result;
+        result.isa = "isa";
+        result.logical_count = 4;
+        result.physical_count = 2;
+        result.models = {
+            "processor1",
+            "processor2",
+            "processor3",
+            "processor4"
+        };
+        result.speed = 10 * 1000 * 1000 * 1000ull;
+        return result;
+    }
+};
+
+struct test_processor_resolver_no_physical_count : processor_resolver
+{
+ protected:
+    virtual data collect_data(collection& facts) override
+    {
+        data result;
+        result.isa = "isa";
+        result.logical_count = 4;
+        result.models = {
+            "processor1",
+            "processor2",
+            "processor3",
+            "processor4"
+        };
+        result.speed = 10 * 1000 * 1000 * 1000ull;
+        return result;
+    }
+};
+
+SCENARIO("using the processor resolver") {
+    collection_fixture facts;
+    WHEN("data is not present") {
+        facts.add(make_shared<empty_processor_resolver>());
+        THEN("facts should not be added") {
+            REQUIRE(facts.size() == 0u);
+        }
+    }
+    WHEN("typical data is present") {
+        facts.add(make_shared<test_processor_resolver>());
+        THEN("a structured fact is added") {
+            REQUIRE(facts.size() == 8u);
+            auto processors = facts.get<map_value>(fact::processors);
+            REQUIRE(processors);
+            REQUIRE(processors->size() == 5u);
+            auto count = processors->get<integer_value>("count");
+            REQUIRE(count);
+            REQUIRE(count->value() == 4);
+            count = processors->get<integer_value>("physicalcount");
+            REQUIRE(count);
+            REQUIRE(count->value() == 2);
+            auto isa = processors->get<string_value>("isa");
+            REQUIRE(isa);
+            REQUIRE(isa->value() == "isa");
+            auto models = processors->get<array_value>("models");
+            REQUIRE(models);
+            REQUIRE(models->size() == 4u);
+            for (size_t i = 0; i < 4; ++i) {
+                auto model = models->get<string_value>(i);
+                REQUIRE(model);
+                REQUIRE(model->value() == "processor" + to_string(i + 1));
+            }
+            auto speed = processors->get<string_value>("speed");
+            REQUIRE(speed);
+            REQUIRE(speed->value() == "10.00 GHz");
+        }
+        THEN("flat facts are added") {
+            REQUIRE(facts.size() == 8u);
+            auto count = facts.get<integer_value>(fact::physical_processor_count);
+            REQUIRE(count);
+            REQUIRE(count->value() == 2);
+            count = facts.get<integer_value>(fact::processor_count);
+            REQUIRE(count);
+            REQUIRE(count->value() == 4);
+            auto isa = facts.get<string_value>(fact::hardware_isa);
+            REQUIRE(isa);
+            REQUIRE(isa->value() == "isa");
+            for (size_t i = 0; i < 4; ++i) {
+                auto model = facts.get<string_value>(fact::processor + to_string(i));
+                REQUIRE(model);
+                REQUIRE(model->value() == "processor" + to_string(i + 1));
+            }
+        }
+    }
+    WHEN("data is present with no physical count") {
+        facts.add(make_shared<test_processor_resolver_no_physical_count>());
+        THEN("a structured fact is added, not including physical_processor_count") {
+            REQUIRE(facts.size() == 7u);
+            auto processors = facts.get<map_value>(fact::processors);
+            REQUIRE(processors);
+            REQUIRE(processors->size() == 4u);
+            auto count = processors->get<integer_value>("count");
+            REQUIRE(count);
+            REQUIRE(count->value() == 4);
+            auto isa = processors->get<string_value>("isa");
+            REQUIRE(isa);
+            REQUIRE(isa->value() == "isa");
+            auto models = processors->get<array_value>("models");
+            REQUIRE(models);
+            REQUIRE(models->size() == 4u);
+            for (size_t i = 0; i < 4; ++i) {
+                auto model = models->get<string_value>(i);
+                REQUIRE(model);
+                REQUIRE(model->value() == "processor" + to_string(i + 1));
+            }
+            auto speed = processors->get<string_value>("speed");
+            REQUIRE(speed);
+            REQUIRE(speed->value() == "10.00 GHz");
+        }
+        THEN("standard flat facts are added, not including physical_processor_count") {
+            REQUIRE(facts.size() == 7u);
+            auto count = facts.get<integer_value>(fact::processor_count);
+            REQUIRE(count);
+            REQUIRE(count->value() == 4);
+            auto isa = facts.get<string_value>(fact::hardware_isa);
+            REQUIRE(isa);
+            REQUIRE(isa->value() == "isa");
+            for (size_t i = 0; i < 4; ++i) {
+                auto model = facts.get<string_value>(fact::processor + to_string(i));
+                REQUIRE(model);
+                REQUIRE(model->value() == "processor" + to_string(i + 1));
+            }
+        }
+    }
+}

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

@@ -0,0 +1,74 @@
+#include <catch.hpp>
+#include <internal/facts/resolvers/ruby_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_ruby_resolver : ruby_resolver
+{
+ protected:
+    virtual data collect_data(collection& facts) override
+    {
+        return {};
+    }
+};
+
+struct test_ruby_resolver : ruby_resolver
+{
+ protected:
+    virtual data collect_data(collection& facts) override
+    {
+        data result;
+        result.platform = "i386-mingw32";
+        result.sitedir = "C:/Ruby21/lib/ruby/site_ruby/2.1.0";
+        result.version = "2.1.4";
+        return result;
+    }
+};
+
+SCENARIO("using the ruby resolver") {
+    collection_fixture facts;
+    WHEN("data is not present") {
+        facts.add(make_shared<empty_ruby_resolver>());
+        THEN("facts should not be added") {
+            REQUIRE(facts.size() == 0u);
+        }
+    }
+    WHEN("data is present") {
+        facts.add(make_shared<test_ruby_resolver>());
+        THEN("a structured fact is added") {
+            REQUIRE(facts.size() == 4u);
+            auto ruby = facts.get<map_value>(fact::ruby);
+            REQUIRE(ruby);
+            REQUIRE(ruby->size() == 3u);
+            auto platform = ruby->get<string_value>("platform");
+            REQUIRE(platform);
+            REQUIRE(platform->value() == "i386-mingw32");
+            auto sitedir = ruby->get<string_value>("sitedir");
+            REQUIRE(sitedir);
+            REQUIRE(sitedir->value() == "C:/Ruby21/lib/ruby/site_ruby/2.1.0");
+            auto version = ruby->get<string_value>("version");
+            REQUIRE(version);
+            REQUIRE(version->value() == "2.1.4");
+        }
+        THEN("flat facts are added") {
+            REQUIRE(facts.size() == 4u);
+            auto platform = facts.get<string_value>(fact::rubyplatform);
+            REQUIRE(platform);
+            REQUIRE(platform->value() == "i386-mingw32");
+            auto sitedir = facts.get<string_value>(fact::rubysitedir);
+            REQUIRE(sitedir);
+            REQUIRE(sitedir->value() == "C:/Ruby21/lib/ruby/site_ruby/2.1.0");
+            auto version = facts.get<string_value>(fact::rubyversion);
+            REQUIRE(version);
+            REQUIRE(version->value() == "2.1.4");
+        }
+    }
+}