cfacter 3.11.0.rc.20180314

data/ext/facter/facter/lib/tests/ruby/ruby_dirfacts.cc

@@ -0,0 +1,35 @@
+#include <catch.hpp>
+#include <facter/facts/scalar_value.hpp>
+#include <facter/ruby/ruby.hpp>
+#include <internal/ruby/ruby_value.hpp>
+#include <leatherman/ruby/api.hpp>
+#include "../fixtures.hpp"
+#include "../collection_fixture.hpp"
+#include "./ruby_helper.hpp"
+
+#include "../mock_server.hpp"
+
+using namespace std;
+using namespace facter::ruby;
+using namespace facter::testing;
+using namespace leatherman::ruby;
+
+SCENARIO("directories of custom facts written in Ruby") {
+    collection_fixture facts;
+    REQUIRE(facts.size() == 0u);
+
+    // Setup ruby
+    auto& ruby = api::instance();
+    REQUIRE(ruby.initialized());
+    ruby.include_stack_trace(true);
+
+    string fixtures = LIBFACTER_TESTS_DIRECTORY "/fixtures/ruby/";
+
+    GIVEN("a fact that performs network activity") {
+        facter::mock_server m(42000);
+        load_custom_facts(facts, vector<string>{fixtures+"custom_dir"});
+        THEN("the network location should resolve") {
+            REQUIRE(ruby_value_to_string(facts.get<ruby_value>("sometest")) == "\"Yay\"");
+        }
+    }
+}

data/ext/facter/facter/lib/tests/ruby/ruby_helper.cc

@@ -0,0 +1,41 @@
+#include "ruby_helper.hpp"
+#include <leatherman/logging/logging.hpp>
+#include <leatherman/ruby/api.hpp>
+#include <internal/ruby/module.hpp>
+#include "../fixtures.hpp"
+
+using namespace std;
+using namespace facter::ruby;
+using namespace facter::facts;
+using namespace leatherman::ruby;
+
+bool load_custom_fact(string const& filename, collection& facts)
+{
+    auto& ruby = api::instance();
+
+    module mod(facts);
+
+    string file = LIBFACTER_TESTS_DIRECTORY "/fixtures/ruby/" + filename;
+    VALUE result = ruby.rescue([&]() {
+        // Do not construct C++ objects in a rescue callback
+        // C++ stack unwinding will not take place if a Ruby exception is thrown!
+        ruby.rb_load(ruby.utf8_value(file), 0);
+        return ruby.true_value();
+    }, [&](VALUE ex) {
+        LOG_ERROR("error while resolving custom facts in {1}: {2}", file, ruby.exception_to_string(ex));
+        return ruby.false_value();
+    });
+
+    mod.resolve_facts();
+
+    return ruby.is_true(result);
+}
+
+string ruby_value_to_string(value const* value)
+{
+    ostringstream ss;
+    if (value) {
+        value->write(ss);
+    }
+    return ss.str();
+}

data/ext/facter/facter/lib/tests/ruby/ruby_helper.hpp

@@ -0,0 +1,8 @@
+#pragma once
+#include <facter/facts/collection.hpp>
+#include <facter/facts/value.hpp>
+#include <string>
+
+bool load_custom_fact(std::string const& filename, facter::facts::collection& facts);
+
+std::string ruby_value_to_string(facter::facts::value const* value);

data/ext/facter/facter/lib/tests/ruby/windows/ruby.cc

