Unit tests and external libraries

src/libstore-test-support/.version

@@ -0,0 +1 @@
+../../.version

src/libstore-test-support/meson.build

@@ -0,0 +1,130 @@
+project('nix-store-test-support', 'cpp',
+  version : files('.version'),
+  default_options : [
+    'cpp_std=c++2a',
+    # TODO(Qyriad): increase the warning level
+    'warning_level=1',
+    'debug=true',
+    'optimization=2',
+    'errorlogs=true', # Please print logs for tests that fail
+  ],
+  meson_version : '>= 1.1',
+  license : 'LGPL-2.1-or-later',
+)
+
+cxx = meson.get_compiler('cpp')
+
+# See note in ../nix-util/meson.build
+deps_private = [ ]
+
+# See note in ../nix-util/meson.build
+deps_public = [ ]
+
+# See note in ../nix-util/meson.build
+deps_public_subproject = [ ]
+
+# See note in ../nix-util/meson.build
+deps_other = [ ]
+
+foreach nix_dep : [
+  dependency('nix-util'),
+  dependency('nix-util-test-support'),
+  dependency('nix-store'),
+]
+  if nix_dep.type_name() == 'internal'
+    deps_public_subproject += nix_dep
+    # subproject sadly no good for pkg-config module
+    deps_other += nix_dep
+  else
+    deps_public += nix_dep
+  endif
+endforeach
+
+rapidcheck = dependency('rapidcheck')
+deps_public += rapidcheck
+
+add_project_arguments(
+  # TODO(Qyriad): Yes this is how the autoconf+Make system did it.
+  # It would be nice for our headers to be idempotent instead.
+  '-include', 'config-util.hh',
+  '-include', 'config-store.hh',
+  '-Wno-deprecated-declarations',
+  '-Wimplicit-fallthrough',
+  '-Werror=switch',
+  '-Werror=switch-enum',
+  '-Wdeprecated-copy',
+  '-Wignored-qualifiers',
+  # Enable assertions in libstdc++ by default. Harmless on libc++. Benchmarked
+  # at ~1% overhead in `nix search`.
+  #
+  # FIXME: remove when we get meson 1.4.0 which will default this to on for us:
+  # https://mesonbuild.com/Release-notes-for-1-4-0.html#ndebug-setting-now-controls-c-stdlib-assertions
+  '-D_GLIBCXX_ASSERTIONS=1',
+  language : 'cpp',
+)
+
+sources = files(
+  'tests/derived-path.cc',
+  'tests/outputs-spec.cc',
+  'tests/path.cc',
+)
+
+include_dirs = [include_directories('.')]
+
+headers = files(
+  'tests/derived-path.hh',
+  'tests/libstore.hh',
+  'tests/nix_api_store.hh',
+  'tests/outputs-spec.hh',
+  'tests/path.hh',
+  'tests/protocol.hh',
+)
+
+if host_machine.system() == 'cygwin' or host_machine.system() == 'windows'
+  # Windows DLLs are stricter about symbol visibility than Unix shared
+  # objects --- see https://gcc.gnu.org/wiki/Visibility for details.
+  # This is a temporary sledgehammer to export everything like on Unix,
+  # and not detail with this yet.
+  #
+  # TODO do not do this, and instead do fine-grained export annotations.
+  linker_export_flags = ['-Wl,--export-all-symbols']
+else
+  linker_export_flags = []
+endif
+
+this_library = library(
+  'nix-store-test-support',
+  sources,
+  dependencies : deps_public + deps_private + deps_other,
+  include_directories : include_dirs,
+  # TODO: Remove `-lrapidcheck` when https://github.com/emil-e/rapidcheck/pull/326
+  #       is available. See also ../libutil/build.meson
+  link_args: linker_export_flags + ['-lrapidcheck'],
+  install : true,
+)
+
+install_headers(headers, subdir : 'nix', preserve_path : true)
+
+requires = []
+foreach dep : deps_public_subproject
+  requires += dep.name()
+endforeach
+requires += deps_public
+
+import('pkgconfig').generate(
+  this_library,
+  filebase : meson.project_name(),
+  name : 'Nix',
+  description : 'Nix Package Manager',
+  subdirs : ['nix'],
+  extra_cflags : ['-std=c++2a'],
+  requires : requires,
+  requires_private : deps_private,
+)
+
+meson.override_dependency(meson.project_name(), declare_dependency(
+  include_directories : include_dirs,
+  link_with : this_library,
+  compile_args : ['-std=c++2a'],
+  dependencies : deps_public_subproject + deps_public,
+))

