facter 3.12.2.cfacter.20181217 → 4.0.7.pre

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

@@ -1,83 +0,0 @@
-#include <catch.hpp>
-#include <internal/facts/resolvers/identity_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_identity_resolver : identity_resolver
-{
- protected:
-    virtual data collect_data(collection& facts) override
-    {
-        return {};
-    }
-};
-
-struct test_identity_resolver : identity_resolver
-{
- protected:
-    virtual data collect_data(collection& facts) override
-    {
-        data result;
-        result.group_id = 123;
-        result.group_name = "foo";
-        result.user_id = 456;
-        result.user_name = "bar";
-        result.privileged = false;
-        return result;
-    }
-};
-
-SCENARIO("using the identity resolver") {
-    collection_fixture facts;
-    WHEN("data is not present") {
-        facts.add(make_shared<empty_identity_resolver>());
-        THEN("facts should not be added") {
-            REQUIRE(facts.size() == 0u);
-        }
-    }
-    WHEN("data is present") {
-        facts.add(make_shared<test_identity_resolver>());
-        THEN("a structured fact is added") {
-            auto identity = facts.get<map_value>(fact::identity);
-            REQUIRE(identity);
-            REQUIRE(identity->size() == 5u);
-
-            auto name = identity->get<string_value>("group");
-            REQUIRE(name);
-            REQUIRE(name->value() == "foo");
-
-            auto id = identity->get<integer_value>("gid");
-            REQUIRE(id);
-            REQUIRE(id->value() == 123);
-
-            name = identity->get<string_value>("user");
-            REQUIRE(name);
-            REQUIRE(name->value() == "bar");
-
-            id = identity->get<integer_value>("uid");
-            REQUIRE(id);
-            REQUIRE(id->value() == 456);
-
-            auto privileged = identity->get<boolean_value>("privileged");
-            REQUIRE(privileged);
-            REQUIRE(privileged->value() == false);
-        }
-        THEN("flat facts are added") {
-            auto name = facts.get<string_value>(fact::gid);
-            REQUIRE(name);
-            REQUIRE(name->value() == "foo");
-
-            name = facts.get<string_value>(fact::id);
-            REQUIRE(name);
-            REQUIRE(name->value() == "bar");
-        }
-    }
-}

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

@@ -1,61 +0,0 @@
-#include <catch.hpp>
-#include <internal/facts/resolvers/kernel_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_kernel_resolver : kernel_resolver
-{
- protected:
-    virtual data collect_data(collection& facts) override
-    {
-        return {};
-    }
-};
-
-struct test_kernel_resolver : kernel_resolver
-{
- protected:
-    virtual data collect_data(collection& facts) override
-    {
-        data result;
-        result.name = "foo";
-        result.release = "1.2.3-foo";
-        result.version = "1.2.3";
-        return result;
-    }
-};
-
-SCENARIO("using the kernel resolver") {
-    collection_fixture facts;
-    WHEN("data is not present") {
-        facts.add(make_shared<empty_kernel_resolver>());
-        THEN("facts should not be added") {
-            REQUIRE(facts.size() == 0u);
-        }
-    }
-    WHEN("data is present") {
-        facts.add(make_shared<test_kernel_resolver>());
-        THEN("flat facts are added") {
-            REQUIRE(facts.size() == 4u);
-            auto kernel = facts.get<string_value>(fact::kernel);
-            REQUIRE(kernel);
-            REQUIRE(kernel->value() == "foo");
-            auto release = facts.get<string_value>(fact::kernel_release);
-            REQUIRE(release);
-            REQUIRE(release->value() == "1.2.3-foo");
-            auto version = facts.get<string_value>(fact::kernel_version);
-            REQUIRE(version);
-            REQUIRE(version->value() == "1.2.3");
-            auto major = facts.get<string_value>(fact::kernel_major_version);
-            REQUIRE(major);
-            REQUIRE(major->value() == "1.2");
-        }
-    }
-}

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