@@ -0,0 +1,53 @@
+#include <catch.hpp>
+#include <leatherman/ruby/api.hpp>
+#include <leatherman/util/scoped_env.hpp>
+#include <leatherman/util/environment.hpp>
+#include <internal/ruby/ruby_value.hpp>
+#include "../ruby_helper.hpp"
+#include "../../collection_fixture.hpp"
+#include "../../fixtures.hpp"
+
+using namespace std;
+using namespace facter::testing;
+using namespace facter::ruby;
+using namespace leatherman::ruby;
+using namespace leatherman::util;
+
+SCENARIO("Windows custom facts written in Ruby") {
+    collection_fixture facts;
+    REQUIRE(facts.size() == 0u);
+
+    // Setup ruby
+    auto& ruby = api::instance();
+    REQUIRE(ruby.initialized());
+    ruby.include_stack_trace(true);
+
+    GIVEN("a fact that loads win32ole") {
+        REQUIRE(load_custom_fact("windows/ole.rb", facts));
+        THEN("the value should be in the collection") {
+            REQUIRE(ruby_value_to_string(facts.get<ruby_value>("foo")) == "\"bar\"");
+        }
+    }
+}
+
+SCENARIO("Run command with space in path") {
+    collection_fixture facts;
+    REQUIRE(facts.size() == 0u);
+
+    // Setup ruby
+    auto& ruby = api::instance();
+    REQUIRE(ruby.initialized());
+    ruby.include_stack_trace(true);
+
+    GIVEN("a directory with a space on the PATH") {
+        string path;
+        environment::get("PATH", path);
+        scoped_env var("PATH", path + environment::get_path_separator() + LIBFACTER_TESTS_DIRECTORY "/fixtures/execution/with space");
+        environment::reload_search_paths();
+        REQUIRE(load_custom_fact("command_with_space.rb", facts));
+        THEN("the command should execute successfully") {
+            REQUIRE(ruby_value_to_string(facts.get<ruby_value>("foo")) == "\"bar\"");
+        }
+    }
+    environment::reload_search_paths();
+}

data/ext/facter/facter/lib/tests/util/bsd/scoped_ifaddrs.cc

@@ -0,0 +1,10 @@
+#include <catch.hpp>
+#include <internal/util/bsd/scoped_ifaddrs.hpp>
+
+using namespace std;
+using namespace facter::util::bsd;
+
+SCENARIO("constructing a scoped_ifaddrs") {
+    scoped_ifaddrs addrs;
+    REQUIRE(static_cast<ifaddrs*>(addrs));
+}

data/ext/facter/facter/lib/tests/util/posix/scoped_addrinfo.cc

@@ -0,0 +1,11 @@
+#include <catch.hpp>
+#include <internal/util/posix/scoped_addrinfo.hpp>
+
+using namespace std;
+using namespace facter::util::posix;
+
+SCENARIO("constructing a scoped_addrinfo") {
+    scoped_addrinfo info("localhost");
+    REQUIRE(info.result() == 0);
+    REQUIRE(static_cast<addrinfo*>(info));
+}

data/ext/facter/facter/lib/tests/util/posix/scoped_bio.cc

@@ -0,0 +1,12 @@
+#pragma clang diagnostic ignored "-Wdeprecated-declarations"
+#include <catch.hpp>
+#include <internal/util/posix/scoped_bio.hpp>
+#include <openssl/evp.h>
+
+using namespace std;
+using namespace facter::util::posix;
+
+SCENARIO("constructing a scoped_bio") {
+    scoped_bio b64((BIO_f_base64()));
+    REQUIRE(static_cast<BIO*>(b64));
+}

data/ext/facter/facter/lib/tests/util/posix/scoped_descriptor.cc

@@ -0,0 +1,22 @@
+#include <catch.hpp>
+#include <internal/util/posix/scoped_descriptor.hpp>
+#include <sys/socket.h>
+#include <fcntl.h>
+
+using namespace std;
+using namespace facter::util::posix;
+
+SCENARIO("constructing a POSIX scoped descriptor") {
+
+    int sock = socket(AF_INET, SOCK_DGRAM, 0);
+
+    {
+        scoped_descriptor scoped(sock);
+    }
+
+    // This check could theoretically fail if the OS reassigns the file
+    // descriptor between the above destructor call and this line
+    // This likely will not happen during testing.
+    REQUIRE(fcntl(sock, F_GETFD) == -1);
+    REQUIRE(errno == EBADF);
+}