src/libstore-test-support/tests/derived-path.cc

@@ -0,0 +1,57 @@
+#include <regex>
+
+#include <rapidcheck.h>
+
+#include "tests/derived-path.hh"
+
+namespace rc {
+using namespace nix;
+
+Gen<DerivedPath::Opaque> Arbitrary<DerivedPath::Opaque>::arbitrary()
+{
+    return gen::just(DerivedPath::Opaque {
+        .path = *gen::arbitrary<StorePath>(),
+    });
+}
+
+Gen<SingleDerivedPath::Built> Arbitrary<SingleDerivedPath::Built>::arbitrary()
+{
+    return gen::just(SingleDerivedPath::Built {
+        .drvPath = make_ref<SingleDerivedPath>(*gen::arbitrary<SingleDerivedPath>()),
+        .output = (*gen::arbitrary<StorePathName>()).name,
+    });
+}
+
+Gen<DerivedPath::Built> Arbitrary<DerivedPath::Built>::arbitrary()
+{
+    return gen::just(DerivedPath::Built {
+        .drvPath = make_ref<SingleDerivedPath>(*gen::arbitrary<SingleDerivedPath>()),
+        .outputs = *gen::arbitrary<OutputsSpec>(),
+    });
+}
+
+Gen<SingleDerivedPath> Arbitrary<SingleDerivedPath>::arbitrary()
+{
+    switch (*gen::inRange<uint8_t>(0, std::variant_size_v<SingleDerivedPath::Raw>)) {
+    case 0:
+        return gen::just<SingleDerivedPath>(*gen::arbitrary<SingleDerivedPath::Opaque>());
+    case 1:
+        return gen::just<SingleDerivedPath>(*gen::arbitrary<SingleDerivedPath::Built>());
+    default:
+        assert(false);
+    }
+}
+
+Gen<DerivedPath> Arbitrary<DerivedPath>::arbitrary()
+{
+    switch (*gen::inRange<uint8_t>(0, std::variant_size_v<DerivedPath::Raw>)) {
+    case 0:
+        return gen::just<DerivedPath>(*gen::arbitrary<DerivedPath::Opaque>());
+    case 1:
+        return gen::just<DerivedPath>(*gen::arbitrary<DerivedPath::Built>());
+    default:
+        assert(false);
+    }
+}
+
+}

src/libstore-test-support/tests/derived-path.hh

@@ -0,0 +1,39 @@
+#pragma once
+///@file
+
+#include <rapidcheck/gen/Arbitrary.h>
+
+#include <derived-path.hh>
+
+#include "tests/path.hh"
+#include "tests/outputs-spec.hh"
+
+namespace rc {
+using namespace nix;
+
+template<>
+struct Arbitrary<SingleDerivedPath::Opaque> {
+    static Gen<SingleDerivedPath::Opaque> arbitrary();
+};
+
+template<>
+struct Arbitrary<SingleDerivedPath::Built> {
+    static Gen<SingleDerivedPath::Built> arbitrary();
+};
+
+template<>
+struct Arbitrary<SingleDerivedPath> {
+    static Gen<SingleDerivedPath> arbitrary();
+};
+
+template<>
+struct Arbitrary<DerivedPath::Built> {
+    static Gen<DerivedPath::Built> arbitrary();
+};
+
+template<>
+struct Arbitrary<DerivedPath> {
+    static Gen<DerivedPath> arbitrary();
+};
+
+}

src/libstore-test-support/tests/libstore.hh

@@ -0,0 +1,34 @@
+#pragma once
+///@file
+
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+
+#include "store-api.hh"
+
+namespace nix {
+
+class LibStoreTest : public virtual ::testing::Test
+{
+public:
+    static void SetUpTestSuite()
+    {
+        initLibStore(false);
+    }
+
+protected:
+    LibStoreTest()
+        : store(openStore({
+            .variant =
+                StoreReference::Specified{
+                    .scheme = "dummy",
+                },
+            .params = {},
+        }))
+    {
+    }
+
+    ref<Store> store;
+};
+
+} /* namespace nix */

