cfacter 3.11.0.rc.20180314

data/ext/facter/facter/lib/tests/collection_fixture.cc

@@ -0,0 +1,15 @@
+#include "collection_fixture.hpp"
+
+namespace facter { namespace testing {
+
+    using namespace std;
+
+    collection_fixture::collection_fixture(set<string> const& blocklist,
+            unordered_map<string, int64_t> const& ttls) : collection(blocklist, ttls) { }
+
+    vector<string> collection_fixture::get_external_fact_directories() const
+    {
+        return {};
+    }
+
+}}  // namespace facter::testing

data/ext/facter/facter/lib/tests/collection_fixture.hpp

@@ -0,0 +1,19 @@
+#pragma once
+
+#include <facter/facts/collection.hpp>
+#include <vector>
+#include <string>
+
+namespace facter { namespace testing {
+
+    class collection_fixture : public facter::facts::collection
+    {
+    public:
+        collection_fixture(std::set<std::string> const& blocklist = std::set<std::string>(),
+                std::unordered_map<std::string, int64_t> const& ttls = std::unordered_map<std::string, int64_t>{});
+
+    protected:
+        virtual std::vector<std::string> get_external_fact_directories() const override;
+    };
+
+}}  // namespace facter::testing

data/ext/facter/facter/lib/tests/cwrapper.cc

@@ -0,0 +1,22 @@
+#include <catch.hpp>
+#include <facter/cwrapper.hpp>
+
+SCENARIO("using the C wrapper function to collect default facts") {
+    GIVEN("a get_default_facts invocation") {
+        char *result {nullptr};
+
+        THEN("no error should be thrown") {
+            REQUIRE_NOTHROW(get_default_facts(&result));
+        }
+
+        THEN("the function execution should succeed") {
+            REQUIRE(get_default_facts(&result) == 0);
+        }
+
+        THEN("the function stores the collected facts and sets the pointer arg") {
+            REQUIRE(result == nullptr);
+            get_default_facts(&result);
+            REQUIRE_FALSE(result == nullptr);
+        }
+    }
+}

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