@@ -1,86 +0,0 @@
-#include <catch.hpp>
-#include <internal/facts/resolvers/ldom_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_ldom_resolver : ldom_resolver
-{
- protected:
-    virtual data collect_data(collection& facts) override
-    {
-        data result;
-        return result;
-    }
-};
-
-struct test_ldom_resolver : ldom_resolver
-{
- protected:
-    virtual data collect_data(collection& facts) override
-    {
-        ldom_info single_value;
-        single_value.key = "domainname";
-        single_value.values.insert({ "domainname", "somedomain"});
-
-        ldom_info multi_value;
-        multi_value.key = "domainrole";
-        multi_value.values.insert({ "impl", "true"});
-        multi_value.values.insert({ "io", "false"});
-
-        data result;
-        result.ldom.emplace_back(single_value);
-        result.ldom.emplace_back(multi_value);
-
-        return result;
-    }
-};
-
-SCENARIO("Using the Solaris LDom resolver") {
-    collection_fixture facts;
-    WHEN("data is not present") {
-        facts.add(make_shared<empty_ldom_resolver>());
-        THEN("no LDom facts should be added") {
-            REQUIRE(facts.size() == 0u);
-        }
-    }
-    WHEN("data is present") {
-        facts.add(make_shared<test_ldom_resolver>());
-        THEN("a structured fact is added") {
-            REQUIRE(facts.size() == 4u);
-            auto ldom = facts.get<map_value>(fact::ldom);
-            REQUIRE(ldom);
-            REQUIRE(ldom->size() == 2u);
-
-            auto sval = ldom->get<string_value>("domainname");
-            REQUIRE(sval);
-            REQUIRE(sval->value() == "somedomain");
-
-            auto mval = ldom->get<map_value>("domainrole");
-            REQUIRE(mval);
-            REQUIRE(mval->size() == 2u);
-        }
-        THEN("flat facts are added") {
-            REQUIRE(facts.size() == 4u);
-            auto sval_2 = facts.get<string_value>("ldom_domainname");
-            REQUIRE(sval_2);
-            REQUIRE(sval_2->value() == "somedomain");
-
-            auto sval_3 = facts.get<string_value>("ldom_domainrole_impl");
-            REQUIRE(sval_3);
-            REQUIRE(sval_3->value() == "true");
-
-            auto sval_4 = facts.get<string_value>("ldom_domainrole_io");
-            REQUIRE(sval_4);
-            REQUIRE(sval_4->value() == "false");
-        }
-    }
-
-}

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