src/libstore-test-support/tests/nix_api_store.hh

@@ -0,0 +1,66 @@
+#pragma once
+///@file
+#include "tests/nix_api_util.hh"
+
+#include "file-system.hh"
+
+#include "nix_api_store.h"
+#include "nix_api_store_internal.h"
+
+#include <filesystem>
+#include <gtest/gtest.h>
+
+namespace fs = std::filesystem;
+
+namespace nixC {
+class nix_api_store_test : public nix_api_util_context
+{
+public:
+    nix_api_store_test()
+    {
+        nix_libstore_init(ctx);
+        init_local_store();
+    };
+
+    ~nix_api_store_test() override
+    {
+        nix_store_free(store);
+
+        for (auto & path : fs::recursive_directory_iterator(nixDir)) {
+            fs::permissions(path, fs::perms::owner_all);
+        }
+        fs::remove_all(nixDir);
+    }
+
+    Store * store;
+    std::string nixDir;
+    std::string nixStoreDir;
+
+protected:
+    void init_local_store()
+    {
+#ifdef _WIN32
+        // no `mkdtemp` with MinGW
+        auto tmpl = nix::defaultTempDir() + "/tests_nix-store.";
+        for (size_t i = 0; true; ++i) {
+            nixDir = tmpl + std::string { i };
+            if (fs::create_directory(nixDir)) break;
+        }
+#else
+        auto tmpl = nix::defaultTempDir() + "/tests_nix-store.XXXXXX";
+        nixDir = mkdtemp((char *) tmpl.c_str());
+#endif
+
+        nixStoreDir = nixDir + "/my_nix_store";
+
+        // Options documented in `nix help-stores`
+        const char * p1[] = {"store", nixStoreDir.c_str()};
+        const char * p2[] = {"state", (new std::string(nixDir + "/my_state"))->c_str()};
+        const char * p3[] = {"log", (new std::string(nixDir + "/my_log"))->c_str()};
+
+        const char ** params[] = {p1, p2, p3, nullptr};
+
+        store = nix_store_open(ctx, "local", params);
+    }
+};
+}

src/libstore-test-support/tests/outputs-spec.cc

@@ -0,0 +1,24 @@
+#include "tests/outputs-spec.hh"
+
+#include <rapidcheck.h>
+
+namespace rc {
+using namespace nix;
+
+Gen<OutputsSpec> Arbitrary<OutputsSpec>::arbitrary()
+{
+    switch (*gen::inRange<uint8_t>(0, std::variant_size_v<OutputsSpec::Raw>)) {
+    case 0:
+        return gen::just((OutputsSpec) OutputsSpec::All { });
+    case 1:
+        return gen::just((OutputsSpec) OutputsSpec::Names {
+            *gen::nonEmpty(gen::container<StringSet>(gen::map(
+                gen::arbitrary<StorePathName>(),
+                [](StorePathName n) { return n.name; }))),
+        });
+    default:
+        assert(false);
+    }
+}
+
+}

src/libstore-test-support/tests/outputs-spec.hh

@@ -0,0 +1,18 @@
+#pragma once
+///@file
+
+#include <rapidcheck/gen/Arbitrary.h>
+
+#include <outputs-spec.hh>
+
+#include "tests/path.hh"
+
+namespace rc {
+using namespace nix;
+
+template<>
+struct Arbitrary<OutputsSpec> {
+    static Gen<OutputsSpec> arbitrary();
+};
+
+}

src/libstore-test-support/tests/path.cc

