lib

Core libraries for Radroots
git clone https://radroots.dev/git/lib.git
Log | Files | Refs | README

fixture.nix (37232B)


      1 {
      2   lib,
      3   nixosSystem,
      4   pkgs,
      5   service,
      6   toolchain,
      7 }:
      8 let
      9   nativeInputs = service.mkNativeInputs {
     10     nativeBuildInputs = [ pkgs.coreutils ];
     11     environment = {
     12       RADROOTS_SERVICE_FIXTURE = {
     13         classification = "nonsecret";
     14         value = "1";
     15       };
     16     };
     17   };
     18   fixtureSource = ./fixture-service;
     19   package = service.mkServicePackage {
     20     inherit nativeInputs toolchain;
     21     source = fixtureSource;
     22     cargoLock = fixtureSource + "/Cargo.lock";
     23     servicePackage = "fixture-service";
     24     binaryName = "fixture-service";
     25     releaseProfile = "release";
     26   };
     27   apps = service.mkServiceApps {
     28     serviceName = "fixture_service";
     29     inherit nativeInputs package toolchain;
     30     binaryName = "fixture-service";
     31     releaseAcceptanceCommand = ''
     32       output="$(fixture-service --help)"
     33       if [ "$output" != "fixture-service" ]; then
     34         echo "fixture release acceptance observed unexpected output" >&2
     35         exit 1
     36       fi
     37       printf '%s\n' "fixture-service release acceptance"
     38     '';
     39   };
     40   devShell = service.mkServiceDevShell {
     41     serviceName = "fixture_service";
     42     inherit nativeInputs toolchain;
     43   };
     44   fixtureBuildInfo = {
     45     serviceVersion = "0.1.0-alpha";
     46     serviceCommit = "1111111111111111111111111111111111111111";
     47     libRevision = "2222222222222222222222222222222222222222";
     48     rustVersion = "1.99.0";
     49     target = pkgs.stdenv.hostPlatform.rust.rustcTarget;
     50     featureProfile = "service-host";
     51     contractVersions = {
     52       config = 1;
     53       state = 2;
     54       admin = 3;
     55       status = 4;
     56       provider = 5;
     57     };
     58   };
     59   ociImage =
     60     if pkgs.stdenv.isLinux then
     61       service.mkServiceOciImage {
     62         serviceName = "fixture_service";
     63         inherit package;
     64         binaryName = "fixture-service";
     65         buildInfo = fixtureBuildInfo;
     66       }
     67     else
     68       null;
     69   ociImageCheck =
     70     if pkgs.stdenv.isLinux then
     71       pkgs.runCommand "fixture-service-oci-image"
     72         {
     73           nativeBuildInputs = [
     74             pkgs.coreutils
     75             pkgs.gnutar
     76             pkgs.gzip
     77             pkgs.jq
     78           ];
     79         }
     80         ''
     81           mkdir image
     82           tar -xzf ${ociImage} -C image
     83           config_file="$(jq -er '.[0].Config' image/manifest.json)"
     84           test -f "image/$config_file"
     85 
     86           jq -e '
     87             .architecture == "${if pkgs.stdenv.hostPlatform.isAarch64 then "arm64" else "amd64"}" and
     88             .os == "linux" and
     89             .created == "1970-01-01T00:00:01+00:00" and
     90             .config.User == "65532:65532" and
     91             .config.Entrypoint == ["${package}/bin/fixture-service"] and
     92             .config.WorkingDir == "/" and
     93             .config.Env == ["SSL_CERT_FILE=/etc/ssl/certs/ca-certificates.crt"] and
     94             .config.StopSignal == "SIGTERM" and
     95             (.config | has("Volumes") | not) and
     96             .config.Labels == {
     97               "dev.radroots.build.feature-profile": "service-host",
     98               "dev.radroots.build.lib-revision": "2222222222222222222222222222222222222222",
     99               "dev.radroots.build.rust-version": "1.99.0",
    100               "dev.radroots.build.target": "${pkgs.stdenv.hostPlatform.rust.rustcTarget}",
    101               "dev.radroots.contract.admin-version": "3",
    102               "dev.radroots.contract.config-version": "1",
    103               "dev.radroots.contract.provider-version": "5",
    104               "dev.radroots.contract.state-version": "2",
    105               "dev.radroots.contract.status-version": "4",
    106               "dev.radroots.mount.config": "/etc/radroots/services/fixture_service",
    107               "dev.radroots.mount.config.mode": "read-only",
    108               "dev.radroots.mount.credentials": "/etc/radroots/secrets/services/fixture_service",
    109               "dev.radroots.mount.credentials.mode": "read-only",
    110               "dev.radroots.mount.runtime": "/run/radroots/services/fixture_service",
    111               "dev.radroots.mount.runtime.mode": "read-write",
    112               "dev.radroots.mount.state": "/var/lib/radroots/services/fixture_service",
    113               "dev.radroots.mount.state.mode": "read-write",
    114               "dev.radroots.rootfs": "read-only-compatible",
    115               "org.opencontainers.image.description": "Hardened fixture_service service image",
    116               "org.opencontainers.image.licenses": "AGPL-3.0-or-later",
    117               "org.opencontainers.image.revision": "1111111111111111111111111111111111111111",
    118               "org.opencontainers.image.title": "fixture_service",
    119               "org.opencontainers.image.version": "0.1.0-alpha"
    120             }
    121           ' "image/$config_file"
    122 
    123           jq -e '.[0].RepoTags == ["fixture-service:0.1.0-alpha"]' image/manifest.json
    124           jq -e '([.[0].Layers | length] | .[0] >= 1 and .[0] <= 2)' image/manifest.json
    125           jq -er '.[0].Layers[]' image/manifest.json | while IFS= read -r layer; do
    126             tar -tf "image/$layer"
    127           done | sort -u > image-entries
    128 
    129           grep -E '/bin/fixture-service$' image-entries
    130           if grep -E '(^|/)(bin/(ba)?sh|bin/nix|bin/cargo|bin/rustc|Cargo.toml|src/)' image-entries; then
    131             echo "fixture OCI image contains a development or shell payload" >&2
    132             exit 1
    133           fi
    134 
    135           touch "$out"
    136         ''
    137     else
    138       null;
    139   nixosModule = service.mkServiceNixosModule {
    140     serviceName = "fixture_service";
    141     binaryName = "fixture-service";
    142     packageFor = _: package;
    143     commandForInstance = instanceName: [
    144       "--instance"
    145       instanceName
    146       "--config"
    147       "/etc/radroots/services/fixture_service/${instanceName}/config.toml"
    148     ];
    149   };
    150   nixosConfiguration =
    151     if pkgs.stdenv.isLinux then
    152       nixosSystem {
    153         system = pkgs.stdenv.hostPlatform.system;
    154         modules = [
    155           nixosModule
    156           {
    157             system.stateVersion = "25.11";
    158             users.groups.fixture-admin = { };
    159             services.radroots.fixture_service = {
    160               enable = true;
    161               adminGroup = "fixture-admin";
    162               instances.primary = {
    163                 configurationFile = pkgs.writeText "fixture-service-config.toml" ''
    164                   contract_version = 1
    165                 '';
    166                 credentials.api-token = "/run/operator/fixture-api-token";
    167               };
    168             };
    169           }
    170         ];
    171       }
    172     else
    173       null;
    174   nixosUnitName = "radroots-fixture_service-primary";
    175   nixosService =
    176     if pkgs.stdenv.isLinux then nixosConfiguration.config.systemd.services.${nixosUnitName} else null;
    177   nixosUnitText =
    178     if pkgs.stdenv.isLinux then
    179       nixosConfiguration.config.system.build.units."${nixosUnitName}.service".text
    180     else
    181       null;
    182   nixosModuleCheck =
    183     if pkgs.stdenv.isLinux then
    184       pkgs.runCommand "fixture-service-nixos-module"
    185         {
    186           nativeBuildInputs = [
    187             pkgs.gnugrep
    188           ];
    189           unit = pkgs.writeText "${nixosUnitName}.service" nixosUnitText;
    190         }
    191         ''
    192           grep -Fx 'Type=simple' "$unit"
    193           grep -Fx 'DynamicUser=true' "$unit"
    194           grep -Fx 'User=radroots-fixture_service' "$unit"
    195           grep -Fx 'Group=fixture-admin' "$unit"
    196           grep -Fx 'UMask=0077' "$unit"
    197           grep -Fx 'ConfigurationDirectory=radroots/services/fixture_service/primary' "$unit"
    198           grep -Fx 'ConfigurationDirectoryMode=0500' "$unit"
    199           grep -Fx 'StateDirectory=radroots/services/fixture_service/primary' "$unit"
    200           grep -Fx 'StateDirectoryMode=0700' "$unit"
    201           grep -Fx 'CacheDirectory=radroots/services/fixture_service/primary' "$unit"
    202           grep -Fx 'CacheDirectoryMode=0700' "$unit"
    203           grep -Fx 'RuntimeDirectory=radroots/services/fixture_service/primary' "$unit"
    204           grep -Fx 'RuntimeDirectoryMode=0750' "$unit"
    205           grep -Fx 'LoadCredential=api-token:/run/operator/fixture-api-token' "$unit"
    206           grep -Fx 'NoNewPrivileges=true' "$unit"
    207           grep -Fx 'PrivateTmp=true' "$unit"
    208           grep -Fx 'PrivateDevices=true' "$unit"
    209           grep -Fx 'ProtectSystem=strict' "$unit"
    210           grep -Fx 'ProtectHome=true' "$unit"
    211           grep -Fx 'ProtectKernelTunables=true' "$unit"
    212           grep -Fx 'ProtectKernelModules=true' "$unit"
    213           grep -Fx 'ProtectKernelLogs=true' "$unit"
    214           grep -Fx 'ProtectControlGroups=true' "$unit"
    215           grep -Fx 'ProtectHostname=true' "$unit"
    216           grep -Fx 'ProtectClock=true' "$unit"
    217           grep -Fx 'RestrictSUIDSGID=true' "$unit"
    218           grep -Fx 'LockPersonality=true' "$unit"
    219           grep -Fx 'CapabilityBoundingSet=' "$unit"
    220           grep -Fx 'AmbientCapabilities=' "$unit"
    221           test "$(grep -c '^RestrictAddressFamilies=' "$unit")" = 3
    222           grep -Fx 'RestrictAddressFamilies=AF_UNIX' "$unit"
    223           grep -Fx 'RestrictAddressFamilies=AF_INET' "$unit"
    224           grep -Fx 'RestrictAddressFamilies=AF_INET6' "$unit"
    225           grep -Fx 'RestrictNamespaces=true' "$unit"
    226           grep -Fx 'RestrictRealtime=true' "$unit"
    227           grep -Fx 'RemoveIPC=true' "$unit"
    228           grep -Fx 'DevicePolicy=closed' "$unit"
    229           grep -Fx 'KeyringMode=private' "$unit"
    230           grep -Fx 'ProcSubset=pid' "$unit"
    231           grep -Fx 'ProtectProc=invisible' "$unit"
    232           grep -Fx 'SystemCallArchitectures=native' "$unit"
    233           grep -Fx 'TimeoutStopSec=30s' "$unit"
    234           grep -Fx 'KillSignal=SIGTERM' "$unit"
    235           grep -Fx 'KillMode=control-group' "$unit"
    236           grep -Fx 'Restart=on-failure' "$unit"
    237           grep -Fx 'RestartSec=5s' "$unit"
    238           if grep -E '^(MemoryDenyWriteExecute|SystemCallFilter)=' "$unit"; then
    239             echo "fixture unit enabled an unqualified hardening control" >&2
    240             exit 1
    241           fi
    242           if grep -E '^Environment=.*(api-token|fixture-api-token)' "$unit"; then
    243             echo "fixture unit exposed credential material through its environment" >&2
    244             exit 1
    245           fi
    246           touch "$out"
    247         ''
    248     else
    249       null;
    250   appSmoke = pkgs.runCommand "fixture-service-app-smoke" { } ''
    251     test "$(${apps.default.program} --help)" = "fixture-service"
    252     test "$(${apps.release-acceptance.program})" = "fixture-service release acceptance"
    253     touch "$out"
    254   '';
    255   hooks = {
    256     sqlx = pkgs.runCommand "fixture-service-sqlx" { } ''
    257       if grep -F "sqlx" ${fixtureSource}/Cargo.toml; then
    258         echo "fixture unexpectedly acquired a SQLx dependency" >&2
    259         exit 1
    260       fi
    261       touch "$out"
    262     '';
    263     config = pkgs.runCommand "fixture-service-config" { } ''
    264       grep -Fx 'publish = false' ${fixtureSource}/Cargo.toml
    265       touch "$out"
    266     '';
    267     source-lock = pkgs.runCommand "fixture-service-source-lock" { } ''
    268       grep -Fx 'version = 4' ${fixtureSource}/Cargo.lock
    269       touch "$out"
    270     '';
    271     integration = pkgs.runCommand "fixture-service-integration" { nativeBuildInputs = [ package ]; } ''
    272       fixture-service --help | grep -Fx "fixture-service"
    273       touch "$out"
    274     '';
    275   };
    276   smoke =
    277     pkgs.runCommand "radroots-service-helper-fixture-smoke"
    278       {
    279         nativeBuildInputs = [
    280           package
    281           pkgs.file
    282           pkgs.gnugrep
    283           pkgs.nix
    284         ];
    285       }
    286       ''
    287         fixture-service --help > output
    288         grep -Fx "fixture-service" output
    289         file ${package}/bin/fixture-service > file-type
    290         if grep -Fi "script" file-type; then
    291           echo "fixture package installed a source wrapper" >&2
    292           exit 1
    293         fi
    294         test ! -e ${package}/Cargo.toml
    295         test ! -e ${package}/src
    296         if nix-store --query --requisites ${package} | grep -Fx ${toolchain}; then
    297           echo "fixture runtime closure retains the Rust toolchain" >&2
    298           exit 1
    299         fi
    300         touch "$out"
    301       '';
    302   checks = service.mkServiceChecks {
    303     serviceName = "fixture_service";
    304     inherit
    305       hooks
    306       nativeInputs
    307       package
    308       toolchain
    309       ;
    310     source = fixtureSource;
    311     cargoLock = fixtureSource + "/Cargo.lock";
    312     extraChecks = {
    313       app-smoke = appSmoke;
    314       inherit smoke;
    315     }
    316     // lib.optionalAttrs pkgs.stdenv.isLinux {
    317       nixos-module = nixosModuleCheck;
    318       oci-image = ociImageCheck;
    319     };
    320   };
    321   outputs = service.mkServiceOutputs {
    322     serviceName = "fixture_service";
    323     inherit nativeInputs package;
    324     inherit apps checks;
    325     devShells.default = devShell;
    326     extraPackages = lib.optionalAttrs pkgs.stdenv.isLinux {
    327       oci = ociImage;
    328     };
    329   };
    330   invalidName = builtins.tryEval (
    331     (service.mkServiceOutputs {
    332       serviceName = "../fixture";
    333       inherit nativeInputs package;
    334     }).packages.default.outPath
    335   );
    336   defaultOverride = builtins.tryEval (
    337     (service.mkServiceOutputs {
    338       serviceName = "fixture_service";
    339       inherit nativeInputs package;
    340       extraPackages.default = package;
    341     }).packages.default.outPath
    342   );
    343   invalidPackage = builtins.tryEval (
    344     (service.mkServiceOutputs {
    345       serviceName = "fixture_service";
    346       inherit nativeInputs;
    347       package = "not-a-derivation";
    348     }).packages.default
    349   );
    350   invalidNativeInputs = builtins.tryEval (
    351     (service.mkServiceOutputs {
    352       serviceName = "fixture_service";
    353       inherit package;
    354       nativeInputs = { };
    355     }).nativeInputs
    356   );
    357   invalidNativeInputDefinitions =
    358     map
    359       (
    360         environment:
    361         builtins.tryEval (builtins.deepSeq (service.mkNativeInputs { inherit environment; }) true)
    362       )
    363       [
    364         {
    365           LEGACY_VALUE = "untyped";
    366         }
    367         {
    368           CLASSIFIED_SECRET = {
    369             classification = "secret";
    370             value = "redacted";
    371           };
    372         }
    373         {
    374           EXTRA_FIELD = {
    375             classification = "nonsecret";
    376             value = "value";
    377             unexpected = true;
    378           };
    379         }
    380         {
    381           API_TOKEN = {
    382             classification = "nonsecret";
    383             value = "redacted";
    384           };
    385         }
    386         {
    387           OVERLONG_VALUE = {
    388             classification = "nonsecret";
    389             value = lib.concatStrings (lib.replicate 4097 "a");
    390           };
    391         }
    392       ];
    393   invalidServicePackage = builtins.tryEval (
    394     (service.mkServicePackage {
    395       inherit nativeInputs toolchain;
    396       source = fixtureSource;
    397       cargoLock = fixtureSource + "/Cargo.lock";
    398       servicePackage = "../fixture";
    399     }).outPath
    400   );
    401   invalidBinaryName = builtins.tryEval (
    402     (service.mkServicePackage {
    403       inherit nativeInputs toolchain;
    404       source = fixtureSource;
    405       cargoLock = fixtureSource + "/Cargo.lock";
    406       servicePackage = "fixture-service";
    407       binaryName = "fixture service";
    408     }).outPath
    409   );
    410   invalidReleaseProfile = builtins.tryEval (
    411     (service.mkServicePackage {
    412       inherit nativeInputs toolchain;
    413       source = fixtureSource;
    414       cargoLock = fixtureSource + "/Cargo.lock";
    415       servicePackage = "fixture-service";
    416       releaseProfile = "dev";
    417     }).outPath
    418   );
    419   profileOverride = builtins.tryEval (
    420     (service.mkServicePackage {
    421       inherit toolchain;
    422       source = fixtureSource;
    423       cargoLock = fixtureSource + "/Cargo.lock";
    424       servicePackage = "fixture-service";
    425       nativeInputs = service.mkNativeInputs {
    426         environment.CARGO_PROFILE = {
    427           classification = "nonsecret";
    428           value = "dev";
    429         };
    430       };
    431     }).outPath
    432   );
    433   checkArgs = {
    434     serviceName = "fixture_service";
    435     inherit
    436       hooks
    437       nativeInputs
    438       package
    439       toolchain
    440       ;
    441     source = fixtureSource;
    442     cargoLock = fixtureSource + "/Cargo.lock";
    443   };
    444   invalidHookResults = map (
    445     hookName:
    446     builtins.tryEval (
    447       (service.mkServiceChecks (
    448         checkArgs
    449         // {
    450           hooks = hooks // {
    451             ${hookName} = "not-a-derivation";
    452           };
    453         }
    454       )).check.outPath
    455     )
    456   ) (builtins.attrNames hooks);
    457   missingHook = builtins.tryEval (
    458     (service.mkServiceChecks (
    459       checkArgs
    460       // {
    461         hooks = builtins.removeAttrs hooks [ "sqlx" ];
    462       }
    463     )).check.outPath
    464   );
    465   unexpectedHook = builtins.tryEval (
    466     (service.mkServiceChecks (
    467       checkArgs
    468       // {
    469         hooks = hooks // {
    470           other = smoke;
    471         };
    472       }
    473     )).check.outPath
    474   );
    475   weakenedPolicyResults =
    476     map
    477       (
    478         variable:
    479         builtins.tryEval (
    480           (service.mkServiceChecks (
    481             checkArgs
    482             // {
    483               nativeInputs = service.mkNativeInputs {
    484                 environment.${variable} = {
    485                   classification = "nonsecret";
    486                   value = "override";
    487                 };
    488               };
    489             }
    490           )).check.outPath
    491         )
    492       )
    493       [
    494         "CARGO_PROFILE"
    495         "RUSTDOCFLAGS"
    496         "RUSTFLAGS"
    497       ];
    498   invalidExtraCheck = builtins.tryEval (
    499     (service.mkServiceChecks (
    500       checkArgs
    501       // {
    502         extraChecks.other = "not-a-derivation";
    503       }
    504     )).check.outPath
    505   );
    506   standardOverride = builtins.tryEval (
    507     (service.mkServiceChecks (
    508       checkArgs
    509       // {
    510         extraChecks.test = smoke;
    511       }
    512     )).check.outPath
    513   );
    514   appArgs = {
    515     serviceName = "fixture_service";
    516     inherit nativeInputs package toolchain;
    517     binaryName = "fixture-service";
    518     releaseAcceptanceCommand = "fixture-service --help";
    519   };
    520   invalidAppResults = [
    521     (builtins.tryEval (
    522       (service.mkServiceApps (appArgs // { serviceName = "../fixture"; })).default.program
    523     ))
    524     (builtins.tryEval (
    525       (service.mkServiceApps (appArgs // { package = "not-a-derivation"; })).default.program
    526     ))
    527     (builtins.tryEval (
    528       (service.mkServiceApps (appArgs // { binaryName = "fixture service"; })).default.program
    529     ))
    530     (builtins.tryEval (
    531       (service.mkServiceApps (appArgs // { toolchain = "not-a-derivation"; })).default.program
    532     ))
    533     (builtins.tryEval ((service.mkServiceApps (appArgs // { nativeInputs = { }; })).default.program))
    534     (builtins.tryEval (
    535       (service.mkServiceApps (
    536         appArgs
    537         // {
    538           nativeInputs = service.mkNativeInputs { nativeBuildInputs = [ "not-a-derivation" ]; };
    539         }
    540       )).default.program
    541     ))
    542     (builtins.tryEval (
    543       (service.mkServiceApps (
    544         appArgs
    545         // {
    546           nativeInputs = service.mkNativeInputs { environment.VALUE = 1; };
    547         }
    548       )).default.program
    549     ))
    550     (builtins.tryEval (
    551       (service.mkServiceApps (
    552         appArgs
    553         // {
    554           nativeInputs = service.mkNativeInputs {
    555             environment."INVALID-NAME" = {
    556               classification = "nonsecret";
    557               value = "value";
    558             };
    559           };
    560         }
    561       )).default.program
    562     ))
    563     (builtins.tryEval (
    564       (service.mkServiceApps (
    565         appArgs
    566         // {
    567           nativeInputs = service.mkNativeInputs {
    568             environment.PATH = {
    569               classification = "nonsecret";
    570               value = "/tmp";
    571             };
    572           };
    573         }
    574       )).default.program
    575     ))
    576     (builtins.tryEval (
    577       (service.mkServiceApps (appArgs // { releaseAcceptanceCommand = ""; })).default.program
    578     ))
    579   ];
    580   devShellArgs = {
    581     serviceName = "fixture_service";
    582     inherit nativeInputs toolchain;
    583   };
    584   invalidDevShellResults = [
    585     (builtins.tryEval (
    586       (service.mkServiceDevShell (devShellArgs // { serviceName = "../fixture"; })).drvPath
    587     ))
    588     (builtins.tryEval (
    589       (service.mkServiceDevShell (devShellArgs // { toolchain = "not-a-derivation"; })).drvPath
    590     ))
    591     (builtins.tryEval ((service.mkServiceDevShell (devShellArgs // { nativeInputs = { }; })).drvPath))
    592     (builtins.tryEval (
    593       (service.mkServiceDevShell (
    594         devShellArgs
    595         // {
    596           nativeInputs = service.mkNativeInputs { buildInputs = [ "not-a-derivation" ]; };
    597         }
    598       )).drvPath
    599     ))
    600     (builtins.tryEval (
    601       (service.mkServiceDevShell (
    602         devShellArgs
    603         // {
    604           nativeInputs = service.mkNativeInputs { environment.VALUE = 1; };
    605         }
    606       )).drvPath
    607     ))
    608     (builtins.tryEval (
    609       (service.mkServiceDevShell (
    610         devShellArgs
    611         // {
    612           nativeInputs = service.mkNativeInputs {
    613             environment."INVALID-NAME" = {
    614               classification = "nonsecret";
    615               value = "value";
    616             };
    617           };
    618         }
    619       )).drvPath
    620     ))
    621     (builtins.tryEval (
    622       (service.mkServiceDevShell (
    623         devShellArgs
    624         // {
    625           nativeInputs = service.mkNativeInputs {
    626             environment.RUSTC = {
    627               classification = "nonsecret";
    628               value = "/tmp/rustc";
    629             };
    630           };
    631         }
    632       )).drvPath
    633     ))
    634   ];
    635   ociArgs = {
    636     serviceName = "fixture_service";
    637     inherit package;
    638     binaryName = "fixture-service";
    639     buildInfo = fixtureBuildInfo;
    640   };
    641   maximumOciResult =
    642     if pkgs.stdenv.isLinux then
    643       builtins.tryEval (
    644         (service.mkServiceOciImage (
    645           ociArgs
    646           // {
    647             serviceName = lib.concatStrings (lib.replicate 128 "a");
    648             buildInfo = fixtureBuildInfo // {
    649               serviceVersion = lib.concatStrings (lib.replicate 128 "1");
    650               contractVersions = lib.mapAttrs (_: _: 4294967295) fixtureBuildInfo.contractVersions;
    651             };
    652           }
    653         )).outPath
    654       )
    655     else
    656       {
    657         success = true;
    658         value = null;
    659       };
    660   invalidOciResults = lib.optionals pkgs.stdenv.isLinux [
    661     (builtins.tryEval (
    662       (service.mkServiceOciImage (ociArgs // { serviceName = "../fixture"; })).outPath
    663     ))
    664     (builtins.tryEval (
    665       (service.mkServiceOciImage (ociArgs // { package = "not-a-derivation"; })).outPath
    666     ))
    667     (builtins.tryEval (
    668       (service.mkServiceOciImage (ociArgs // { binaryName = "fixture service"; })).outPath
    669     ))
    670     (builtins.tryEval (
    671       (service.mkServiceOciImage (
    672         ociArgs
    673         // {
    674           serviceName = lib.concatStrings (lib.replicate 129 "a");
    675         }
    676       )).outPath
    677     ))
    678     (builtins.tryEval (
    679       (service.mkServiceOciImage (
    680         ociArgs
    681         // {
    682           binaryName = lib.concatStrings (lib.replicate 129 "b");
    683         }
    684       )).outPath
    685     ))
    686     (builtins.tryEval (
    687       (service.mkServiceOciImage (
    688         ociArgs
    689         // {
    690           buildInfo = fixtureBuildInfo // {
    691             serviceVersion = "bad value";
    692           };
    693         }
    694       )).outPath
    695     ))
    696     (builtins.tryEval (
    697       (service.mkServiceOciImage (
    698         ociArgs
    699         // {
    700           buildInfo = fixtureBuildInfo // {
    701             serviceVersion = lib.concatStrings (lib.replicate 129 "1");
    702           };
    703         }
    704       )).outPath
    705     ))
    706     (builtins.tryEval (
    707       (service.mkServiceOciImage (
    708         ociArgs
    709         // {
    710           buildInfo = fixtureBuildInfo // {
    711             serviceCommit = "ABCDEF";
    712           };
    713         }
    714       )).outPath
    715     ))
    716     (builtins.tryEval (
    717       (service.mkServiceOciImage (
    718         ociArgs
    719         // {
    720           buildInfo = fixtureBuildInfo // {
    721             libRevision = "bad";
    722           };
    723         }
    724       )).outPath
    725     ))
    726     (builtins.tryEval (
    727       (service.mkServiceOciImage (
    728         ociArgs
    729         // {
    730           buildInfo = fixtureBuildInfo // {
    731             rustVersion = "stable";
    732           };
    733         }
    734       )).outPath
    735     ))
    736     (builtins.tryEval (
    737       (service.mkServiceOciImage (
    738         ociArgs
    739         // {
    740           buildInfo = fixtureBuildInfo // {
    741             rustVersion = "1.97.1";
    742           };
    743         }
    744       )).outPath
    745     ))
    746     (builtins.tryEval (
    747       (service.mkServiceOciImage (
    748         ociArgs
    749         // {
    750           buildInfo = fixtureBuildInfo // {
    751             target = "x86_64-unknown-linux-musl";
    752           };
    753         }
    754       )).outPath
    755     ))
    756     (builtins.tryEval (
    757       (service.mkServiceOciImage (
    758         ociArgs
    759         // {
    760           buildInfo = fixtureBuildInfo // {
    761             featureProfile = "development";
    762           };
    763         }
    764       )).outPath
    765     ))
    766     (builtins.tryEval (
    767       (service.mkServiceOciImage (
    768         ociArgs
    769         // {
    770           buildInfo = fixtureBuildInfo // {
    771             extra = "unexpected";
    772           };
    773         }
    774       )).outPath
    775     ))
    776     (builtins.tryEval (
    777       (service.mkServiceOciImage (
    778         ociArgs
    779         // {
    780           buildInfo = fixtureBuildInfo // {
    781             contractVersions = fixtureBuildInfo.contractVersions // {
    782               config = 0;
    783             };
    784           };
    785         }
    786       )).outPath
    787     ))
    788     (builtins.tryEval (
    789       (service.mkServiceOciImage (
    790         ociArgs
    791         // {
    792           buildInfo = fixtureBuildInfo // {
    793             contractVersions = fixtureBuildInfo.contractVersions // {
    794               config = 4294967296;
    795             };
    796           };
    797         }
    798       )).outPath
    799     ))
    800     (builtins.tryEval (
    801       (service.mkServiceOciImage (
    802         ociArgs
    803         // {
    804           buildInfo = fixtureBuildInfo // {
    805             contractVersions = builtins.removeAttrs fixtureBuildInfo.contractVersions [ "provider" ];
    806           };
    807         }
    808       )).outPath
    809     ))
    810   ];
    811   nixosServiceConfig = if pkgs.stdenv.isLinux then nixosService.serviceConfig else null;
    812   nixosModuleArguments = {
    813     serviceName = "fixture_service";
    814     binaryName = "fixture-service";
    815     packageFor = _: package;
    816     commandForInstance = _: [ "--help" ];
    817   };
    818   invalidNixosModuleConstructors = [
    819     (nixosModuleArguments // { serviceName = "../fixture"; })
    820     (nixosModuleArguments // { serviceName = "fixture-service"; })
    821     (nixosModuleArguments // { serviceName = lib.concatStrings (lib.replicate 129 "a"); })
    822     (nixosModuleArguments // { binaryName = "fixture service"; })
    823     (nixosModuleArguments // { binaryName = lib.concatStrings (lib.replicate 129 "b"); })
    824     (nixosModuleArguments // { packageFor = "not-a-function"; })
    825     (nixosModuleArguments // { commandForInstance = "not-a-function"; })
    826     (nixosModuleArguments // { stopTimeoutSeconds = 0; })
    827     (nixosModuleArguments // { stopTimeoutSeconds = 86401; })
    828     (nixosModuleArguments // { addressFamilies = [ ]; })
    829     (
    830       nixosModuleArguments
    831       // {
    832         addressFamilies = [
    833           "AF_UNIX"
    834           "AF_UNIX"
    835         ];
    836       }
    837     )
    838     (nixosModuleArguments // { addressFamilies = [ "AF_PACKET" ]; })
    839   ];
    840   invalidNixosModuleConstructorResults = map (
    841     arguments: builtins.tryEval ((service.mkServiceNixosModule arguments) { })
    842   ) invalidNixosModuleConstructors;
    843   baseNixosModuleConfiguration = {
    844     enable = true;
    845     inherit package;
    846     adminGroup = null;
    847     instances.primary = {
    848       configurationFile = pkgs.writeText "fixture-service-assertion-config.toml" "";
    849       credentials = { };
    850     };
    851   };
    852   nixosModuleAssertionsPass =
    853     module: moduleServiceName: moduleConfiguration:
    854     let
    855       evaluated = module {
    856         config = lib.setAttrByPath [
    857           "services"
    858           "radroots"
    859           moduleServiceName
    860         ] moduleConfiguration;
    861         inherit pkgs;
    862       };
    863     in
    864     lib.all (entry: entry.assertion) evaluated.config.assertions;
    865   invalidNixosModuleConfigurations = [
    866     (baseNixosModuleConfiguration // { enable = false; })
    867     (baseNixosModuleConfiguration // { instances = { }; })
    868     (baseNixosModuleConfiguration // { adminGroup = "INVALID GROUP"; })
    869     (
    870       baseNixosModuleConfiguration
    871       // {
    872         adminGroup = lib.concatStrings (lib.replicate 129 "a");
    873       }
    874     )
    875     (
    876       baseNixosModuleConfiguration
    877       // {
    878         instances = {
    879           "../primary" = baseNixosModuleConfiguration.instances.primary;
    880         };
    881       }
    882     )
    883     (
    884       baseNixosModuleConfiguration
    885       // {
    886         instances = {
    887           ${lib.concatStrings (lib.replicate 129 "a")} = baseNixosModuleConfiguration.instances.primary;
    888         };
    889       }
    890     )
    891     (
    892       baseNixosModuleConfiguration
    893       // {
    894         instances.primary.credentials."bad:name" = "/run/operator/token";
    895       }
    896     )
    897     (
    898       baseNixosModuleConfiguration
    899       // {
    900         instances.primary.credentials.token = "relative/token";
    901       }
    902     )
    903     (
    904       baseNixosModuleConfiguration
    905       // {
    906         instances.primary.credentials.token = "/nix/store";
    907       }
    908     )
    909     (
    910       baseNixosModuleConfiguration
    911       // {
    912         instances.primary.credentials.token = "/nix/store/secret";
    913       }
    914     )
    915     (
    916       baseNixosModuleConfiguration
    917       // {
    918         instances.primary.credentials.token = "/run/operator/token:alias";
    919       }
    920     )
    921     (
    922       baseNixosModuleConfiguration
    923       // {
    924         instances.primary.credentials.token = "/run/operator/token\nvalue";
    925       }
    926     )
    927     (
    928       baseNixosModuleConfiguration
    929       // {
    930         instances.primary.credentials.token = "/run//operator/token";
    931       }
    932     )
    933     (
    934       baseNixosModuleConfiguration
    935       // {
    936         instances.primary.credentials.token = "/run/operator/./token";
    937       }
    938     )
    939     (
    940       baseNixosModuleConfiguration
    941       // {
    942         instances.primary.credentials.token = "/run/operator/../token";
    943       }
    944     )
    945     (
    946       baseNixosModuleConfiguration
    947       // {
    948         instances.primary.credentials.token = "/run/operator/token/";
    949       }
    950     )
    951     (
    952       baseNixosModuleConfiguration
    953       // {
    954         instances.primary.credentials.token = "/";
    955       }
    956     )
    957     (
    958       baseNixosModuleConfiguration
    959       // {
    960         instances.primary.credentials.token = "/${lib.concatStrings (lib.replicate 4096 "a")}";
    961       }
    962     )
    963     (
    964       baseNixosModuleConfiguration
    965       // {
    966         instances.primary.credentials = lib.genAttrs (lib.genList (
    967           index: "credential-${toString index}"
    968         ) 33) (_: "/run/operator/token");
    969       }
    970     )
    971     (
    972       baseNixosModuleConfiguration
    973       // {
    974         instances = lib.genAttrs (lib.genList (index: "instance-${toString index}") 65) (
    975           _: baseNixosModuleConfiguration.instances.primary
    976         );
    977       }
    978     )
    979   ];
    980   invalidNixosModuleConfigurationResults = map (
    981     moduleConfiguration:
    982     builtins.tryEval (nixosModuleAssertionsPass nixosModule "fixture_service" moduleConfiguration)
    983   ) invalidNixosModuleConfigurations;
    984   commandNixosModule =
    985     command:
    986     service.mkServiceNixosModule (
    987       nixosModuleArguments
    988       // {
    989         commandForInstance = _: command;
    990       }
    991     );
    992   invalidNixosCommandResults =
    993     map
    994       (
    995         command:
    996         builtins.tryEval (
    997           nixosModuleAssertionsPass (commandNixosModule command) "fixture_service"
    998             baseNixosModuleConfiguration
    999         )
   1000       )
   1001       [
   1002         (lib.replicate 65 "argument")
   1003         [ (lib.concatStrings (lib.replicate 4097 "a")) ]
   1004         [ "argument\nvalue" ]
   1005         [ "argument\rvalue" ]
   1006       ];
   1007   maximumNixosModule = service.mkServiceNixosModule (
   1008     nixosModuleArguments
   1009     // {
   1010       serviceName = lib.concatStrings (lib.replicate 128 "a");
   1011       binaryName = lib.concatStrings (lib.replicate 128 "b");
   1012       stopTimeoutSeconds = 86400;
   1013       addressFamilies = [ "AF_UNIX" ];
   1014     }
   1015   );
   1016   maximumNixosModuleConfiguration = {
   1017     enable = true;
   1018     inherit package;
   1019     adminGroup = lib.concatStrings (lib.replicate 128 "a");
   1020     instances.${lib.concatStrings (lib.replicate 109 "b")} = {
   1021       configurationFile = pkgs.writeText "fixture-service-maximum-config.toml" "";
   1022       credentials = lib.genAttrs (lib.genList (index: "credential-${toString index}") 32) (
   1023         _: "/${lib.concatStrings (lib.replicate 4095 "c")}"
   1024       );
   1025     };
   1026   };
   1027   overlongNixosUnitConfiguration = maximumNixosModuleConfiguration // {
   1028     instances = {
   1029       ${lib.concatStrings (lib.replicate 110 "b")} = baseNixosModuleConfiguration.instances.primary;
   1030     };
   1031   };
   1032   overlongNixosUnitResult = builtins.tryEval (
   1033     nixosModuleAssertionsPass maximumNixosModule (lib.concatStrings (
   1034       lib.replicate 128 "a"
   1035     )) overlongNixosUnitConfiguration
   1036   );
   1037   maximumNixosInstanceCountConfiguration = baseNixosModuleConfiguration // {
   1038     instances = lib.genAttrs (lib.genList (index: "instance-${toString index}") 64) (
   1039       _: baseNixosModuleConfiguration.instances.primary
   1040     );
   1041   };
   1042   maximumNixosCommandModule = commandNixosModule (
   1043     lib.replicate 64 (lib.concatStrings (lib.replicate 4096 "a"))
   1044   );
   1045   noAdminNixosEvaluation = nixosModule {
   1046     config = lib.setAttrByPath [
   1047       "services"
   1048       "radroots"
   1049       "fixture_service"
   1050     ] baseNixosModuleConfiguration;
   1051     inherit pkgs;
   1052   };
   1053   noAdminNixosServiceConfig =
   1054     noAdminNixosEvaluation.config.systemd.services.content.${nixosUnitName}.serviceConfig;
   1055 in
   1056 assert
   1057   service.supportedSystems == [
   1058     "aarch64-darwin"
   1059     "x86_64-linux"
   1060   ];
   1061 assert nativeInputs.nativeBuildInputs == [ pkgs.coreutils ];
   1062 assert nativeInputs.buildInputs == [ ];
   1063 assert nativeInputs.environment.RADROOTS_SERVICE_FIXTURE == "1";
   1064 assert
   1065   nativeInputs.environmentContract.RADROOTS_SERVICE_FIXTURE == {
   1066     classification = "nonsecret";
   1067     value = "1";
   1068   };
   1069 assert outputs.serviceName == "fixture_service";
   1070 assert outputs.packages.default == package;
   1071 assert (pkgs.stdenv.isLinux -> outputs.packages.oci == ociImage);
   1072 assert (
   1073   pkgs.stdenv.isLinux
   1074   ->
   1075     ociImage.meta.platforms == [
   1076       "x86_64-linux"
   1077     ]
   1078 );
   1079 assert (!pkgs.stdenv.isLinux -> !(builtins.hasAttr "oci" outputs.packages));
   1080 assert outputs.checks == checks;
   1081 assert
   1082   builtins.attrNames checks == [
   1083     "app-smoke"
   1084     "check"
   1085     "clippy"
   1086     "config"
   1087     "docs"
   1088     "fmt"
   1089     "integration"
   1090   ]
   1091   ++ lib.optionals pkgs.stdenv.isLinux [
   1092     "nixos-module"
   1093     "oci-image"
   1094   ]
   1095   ++ [
   1096     "package"
   1097     "smoke"
   1098     "source-lock"
   1099     "sqlx"
   1100     "test"
   1101   ];
   1102 assert checks.package == package;
   1103 assert checks.sqlx == hooks.sqlx;
   1104 assert checks.config == hooks.config;
   1105 assert checks.source-lock == hooks.source-lock;
   1106 assert checks.integration == hooks.integration;
   1107 assert checks.app-smoke == appSmoke;
   1108 assert checks.smoke == smoke;
   1109 assert outputs.apps == apps;
   1110 assert
   1111   builtins.attrNames apps == [
   1112     "default"
   1113     "release-acceptance"
   1114   ];
   1115 assert apps.default.program == "${package}/bin/fixture-service";
   1116 assert lib.hasSuffix "/bin/fixture_service-release-acceptance" apps.release-acceptance.program;
   1117 assert outputs.devShells.default == devShell;
   1118 assert devShell.name == "fixture_service-dev-shell";
   1119 assert invalidName.success == false;
   1120 assert defaultOverride.success == false;
   1121 assert invalidPackage.success == false;
   1122 assert invalidNativeInputs.success == false;
   1123 assert lib.all (result: result.success == false) invalidNativeInputDefinitions;
   1124 assert invalidServicePackage.success == false;
   1125 assert invalidBinaryName.success == false;
   1126 assert invalidReleaseProfile.success == false;
   1127 assert profileOverride.success == false;
   1128 assert lib.all (result: result.success == false) invalidHookResults;
   1129 assert missingHook.success == false;
   1130 assert unexpectedHook.success == false;
   1131 assert lib.all (result: result.success == false) weakenedPolicyResults;
   1132 assert invalidExtraCheck.success == false;
   1133 assert standardOverride.success == false;
   1134 assert lib.all (result: result.success == false) invalidAppResults;
   1135 assert lib.all (result: result.success == false) invalidDevShellResults;
   1136 assert maximumOciResult.success;
   1137 assert lib.all (result: result.success == false) invalidOciResults;
   1138 assert (
   1139   pkgs.stdenv.isLinux
   1140   ->
   1141     builtins.attrNames (
   1142       lib.filterAttrs (name: _: lib.hasPrefix "radroots-" name) nixosConfiguration.config.systemd.services
   1143     ) == [ nixosUnitName ]
   1144 );
   1145 assert (pkgs.stdenv.isLinux -> nixosService.wantedBy == [ "multi-user.target" ]);
   1146 assert (pkgs.stdenv.isLinux -> nixosService.wants == [ "network-online.target" ]);
   1147 assert (pkgs.stdenv.isLinux -> nixosService.after == [ "network-online.target" ]);
   1148 assert (pkgs.stdenv.isLinux -> nixosServiceConfig.Type == "simple");
   1149 assert (pkgs.stdenv.isLinux -> nixosServiceConfig.DynamicUser);
   1150 assert (pkgs.stdenv.isLinux -> nixosServiceConfig.RuntimeDirectoryMode == "0750");
   1151 assert (
   1152   pkgs.stdenv.isLinux
   1153   ->
   1154     nixosServiceConfig.BindReadOnlyPaths == [
   1155       "${nixosConfiguration.config.services.radroots.fixture_service.instances.primary.configurationFile}:/etc/radroots/services/fixture_service/primary/config.toml"
   1156     ]
   1157 );
   1158 assert (
   1159   pkgs.stdenv.isLinux
   1160   ->
   1161     nixosServiceConfig.LoadCredential == [
   1162       "api-token:/run/operator/fixture-api-token"
   1163     ]
   1164 );
   1165 assert (pkgs.stdenv.isLinux -> !(nixosServiceConfig ? MemoryDenyWriteExecute));
   1166 assert (pkgs.stdenv.isLinux -> !(nixosServiceConfig ? SystemCallFilter));
   1167 assert lib.all (result: result.success == false) invalidNixosModuleConstructorResults;
   1168 assert lib.all (
   1169   result: result.success && result.value == false
   1170 ) invalidNixosModuleConfigurationResults;
   1171 assert lib.all (result: result.success && result.value == false) invalidNixosCommandResults;
   1172 assert (
   1173   nixosModuleAssertionsPass maximumNixosModule (lib.concatStrings (
   1174     lib.replicate 128 "a"
   1175   )) maximumNixosModuleConfiguration
   1176 );
   1177 assert (overlongNixosUnitResult.success && overlongNixosUnitResult.value == false);
   1178 assert (
   1179   nixosModuleAssertionsPass nixosModule "fixture_service" maximumNixosInstanceCountConfiguration
   1180 );
   1181 assert (
   1182   nixosModuleAssertionsPass maximumNixosCommandModule "fixture_service" baseNixosModuleConfiguration
   1183 );
   1184 assert noAdminNixosServiceConfig.Group == "radroots-fixture_service";
   1185 assert noAdminNixosServiceConfig.RuntimeDirectoryMode == "0700";
   1186 assert !(noAdminNixosServiceConfig ? SupplementaryGroups);
   1187 assert (
   1188   !pkgs.stdenv.isLinux
   1189   -> (builtins.tryEval ((service.mkServiceOciImage ociArgs).outPath)).success == false
   1190 );
   1191 {
   1192   inherit outputs;
   1193 }