1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
|
#include "libstore/derivations.hh"
#include <memory>
#include <absl/strings/str_cat.h>
#include <gtest/gtest.h>
#include <rapidcheck.h>
#include <rapidcheck/Assertions.h>
#include <rapidcheck/gen/Arbitrary.h>
#include <rapidcheck/gen/Build.h>
#include <rapidcheck/gen/Container.h>
#include <rapidcheck/gen/Tuple.h>
#include <rapidcheck/gtest.h>
#include <rapidcheck/state.h>
#include "libexpr/eval.hh"
#include "libutil/hash.hh"
#include "libutil/types.hh"
#include "tests/arbitrary.hh"
namespace nix {
void AssertDerivationsEqual(const Derivation& lhs, const Derivation& rhs) {
RC_ASSERT(lhs.outputs.size() == rhs.outputs.size());
for (const auto& [k, lhs_v] : lhs.outputs) {
auto rhs_v = rhs.outputs.find(k);
RC_ASSERT(rhs_v != rhs.outputs.end());
RC_ASSERT(lhs_v.path == rhs_v->second.path);
RC_ASSERT(lhs_v.hashAlgo == rhs_v->second.hashAlgo);
RC_ASSERT(lhs_v.hash == rhs_v->second.hash);
}
RC_ASSERT(lhs.inputSrcs == rhs.inputSrcs);
RC_ASSERT(lhs.platform == rhs.platform);
RC_ASSERT(lhs.builder == rhs.builder);
RC_ASSERT(lhs.args == rhs.args);
RC_ASSERT(lhs.env == rhs.env);
RC_ASSERT(lhs.inputDrvs == rhs.inputDrvs);
}
class DerivationsTest : public ::testing::Test {};
// NOLINTNEXTLINE
RC_GTEST_FIXTURE_PROP(DerivationsTest, UnparseParseRoundTrip,
(Derivation && drv)) {
auto unparsed = drv.unparse();
auto parsed = parseDerivation(unparsed);
AssertDerivationsEqual(drv, parsed);
}
// NOLINTNEXTLINE
RC_GTEST_FIXTURE_PROP(DerivationsTest, ToProtoPreservesInput,
(Derivation && drv)) {
auto proto = drv.to_proto();
RC_ASSERT(proto.outputs_size() == drv.outputs.size());
RC_ASSERT(proto.input_sources().paths_size() == drv.inputSrcs.size());
auto paths = proto.input_sources().paths();
for (const auto& input_src : drv.inputSrcs) {
RC_ASSERT(std::find(paths.begin(), paths.end(), input_src) != paths.end());
}
RC_ASSERT(proto.platform() == drv.platform);
RC_ASSERT(proto.builder().path() == drv.builder);
RC_ASSERT(proto.args_size() == drv.args.size());
auto args = proto.args();
for (const auto& arg : drv.args) {
RC_ASSERT(std::find(args.begin(), args.end(), arg) != args.end());
}
RC_ASSERT(proto.env_size() == drv.env.size());
auto env = proto.env();
for (const auto& [key, value] : drv.env) {
RC_ASSERT(env.at(key) == value);
}
}
class ParseDrvPathWithOutputsTest : public DerivationsTest {};
TEST(ParseDrvPathWithOutputsTest, ParseDrvPathWithOutputs) {
auto input = "/nix/store/my51f75kp056md84gq2v08pd140pcz57-test.drv!out";
auto result = nix::parseDrvPathWithOutputs(input);
ASSERT_EQ(result.first,
"/nix/store/my51f75kp056md84gq2v08pd140pcz57-test.drv");
ASSERT_EQ(result.second, nix::PathSet{"out"});
}
TEST(ParseDrvPathWithOutputsTest, ParseDrvPathWithMultipleOutputs) {
auto input = "/nix/store/my51f75kp056md84gq2v08pd140pcz57-test.drv!out,dev";
auto result = nix::parseDrvPathWithOutputs(input);
nix::PathSet expected = {"out", "dev"};
ASSERT_EQ(result.first,
"/nix/store/my51f75kp056md84gq2v08pd140pcz57-test.drv");
ASSERT_EQ(result.second, expected);
}
TEST(ParseDrvPathWithOutputsTest, ParseDrvPathWithNoOutputs) {
auto input = "/nix/store/my51f75kp056md84gq2v08pd140pcz57-test";
auto result = nix::parseDrvPathWithOutputs(input);
ASSERT_EQ(result.first, "/nix/store/my51f75kp056md84gq2v08pd140pcz57-test");
ASSERT_EQ(result.second, nix::PathSet());
}
} // namespace nix
|