@@ -0,0 +1,80 @@
+#include <rapidcheck/gen/Arbitrary.h>
+#include <regex>
+
+#include <rapidcheck.h>
+
+#include "path-regex.hh"
+#include "store-api.hh"
+
+#include "tests/hash.hh"
+#include "tests/path.hh"
+
+namespace nix {
+
+void showValue(const StorePath & p, std::ostream & os)
+{
+    os << p.to_string();
+}
+
+}
+
+namespace rc {
+using namespace nix;
+
+Gen<char> storePathChar()
+{
+    return rc::gen::apply([](uint8_t i) -> char {
+        switch (i) {
+            case 0 ... 9:
+                return '0' + i;
+            case 10 ... 35:
+                return 'A' + (i - 10);
+            case 36 ... 61:
+                return 'a' + (i - 36);
+            case 62:
+                return '+';
+            case 63:
+                return '-';
+            case 64:
+                return '.';
+            case 65:
+                return '_';
+            case 66:
+                return '?';
+            case 67:
+                return '=';
+            default:
+                assert(false);
+        }
+    },
+    gen::inRange<uint8_t>(0, 10 + 2 * 26 + 6));
+}
+
+Gen<StorePathName> Arbitrary<StorePathName>::arbitrary()
+{
+    return gen::construct<StorePathName>(
+        gen::suchThat(
+            gen::container<std::string>(storePathChar()),
+            [](const std::string & s) {
+                return
+                    !( s == ""
+                    || s == "."
+                    || s == ".."
+                    || s.starts_with(".-")
+                    || s.starts_with("..-")
+                    );
+            }
+        )
+    );
+}
+
+Gen<StorePath> Arbitrary<StorePath>::arbitrary()
+{
+    return
+        gen::construct<StorePath>(
+            gen::arbitrary<Hash>(),
+            gen::apply([](StorePathName n){ return n.name; }, gen::arbitrary<StorePathName>())
+        );
+}
+
+} // namespace rc

src/libstore-test-support/tests/path.hh

@@ -0,0 +1,32 @@
+#pragma once
+///@file
+
+#include <rapidcheck/gen/Arbitrary.h>
+
+#include <path.hh>
+
+namespace nix {
+
+struct StorePathName {
+    std::string name;
+};
+
+// For rapidcheck
+void showValue(const StorePath & p, std::ostream & os);
+
+}
+
+namespace rc {
+using namespace nix;
+
+template<>
+struct Arbitrary<StorePathName> {
+    static Gen<StorePathName> arbitrary();
+};
+
+template<>
+struct Arbitrary<StorePath> {
+    static Gen<StorePath> arbitrary();
+};
+
+}

src/libstore-test-support/tests/protocol.hh

@@ -0,0 +1,75 @@
+#pragma once
+///@file
+
+#include <nlohmann/json.hpp>
+#include <gtest/gtest.h>
+
+#include "tests/libstore.hh"
+#include "tests/characterization.hh"
+
+namespace nix {
+
+template<class Proto, const char * protocolDir>
+class ProtoTest : public CharacterizationTest, public LibStoreTest
+{
+    Path unitTestData = getUnitTestData() + "/" + protocolDir;
+
+    Path goldenMaster(std::string_view testStem) const override {
+        return unitTestData + "/" + testStem + ".bin";
+    }
+};
+
+template<class Proto, const char * protocolDir>
+class VersionedProtoTest : public ProtoTest<Proto, protocolDir>
+{
+public:
+    /**
+     * Golden test for `T` reading
+     */
+    template<typename T>
+    void readProtoTest(PathView testStem, typename Proto::Version version, T expected)
+    {
+        CharacterizationTest::readTest(testStem, [&](const auto & encoded) {
+            T got = ({
+                StringSource from { encoded };
+                Proto::template Serialise<T>::read(
+                    *LibStoreTest::store,
+                    typename Proto::ReadConn {
+                        .from = from,
+                        .version = version,
+                    });
+            });
+
+            ASSERT_EQ(got, expected);
+        });
+    }
+
+    /**
+     * Golden test for `T` write
+     */
+    template<typename T>
+    void writeProtoTest(PathView testStem, typename Proto::Version version, const T & decoded)
+    {
+        CharacterizationTest::writeTest(testStem, [&]() {
+            StringSink to;
+            Proto::template Serialise<T>::write(
+                *LibStoreTest::store,
+                typename Proto::WriteConn {
+                    .to = to,
+                    .version = version,
+                },
+                decoded);
+            return std::move(to.s);
+        });
+    }
+};
+
+#define VERSIONED_CHARACTERIZATION_TEST(FIXTURE, NAME, STEM, VERSION, VALUE) \
+    TEST_F(FIXTURE, NAME ## _read) { \
+        readProtoTest(STEM, VERSION, VALUE); \
+    } \
+    TEST_F(FIXTURE, NAME ## _write) { \
+        writeProtoTest(STEM, VERSION, VALUE); \
+    }
+
+}