@@ -1,135 +0,0 @@
-#include <catch.hpp>
-#include <internal/facts/resolvers/memory_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_memory_resolver : memory_resolver
-{
- protected:
-    virtual data collect_data(collection& facts) override
-    {
-        return {};
-    }
-};
-
-struct test_memory_resolver : memory_resolver
-{
- protected:
-    virtual data collect_data(collection& facts) override
-    {
-        data result;
-        result.swap_encryption = encryption_status::encrypted;
-        result.mem_total = 10 * 1024 * 1024;
-        result.mem_free = 5 * 1024 * 1024;
-        result.swap_total = 20 * 1024 * 1024;
-        result.swap_free = 4 * 1024 * 1024;
-        return result;
-    }
-};
-
-SCENARIO("using the memory resolver") {
-    collection_fixture facts;
-    WHEN("data is not present") {
-        facts.add(make_shared<empty_memory_resolver>());
-        THEN("facts should not be added") {
-            REQUIRE(facts.size() == 0u);
-        }
-    }
-    WHEN("data is present") {
-        facts.add(make_shared<test_memory_resolver>());
-        THEN("a structured fact is added") {
-            REQUIRE(facts.size() == 10u);
-            auto memory = facts.get<map_value>(fact::memory);
-            REQUIRE(memory);
-            auto info = memory->get<map_value>("swap");
-            REQUIRE(info);
-            REQUIRE(info->size() == 8u);
-            auto available = info->get<string_value>("available");
-            REQUIRE(available);
-            REQUIRE(available->value() == "4.00 MiB");
-            auto available_bytes = info->get<integer_value>("available_bytes");
-            REQUIRE(available_bytes);
-            REQUIRE(available_bytes->value() == 4194304);
-            auto capacity = info->get<string_value>("capacity");
-            REQUIRE(capacity);
-            REQUIRE(capacity->value() == "80.00%");
-            auto encrypted = info->get<boolean_value>("encrypted");
-            REQUIRE(encrypted);
-            REQUIRE(encrypted->value());
-            auto total = info->get<string_value>("total");
-            REQUIRE(total);
-            REQUIRE(total->value() == "20.00 MiB");
-            auto total_bytes = info->get<integer_value>("total_bytes");
-            REQUIRE(total_bytes);
-            REQUIRE(total_bytes->value() == 20971520);
-            auto used = info->get<string_value>("used");
-            REQUIRE(used);
-            REQUIRE(used->value() == "16.00 MiB");
-            auto used_bytes = info->get<integer_value>("used_bytes");
-            REQUIRE(used_bytes);
-            REQUIRE(used_bytes->value() == 16777216);
-            info = memory->get<map_value>("system");
-            REQUIRE(info);
-            REQUIRE(info->size() == 7u);
-            available = info->get<string_value>("available");
-            REQUIRE(available);
-            REQUIRE(available->value() == "5.00 MiB");
-            available_bytes = info->get<integer_value>("available_bytes");
-            REQUIRE(available_bytes);
-            REQUIRE(available_bytes->value() == 5242880);
-            capacity = info->get<string_value>("capacity");
-            REQUIRE(capacity);
-            REQUIRE(capacity->value() == "50.00%");
-            total = info->get<string_value>("total");
-            REQUIRE(total);
-            REQUIRE(total->value() == "10.00 MiB");
-            total_bytes = info->get<integer_value>("total_bytes");
-            REQUIRE(total_bytes);
-            REQUIRE(total_bytes->value() == 10485760);
-            used = info->get<string_value>("used");
-            REQUIRE(used);
-            REQUIRE(used->value() == "5.00 MiB");
-            used_bytes = info->get<integer_value>("used_bytes");
-            REQUIRE(used_bytes);
-            REQUIRE(used_bytes->value() == 5242880);
-        }
-        THEN("flat facts are added") {
-            REQUIRE(facts.size() == 10u);
-            auto memoryfree = facts.get<string_value>(fact::memoryfree);
-            REQUIRE(memoryfree);
-            REQUIRE(memoryfree->value() == "5.00 MiB");
-            auto memoryfree_mb = facts.get<double_value>(fact::memoryfree_mb);
-            REQUIRE(memoryfree_mb);
-            REQUIRE(memoryfree_mb->value() == Approx(5.0));
-            auto memorysize = facts.get<string_value>(fact::memorysize);
-            REQUIRE(memorysize);
-            REQUIRE(memorysize->value() == "10.00 MiB");
-            auto memorysize_mb = facts.get<double_value>(fact::memorysize_mb);
-            REQUIRE(memorysize_mb);
-            REQUIRE(memorysize_mb->value() == Approx(10.0));
-            auto swapencrypted = facts.get<boolean_value>(fact::swapencrypted);
-            REQUIRE(swapencrypted);
-            REQUIRE(swapencrypted->value());
-            auto swapfree = facts.get<string_value>(fact::swapfree);
-            REQUIRE(swapfree);
-            REQUIRE(swapfree->value() == "4.00 MiB");
-            auto swapfree_mb = facts.get<double_value>(fact::swapfree_mb);
-            REQUIRE(swapfree_mb);
-            REQUIRE(swapfree_mb->value() == Approx(4.0));
-            auto swapsize = facts.get<string_value>(fact::swapsize);
-            REQUIRE(swapsize);
-            REQUIRE(swapsize->value() == "20.00 MiB");
-            auto swapsize_mb = facts.get<double_value>(fact::swapsize_mb);
-            REQUIRE(swapsize_mb);
-            REQUIRE(swapsize_mb->value() == Approx(20.0));
-        }
-    }
-}

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

