2023-09-04 22:15:32 +00:00
|
|
|
#include <regex>
|
|
|
|
|
|
|
|
#include <nlohmann/json.hpp>
|
|
|
|
#include <gtest/gtest.h>
|
|
|
|
|
|
|
|
#include "worker-protocol.hh"
|
|
|
|
#include "worker-protocol-impl.hh"
|
|
|
|
#include "derived-path.hh"
|
2023-09-26 18:44:15 +00:00
|
|
|
#include "build-result.hh"
|
2023-10-05 03:27:50 +00:00
|
|
|
#include "tests/protocol.hh"
|
|
|
|
#include "tests/characterization.hh"
|
2023-09-04 22:15:32 +00:00
|
|
|
|
|
|
|
namespace nix {
|
|
|
|
|
2023-10-05 03:27:50 +00:00
|
|
|
const char workerProtoDir[] = "worker-protocol";
|
2023-09-04 22:15:32 +00:00
|
|
|
|
2022-03-25 04:40:49 +00:00
|
|
|
struct WorkerProtoTest : VersionedProtoTest<WorkerProto, workerProtoDir>
|
|
|
|
{
|
|
|
|
/**
|
|
|
|
* For serializers that don't care about the minimum version, we
|
|
|
|
* used the oldest one: 1.0.
|
|
|
|
*/
|
|
|
|
WorkerProto::Version defaultVersion = 1 << 8 | 0;
|
|
|
|
};
|
2023-09-04 22:15:32 +00:00
|
|
|
|
2022-03-25 04:40:49 +00:00
|
|
|
|
|
|
|
VERSIONED_CHARACTERIZATION_TEST(
|
2023-10-05 03:27:50 +00:00
|
|
|
WorkerProtoTest,
|
2023-09-04 22:15:32 +00:00
|
|
|
string,
|
|
|
|
"string",
|
2022-03-25 04:40:49 +00:00
|
|
|
defaultVersion,
|
2023-09-04 22:15:32 +00:00
|
|
|
(std::tuple<std::string, std::string, std::string, std::string, std::string> {
|
|
|
|
"",
|
|
|
|
"hi",
|
|
|
|
"white rabbit",
|
|
|
|
"大白兔",
|
|
|
|
"oh no \0\0\0 what was that!",
|
|
|
|
}))
|
|
|
|
|
2022-03-25 04:40:49 +00:00
|
|
|
VERSIONED_CHARACTERIZATION_TEST(
|
2023-10-05 03:27:50 +00:00
|
|
|
WorkerProtoTest,
|
2023-09-04 22:15:32 +00:00
|
|
|
storePath,
|
|
|
|
"store-path",
|
2022-03-25 04:40:49 +00:00
|
|
|
defaultVersion,
|
2023-09-04 22:15:32 +00:00
|
|
|
(std::tuple<StorePath, StorePath> {
|
|
|
|
StorePath { "g1w7hy3qg1w7hy3qg1w7hy3qg1w7hy3q-foo" },
|
|
|
|
StorePath { "g1w7hy3qg1w7hy3qg1w7hy3qg1w7hy3q-foo-bar" },
|
|
|
|
}))
|
|
|
|
|
2022-03-25 04:40:49 +00:00
|
|
|
VERSIONED_CHARACTERIZATION_TEST(
|
2023-10-05 03:27:50 +00:00
|
|
|
WorkerProtoTest,
|
2023-09-04 22:15:32 +00:00
|
|
|
contentAddress,
|
|
|
|
"content-address",
|
2022-03-25 04:40:49 +00:00
|
|
|
defaultVersion,
|
2023-09-04 22:15:32 +00:00
|
|
|
(std::tuple<ContentAddress, ContentAddress, ContentAddress> {
|
|
|
|
ContentAddress {
|
|
|
|
.method = TextIngestionMethod {},
|
|
|
|
.hash = hashString(HashType::htSHA256, "Derive(...)"),
|
|
|
|
},
|
|
|
|
ContentAddress {
|
|
|
|
.method = FileIngestionMethod::Flat,
|
|
|
|
.hash = hashString(HashType::htSHA1, "blob blob..."),
|
|
|
|
},
|
|
|
|
ContentAddress {
|
|
|
|
.method = FileIngestionMethod::Recursive,
|
|
|
|
.hash = hashString(HashType::htSHA256, "(...)"),
|
|
|
|
},
|
|
|
|
}))
|
|
|
|
|
2022-03-25 04:40:49 +00:00
|
|
|
VERSIONED_CHARACTERIZATION_TEST(
|
2023-10-05 03:27:50 +00:00
|
|
|
WorkerProtoTest,
|
2023-05-26 18:48:11 +00:00
|
|
|
derivedPath_1_29,
|
|
|
|
"derived-path-1.29",
|
|
|
|
1 << 8 | 29,
|
|
|
|
(std::tuple<DerivedPath, DerivedPath, DerivedPath> {
|
|
|
|
DerivedPath::Opaque {
|
|
|
|
.path = StorePath { "g1w7hy3qg1w7hy3qg1w7hy3qg1w7hy3q-foo" },
|
|
|
|
},
|
|
|
|
DerivedPath::Built {
|
|
|
|
.drvPath = makeConstantStorePathRef(StorePath {
|
|
|
|
"g1w7hy3qg1w7hy3qg1w7hy3qg1w7hy3q-bar.drv",
|
|
|
|
}),
|
|
|
|
.outputs = OutputsSpec::All { },
|
|
|
|
},
|
|
|
|
DerivedPath::Built {
|
|
|
|
.drvPath = makeConstantStorePathRef(StorePath {
|
|
|
|
"g1w7hy3qg1w7hy3qg1w7hy3qg1w7hy3q-bar.drv",
|
|
|
|
}),
|
|
|
|
.outputs = OutputsSpec::Names { "x", "y" },
|
|
|
|
},
|
|
|
|
}))
|
|
|
|
|
|
|
|
VERSIONED_CHARACTERIZATION_TEST(
|
|
|
|
WorkerProtoTest,
|
|
|
|
derivedPath_1_30,
|
|
|
|
"derived-path-1.30",
|
|
|
|
1 << 8 | 30,
|
2023-10-16 05:45:06 +00:00
|
|
|
(std::tuple<DerivedPath, DerivedPath, DerivedPath, DerivedPath> {
|
2023-09-04 22:15:32 +00:00
|
|
|
DerivedPath::Opaque {
|
|
|
|
.path = StorePath { "g1w7hy3qg1w7hy3qg1w7hy3qg1w7hy3q-foo" },
|
|
|
|
},
|
2023-10-16 05:45:06 +00:00
|
|
|
DerivedPath::Opaque {
|
|
|
|
.path = StorePath { "g1w7hy3qg1w7hy3qg1w7hy3qg1w7hy3q-foo.drv" },
|
|
|
|
},
|
|
|
|
DerivedPath::Built {
|
|
|
|
.drvPath = makeConstantStorePathRef(StorePath {
|
|
|
|
"g1w7hy3qg1w7hy3qg1w7hy3qg1w7hy3q-bar.drv",
|
|
|
|
}),
|
|
|
|
.outputs = OutputsSpec::All { },
|
|
|
|
},
|
2023-09-04 22:15:32 +00:00
|
|
|
DerivedPath::Built {
|
|
|
|
.drvPath = makeConstantStorePathRef(StorePath {
|
|
|
|
"g1w7hy3qg1w7hy3qg1w7hy3qg1w7hy3q-bar.drv",
|
|
|
|
}),
|
|
|
|
.outputs = OutputsSpec::Names { "x", "y" },
|
|
|
|
},
|
|
|
|
}))
|
|
|
|
|
2022-03-25 04:40:49 +00:00
|
|
|
VERSIONED_CHARACTERIZATION_TEST(
|
2023-10-05 03:27:50 +00:00
|
|
|
WorkerProtoTest,
|
2023-09-26 18:44:15 +00:00
|
|
|
drvOutput,
|
|
|
|
"drv-output",
|
2022-03-25 04:40:49 +00:00
|
|
|
defaultVersion,
|
2023-09-26 18:44:15 +00:00
|
|
|
(std::tuple<DrvOutput, DrvOutput> {
|
|
|
|
{
|
|
|
|
.drvHash = Hash::parseSRI("sha256-FePFYIlMuycIXPZbWi7LGEiMmZSX9FMbaQenWBzm1Sc="),
|
|
|
|
.outputName = "baz",
|
|
|
|
},
|
|
|
|
DrvOutput {
|
|
|
|
.drvHash = Hash::parseSRI("sha256-b4afnqKCO9oWXgYHb9DeQ2berSwOjS27rSd9TxXDc/U="),
|
|
|
|
.outputName = "quux",
|
|
|
|
},
|
|
|
|
}))
|
|
|
|
|
2022-03-25 04:40:49 +00:00
|
|
|
VERSIONED_CHARACTERIZATION_TEST(
|
2023-10-05 03:27:50 +00:00
|
|
|
WorkerProtoTest,
|
2023-09-26 18:44:15 +00:00
|
|
|
realisation,
|
|
|
|
"realisation",
|
2022-03-25 04:40:49 +00:00
|
|
|
defaultVersion,
|
2023-09-26 18:44:15 +00:00
|
|
|
(std::tuple<Realisation, Realisation> {
|
|
|
|
Realisation {
|
|
|
|
.id = DrvOutput {
|
|
|
|
.drvHash = Hash::parseSRI("sha256-FePFYIlMuycIXPZbWi7LGEiMmZSX9FMbaQenWBzm1Sc="),
|
|
|
|
.outputName = "baz",
|
|
|
|
},
|
|
|
|
.outPath = StorePath { "g1w7hy3qg1w7hy3qg1w7hy3qg1w7hy3q-foo" },
|
|
|
|
.signatures = { "asdf", "qwer" },
|
|
|
|
},
|
|
|
|
Realisation {
|
|
|
|
.id = {
|
|
|
|
.drvHash = Hash::parseSRI("sha256-FePFYIlMuycIXPZbWi7LGEiMmZSX9FMbaQenWBzm1Sc="),
|
|
|
|
.outputName = "baz",
|
|
|
|
},
|
|
|
|
.outPath = StorePath { "g1w7hy3qg1w7hy3qg1w7hy3qg1w7hy3q-foo" },
|
|
|
|
.signatures = { "asdf", "qwer" },
|
|
|
|
.dependentRealisations = {
|
|
|
|
{
|
|
|
|
DrvOutput {
|
|
|
|
.drvHash = Hash::parseSRI("sha256-b4afnqKCO9oWXgYHb9DeQ2berSwOjS27rSd9TxXDc/U="),
|
|
|
|
.outputName = "quux",
|
|
|
|
},
|
|
|
|
StorePath { "g1w7hy3qg1w7hy3qg1w7hy3qg1w7hy3q-foo" },
|
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
}))
|
|
|
|
|
2022-03-25 04:40:49 +00:00
|
|
|
VERSIONED_CHARACTERIZATION_TEST(
|
2023-10-05 03:27:50 +00:00
|
|
|
WorkerProtoTest,
|
2021-02-28 18:42:46 +00:00
|
|
|
buildResult_1_27,
|
|
|
|
"build-result-1.27",
|
|
|
|
1 << 8 | 27,
|
|
|
|
({
|
|
|
|
using namespace std::literals::chrono_literals;
|
|
|
|
std::tuple<BuildResult, BuildResult, BuildResult> t {
|
|
|
|
BuildResult {
|
|
|
|
.status = BuildResult::OutputRejected,
|
|
|
|
.errorMsg = "no idea why",
|
|
|
|
},
|
|
|
|
BuildResult {
|
|
|
|
.status = BuildResult::NotDeterministic,
|
|
|
|
.errorMsg = "no idea why",
|
|
|
|
},
|
|
|
|
BuildResult {
|
|
|
|
.status = BuildResult::Built,
|
|
|
|
},
|
|
|
|
};
|
|
|
|
t;
|
|
|
|
}))
|
|
|
|
|
|
|
|
VERSIONED_CHARACTERIZATION_TEST(
|
|
|
|
WorkerProtoTest,
|
|
|
|
buildResult_1_28,
|
|
|
|
"build-result-1.28",
|
|
|
|
1 << 8 | 28,
|
|
|
|
({
|
|
|
|
using namespace std::literals::chrono_literals;
|
|
|
|
std::tuple<BuildResult, BuildResult, BuildResult> t {
|
|
|
|
BuildResult {
|
|
|
|
.status = BuildResult::OutputRejected,
|
|
|
|
.errorMsg = "no idea why",
|
|
|
|
},
|
|
|
|
BuildResult {
|
|
|
|
.status = BuildResult::NotDeterministic,
|
|
|
|
.errorMsg = "no idea why",
|
|
|
|
},
|
|
|
|
BuildResult {
|
|
|
|
.status = BuildResult::Built,
|
|
|
|
.builtOutputs = {
|
|
|
|
{
|
|
|
|
"foo",
|
|
|
|
{
|
|
|
|
.id = DrvOutput {
|
|
|
|
.drvHash = Hash::parseSRI("sha256-b4afnqKCO9oWXgYHb9DeQ2berSwOjS27rSd9TxXDc/U="),
|
|
|
|
.outputName = "foo",
|
|
|
|
},
|
|
|
|
.outPath = StorePath { "g1w7hy3qg1w7hy3qg1w7hy3qg1w7hy3q-foo" },
|
|
|
|
},
|
|
|
|
},
|
|
|
|
{
|
|
|
|
"bar",
|
|
|
|
{
|
|
|
|
.id = DrvOutput {
|
|
|
|
.drvHash = Hash::parseSRI("sha256-b4afnqKCO9oWXgYHb9DeQ2berSwOjS27rSd9TxXDc/U="),
|
|
|
|
.outputName = "bar",
|
|
|
|
},
|
|
|
|
.outPath = StorePath { "g1w7hy3qg1w7hy3qg1w7hy3qg1w7hy3q-bar" },
|
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
};
|
|
|
|
t;
|
|
|
|
}))
|
|
|
|
|
|
|
|
VERSIONED_CHARACTERIZATION_TEST(
|
|
|
|
WorkerProtoTest,
|
|
|
|
buildResult_1_29,
|
|
|
|
"build-result-1.29",
|
|
|
|
1 << 8 | 29,
|
2023-09-26 18:44:15 +00:00
|
|
|
({
|
|
|
|
using namespace std::literals::chrono_literals;
|
2023-10-04 21:36:49 +00:00
|
|
|
std::tuple<BuildResult, BuildResult, BuildResult> t {
|
2023-09-26 18:44:15 +00:00
|
|
|
BuildResult {
|
|
|
|
.status = BuildResult::OutputRejected,
|
|
|
|
.errorMsg = "no idea why",
|
|
|
|
},
|
|
|
|
BuildResult {
|
|
|
|
.status = BuildResult::NotDeterministic,
|
|
|
|
.errorMsg = "no idea why",
|
|
|
|
.timesBuilt = 3,
|
|
|
|
.isNonDeterministic = true,
|
|
|
|
.startTime = 30,
|
|
|
|
.stopTime = 50,
|
|
|
|
},
|
|
|
|
BuildResult {
|
|
|
|
.status = BuildResult::Built,
|
|
|
|
.timesBuilt = 1,
|
|
|
|
.builtOutputs = {
|
|
|
|
{
|
|
|
|
"foo",
|
|
|
|
{
|
|
|
|
.id = DrvOutput {
|
|
|
|
.drvHash = Hash::parseSRI("sha256-b4afnqKCO9oWXgYHb9DeQ2berSwOjS27rSd9TxXDc/U="),
|
|
|
|
.outputName = "foo",
|
|
|
|
},
|
|
|
|
.outPath = StorePath { "g1w7hy3qg1w7hy3qg1w7hy3qg1w7hy3q-foo" },
|
|
|
|
},
|
|
|
|
},
|
|
|
|
{
|
|
|
|
"bar",
|
|
|
|
{
|
|
|
|
.id = DrvOutput {
|
|
|
|
.drvHash = Hash::parseSRI("sha256-b4afnqKCO9oWXgYHb9DeQ2berSwOjS27rSd9TxXDc/U="),
|
|
|
|
.outputName = "bar",
|
|
|
|
},
|
|
|
|
.outPath = StorePath { "g1w7hy3qg1w7hy3qg1w7hy3qg1w7hy3q-bar" },
|
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
.startTime = 30,
|
|
|
|
.stopTime = 50,
|
2023-10-04 21:36:49 +00:00
|
|
|
#if 0
|
|
|
|
// These fields are not yet serialized.
|
|
|
|
// FIXME Include in next version of protocol or document
|
|
|
|
// why they are skipped.
|
2023-09-26 18:44:15 +00:00
|
|
|
.cpuUser = std::chrono::milliseconds(500s),
|
|
|
|
.cpuSystem = std::chrono::milliseconds(604s),
|
|
|
|
#endif
|
2023-10-04 21:36:49 +00:00
|
|
|
},
|
2023-09-26 18:44:15 +00:00
|
|
|
};
|
|
|
|
t;
|
|
|
|
}))
|
|
|
|
|
2022-03-25 04:40:49 +00:00
|
|
|
VERSIONED_CHARACTERIZATION_TEST(
|
2023-10-05 03:27:50 +00:00
|
|
|
WorkerProtoTest,
|
2021-02-28 18:42:46 +00:00
|
|
|
keyedBuildResult_1_29,
|
|
|
|
"keyed-build-result-1.29",
|
|
|
|
1 << 8 | 29,
|
2023-09-26 18:44:15 +00:00
|
|
|
({
|
|
|
|
using namespace std::literals::chrono_literals;
|
|
|
|
std::tuple<KeyedBuildResult, KeyedBuildResult/*, KeyedBuildResult*/> t {
|
|
|
|
KeyedBuildResult {
|
|
|
|
{
|
|
|
|
.status = KeyedBuildResult::OutputRejected,
|
|
|
|
.errorMsg = "no idea why",
|
|
|
|
},
|
|
|
|
/* .path = */ DerivedPath::Opaque {
|
|
|
|
StorePath { "g1w7hy3qg1w7hy3qg1w7hy3qg1w7hy3q-xxx" },
|
|
|
|
},
|
|
|
|
},
|
|
|
|
KeyedBuildResult {
|
|
|
|
{
|
|
|
|
.status = KeyedBuildResult::NotDeterministic,
|
|
|
|
.errorMsg = "no idea why",
|
|
|
|
.timesBuilt = 3,
|
|
|
|
.isNonDeterministic = true,
|
|
|
|
.startTime = 30,
|
|
|
|
.stopTime = 50,
|
|
|
|
},
|
|
|
|
/* .path = */ DerivedPath::Built {
|
|
|
|
.drvPath = makeConstantStorePathRef(StorePath {
|
|
|
|
"g1w7hy3qg1w7hy3qg1w7hy3qg1w7hy3q-bar.drv",
|
|
|
|
}),
|
|
|
|
.outputs = OutputsSpec::Names { "out" },
|
|
|
|
},
|
|
|
|
},
|
|
|
|
};
|
|
|
|
t;
|
|
|
|
}))
|
|
|
|
|
2023-04-17 21:13:44 +00:00
|
|
|
VERSIONED_CHARACTERIZATION_TEST(
|
|
|
|
WorkerProtoTest,
|
|
|
|
unkeyedValidPathInfo_1_15,
|
|
|
|
"unkeyed-valid-path-info-1.15",
|
|
|
|
1 << 8 | 15,
|
|
|
|
(std::tuple<UnkeyedValidPathInfo, UnkeyedValidPathInfo> {
|
|
|
|
({
|
|
|
|
UnkeyedValidPathInfo info {
|
|
|
|
Hash::parseSRI("sha256-FePFYIlMuycIXPZbWi7LGEiMmZSX9FMbaQenWBzm1Sc="),
|
|
|
|
};
|
|
|
|
info.registrationTime = 23423;
|
|
|
|
info.narSize = 34878;
|
|
|
|
info;
|
|
|
|
}),
|
|
|
|
({
|
|
|
|
UnkeyedValidPathInfo info {
|
|
|
|
Hash::parseSRI("sha256-FePFYIlMuycIXPZbWi7LGEiMmZSX9FMbaQenWBzm1Sc="),
|
|
|
|
};
|
|
|
|
info.deriver = StorePath {
|
|
|
|
"g1w7hy3qg1w7hy3qg1w7hy3qg1w7hy3q-bar.drv",
|
|
|
|
};
|
|
|
|
info.references = {
|
|
|
|
StorePath {
|
|
|
|
"g1w7hyyyy1w7hy3qg1w7hy3qgqqqqy3q-foo.drv",
|
|
|
|
},
|
|
|
|
};
|
|
|
|
info.registrationTime = 23423;
|
|
|
|
info.narSize = 34878;
|
|
|
|
info;
|
|
|
|
}),
|
|
|
|
}))
|
|
|
|
|
|
|
|
VERSIONED_CHARACTERIZATION_TEST(
|
|
|
|
WorkerProtoTest,
|
|
|
|
validPathInfo_1_15,
|
|
|
|
"valid-path-info-1.15",
|
|
|
|
1 << 8 | 15,
|
|
|
|
(std::tuple<ValidPathInfo, ValidPathInfo> {
|
|
|
|
({
|
|
|
|
ValidPathInfo info {
|
|
|
|
StorePath {
|
|
|
|
"g1w7hy3qg1w7hy3qg1w7hy3qg1w7hy3q-bar",
|
|
|
|
},
|
|
|
|
UnkeyedValidPathInfo {
|
|
|
|
Hash::parseSRI("sha256-FePFYIlMuycIXPZbWi7LGEiMmZSX9FMbaQenWBzm1Sc="),
|
|
|
|
},
|
|
|
|
};
|
|
|
|
info.registrationTime = 23423;
|
|
|
|
info.narSize = 34878;
|
|
|
|
info;
|
|
|
|
}),
|
|
|
|
({
|
|
|
|
ValidPathInfo info {
|
|
|
|
StorePath {
|
|
|
|
"g1w7hy3qg1w7hy3qg1w7hy3qg1w7hy3q-bar",
|
|
|
|
},
|
|
|
|
UnkeyedValidPathInfo {
|
|
|
|
Hash::parseSRI("sha256-FePFYIlMuycIXPZbWi7LGEiMmZSX9FMbaQenWBzm1Sc="),
|
|
|
|
},
|
|
|
|
};
|
|
|
|
info.deriver = StorePath {
|
|
|
|
"g1w7hy3qg1w7hy3qg1w7hy3qg1w7hy3q-bar.drv",
|
|
|
|
};
|
|
|
|
info.references = {
|
|
|
|
// other reference
|
|
|
|
StorePath {
|
|
|
|
"g1w7hyyyy1w7hy3qg1w7hy3qgqqqqy3q-foo",
|
|
|
|
},
|
|
|
|
// self reference
|
|
|
|
StorePath {
|
|
|
|
"g1w7hy3qg1w7hy3qg1w7hy3qg1w7hy3q-bar",
|
|
|
|
},
|
|
|
|
};
|
|
|
|
info.registrationTime = 23423;
|
|
|
|
info.narSize = 34878;
|
|
|
|
info;
|
|
|
|
}),
|
|
|
|
}))
|
|
|
|
|
|
|
|
VERSIONED_CHARACTERIZATION_TEST(
|
|
|
|
WorkerProtoTest,
|
|
|
|
validPathInfo_1_16,
|
|
|
|
"valid-path-info-1.16",
|
|
|
|
1 << 8 | 16,
|
|
|
|
(std::tuple<ValidPathInfo, ValidPathInfo, ValidPathInfo> {
|
|
|
|
({
|
|
|
|
ValidPathInfo info {
|
|
|
|
StorePath {
|
|
|
|
"g1w7hy3qg1w7hy3qg1w7hy3qg1w7hy3q-bar",
|
|
|
|
},
|
|
|
|
UnkeyedValidPathInfo {
|
|
|
|
Hash::parseSRI("sha256-FePFYIlMuycIXPZbWi7LGEiMmZSX9FMbaQenWBzm1Sc="),
|
|
|
|
},
|
|
|
|
};
|
|
|
|
info.registrationTime = 23423;
|
|
|
|
info.narSize = 34878;
|
|
|
|
info.ultimate = true;
|
|
|
|
info;
|
|
|
|
}),
|
|
|
|
({
|
|
|
|
ValidPathInfo info {
|
|
|
|
StorePath {
|
|
|
|
"g1w7hy3qg1w7hy3qg1w7hy3qg1w7hy3q-bar",
|
|
|
|
},
|
|
|
|
UnkeyedValidPathInfo {
|
|
|
|
Hash::parseSRI("sha256-FePFYIlMuycIXPZbWi7LGEiMmZSX9FMbaQenWBzm1Sc="),
|
|
|
|
},
|
|
|
|
};
|
|
|
|
info.deriver = StorePath {
|
|
|
|
"g1w7hy3qg1w7hy3qg1w7hy3qg1w7hy3q-bar.drv",
|
|
|
|
};
|
|
|
|
info.references = {
|
|
|
|
// other reference
|
|
|
|
StorePath {
|
|
|
|
"g1w7hyyyy1w7hy3qg1w7hy3qgqqqqy3q-foo",
|
|
|
|
},
|
|
|
|
// self reference
|
|
|
|
StorePath {
|
|
|
|
"g1w7hy3qg1w7hy3qg1w7hy3qg1w7hy3q-bar",
|
|
|
|
},
|
|
|
|
};
|
|
|
|
info.registrationTime = 23423;
|
|
|
|
info.narSize = 34878;
|
|
|
|
info.sigs = {
|
|
|
|
"fake-sig-1",
|
|
|
|
"fake-sig-2",
|
|
|
|
},
|
|
|
|
info;
|
|
|
|
}),
|
|
|
|
({
|
|
|
|
ValidPathInfo info {
|
|
|
|
*LibStoreTest::store,
|
|
|
|
"foo",
|
|
|
|
FixedOutputInfo {
|
|
|
|
.method = FileIngestionMethod::Recursive,
|
|
|
|
.hash = hashString(HashType::htSHA256, "(...)"),
|
|
|
|
.references = {
|
|
|
|
.others = {
|
|
|
|
StorePath {
|
|
|
|
"g1w7hy3qg1w7hy3qg1w7hy3qg1w7hy3q-bar",
|
|
|
|
},
|
|
|
|
},
|
|
|
|
.self = true,
|
|
|
|
},
|
|
|
|
},
|
|
|
|
Hash::parseSRI("sha256-FePFYIlMuycIXPZbWi7LGEiMmZSX9FMbaQenWBzm1Sc="),
|
|
|
|
};
|
|
|
|
info.registrationTime = 23423;
|
|
|
|
info.narSize = 34878;
|
|
|
|
info;
|
|
|
|
}),
|
|
|
|
}))
|
|
|
|
|
2022-03-25 04:40:49 +00:00
|
|
|
VERSIONED_CHARACTERIZATION_TEST(
|
2023-10-05 03:27:50 +00:00
|
|
|
WorkerProtoTest,
|
2023-09-26 18:44:15 +00:00
|
|
|
optionalTrustedFlag,
|
|
|
|
"optional-trusted-flag",
|
2022-03-25 04:40:49 +00:00
|
|
|
defaultVersion,
|
2023-09-26 18:44:15 +00:00
|
|
|
(std::tuple<std::optional<TrustedFlag>, std::optional<TrustedFlag>, std::optional<TrustedFlag>> {
|
|
|
|
std::nullopt,
|
|
|
|
std::optional { Trusted },
|
|
|
|
std::optional { NotTrusted },
|
|
|
|
}))
|
|
|
|
|
2022-03-25 04:40:49 +00:00
|
|
|
VERSIONED_CHARACTERIZATION_TEST(
|
2023-10-05 03:27:50 +00:00
|
|
|
WorkerProtoTest,
|
2023-09-26 18:44:15 +00:00
|
|
|
vector,
|
|
|
|
"vector",
|
2022-03-25 04:40:49 +00:00
|
|
|
defaultVersion,
|
2023-09-26 18:44:15 +00:00
|
|
|
(std::tuple<std::vector<std::string>, std::vector<std::string>, std::vector<std::string>, std::vector<std::vector<std::string>>> {
|
|
|
|
{ },
|
|
|
|
{ "" },
|
|
|
|
{ "", "foo", "bar" },
|
|
|
|
{ {}, { "" }, { "", "1", "2" } },
|
|
|
|
}))
|
|
|
|
|
2022-03-25 04:40:49 +00:00
|
|
|
VERSIONED_CHARACTERIZATION_TEST(
|
2023-10-05 03:27:50 +00:00
|
|
|
WorkerProtoTest,
|
2023-09-26 18:44:15 +00:00
|
|
|
set,
|
|
|
|
"set",
|
2022-03-25 04:40:49 +00:00
|
|
|
defaultVersion,
|
2023-09-26 18:44:15 +00:00
|
|
|
(std::tuple<std::set<std::string>, std::set<std::string>, std::set<std::string>, std::set<std::set<std::string>>> {
|
|
|
|
{ },
|
|
|
|
{ "" },
|
|
|
|
{ "", "foo", "bar" },
|
|
|
|
{ {}, { "" }, { "", "1", "2" } },
|
|
|
|
}))
|
|
|
|
|
2022-03-25 04:40:49 +00:00
|
|
|
VERSIONED_CHARACTERIZATION_TEST(
|
2023-10-05 03:27:50 +00:00
|
|
|
WorkerProtoTest,
|
2023-09-26 18:44:15 +00:00
|
|
|
optionalStorePath,
|
|
|
|
"optional-store-path",
|
2022-03-25 04:40:49 +00:00
|
|
|
defaultVersion,
|
2023-09-26 18:44:15 +00:00
|
|
|
(std::tuple<std::optional<StorePath>, std::optional<StorePath>> {
|
|
|
|
std::nullopt,
|
|
|
|
std::optional {
|
|
|
|
StorePath { "g1w7hy3qg1w7hy3qg1w7hy3qg1w7hy3q-foo-bar" },
|
|
|
|
},
|
|
|
|
}))
|
|
|
|
|
2022-03-25 04:40:49 +00:00
|
|
|
VERSIONED_CHARACTERIZATION_TEST(
|
2023-10-05 03:27:50 +00:00
|
|
|
WorkerProtoTest,
|
2023-09-26 18:44:15 +00:00
|
|
|
optionalContentAddress,
|
|
|
|
"optional-content-address",
|
2022-03-25 04:40:49 +00:00
|
|
|
defaultVersion,
|
2023-09-26 18:44:15 +00:00
|
|
|
(std::tuple<std::optional<ContentAddress>, std::optional<ContentAddress>> {
|
|
|
|
std::nullopt,
|
|
|
|
std::optional {
|
|
|
|
ContentAddress {
|
|
|
|
.method = FileIngestionMethod::Flat,
|
|
|
|
.hash = hashString(HashType::htSHA1, "blob blob..."),
|
|
|
|
},
|
|
|
|
},
|
|
|
|
}))
|
|
|
|
|
2023-09-04 22:15:32 +00:00
|
|
|
}
|