@@ -0,0 +1,140 @@
+#include <catch.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 an array fact value") {
+    array_value value;
+    REQUIRE(value.empty());
+    GIVEN("a null value to add") {
+        value.add(nullptr);
+        THEN("it should still be empty") {
+            REQUIRE(value.empty());
+        }
+    }
+    GIVEN("an out of range index") {
+        THEN("get() raises out_of_range") {
+            REQUIRE_THROWS_AS(value.get<string_value>(0), std::out_of_range);
+        }
+        THEN("operator[] returns nullptr") {
+            REQUIRE_FALSE(value[42]);
+        }
+    }
+    GIVEN("a string value to add") {
+        value.add(make_value<string_value>("hello"));
+        THEN("it should contain the string value") {
+            REQUIRE_FALSE(value.empty());
+            REQUIRE(value.size() == 1u);
+            REQUIRE(value.get<string_value>(0));
+            REQUIRE(value.get<string_value>(0)->value() == "hello");
+        }
+    }
+    GIVEN("an integer value to add") {
+        value.add(make_value<integer_value>(123));
+        THEN("it should contain the string value") {
+            REQUIRE_FALSE(value.empty());
+            REQUIRE(value.size() == 1u);
+            REQUIRE(value.get<integer_value>(0));
+            REQUIRE(value.get<integer_value>(0)->value() == 123);
+        }
+    }
+    GIVEN("multiple values to add") {
+        auto subarray = make_value<array_value>();
+        subarray->add(make_value<string_value>("element"));
+        value.add(make_value<string_value>("1"));
+        value.add(make_value<integer_value>(2));
+        value.add(move(subarray));
+        THEN("it should contain the values in order they were added") {
+            REQUIRE(value.size() == 3u);
+            auto string_val = value.get<string_value>(0);
+            REQUIRE(string_val);
+            REQUIRE(string_val->value() == "1");
+            auto int_val = value.get<integer_value>(1);
+            REQUIRE(int_val);
+            REQUIRE(int_val->value() == 2);
+            auto subarray = value.get<array_value>(2);
+            REQUIRE(subarray);
+            REQUIRE(subarray->size() == 1u);
+            string_val = subarray->get<string_value>(0);
+            REQUIRE(string_val);
+            REQUIRE(string_val->value() == "element");
+        }
+        THEN("each is enumerated in order") {
+            size_t index = 0u;
+            value.each([&](struct value const* val) {
+                if (index == 0u) {
+                    auto string_val = dynamic_cast<string_value const*>(val);
+                    REQUIRE(string_val);
+                    REQUIRE(string_val->value() == "1");
+                } else if (index == 1u) {
+                    auto int_val = dynamic_cast<integer_value const*>(val);
+                    REQUIRE(int_val);
+                    REQUIRE(int_val->value() == 2);
+                } else if (index == 2u) {
+                    auto subarray = dynamic_cast<array_value const*>(val);
+                    REQUIRE(subarray);
+                    REQUIRE(subarray->size() == 1u);
+                    auto string_val = subarray->get<string_value>(0);
+                    REQUIRE(string_val);
+                    REQUIRE(string_val->value() == "element");
+                } else {
+                    FAIL("should not be reached");
+                }
+                ++index;
+                return true;
+            });
+            REQUIRE(index == value.size());
+        }
+        WHEN("serialized to JSON") {
+            THEN("it should contain the same values") {
+                json_value json;
+                json_allocator allocator;
+                value.to_json(allocator, json);
+                REQUIRE(json.IsArray());
+                REQUIRE(json.Size() == 3);
+                REQUIRE(json[0u].IsString());
+                REQUIRE(string(json[0u].GetString()) == "1");
+                REQUIRE(json[1u].IsNumber());
+                REQUIRE(json[1u].GetInt64() == 2ll);
+                REQUIRE(json[2u].IsArray());
+                REQUIRE(json[2u].Size() == 1);
+                REQUIRE(json[2u][0u].IsString());
+                REQUIRE(string(json[2u][0u].GetString()) == "element");
+            }
+        }
+        WHEN("serialized to text") {
+            THEN("it should contain the same values") {
+                ostringstream stream;
+                value.write(stream);
+                REQUIRE(stream.str() == "[\n  \"1\",\n  2,\n  [\n    \"element\"\n  ]\n]");
+            }
+        }
+        WHEN("serialized to YAML") {
+            THEN("it should contain the same values") {
+                Emitter emitter;
+                value.write(emitter);
+                REQUIRE(string(emitter.c_str()) == "- \"1\"\n- 2\n-\n  - element");
+            }
+        }
+    }
+    GIVEN("each with a callback that returns false") {
+        THEN("it should stop enumerating") {
+            value.add(make_value<integer_value>(1));
+            value.add(make_value<integer_value>(2));
+            value.add(make_value<integer_value>(3));
+            size_t index = 0u;
+            value.each([&](struct value const* val) {
+                ++index;
+                return false;
+            });
+            REQUIRE(index == 1u);
+        }
+    }
+}

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

@@ -0,0 +1,67 @@
+#include <catch.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 boolean fact value") {
+    GIVEN("true to the constructor") {
+        boolean_value value(true);
+        REQUIRE(value.value());
+        WHEN("serialized to JSON") {
+            THEN("it should serialize as true") {
+                json_value json;
+                json_allocator allocator;
+                value.to_json(allocator, json);
+                REQUIRE(json.IsBool());
+                REQUIRE(json.GetBool());
+            }
+        }
+        WHEN("serialized to YAML") {
+            THEN("it should serialize as true") {
+                Emitter emitter;
+                value.write(emitter);
+                REQUIRE(string(emitter.c_str()) == "true");
+            }
+        }
+        WHEN("serialized to text") {
+            THEN("it should serialize to text as true") {
+                ostringstream stream;
+                value.write(stream);
+                REQUIRE(stream.str() == "true");
+            }
+        }
+    }
+    GIVEN("false to the constructor") {
+        boolean_value value(false);
+        REQUIRE_FALSE(value.value());
+        WHEN("serialized to JSON") {
+            THEN("it should serialize as false") {
+                json_value json;
+                json_allocator allocator;
+                value.to_json(allocator, json);
+                REQUIRE(json.IsBool());
+                REQUIRE_FALSE(json.GetBool());
+            }
+        }
+        WHEN("serialized to YAML") {
+            THEN("it should serialize as false") {
+                Emitter emitter;
+                value.write(emitter);
+                REQUIRE(string(emitter.c_str()) == "false");
+            }
+        }
+        WHEN("serialized to text") {
+            THEN("it should serialize to text as false") {
+                ostringstream stream;
+                value.write(stream);
+                REQUIRE(stream.str() == "false");
+            }
+        }
+    }
+}

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