data/ext/facter/facter/lib/tests/util/string.cc

@@ -0,0 +1,291 @@
+#include <catch.hpp>
+#include <facter/util/string.hpp>
+
+using namespace std;
+using namespace facter::util;
+
+SCENARIO("converting bytes to hex strings") {
+    uint8_t buffer[] = { 0xBA, 0xAD, 0xF0, 0x0D };
+    WHEN("specifying uppercase") {
+        THEN("hex characters should be uppercase") {
+            REQUIRE(to_hex(buffer, sizeof(buffer), true) == "BAADF00D");
+        }
+    }
+    WHEN("specifying the default lowercase") {
+        THEN("hex characters should be lowercase") {
+            REQUIRE(to_hex(buffer, sizeof(buffer)) == "baadf00d");
+        }
+    }
+    GIVEN("a null buffer") {
+        THEN("an empty string should be returned") {
+            REQUIRE(to_hex(nullptr, 0) == "");
+        }
+    }
+    GIVEN("an empty buffer") {
+        THEN("an empty string should be returned") {
+            REQUIRE(to_hex(buffer, 0) == "");
+        }
+    }
+}
+
+SCENARIO("converting bytes to SI unit strings") {
+    GIVEN("zero bytes") {
+        THEN("the string should show 0 bytes") {
+            REQUIRE(si_string(0) == "0 bytes");
+        }
+    }
+    GIVEN("less than 1 KiB") {
+        WHEN("not close to 1 KiB") {
+            THEN("the string should be in bytes") {
+                REQUIRE(si_string(100) == "100 bytes");
+            }
+        }
+        WHEN("close to 1 KiB") {
+            THEN("the string should be in bytes") {
+                REQUIRE(si_string(1023) == "1023 bytes");
+            }
+        }
+    }
+    GIVEN("exactly 1 KiB") {
+        THEN("the string should be in KiB") {
+            REQUIRE(si_string(1024) == "1.00 KiB");
+        }
+    }
+    GIVEN("less than 1 MiB") {
+        WHEN("not close to 1 MiB") {
+            THEN("the string should be in KiB") {
+                REQUIRE(si_string(4097) == "4.00 KiB");
+            }
+        }
+        WHEN("almost 1 MiB") {
+            THEN("the string should be in MiB") {
+                REQUIRE(si_string((1024ull * 1024ull) - 1) == "1.00 MiB");
+            }
+        }
+    }
+    GIVEN("exactly 1 MiB") {
+        THEN("the string should be in MiB") {
+            REQUIRE(si_string(1024ull * 1024ull) == "1.00 MiB");
+        }
+    }
+    GIVEN("less than 1 GiB") {
+        WHEN("not close to 1 GiB") {
+            THEN("the string should be in MiB") {
+                REQUIRE(si_string(10ull * 1024ull * 1023ull) == "9.99 MiB");
+            }
+        }
+        WHEN("almost 1 GiB") {
+            THEN("the string should be in GiB") {
+                REQUIRE(si_string((1024ull * 1024ull * 1024ull) - 1) == "1.00 GiB");
+            }
+        }
+    }
+    GIVEN("exactly 1 GiB") {
+        THEN("the string should be in GiB") {
+            REQUIRE(si_string(1024ull * 1024ull * 1024ull) == "1.00 GiB");
+        }
+    }
+    GIVEN("less than 1 TiB") {
+        WHEN("not close to 1 TiB") {
+            THEN("the string should be in GiB") {
+                REQUIRE(si_string(12ull * 1024ull * 1024ull * 1023ull) == "11.99 GiB");
+            }
+        }
+        WHEN("almost 1 TiB") {
+            THEN("the string should be in TiB") {
+                REQUIRE(si_string((1024ull * 1024ull * 1024ull * 1024ull) - 1) == "1.00 TiB");
+            }
+        }
+    }
+    GIVEN("exactly 1 TiB") {
+        THEN("the string should be in TiB") {
+            REQUIRE(si_string(1024ull * 1024ull * 1024ull * 1024ull) == "1.00 TiB");
+        }
+    }
+    GIVEN("less than 1 PiB") {
+        WHEN("not close to 1 PiB") {
+            THEN("the string should be in TiB") {
+                REQUIRE(si_string(50ull * 1024ull * 1024ull * 1024ull * 1023ull) == "49.95 TiB");
+            }
+        }
+        WHEN("almost 1 PiB") {
+            THEN("the string should be in PiB") {
+                REQUIRE(si_string((1024ull * 1024ull * 1024ull * 1024ull * 1024ull) - 1) == "1.00 PiB");
+            }
+        }
+    }
+    GIVEN("exactly 1 PiB") {
+        THEN("the string should be in PiB") {
+            REQUIRE(si_string(1024ull * 1024ull * 1024ull * 1024ull * 1024ull) == "1.00 PiB");
+        }
+    }
+    GIVEN("less than 1 EiB") {
+        WHEN("not close to 1 EiB") {
+            THEN("the string should be in PiB") {
+                REQUIRE(si_string(100ull * 1024ull * 1024ull * 1024ull * 1024ull * 1023ull) == "99.90 PiB");
+            }
+        }
+        WHEN("almost 1 EiB") {
+            THEN("the string should be in EiB") {
+                REQUIRE(si_string((1024ull * 1024ull * 1024ull * 1024ull * 1024ull * 1024ull) - 1) == "1.00 EiB");
+            }
+        }
+    }
+    GIVEN("exactly 1 EiB") {
+        THEN("the string should be in PiB") {
+            REQUIRE(si_string(1024ull * 1024ull * 1024ull * 1024ull * 1024ull * 1024ull) == "1.00 EiB");
+        }
+    }
+    GIVEN("the unsigned maximum 64-bit value") {
+        THEN("the string should be in EiB") {
+            REQUIRE(si_string(numeric_limits<uint64_t>::max()) == "16.00 EiB");
+        }
+    }
+}
+
+SCENARIO("converting percentages to strings") {
+    GIVEN("any value out of zero") {
+        THEN("it should be 100%") {
+            REQUIRE(percentage(0, 0) == "100%");
+            REQUIRE(percentage(10000, 0) == "100%");
+        }
+    }
+    GIVEN("zero out of any value") {
+        THEN("it should be 0%") {
+            REQUIRE(percentage(0, 10) == "0%");
+            REQUIRE(percentage(0, 100) == "0%");
+        }
+    }
+    GIVEN("more than the maximum") {
+        THEN("it should be 100%") {
+            REQUIRE(percentage(1000, 100) == "100%");
+        }
+    }
+    GIVEN("small percentages") {
+        THEN("it should round to the nearest hundred of a percent") {
+            REQUIRE(percentage(1, 100) == "1.00%");
+            REQUIRE(percentage(11, 1000) == "1.10%");
+            REQUIRE(percentage(111, 10000) == "1.11%");
+            REQUIRE(percentage(1140000000ul, 50000000000ul) == "2.28%");
+            REQUIRE(percentage(1000, 10000) == "10.00%");
+        }
+    }
+    GIVEN("large percentages") {
+        THEN("it should round to the nearest hundred of a percent, but never 100%") {
+            REQUIRE(percentage(414906340801ul, 560007030104ul) == "74.09%");
+            REQUIRE(percentage(99984, 100000) == "99.98%");
+            REQUIRE(percentage(999899, 1000000) == "99.99%");
+            REQUIRE(percentage(99999, 100000) == "99.99%");
+        }
+    }
+    GIVEN("the maximum value") {
+        WHEN("off by one") {
+            THEN("it should not be 100%") {
+                REQUIRE(percentage(numeric_limits<uint64_t>::max() - 1, numeric_limits<uint64_t>::max()) == "99.99%");
+
+            }
+        }
+        WHEN("both are maximum") {
+            THEN("it should be 100%") {
+                REQUIRE(percentage(numeric_limits<uint64_t>::max(), numeric_limits<uint64_t>::max()) == "100%");
+            }
+        }
+    }
+
+}
+
+SCENARIO("converting frequencies to strings") {
+    GIVEN("a frequency of 0") {
+        THEN("it should report in Hz") {
+            REQUIRE(frequency(0) == "0 Hz");
+        }
+    }
+    GIVEN("a frequency of less than 1 kHz") {
+        WHEN("not close to 1 kHz") {
+            THEN("it should be in Hz") {
+                REQUIRE(frequency(100) == "100 Hz");
+            }
+        }
+        WHEN("close to 1 kHz") {
+            THEN("it should be in Hz") {
+                REQUIRE(frequency(999) == "999 Hz");
+            }
+        }
+    }
+    GIVEN("exactly 1 kHz") {
+        THEN("it should be in kHz") {
+            REQUIRE(frequency(1000) == "1.00 kHz");
+        }
+    }
+    GIVEN("a frequency of less than 1 MHz") {
+        WHEN("not close to 1 MHz") {
+            THEN("it should be in kHz") {
+                REQUIRE(frequency(1000 * 999) == "999.00 kHz");
+            }
+        }
+        WHEN("close to 1 MHz") {
+            THEN("it should be in MHz") {
+                REQUIRE(frequency((1000 * 1000) - 1) == "1.00 MHz");
+            }
+        }
+    }
+    GIVEN("exactly 1 MHz") {
+        THEN("it should be in MHz") {
+            REQUIRE(frequency(1000 * 1000) == "1.00 MHz");
+        }
+    }
+    GIVEN("a frequency of less than 1 GHz") {
+        WHEN("not close to 1 GHz") {
+            THEN("it should be in MHz") {
+                REQUIRE(frequency(1000 * 1000 * 999) == "999.00 MHz");
+            }
+        }
+        WHEN("close to 1 GHz") {
+            THEN("it should be in GHz") {
+                REQUIRE(frequency((1000 * 1000 * 1000) - 1) == "1.00 GHz");
+            }
+        }
+    }
+    GIVEN("exactly 1 GHz") {
+        THEN("it should be in GHz") {
+            REQUIRE(frequency(1000 * 1000 * 1000) == "1.00 GHz");
+        }
+    }
+    GIVEN("a frequency of less than 1 THz") {
+        WHEN("not close to 1 THz") {
+            THEN("it should be in GHz") {
+                REQUIRE(frequency(1000ull * 1000 * 1000 * 999) == "999.00 GHz");
+            }
+        }
+        WHEN("close to 1 THz") {
+            THEN("it should be in THz") {
+                REQUIRE(frequency((1000ull * 1000 * 1000 * 1000) - 1) == "1.00 THz");
+            }
+        }
+    }
+    GIVEN("exactly 1 THz") {
+        THEN("it should be in THz") {
+            REQUIRE(frequency(1000ull * 1000 * 1000 * 1000) == "1.00 THz");
+        }
+    }
+    GIVEN("the maximum value") {
+        THEN("it should be in Hz") {
+            REQUIRE(frequency(numeric_limits<int64_t>::max()) == "9223372036854775807 Hz");
+        }
+    }
+}
+
+SCENARIO("converting strings to integers") {
+    GIVEN("a string that is a valid integer") {
+        THEN("it should be converted to its integer representation") {
+            auto oint = maybe_stoi("12");
+            REQUIRE(oint.is_initialized());
+            REQUIRE(oint.get_value_or(0) == 12);
+        }
+    }
+    GIVEN("a string that is not a valid integer") {
+        THEN("nothing should be returned") {
+            REQUIRE_FALSE(maybe_stoi("foo").is_initialized());
+        }
+    }
+}