@@ -1,507 +0,0 @@
-#include <catch.hpp>
-#include <internal/facts/resolvers/networking_resolver.hpp>
-#include <facter/facts/collection.hpp>
-#include <facter/facts/fact.hpp>
-#include <facter/facts/scalar_value.hpp>
-#include <facter/facts/array_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_networking_resolver : networking_resolver
-{
- protected:
-    virtual data collect_data(collection& facts) override
-    {
-        return {};
-    }
-};
-
-struct test_hostname_resolver : networking_resolver
-{
- protected:
-    virtual data collect_data(collection& facts) override
-    {
-        data result;
-        result.hostname = "hostname";
-        return result;
-    }
-};
-
-struct test_domain_resolver : networking_resolver
-{
- protected:
-    virtual data collect_data(collection& facts) override
-    {
-        data result;
-        result.domain = "domain";
-        return result;
-    }
-};
-
-struct test_fqdn_resolver : networking_resolver
-{
- protected:
-    virtual data collect_data(collection& facts) override
-    {
-        data result;
-        result.fqdn = "fqdn";
-        return result;
-    }
-};
-
-struct test_missing_fqdn_resolver : networking_resolver
-{
- protected:
-    virtual data collect_data(collection& facts) override
-    {
-        data result;
-        result.hostname = "hostname";
-        result.domain = "domain.com";
-        return result;
-    }
-};
-
-struct test_domain_with_trailing_dot : networking_resolver
-{
- protected:
-    virtual data collect_data(collection& facts) override
-    {
-        data result;
-        result.domain = "domain.com.";
-        return result;
-    }
-};
-
-struct test_interface_resolver : networking_resolver
-{
- protected:
-    virtual data collect_data(collection& facts) override
-    {
-        data result;
-        for (int i = 0; i < 5; ++i) {
-            string num = to_string(i);
-
-            interface iface;
-            iface.name = "iface_" + num;
-            iface.dhcp_server = "dhcp_" + num;
-            for (int binding_index = 0; binding_index < 2; ++binding_index) {
-                string binding_num = to_string(binding_index);
-                iface.ipv4_bindings.emplace_back(binding { "ip_" + num + "_" + binding_num, "netmask_" + num + "_" + binding_num, "network_" + num + "_" + binding_num });
-                iface.ipv6_bindings.emplace_back(binding { "ip6_" + num + "_" + binding_num, "netmask6_" + num + "_" + binding_num, "network6_" + num + "_" + binding_num });
-            }
-            iface.macaddress = "macaddress_" + num;
-            iface.mtu = i;
-            result.interfaces.emplace_back(move(iface));
-        }
-        result.primary_interface = "iface_2";
-        return result;
-    }
-};
-
-struct primary_interface_resolver : networking_resolver
-{
- protected:
-    virtual data collect_data(collection& facts) override
-    {
-        data result;
-
-        interface lo0;
-        lo0.name = "lo0";
-        lo0.ipv4_bindings.emplace_back(binding { "127.0.0.1", "255.255.255.0", "127.0.0.0" });
-        lo0.ipv6_bindings.emplace_back(binding { "::1", "ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff", "::1" });
-        result.interfaces.emplace_back(move(lo0));
-
-        interface en0;
-        en0.name = "en0";
-        en0.ipv4_bindings.emplace_back(binding { "123.123.123.123", "255.255.255.0", "123.123.123.0" });
-        en0.ipv6_bindings.emplace_back(binding { "fe80::6203:8ff:fe95:2d16", "ffff:ffff:ffff:ffff::", "fe80::" });
-        result.interfaces.emplace_back(move(en0));
-
-        interface en1;
-        en1.name = "en1";
-        en1.ipv4_bindings.emplace_back(binding { "123.123.123.124", "255.255.255.0", "123.123.123.0" });
-        en1.ipv6_bindings.emplace_back(binding { "fe80::6203:8ff:fe95:2d17", "ffff:ffff:ffff:ffff::", "fe80::" });
-        result.interfaces.emplace_back(move(en1));
-
-        return result;
-    }
-};
-
-SCENARIO("using the networking resolver") {
-    collection_fixture facts;
-    WHEN("data is not present") {
-        facts.add(make_shared<empty_networking_resolver>());
-        THEN("facts should not be added") {
-            REQUIRE(facts.size() == 0u);
-        }
-    }
-    WHEN("only hostname is present") {
-        facts.add(make_shared<test_hostname_resolver>());
-        REQUIRE(facts.size() == 3u);
-        THEN("a flat fact is added") {
-            auto hostname = facts.get<string_value>(fact::hostname);
-            REQUIRE(hostname);
-            REQUIRE(hostname->value() == "hostname");
-        }
-        THEN("a structured fact is added") {
-            auto networking = facts.get<map_value>(fact::networking);
-            REQUIRE(networking);
-            REQUIRE(networking->size() == 2u);
-
-            auto hostname = networking->get<string_value>("hostname");
-            REQUIRE(hostname);
-            REQUIRE(hostname->value() == "hostname");
-
-            auto fqdn = networking->get<string_value>("fqdn");
-            REQUIRE(fqdn);
-            REQUIRE(fqdn->value() == "hostname");
-        }
-        THEN("the FQDN fact is the hostname") {
-            auto fqdn = facts.get<string_value>(fact::fqdn);
-            REQUIRE(fqdn);
-            REQUIRE(fqdn->value() == "hostname");
-        }
-    }
-    WHEN("only domain is present") {
-        facts.add(make_shared<test_domain_resolver>());
-        REQUIRE(facts.size() == 2u);
-        THEN("a flat fact is added") {
-            auto domain = facts.get<string_value>(fact::domain);
-            REQUIRE(domain);
-            REQUIRE(domain->value() == "domain");
-        }
-        THEN("a structured fact is added") {
-            auto networking = facts.get<map_value>(fact::networking);
-            REQUIRE(networking);
-            REQUIRE(networking->size() == 1u);
-
-            auto domain = networking->get<string_value>("domain");
-            REQUIRE(domain);
-            REQUIRE(domain->value() == "domain");
-        }
-        THEN("the FQDN fact is not present") {
-            auto fqdn = facts.get<string_value>(fact::fqdn);
-            REQUIRE_FALSE(fqdn);
-        }
-    }
-    WHEN("domain contains a trailing dot, the dot is removed") {
-        facts.add(make_shared<test_domain_with_trailing_dot>());
-        REQUIRE(facts.size() == 2u);
-        THEN("a flat fact is added") {
-            auto domain = facts.get<string_value>(fact::domain);
-            REQUIRE(domain);
-            REQUIRE(domain->value() == "domain.com");
-        }
-        THEN("a structured fact is added") {
-            auto networking = facts.get<map_value>(fact::networking);
-            REQUIRE(networking);
-            REQUIRE(networking->size() == 1u);
-
-            auto domain = networking->get<string_value>("domain");
-            REQUIRE(domain);
-            REQUIRE(domain->value() == "domain.com");
-        }
-        THEN("the FQDN fact is not present") {
-            auto fqdn = facts.get<string_value>(fact::fqdn);
-            REQUIRE_FALSE(fqdn);
-        }
-    }
-    WHEN("FQDN is present") {
-        facts.add(make_shared<test_fqdn_resolver>());
-        REQUIRE(facts.size() == 2u);
-        THEN("a flat fact is added") {
-            auto fqdn = facts.get<string_value>(fact::fqdn);
-            REQUIRE(fqdn);
-            REQUIRE(fqdn->value() == "fqdn");
-        }
-        THEN("a structured fact is added") {
-            auto networking = facts.get<map_value>(fact::networking);
-            REQUIRE(networking);
-            REQUIRE(networking->size() == 1u);
-            auto fqdn = networking->get<string_value>("fqdn");
-            REQUIRE(fqdn);
-            REQUIRE(fqdn->value() == "fqdn");
-        }
-        THEN("the FQDN fact is present") {
-            auto fqdn = facts.get<string_value>(fact::fqdn);
-            REQUIRE(fqdn);
-            REQUIRE(fqdn->value() == "fqdn");
-        }
-    }
-    WHEN("FQDN is not present") {
-        facts.add(make_shared<test_missing_fqdn_resolver>());
-        REQUIRE(facts.size() == 4u);
-        THEN("the FQDN fact is the combination of hostname and domain") {
-            auto svalue = facts.get<string_value>(fact::hostname);
-            REQUIRE(svalue);
-            REQUIRE(svalue->value() == "hostname");
-            svalue = facts.get<string_value>(fact::domain);
-            REQUIRE(svalue);
-            REQUIRE(svalue->value() == "domain.com");
-            svalue = facts.get<string_value>(fact::fqdn);
-            REQUIRE(svalue);
-            REQUIRE(svalue->value() == "hostname.domain.com");
-        }
-        THEN("the FQDN in the structured fact is the combination of hostname and domain") {
-            auto networking = facts.get<map_value>(fact::networking);
-            REQUIRE(networking);
-            REQUIRE(networking->size() == 3u);
-            auto svalue = networking->get<string_value>("hostname");
-            REQUIRE(svalue);
-            REQUIRE(svalue->value() == "hostname");
-            svalue = networking->get<string_value>("domain");
-            REQUIRE(svalue);
-            REQUIRE(svalue->value() == "domain.com");
-            svalue = networking->get<string_value>("fqdn");
-            REQUIRE(svalue);
-            REQUIRE(svalue->value() == "hostname.domain.com");
-        }
-    }
-    WHEN("network interfaces are present") {
-        facts.add(make_shared<test_interface_resolver>());
-        REQUIRE(facts.size() == 50u);
-        THEN("the DHCP servers fact is present") {
-            auto dhcp_servers = facts.get<map_value>(fact::dhcp_servers);
-            REQUIRE(dhcp_servers);
-            REQUIRE(dhcp_servers->size() == 6u);
-            for (unsigned int i = 0; i < 5; ++i) {
-                string num = to_string(i);
-                auto server = dhcp_servers->get<string_value>("iface_" + num);
-                REQUIRE(server);
-                REQUIRE(server->value() == "dhcp_" + num);
-            }
-            auto dhcp = dhcp_servers->get<string_value>("system");
-            REQUIRE(dhcp);
-            REQUIRE(dhcp->value() == "dhcp_2");
-        }
-        THEN("the interface names fact is present") {
-            auto interfaces_list = facts.get<string_value>(fact::interfaces);
-            REQUIRE(interfaces_list);
-            REQUIRE(interfaces_list->value() == "iface_0,iface_1,iface_2,iface_3,iface_4");
-        }
-        THEN("the interface flat facts are present") {
-            for (unsigned int i = 0; i < 5; ++i) {
-                string num = to_string(i);
-                auto ip = facts.get<string_value>(fact::ipaddress + string("_iface_") + num);
-                REQUIRE(ip);
-                REQUIRE(ip->value() == "ip_" + num + "_0");
-                auto ip6 = facts.get<string_value>(fact::ipaddress6 + string("_iface_") + num);
-                REQUIRE(ip6);
-                REQUIRE(ip6->value() == "ip6_" + num + "_0");
-                auto macaddress = facts.get<string_value>(fact::macaddress + string("_iface_") + num);
-                REQUIRE(macaddress);
-                REQUIRE(macaddress->value() == "macaddress_" + num);
-                auto mtu = facts.get<integer_value>(fact::mtu + string("_iface_") + num);
-                REQUIRE(mtu);
-                REQUIRE(mtu->value() == i);
-                auto netmask = facts.get<string_value>(fact::netmask + string("_iface_") + num);
-                REQUIRE(netmask);
-                REQUIRE(netmask->value() == "netmask_" + num + "_0");
-                auto netmask6 = facts.get<string_value>(fact::netmask6 + string("_iface_") + num);
-                REQUIRE(netmask6);
-                REQUIRE(netmask6->value() == "netmask6_" + num + "_0");
-                auto network = facts.get<string_value>(fact::network + string("_iface_") + num);
-                REQUIRE(network);
-                REQUIRE(network->value() == "network_" + num + "_0");
-                auto network6 = facts.get<string_value>(fact::network6 + string("_iface_") + num);
-                REQUIRE(network6);
-                REQUIRE(network6->value() == "network6_" + num + "_0");
-            }
-        }
-        THEN("the system fact facts are present") {
-            auto ip = facts.get<string_value>(fact::ipaddress);
-            REQUIRE(ip);
-            REQUIRE(ip->value() == "ip_2_0");
-            auto ip6 = facts.get<string_value>(fact::ipaddress6);
-            REQUIRE(ip6);
-            REQUIRE(ip6->value() == "ip6_2_0");
-            auto macaddress = facts.get<string_value>(fact::macaddress);
-            REQUIRE(macaddress);
-            REQUIRE(macaddress->value() == "macaddress_2");
-            auto netmask = facts.get<string_value>(fact::netmask);
-            REQUIRE(netmask);
-            REQUIRE(netmask->value() == "netmask_2_0");
-            auto netmask6 = facts.get<string_value>(fact::netmask6);
-            REQUIRE(netmask6);
-            REQUIRE(netmask6->value() == "netmask6_2_0");
-            auto network = facts.get<string_value>(fact::network);
-            REQUIRE(network);
-            REQUIRE(network->value() == "network_2_0");
-            auto network6 = facts.get<string_value>(fact::network6);
-            REQUIRE(network6);
-            REQUIRE(network6->value() == "network6_2_0");
-        }
-        THEN("the networking structured fact is present") {
-            auto networking = facts.get<map_value>(fact::networking);
-            REQUIRE(networking);
-            REQUIRE(networking->size() == 11u);
-            auto primary = networking->get<string_value>("primary");
-            REQUIRE(primary);
-            REQUIRE(primary->value() == "iface_2");
-            auto dhcp = networking->get<string_value>("dhcp");
-            REQUIRE(dhcp);
-            REQUIRE(dhcp->value() == "dhcp_2");
-            auto ip = networking->get<string_value>("ip");
-            REQUIRE(ip);
-            REQUIRE(ip->value() == "ip_2_0");
-            auto ip6 = networking->get<string_value>("ip6");
-            REQUIRE(ip6);
-            REQUIRE(ip6->value() == "ip6_2_0");
-            auto macaddress = networking->get<string_value>("mac");
-            REQUIRE(macaddress);
-            REQUIRE(macaddress->value() == "macaddress_2");
-            auto netmask = networking->get<string_value>("netmask");
-            REQUIRE(netmask);
-            REQUIRE(netmask->value() == "netmask_2_0");
-            auto netmask6 = networking->get<string_value>("netmask6");
-            REQUIRE(netmask6);
-            REQUIRE(netmask6->value() == "netmask6_2_0");
-            auto network = networking->get<string_value>("network");
-            REQUIRE(network);
-            REQUIRE(network->value() == "network_2_0");
-            auto network6 = networking->get<string_value>("network6");
-            REQUIRE(network6);
-            REQUIRE(network6->value() == "network6_2_0");
-            auto mtu = networking->get<integer_value>("mtu");
-            REQUIRE(mtu);
-            REQUIRE(mtu->value() == 2);
-            auto interfaces = networking->get<map_value>("interfaces");
-            REQUIRE(interfaces);
-            for (unsigned int i = 0; i < 5; ++i) {
-                string num = to_string(i);
-                auto interface = interfaces->get<map_value>("iface_" + num);
-                REQUIRE(interface);
-                dhcp = interface->get<string_value>("dhcp");
-                REQUIRE(dhcp);
-                REQUIRE(dhcp->value() == "dhcp_" + num);
-                ip = interface->get<string_value>("ip");
-                REQUIRE(ip);
-                REQUIRE(ip->value() == "ip_" + num + "_0");
-                ip6 = interface->get<string_value>("ip6");
-                REQUIRE(ip6);
-                REQUIRE(ip6->value() == "ip6_" + num + "_0");
-                macaddress = interface->get<string_value>("mac");
-                REQUIRE(macaddress);
-                REQUIRE(macaddress->value() == "macaddress_" + num);
-                netmask = interface->get<string_value>("netmask");
-                REQUIRE(netmask);
-                REQUIRE(netmask->value() == "netmask_" + num + "_0");
-                netmask6 = interface->get<string_value>("netmask6");
-                REQUIRE(netmask6);
-                REQUIRE(netmask6->value() == "netmask6_" + num + "_0");
-                network = interface->get<string_value>("network");
-                REQUIRE(network);
-                REQUIRE(network->value() == "network_" + num + "_0");
-                network6 = interface->get<string_value>("network6");
-                REQUIRE(network6);
-                REQUIRE(network6->value() == "network6_" + num + "_0");
-                mtu = interface->get<integer_value>("mtu");
-                REQUIRE(mtu);
-                REQUIRE(mtu->value() == i);
-                auto bindings = interface->get<array_value>("bindings");
-                REQUIRE(bindings);
-                REQUIRE(bindings->size() == 2u);
-                for (size_t binding_index = 0; binding_index < bindings->size(); ++binding_index) {
-                    auto interface_num = to_string(binding_index);
-                    auto binding = bindings->get<map_value>(binding_index);
-                    REQUIRE(binding);
-                    auto address = binding->get<string_value>("address");
-                    REQUIRE(address);
-                    REQUIRE(address->value() == "ip_" + num + "_" + interface_num);
-                    auto netmask = binding->get<string_value>("netmask");
-                    REQUIRE(netmask);
-                    REQUIRE(netmask->value() == "netmask_" + num + "_" + interface_num);
-                    auto network = binding->get<string_value>("network");
-                    REQUIRE(network);
-                    REQUIRE(network->value() == "network_" + num + "_" + interface_num);
-                }
-                bindings = interface->get<array_value>("bindings6");
-                REQUIRE(bindings);
-                REQUIRE(bindings->size() == 2u);
-                for (size_t binding_index = 0; binding_index < bindings->size(); ++binding_index) {
-                    auto interface_num = to_string(binding_index);
-                    auto binding = bindings->get<map_value>(binding_index);
-                    REQUIRE(binding);
-                    auto address = binding->get<string_value>("address");
-                    REQUIRE(address);
-                    REQUIRE(address->value() == "ip6_" + num + "_" + interface_num);
-                    auto netmask = binding->get<string_value>("netmask");
-                    REQUIRE(netmask);
-                    REQUIRE(netmask->value() == "netmask6_" + num + "_" + interface_num);
-                    auto network = binding->get<string_value>("network");
-                    REQUIRE(network);
-                    REQUIRE(network->value() == "network6_" + num + "_" + interface_num);
-                }
-            }
-        }
-    }
-    WHEN("the primary interface is not resolved") {
-        facts.add(make_shared<primary_interface_resolver>());
-        THEN("the first interface with a valid address should be treated as primary") {
-            REQUIRE(facts.query<string_value>("networking.primary"));
-            REQUIRE(facts.query<string_value>("networking.primary")->value() == "en0");
-        }
-    }
-}
-
-SCENARIO("ignored IPv4 addresses") {
-    char const* ignored_addresses[] = {
-            "",
-            "127.0.0.1",
-            "127.0.0.2",
-            "127.1.0.0",
-            "127.0.1.0",
-            "169.254.7.14",
-            "169.254.0.0",
-            "169.254.255.255"
-    };
-    for (auto s : ignored_addresses) {
-        CAPTURE(s);
-        REQUIRE(networking_resolver::ignored_ipv4_address(s));
-    }
-    char const* accepted_addresses[] = {
-            "169.253.0.0",
-            "169.255.0.0",
-            "100.100.100.100",
-            "0.0.0.0",
-            "1.1.1.1",
-            "10.0.18.142",
-            "192.168.0.1",
-            "255.255.255.255",
-            "128.0.0.1",
-    };
-    for (auto s : accepted_addresses) {
-        CAPTURE(s);
-        REQUIRE_FALSE(networking_resolver::ignored_ipv4_address(s));
-    }
-}
-
-
-SCENARIO("ignore IPv6 adddresses") {
-    char const* ignored_addresses[] = {
-            "",
-            "::1",
-            "fe80::9c84:7ca1:794b:12ed",
-            "fe80::75f2:2f55:823b:a513%10"
-    };
-    for (auto s : ignored_addresses) {
-        CAPTURE(s);
-        REQUIRE(networking_resolver::ignored_ipv6_address(s));
-    }
-    char const* accepted_addresses[] = {
-            "::fe80:75f2:2f55:823b:a513",
-            "fe7f::75f2:2f55:823b:a513%10",
-            "::2",
-            "::fe01",
-            "::fe80"
-    };
-    for (auto s : accepted_addresses) {
-        CAPTURE(s);
-        REQUIRE_FALSE(networking_resolver::ignored_ipv6_address(s));
-    }
-}