@@ -0,0 +1,100 @@
+#include <catch.hpp>
+#include "../fixtures.hpp"
+
+#include<internal/facts/cache.hpp>
+#include <facter/facts/scalar_value.hpp>
+
+#include <leatherman/file_util/file.hpp>
+
+using namespace std;
+using namespace facter::testing;
+using namespace facter::facts;
+namespace boost_file = boost::filesystem;
+
+struct simple_resolver : facter::facts::resolver
+{
+    simple_resolver() : resolver("test", { "foo" })
+    {
+    }
+
+    virtual void resolve(collection& facts) override
+    {
+        facts.add("foo", make_value<string_value>("bar"));
+    }
+
+    bool is_blockable() const override
+    {
+        return true;
+    }
+};
+
+SCENARIO("refreshing cache") {
+    boost_file::path cache_dir(LIBFACTER_TESTS_DIRECTORY + string("/fixtures/cache"));
+
+    GIVEN("a resolver that needs to be cached") {
+        collection_fixture facts;
+        auto test_res = make_shared<simple_resolver>();
+        boost_file::create_directories(cache_dir);
+
+        THEN("new JSON files should be written") {
+            auto cache_file = (cache_dir / "test").string();
+            REQUIRE_FALSE(leatherman::file_util::file_readable(cache_file));
+
+            cache::refresh_cache(test_res, cache_file, facts);
+            REQUIRE(leatherman::file_util::file_readable(cache_file));
+            string contents;
+            load_fixture("cache/test", contents);
+            REQUIRE(contents.find("foo") != string::npos);
+        }
+    }
+
+    // Clean up directory
+    boost_file::remove_all(cache_dir);
+}
+
+SCENARIO("loading facts from cache") {
+    boost_file::path cache_dir(LIBFACTER_TESTS_DIRECTORY + string("/fixtures/cache"));
+
+    GIVEN("an existing cache directory with cached fact") {
+        collection_fixture facts;
+        auto test_res = make_shared<simple_resolver>();
+        boost_file::create_directories(cache_dir);
+        auto cache_file = cache_dir / "test";
+        leatherman::file_util::atomic_write_to_file("{ \"foo\" : \"bar\" }", cache_file.string());
+
+        THEN("facts should be loaded from the cache") {
+            cache::load_facts_from_cache(cache_file, test_res, facts);
+            REQUIRE(facts.get_resolved("foo"));
+        }
+    }
+
+    // Clean up directory
+    boost_file::remove_all(cache_dir);
+}
+
+SCENARIO("cleaning the cache") {
+    boost_file::path cache_dir(LIBFACTER_TESTS_DIRECTORY + string("/fixtures/cache"));
+
+    GIVEN("an existing cache directory with a fact that should no longer be cached") {
+        boost_file::create_directories(cache_dir);
+        // unused cache file
+        auto unused_cache_file = (cache_dir / "unused").string();
+        leatherman::file_util::atomic_write_to_file("{ \"foo\" : \"bar\" }",
+                unused_cache_file);
+        // used cached file
+        auto used_cache_file = (cache_dir / "test").string();
+        leatherman::file_util::atomic_write_to_file("{ \"foo\" : \"bar\" }",
+                used_cache_file);
+
+        THEN("unused cache file should be deleted") {
+            // cache "test", but not "unused"
+            cache::clean_cache(unordered_map<string, int64_t>({
+                        make_pair("test", 600)
+                        }), cache_dir.string());
+            REQUIRE_FALSE(leatherman::file_util::file_readable(unused_cache_file));
+            REQUIRE(leatherman::file_util::file_readable(used_cache_file));
+        }
+    }
+
+    boost_file::remove_all(cache_dir);
+}

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

@@ -0,0 +1,576 @@
+#include <catch.hpp>
+#include <facter/facts/collection.hpp>
+#include <facter/facts/resolver.hpp>
+#include <facter/facts/array_value.hpp>
+#include <facter/facts/map_value.hpp>
+#include <facter/facts/scalar_value.hpp>
+#include <leatherman/util/environment.hpp>
+#include "../fixtures.hpp"
+#include <sstream>
+
+using namespace std;
+using namespace facter::facts;
+using namespace leatherman::util;
+using namespace facter::testing;
+
+struct simple_resolver : facter::facts::resolver
+{
+    simple_resolver() : resolver("test", { "foo" })
+    {
+    }
+
+    virtual void resolve(collection& facts) override
+    {
+        facts.add("foo", make_value<string_value>("bar"));
+    }
+
+    bool is_blockable() const override
+    {
+        return true;
+    }
+};
+
+struct unblockable_resolver : facter::facts::resolver
+{
+    unblockable_resolver() : resolver("unblockable", { "foo" })
+    {
+    }
+
+    virtual void resolve(collection& facts) override
+    {
+        facts.add("foo", make_value<string_value>("bar"));
+    }
+
+    bool is_blockable() const override
+    {
+        return false;
+    }
+};
+
+struct multi_resolver : facter::facts::resolver
+{
+    multi_resolver() : resolver("test", { "foo", "bar" })
+    {
+    }
+
+    virtual void resolve(collection& facts) override
+    {
+        facts.add("foo", make_value<string_value>("bar"));
+        facts.add("bar", make_value<string_value>("foo"));
+    }
+
+    bool is_blockable() const override
+    {
+        return true;
+    }
+};
+
+struct temp_variable
+{
+    temp_variable(string name, string const& value) :
+        _name(move(name))
+    {
+        environment::set(_name, value);
+    }
+
+    ~temp_variable()
+    {
+        environment::clear(_name);
+    }
+
+    string _name;
+};
+
+SCENARIO("using the fact collection") {
+    collection_fixture facts;
+    REQUIRE(facts.size() == 0u);
+    REQUIRE(facts.empty());
+
+    GIVEN("default facts") {
+        facts.add_default_facts(true);
+        THEN("facts should resolve") {
+            REQUIRE(facts.size() > 0u);
+            REQUIRE_FALSE(facts.empty());
+        }
+    }
+    GIVEN("a hidden fact and a revealed fact") {
+        facts.add("foo", make_value<string_value>("bar"));
+        facts.add("hidden_foo", make_value<string_value>("hidden_bar", true));
+        THEN("they should be in the collection") {
+            REQUIRE(facts.size() == 2u);
+            REQUIRE_FALSE(facts.empty());
+            auto fact = facts.get<string_value>("foo");
+            REQUIRE(fact);
+            REQUIRE(fact->value() == "bar");
+            fact = dynamic_cast<string_value const *>(facts["foo"]);
+            REQUIRE(fact);
+            REQUIRE(fact->value() == "bar");
+            auto hidden_fact = facts.get<string_value>("hidden_foo");
+            REQUIRE(hidden_fact);
+            REQUIRE(hidden_fact->value() == "hidden_bar");
+            hidden_fact = dynamic_cast<string_value const *>(facts["hidden_foo"]);
+            REQUIRE(hidden_fact);
+            REQUIRE(hidden_fact->value() == "hidden_bar");
+        }
+        WHEN("writing default facts") {
+            THEN("it should serialize the revealed fact to JSON") {
+                ostringstream ss;
+                facts.write(ss, format::json);
+                REQUIRE(ss.str() == "{\n  \"foo\": \"bar\"\n}");
+            }
+            THEN("it should serialize the revealed fact to YAML") {
+                ostringstream ss;
+                facts.write(ss, format::yaml);
+                REQUIRE(ss.str() == "foo: bar");
+            }
+            THEN("it should serialize the revealed fact to text") {
+                ostringstream ss;
+                facts.write(ss, format::hash);
+                REQUIRE(ss.str() == "foo => bar");
+            }
+        }
+        WHEN("writing all (hidden) facts") {
+            THEN("it should serialize both facts to JSON") {
+                ostringstream ss;
+                facts.write(ss, format::json, set<string>{}, true, false);
+                REQUIRE(ss.str() == "{\n  \"foo\": \"bar\",\n  \"hidden_foo\": \"hidden_bar\"\n}");
+            }
+            THEN("it should serialize both facts to YAML") {
+                ostringstream ss;
+                facts.write(ss, format::yaml, set<string>{}, true, false);
+                REQUIRE(ss.str() == "foo: bar\nhidden_foo: hidden_bar");
+            }
+            THEN("it should serialize both facts to text") {
+                ostringstream ss;
+                facts.write(ss, format::hash, set<string>{}, true, false);
+                REQUIRE(ss.str() == "foo => bar\nhidden_foo => hidden_bar");
+            }
+        }
+        WHEN("querying facts") {
+            THEN("it should serialize both facts to JSON") {
+                ostringstream ss;
+                facts.write(ss, format::json, {"foo", "hidden_foo"});
+                REQUIRE(ss.str() == "{\n  \"foo\": \"bar\",\n  \"hidden_foo\": \"hidden_bar\"\n}");
+            }
+            THEN("it should serialize both facts to YAML") {
+                ostringstream ss;
+                facts.write(ss, format::yaml, {"foo", "hidden_foo"});
+                REQUIRE(ss.str() == "foo: bar\nhidden_foo: hidden_bar");
+            }
+            THEN("it should serialize both facts to text") {
+                ostringstream ss;
+                facts.write(ss, format::hash, {"foo", "hidden_foo"});
+                REQUIRE(ss.str() == "foo => bar\nhidden_foo => hidden_bar");
+            }
+        }
+        WHEN("querying hidden facts") {
+            THEN("it should serialize both facts to JSON") {
+                ostringstream ss;
+                facts.write(ss, format::json, {"foo", "hidden_foo"}, true, false);
+                REQUIRE(ss.str() == "{\n  \"foo\": \"bar\",\n  \"hidden_foo\": \"hidden_bar\"\n}");
+            }
+            THEN("it should serialize both facts to YAML") {
+                ostringstream ss;
+                facts.write(ss, format::yaml, {"foo", "hidden_foo"}, true, false);
+                REQUIRE(ss.str() == "foo: bar\nhidden_foo: hidden_bar");
+            }
+            THEN("it should serialize both facts to text") {
+                ostringstream ss;
+                facts.write(ss, format::hash, {"foo", "hidden_foo"}, true, false);
+                REQUIRE(ss.str() == "foo => bar\nhidden_foo => hidden_bar");
+            }
+        }
+    }
+    GIVEN("a resolver that adds a single fact") {
+        facts.add(make_shared<simple_resolver>());
+        THEN("it should resolve facts into the collection") {
+            REQUIRE(facts.size() == 1u);
+            REQUIRE_FALSE(facts.empty());
+            auto fact = facts.get<string_value>("foo");
+            REQUIRE(fact);
+            REQUIRE(fact->value() == "bar");
+            fact = dynamic_cast<string_value const *>(facts["foo"]);
+            REQUIRE(fact);
+            REQUIRE(fact->value() == "bar");
+        }
+        WHEN("serializing to JSON") {
+            THEN("it should contain the same values") {
+                ostringstream ss;
+                facts.write(ss, format::json);
+                REQUIRE(ss.str() == "{\n  \"foo\": \"bar\"\n}");
+            }
+        }
+        WHEN("serializing to YAML") {
+            THEN("it should contain the same values") {
+                ostringstream ss;
+                facts.write(ss, format::yaml);
+                REQUIRE(ss.str() == "foo: bar");
+            }
+        }
+        WHEN("serializing to text") {
+            GIVEN("only a single query") {
+                THEN("it should output only the value") {
+                    ostringstream ss;
+                    facts.write(ss, format::hash, {"foo"});
+                    REQUIRE(ss.str() == "bar");
+                }
+            }
+            GIVEN("no queries") {
+                THEN("it should contain the same values") {
+                    ostringstream ss;
+                    facts.write(ss, format::hash);
+                    REQUIRE(ss.str() == "foo => bar");
+                }
+            }
+        }
+    }
+    GIVEN("a resolver that adds multiple facts") {
+        facts.add(make_shared<multi_resolver>());
+        THEN("it should enumerate the facts in order") {
+            int index = 0;
+            facts.each([&](string const &name, value const *val) {
+                auto string_val = dynamic_cast<string_value const *>(val);
+                REQUIRE(string_val);
+                if (index == 0) {
+                    REQUIRE(name == "bar");
+                    REQUIRE(string_val->value() == "foo");
+                } else if (index == 1) {
+                    REQUIRE(name == "foo");
+                    REQUIRE(string_val->value() == "bar");
+                } else {
+                    FAIL("should not be reached");
+                }
+                ++index;
+                return true;
+            });
+        }
+        WHEN("serializing to JSON") {
+            THEN("it should contain the same values") {
+                ostringstream ss;
+                facts.write(ss, format::json);
+                REQUIRE(ss.str() == "{\n  \"bar\": \"foo\",\n  \"foo\": \"bar\"\n}");
+            }
+        }
+        WHEN("serializing to YAML") {
+            THEN("it should contain the same values") {
+                ostringstream ss;
+                facts.write(ss, format::yaml);
+                REQUIRE(ss.str() == "bar: foo\nfoo: bar");
+            }
+        }
+        WHEN("serializing to text") {
+            THEN("it should contain the same values") {
+                ostringstream ss;
+                facts.write(ss, format::hash);
+                REQUIRE(ss.str() == "bar => foo\nfoo => bar");
+            }
+        }
+    }
+    GIVEN("external facts paths to search") {
+        facts.add_external_facts({
+                LIBFACTER_TESTS_DIRECTORY "/fixtures/facts/external/yaml",
+                LIBFACTER_TESTS_DIRECTORY "/fixtures/facts/external/json",
+                LIBFACTER_TESTS_DIRECTORY "/fixtures/facts/external/text",
+        });
+        REQUIRE_FALSE(facts.empty());
+        REQUIRE(facts.size() == 20u);
+        WHEN("YAML files are present") {
+            THEN("facts should be added") {
+                REQUIRE(facts.get<string_value>("yaml_fact1"));
+                REQUIRE(facts.get<integer_value>("yaml_fact2"));
+                REQUIRE(facts.get<boolean_value>("yaml_fact3"));
+                REQUIRE(facts.get<double_value>("yaml_fact4"));
+                REQUIRE(facts.get<array_value>("yaml_fact5"));
+                REQUIRE(facts.get<map_value>("yaml_fact6"));
+                REQUIRE(facts.get<string_value>("yaml_fact7"));
+                REQUIRE(facts.get<string_value>("not_bool"));
+                REQUIRE(facts.get<string_value>("not_int"));
+                REQUIRE(facts.get<string_value>("not_double"));
+            }
+        }
+        WHEN("JSON files are present") {
+            THEN("facts should be added") {
+                REQUIRE(facts.get<string_value>("json_fact1"));
+                REQUIRE(facts.get<integer_value>("json_fact2"));
+                REQUIRE(facts.get<boolean_value>("json_fact3"));
+                REQUIRE(facts.get<double_value>("json_fact4"));
+                REQUIRE(facts.get<array_value>("json_fact5"));
+                REQUIRE(facts.get<map_value>("json_fact6"));
+                REQUIRE(facts.get<string_value>("json_fact7"));
+            }
+        }
+        WHEN("text files are present") {
+            THEN("facts should be added") {
+                REQUIRE(facts.get<string_value>("txt_fact1"));
+                REQUIRE(facts.get<string_value>("txt_fact2"));
+                REQUIRE_FALSE(facts.get<string_value>("txt_fact3"));
+                REQUIRE(facts.get<string_value>("txt_fact4"));
+            }
+        }
+    }
+    GIVEN("structured fact data") {
+        auto map = make_value<map_value>();
+        map->add("string", make_value<string_value>("hello"));
+        map->add("integer", make_value<integer_value>(5));
+        map->add("double", make_value<double_value>(0.3));
+        map->add("boolean", make_value<boolean_value>(true));
+        auto submap = make_value<map_value>();
+        submap->add("foo", make_value<string_value>("bar"));
+        map->add("submap", move(submap));
+        submap = make_value<map_value>();
+        submap->add("jam", make_value<string_value>("cakes"));
+        map->add("name.with.dots", move(submap));
+        auto array = make_value<array_value>();
+        array->add(make_value<string_value>("foo"));
+        array->add(make_value<integer_value>(10));
+        array->add(make_value<double_value>(2.3));
+        array->add(make_value<boolean_value>(false));
+        submap = make_value<map_value>();
+        submap->add("bar", make_value<string_value>("baz"));
+        array->add(move(submap));
+        map->add("array", move(array));
+        facts.add("map", move(map));
+        facts.add("string", make_value<string_value>("world"));
+
+        WHEN("queried with a matching top level name") {
+            THEN("a value should be returned") {
+                auto mvalue = facts.query<map_value>("map");
+                REQUIRE(mvalue);
+                REQUIRE(mvalue->size() == 7u);
+            }
+        }
+        WHEN("queried with a non-matching top level name") {
+            THEN("it should return null") {
+                REQUIRE_FALSE(facts.query<string_value>("does not exist"));
+            }
+        }
+        WHEN("querying for a sub element of a type that is not a map") {
+            THEN("it should return null") {
+                REQUIRE_FALSE(facts.query<string_value>("string.foo"));
+            }
+        }
+        WHEN("queried with for a sub element") {
+            THEN("a value should be returned") {
+                auto svalue = facts.query<string_value>("map.string");
+                REQUIRE(svalue);
+                REQUIRE(svalue->value() == "hello");
+                auto ivalue = facts.query<integer_value>("map.integer");
+                REQUIRE(ivalue);
+                REQUIRE(ivalue->value() == 5);
+                auto dvalue = facts.query<double_value>("map.double");
+                REQUIRE(dvalue);
+                REQUIRE(dvalue->value() == Approx(0.3));
+                auto bvalue = facts.query<boolean_value>("map.boolean");
+                REQUIRE(bvalue);
+                REQUIRE(bvalue->value());
+                auto mvalue = facts.query<map_value>("map.submap");
+                REQUIRE(mvalue);
+                REQUIRE(mvalue->size() == 1u);
+            }
+        }
+        WHEN("querying along a path of map values") {
+            THEN("a value should be returned") {
+                auto svalue = facts.query<string_value>("map.submap.foo");
+                REQUIRE(svalue);
+                REQUIRE(svalue->value() == "bar");
+            }
+        }
+        WHEN("querying into an array with an in-bounds index") {
+            THEN("a value should be returned") {
+                auto avalue = facts.query<array_value>("map.array");
+                REQUIRE(avalue);
+                REQUIRE(avalue->size() == 5u);
+                for (size_t i = 0; i < avalue->size(); ++i) {
+                    REQUIRE(facts.query("map.array." + to_string(i)));
+                }
+            }
+        }
+        WHEN("querying into an array with a non-numeric index") {
+            THEN("it should return null") {
+                REQUIRE_FALSE(facts.query("map.array.foo"));
+            }
+        }
+        WHEN("uerying into an array with an out-of-bounds index") {
+            THEN("it should return null") {
+                REQUIRE_FALSE(facts.query("map.array.5"));
+            }
+        }
+        WHEN("querying into an element inside of an array") {
+            THEN("it should return a value") {
+                auto svalue = facts.query<string_value>("map.array.4.bar");
+                REQUIRE(svalue);
+                REQUIRE(svalue->value() == "baz");
+            }
+        }
+        WHEN("a fact name contains dots") {
+            THEN("it not return a value unless quoted") {
+                REQUIRE_FALSE(facts.query("map.name.with.dots"));
+            }
+            THEN("it should return a value when quoted") {
+                auto svalue = facts.query<string_value>("map.\"name.with.dots\".jam");
+                REQUIRE(svalue);
+                REQUIRE(svalue->value() == "cakes");
+            }
+        }
+    }
+    GIVEN("a fact from an environment variable") {
+        auto var = temp_variable("FACTER_Foo", "bar");
+        bool added = false;
+        facts.add_environment_facts([&](string const& name) {
+            added = name == "foo";
+        });
+        REQUIRE(added);
+
+        THEN("the fact should be present in the collection") {
+            REQUIRE(facts.size() == 1u);
+            auto value = facts.get<string_value>("foo");
+            REQUIRE(value);
+            REQUIRE(value->value() == "bar");
+        }
+    }
+    GIVEN("a fact from an environment with the same name as a built-in fact") {
+        facts.add_default_facts(true);
+        auto var = temp_variable("FACTER_KERNEL", "overridden");
+        bool added = false;
+        facts.add_environment_facts([&](string const& name) {
+            added = name == "kernel";
+        });
+        REQUIRE(added);
+
+        THEN("it should override the built-in fact's value") {
+            auto value = facts.get<string_value>("kernel");
+            REQUIRE(value);
+            REQUIRE(value->value() == "overridden");
+        }
+    }
+    GIVEN("two external fact directories to search") {
+        facts.add_external_facts({
+            LIBFACTER_TESTS_DIRECTORY "/fixtures/facts/external/ordering/foo",
+            LIBFACTER_TESTS_DIRECTORY "/fixtures/facts/external/ordering/bar"
+        });
+        THEN("it should have the fact value from the last file loaded") {
+            REQUIRE(facts.size() == 1u);
+            REQUIRE(facts.get<string_value>("foo"));
+            REQUIRE(facts.get<string_value>("foo")->value() == "set in bar/foo.yaml");
+        }
+        facts.clear();
+        facts.add_external_facts({
+            LIBFACTER_TESTS_DIRECTORY "/fixtures/facts/external/ordering/bar",
+            LIBFACTER_TESTS_DIRECTORY "/fixtures/facts/external/ordering/foo"
+        });
+        THEN("it should have the fact value from the last file loaded") {
+            REQUIRE(facts.size() == 1u);
+            REQUIRE(facts.get<string_value>("foo"));
+            REQUIRE(facts.get<string_value>("foo")->value() == "set in foo/foo.yaml");
+        }
+    }
+}
+
+class collection_override : public collection
+{
+ protected:
+    virtual vector<string> get_external_fact_directories() const override
+    {
+        return {LIBFACTER_TESTS_DIRECTORY "/fixtures/facts/external/ordering/foo"};
+    }
+};
+
+SCENARIO("using the fact collection with a default external fact path") {
+    collection_override facts;
+    REQUIRE(facts.size() == 0u);
+    REQUIRE(facts.empty());
+
+    GIVEN("a specified external fact directory with an overriding fact to search") {
+        facts.add_external_facts({
+            LIBFACTER_TESTS_DIRECTORY "/fixtures/facts/external/ordering/bar"
+        });
+        THEN("it should have the fact value from the last file loaded") {
+            REQUIRE(facts.size() == 1u);
+            REQUIRE(facts.get<string_value>("foo"));
+            REQUIRE(facts.get<string_value>("foo")->value() == "set in bar/foo.yaml");
+        }
+    }
+
+    GIVEN("a specified external fact directory with new facts to search") {
+        facts.add_external_facts({
+            LIBFACTER_TESTS_DIRECTORY "/fixtures/facts/external/text",
+        });
+        REQUIRE_FALSE(facts.empty());
+        REQUIRE(facts.size() == 4u);
+        THEN("facts from both directories should be added") {
+            REQUIRE(facts.get<string_value>("foo"));
+            REQUIRE(facts.get<string_value>("txt_fact1"));
+            REQUIRE(facts.get<string_value>("txt_fact2"));
+            REQUIRE_FALSE(facts.get<string_value>("txt_fact3"));
+            REQUIRE(facts.get<string_value>("txt_fact4"));
+        }
+    }
+}
+
+SCENARIO("using the fact collection with a blocklist") {
+    collection_fixture facts({ "test" });
+    REQUIRE(facts.size() == 0u);
+    REQUIRE(facts.empty());
+
+    GIVEN("a resolver that adds a single fact") {
+        facts.add(make_shared<simple_resolver>());
+        THEN("the fact should not be resolved") {
+            REQUIRE(facts.size() == 0u);
+            REQUIRE_FALSE(facts.get<string_value>("foo"));
+        }
+    }
+    GIVEN("a resolver that adds multiple facts") {
+        facts.add(make_shared<multi_resolver>());
+        THEN("none of the facts should resolve") {
+            REQUIRE(facts.size() == 0u);
+            REQUIRE_FALSE(facts.get<string_value>("foo"));
+            REQUIRE_FALSE(facts.get<string_value>("bar"));
+        }
+    }
+}
+
+SCENARIO("querying blockable and cacheable fact groups") {
+    collection_fixture facts;
+    REQUIRE(facts.size() == 0u);
+    REQUIRE(facts.empty());
+
+    GIVEN("a blockable resolver that adds a single fact") {
+        facts.add(make_shared<simple_resolver>());
+        THEN("resolver and its fact should be listed as blockable") {
+            auto blockable = facts.get_blockable_fact_groups();
+            REQUIRE(blockable.size() == 1);
+            REQUIRE(blockable["test"] == vector<string>({"foo"}));
+        }
+        THEN("resolver and its fact should be listed as in the collection") {
+            auto facts_present = facts.get_fact_groups();
+            REQUIRE(facts_present.size() == 1);
+            REQUIRE(facts_present["test"] == vector<string>({"foo"}));
+        }
+    }
+    GIVEN("a blockable resolver that adds multiple facts") {
+        facts.add(make_shared<multi_resolver>());
+        THEN("resolver and its facts should be listed as blockable") {
+            auto blockable = facts.get_blockable_fact_groups();
+            REQUIRE(blockable.size() == 1);
+            REQUIRE(blockable["test"] == vector<string>({"foo", "bar"}));
+        }
+        THEN("resolver and its facts should be listed as in the collection") {
+            auto facts_present = facts.get_fact_groups();
+            REQUIRE(facts_present.size() == 1);
+            REQUIRE(facts_present["test"] == vector<string>({"foo", "bar"}));
+        }
+    }
+    GIVEN("a unblockable resolver that adds a single fact") {
+        facts.add(make_shared<unblockable_resolver>());
+        THEN("resolver and its facts should not be listed as blockable") {
+            auto blockable = facts.get_blockable_fact_groups();
+            REQUIRE(blockable.size() == 0);
+        }
+        THEN("resolver and its fact should be listed as in the collection") {
+            auto facts_present = facts.get_fact_groups();
+            REQUIRE(facts_present.size() == 1);
+            REQUIRE(facts_present["unblockable"] == vector<string>({"foo"}));
+        }
+    }
+
+}