···

       
1417
       
 
       
  systemd = runTest ./systemd.nix;

     

       
1418
       
 
       
  systemd-analyze = runTest ./systemd-analyze.nix;

     

       
1419
       
 
       
  systemd-binfmt = handleTestOn [ "x86_64-linux" ] ./systemd-binfmt.nix { };

     

       
1420
       
-
       
  systemd-boot = handleTest ./systemd-boot.nix { };

     

       
1421
       
 
       
  systemd-bpf = runTest ./systemd-bpf.nix;

     

       
1422
       
 
       
  systemd-capsules = runTest ./systemd-capsules.nix;

     

       
1423
       
 
       
  systemd-confinement = handleTest ./systemd-confinement { };

     

···

       
1417
       
 
       
  systemd = runTest ./systemd.nix;

     

       
1418
       
 
       
  systemd-analyze = runTest ./systemd-analyze.nix;

     

       
1419
       
 
       
  systemd-binfmt = handleTestOn [ "x86_64-linux" ] ./systemd-binfmt.nix { };

     

       
1420
       
+
       
  systemd-boot = import ./systemd-boot.nix { inherit runTest runTestOn; };

     

       
1421
       
 
       
  systemd-bpf = runTest ./systemd-bpf.nix;

     

       
1422
       
 
       
  systemd-capsules = runTest ./systemd-capsules.nix;

     

       
1423
       
 
       
  systemd-confinement = handleTest ./systemd-confinement { };

     

···

       
1
       
 
       
{

     

       
2
       
-
       
  system ? builtins.currentSystem,

     

       
3
       
-
       
  config ? { },

     

       
4
       
-
       
  pkgs ? import ../.. { inherit system config; },

     

       
5
       
 
       
}:

     

       
6
       
 
       


     

       
7
       
-
       
with import ../lib/testing-python.nix { inherit system pkgs; };

     

       
8
       
-
       
with pkgs.lib;

     

       
9
       
-
       


     

       
10
       
 
       
let

     

       
11
       
-
       
  common = {

     

       
12
       
-
       
    virtualisation.useBootLoader = true;

     

       
13
       
-
       
    virtualisation.useEFIBoot = true;

     

       
14
       
-
       
    boot.loader.systemd-boot.enable = true;

     

       
15
       
-
       
    boot.loader.efi.canTouchEfiVariables = true;

     

       
16
       
-
       
    environment.systemPackages = [ pkgs.efibootmgr ];

     

       
17
       
-
       
    system.switch.enable = true;

     

       
18
       
-
       
  };

     

       
0
       
 
       

     

       
0
       
 
       

     

       
19
       
 
       


     

       
20
       
 
       
  commonXbootldr =

     

       
21
       
 
       
    {

     
···

       
32
       
 
       
        partitionTableType = "efixbootldr";

     

       
33
       
 
       
        touchEFIVars = true;

     

       
34
       
 
       
        installBootLoader = true;

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
35
       
 
       
      };

     

       
36
       
 
       
    in

     

       
37
       
 
       
    {

     
···

       
90
       
 
       
  '';

     

       
91
       
 
       
in

     

       
92
       
 
       
{

     

       
93
       
-
       
  basic = makeTest {

     

       
94
       
-
       
    name = "systemd-boot";

     

       
95
       
-
       
    meta.maintainers = with pkgs.lib.maintainers; [

     

       
96
       
-
       
      danielfullmer

     

       
97
       
-
       
      julienmalka

     

       
98
       
-
       
    ];

     

       
0
       
 
       

     

       
0
       
 
       

     

       
99
       
 
       


     

       
100
       
-
       
    nodes.machine = common;

     

       
101
       
 
       


     

       
102
       
-
       
    testScript = ''

     

       
103
       
-
       
      machine.start()

     

       
104
       
-
       
      machine.wait_for_unit("multi-user.target")

     

       
105
       
 
       


     

       
106
       
-
       
      machine.succeed("test -e /boot/loader/entries/nixos-generation-1.conf")

     

       
107
       
-
       
      machine.succeed("grep 'sort-key nixos' /boot/loader/entries/nixos-generation-1.conf")

     

       
108
       
 
       


     

       
109
       
-
       
      # Ensure we actually booted using systemd-boot

     

       
110
       
-
       
      # Magic number is the vendor UUID used by systemd-boot.

     

       
111
       
-
       
      machine.succeed(

     

       
112
       
-
       
          "test -e /sys/firmware/efi/efivars/LoaderEntrySelected-4a67b082-0a4c-41cf-b6c7-440b29bb8c4f"

     

       
113
       
-
       
      )

     

       
114
       
 
       


     

       
115
       
-
       
      # "bootctl install" should have created an EFI entry

     

       
116
       
-
       
      machine.succeed('efibootmgr | grep "Linux Boot Manager"')

     

       
117
       
-
       
    '';

     

       
118
       
-
       
  };

     

       
0
       
 
       

     

       
119
       
 
       


     

       
120
       
 
       
  # Test that systemd-boot works with secure boot

     

       
121
       
-
       
  secureBoot = makeTest {

     

       
122
       
-
       
    name = "systemd-boot-secure-boot";

     

       
0
       
 
       

     

       
0
       
 
       

     

       
123
       
 
       


     

       
124
       
-
       
    nodes.machine = {

     

       
125
       
-
       
      imports = [ common ];

     

       
126
       
-
       
      environment.systemPackages = [ pkgs.sbctl ];

     

       
127
       
-
       
      virtualisation.useSecureBoot = true;

     

       
128
       
-
       
    };

     

       
0
       
 
       

     

       
0
       
 
       

     

       
129
       
 
       


     

       
130
       
-
       
    testScript =

     

       
131
       
-
       
      let

     

       
132
       
-
       
        efiArch = pkgs.stdenv.hostPlatform.efiArch;

     

       
133
       
-
       
      in

     

       
134
       
-
       
      { nodes, ... }:

     

       
135
       
-
       
      ''

     

       
136
       
-
       
        machine.start(allow_reboot=True)

     

       
137
       
-
       
        machine.wait_for_unit("multi-user.target")

     

       
138
       
 
       


     

       
139
       
-
       
        machine.succeed("sbctl create-keys")

     

       
140
       
-
       
        machine.succeed("sbctl enroll-keys --yes-this-might-brick-my-machine")

     

       
141
       
-
       
        machine.succeed('sbctl sign /boot/EFI/systemd/systemd-boot${efiArch}.efi')

     

       
142
       
-
       
        machine.succeed('sbctl sign /boot/EFI/BOOT/BOOT${toUpper efiArch}.EFI')

     

       
143
       
-
       
        machine.succeed('sbctl sign /boot/EFI/nixos/*${nodes.machine.system.boot.loader.kernelFile}.efi')

     

       
144
       
 
       


     

       
145
       
-
       
        machine.reboot()

     

       
146
       
 
       


     

       
147
       
-
       
        assert "Secure Boot: enabled (user)" in machine.succeed("bootctl status")

     

       
148
       
-
       
      '';

     

       
149
       
-
       
  };

     

       
0
       
 
       

     

       
150
       
 
       


     

       
151
       
-
       
  basicXbootldr = makeTest {

     

       
152
       
-
       
    name = "systemd-boot-xbootldr";

     

       
153
       
-
       
    meta.maintainers = with pkgs.lib.maintainers; [ sdht0 ];

     

       
0
       
 
       

     

       
0
       
 
       

     

       
154
       
 
       


     

       
155
       
-
       
    nodes.machine = commonXbootldr;

     

       
156
       
 
       


     

       
157
       
-
       
    testScript =

     

       
158
       
-
       
      { nodes, ... }:

     

       
159
       
-
       
      ''

     

       
160
       
-
       
        ${customDiskImage nodes}

     

       
161
       
 
       


     

       
162
       
-
       
        machine.start()

     

       
163
       
-
       
        machine.wait_for_unit("multi-user.target")

     

       
164
       
 
       


     

       
165
       
-
       
        machine.succeed("test -e /efi/EFI/systemd/systemd-bootx64.efi")

     

       
166
       
-
       
        machine.succeed("test -e /boot/loader/entries/nixos-generation-1.conf")

     

       
167
       
 
       


     

       
168
       
-
       
        # Ensure we actually booted using systemd-boot

     

       
169
       
-
       
        # Magic number is the vendor UUID used by systemd-boot.

     

       
170
       
-
       
        machine.succeed(

     

       
171
       
-
       
            "test -e /sys/firmware/efi/efivars/LoaderEntrySelected-4a67b082-0a4c-41cf-b6c7-440b29bb8c4f"

     

       
172
       
-
       
        )

     

       
173
       
 
       


     

       
174
       
-
       
        # "bootctl install" should have created an EFI entry

     

       
175
       
-
       
        machine.succeed('efibootmgr | grep "Linux Boot Manager"')

     

       
176
       
-
       
      '';

     

       
177
       
-
       
  };

     

       
0
       
 
       

     

       
178
       
 
       


     

       
179
       
 
       
  # Check that specialisations create corresponding boot entries.

     

       
180
       
-
       
  specialisation = makeTest {

     

       
181
       
-
       
    name = "systemd-boot-specialisation";

     

       
182
       
-
       
    meta.maintainers = with pkgs.lib.maintainers; [

     

       
183
       
-
       
      lukegb

     

       
184
       
-
       
      julienmalka

     

       
185
       
-
       
    ];

     

       
0
       
 
       

     

       
0
       
 
       

     

       
186
       
 
       


     

       
187
       
-
       
    nodes.machine =

     

       
188
       
-
       
      { pkgs, lib, ... }:

     

       
189
       
-
       
      {

     

       
190
       
-
       
        imports = [ common ];

     

       
191
       
-
       
        specialisation.something.configuration = {

     

       
192
       
-
       
          boot.loader.systemd-boot.sortKey = "something";

     

       
193
       
 
       


     

       
194
       
-
       
          # Since qemu will dynamically create a devicetree blob when starting

     

       
195
       
-
       
          # up, it is not straight forward to create an export of that devicetree

     

       
196
       
-
       
          # blob without knowing before-hand all the flags we would pass to qemu

     

       
197
       
-
       
          # (we would then be able to use `dumpdtb`). Thus, the following config

     

       
198
       
-
       
          # will not boot, but it does allow us to assert that the boot entry has

     

       
199
       
-
       
          # the correct contents.

     

       
200
       
-
       
          boot.loader.systemd-boot.installDeviceTree = pkgs.stdenv.hostPlatform.isAarch64;

     

       
201
       
-
       
          hardware.deviceTree.name = "dummy.dtb";

     

       
202
       
-
       
          hardware.deviceTree.package = lib.mkForce (

     

       
203
       
-
       
            pkgs.runCommand "dummy-devicetree-package" { } ''

     

       
204
       
-
       
              mkdir -p $out

     

       
205
       
-
       
              cp ${pkgs.emptyFile} $out/dummy.dtb

     

       
206
       
-
       
            ''

     

       
207
       
-
       
          );

     

       
0
       
 
       

     

       
208
       
 
       
        };

     

       
209
       
-
       
      };

     

       
210
       
 
       


     

       
211
       
-
       
    testScript =

     

       
212
       
-
       
      { nodes, ... }:

     

       
213
       
-
       
      ''

     

       
214
       
-
       
        machine.start()

     

       
215
       
-
       
        machine.wait_for_unit("multi-user.target")

     

       
216
       
 
       


     

       
217
       
-
       
        machine.succeed(

     

       
218
       
-
       
            "test -e /boot/loader/entries/nixos-generation-1-specialisation-something.conf"

     

       
219
       
-
       
        )

     

       
220
       
-
       
        machine.succeed(

     

       
221
       
-
       
            "grep -q 'title NixOS (something)' /boot/loader/entries/nixos-generation-1-specialisation-something.conf"

     

       
222
       
-
       
        )

     

       
223
       
-
       
        machine.succeed(

     

       
224
       
-
       
            "grep 'sort-key something' /boot/loader/entries/nixos-generation-1-specialisation-something.conf"

     

       
225
       
-
       
        )

     

       
226
       
-
       
      ''

     

       
227
       
-
       
      + pkgs.lib.optionalString pkgs.stdenv.hostPlatform.isAarch64 ''

     

       
228
       
-
       
        machine.succeed(

     

       
229
       
-
       
            r"grep 'devicetree /EFI/nixos/[a-z0-9]\{32\}.*dummy' /boot/loader/entries/nixos-generation-1-specialisation-something.conf"

     

       
230
       
-
       
        )

     

       
231
       
-
       
      '';

     

       
232
       
-
       
  };

     

       
0
       
 
       

     

       
233
       
 
       


     

       
234
       
 
       
  # Boot without having created an EFI entry--instead using default "/EFI/BOOT/BOOTX64.EFI"

     

       
235
       
-
       
  fallback = makeTest {

     

       
236
       
-
       
    name = "systemd-boot-fallback";

     

       
237
       
-
       
    meta.maintainers = with pkgs.lib.maintainers; [

     

       
238
       
-
       
      danielfullmer

     

       
239
       
-
       
      julienmalka

     

       
240
       
-
       
    ];

     

       
0
       
 
       

     

       
0
       
 
       

     

       
241
       
 
       


     

       
242
       
-
       
    nodes.machine =

     

       
243
       
-
       
      { pkgs, lib, ... }:

     

       
244
       
-
       
      {

     

       
245
       
-
       
        imports = [ common ];

     

       
246
       
-
       
        boot.loader.efi.canTouchEfiVariables = mkForce false;

     

       
247
       
-
       
      };

     

       
248
       
 
       


     

       
249
       
-
       
    testScript = ''

     

       
250
       
-
       
      machine.start()

     

       
251
       
-
       
      machine.wait_for_unit("multi-user.target")

     

       
252
       
 
       


     

       
253
       
-
       
      machine.succeed("test -e /boot/loader/entries/nixos-generation-1.conf")

     

       
254
       
 
       


     

       
255
       
-
       
      # Ensure we actually booted using systemd-boot

     

       
256
       
-
       
      # Magic number is the vendor UUID used by systemd-boot.

     

       
257
       
-
       
      machine.succeed(

     

       
258
       
-
       
          "test -e /sys/firmware/efi/efivars/LoaderEntrySelected-4a67b082-0a4c-41cf-b6c7-440b29bb8c4f"

     

       
259
       
-
       
      )

     

       
260
       
 
       


     

       
261
       
-
       
      # "bootctl install" should _not_ have created an EFI entry

     

       
262
       
-
       
      machine.fail('efibootmgr | grep "Linux Boot Manager"')

     

       
263
       
-
       
    '';

     

       
264
       
-
       
  };

     

       
0
       
 
       

     

       
265
       
 
       


     

       
266
       
-
       
  update = makeTest {

     

       
267
       
-
       
    name = "systemd-boot-update";

     

       
268
       
-
       
    meta.maintainers = with pkgs.lib.maintainers; [

     

       
269
       
-
       
      danielfullmer

     

       
270
       
-
       
      julienmalka

     

       
271
       
-
       
    ];

     

       
0
       
 
       

     

       
0
       
 
       

     

       
272
       
 
       


     

       
273
       
-
       
    nodes.machine = common;

     

       
274
       
 
       


     

       
275
       
-
       
    testScript = ''

     

       
276
       
-
       
      machine.succeed("mount -o remount,rw /boot")

     

       
277
       
 
       


     

       
278
       
-
       
      def switch():

     

       
279
       
-
       
          # Replace version inside sd-boot with something older. See magic[] string in systemd src/boot/efi/boot.c

     

       
280
       
-
       
          machine.succeed(

     

       
281
       
-
       
            """

     

       
282
       
-
       
            find /boot -iname '*boot*.efi' -print0 | \

     

       
283
       
-
       
            xargs -0 -I '{}' sed -i 's/#### LoaderInfo: systemd-boot .* ####/#### LoaderInfo: systemd-boot 000.0-1-notnixos ####/' '{}'

     

       
284
       
-
       
            """

     

       
285
       
-
       
          )

     

       
286
       
-
       
          return machine.succeed("/run/current-system/bin/switch-to-configuration boot 2>&1")

     

       
287
       
 
       


     

       
288
       
-
       
      output = switch()

     

       
289
       
-
       
      assert "updating systemd-boot from 000.0-1-notnixos to " in output, "Couldn't find systemd-boot update message"

     

       
290
       
-
       
      assert 'to "/boot/EFI/systemd/systemd-bootx64.efi"' in output, "systemd-boot not copied to to /boot/EFI/systemd/systemd-bootx64.efi"

     

       
291
       
-
       
      assert 'to "/boot/EFI/BOOT/BOOTX64.EFI"' in output, "systemd-boot not copied to to /boot/EFI/BOOT/BOOTX64.EFI"

     

       
292
       
 
       


     

       
293
       
-
       
      with subtest("Test that updating works with lowercase bootx64.efi"):

     

       
294
       
-
       
          machine.succeed(

     

       
295
       
-
       
              # Move to tmp file name first, otherwise mv complains the new location is the same

     

       
296
       
-
       
              "mv /boot/EFI/BOOT/BOOTX64.EFI /boot/EFI/BOOT/bootx64.efi.new",

     

       
297
       
-
       
              "mv /boot/EFI/BOOT/bootx64.efi.new /boot/EFI/BOOT/bootx64.efi",

     

       
298
       
-
       
          )

     

       
299
       
-
       
          output = switch()

     

       
300
       
-
       
          assert "updating systemd-boot from 000.0-1-notnixos to " in output, "Couldn't find systemd-boot update message"

     

       
301
       
-
       
          assert 'to "/boot/EFI/systemd/systemd-bootx64.efi"' in output, "systemd-boot not copied to to /boot/EFI/systemd/systemd-bootx64.efi"

     

       
302
       
-
       
          assert 'to "/boot/EFI/BOOT/BOOTX64.EFI"' in output, "systemd-boot not copied to to /boot/EFI/BOOT/BOOTX64.EFI"

     

       
303
       
-
       
    '';

     

       
304
       
-
       
  };

     

       
0
       
 
       

     

       
305
       
 
       


     

       
306
       
-
       
  memtest86 =

     

       
307
       
-
       
    with pkgs.lib;

     

       
308
       
-
       
    optionalAttrs (meta.availableOn { inherit system; } pkgs.memtest86plus) (makeTest {

     

       
309
       
 
       
      name = "systemd-boot-memtest86";

     

       
310
       
-
       
      meta.maintainers = with maintainers; [ julienmalka ];

     

       
311
       
 
       


     

       
312
       
 
       
      nodes.machine =

     

       
313
       
 
       
        { pkgs, lib, ... }:

     
···

       
320
       
 
       
        machine.succeed("test -e /boot/loader/entries/memtest86.conf")

     

       
321
       
 
       
        machine.succeed("test -e /boot/efi/memtest86/memtest.efi")

     

       
322
       
 
       
      '';

     

       
323
       
-
       
    });

     

       
0
       
 
       

     

       
324
       
 
       


     

       
325
       
-
       
  netbootxyz = makeTest {

     

       
326
       
-
       
    name = "systemd-boot-netbootxyz";

     

       
327
       
-
       
    meta.maintainers = with pkgs.lib.maintainers; [ julienmalka ];

     

       
0
       
 
       

     

       
0
       
 
       

     

       
328
       
 
       


     

       
329
       
-
       
    nodes.machine =

     

       
330
       
-
       
      { pkgs, lib, ... }:

     

       
331
       
-
       
      {

     

       
332
       
-
       
        imports = [ common ];

     

       
333
       
-
       
        boot.loader.systemd-boot.netbootxyz.enable = true;

     

       
334
       
-
       
      };

     

       
335
       
 
       


     

       
336
       
-
       
    testScript = ''

     

       
337
       
-
       
      machine.succeed("test -e /boot/loader/entries/netbootxyz.conf")

     

       
338
       
-
       
      machine.succeed("test -e /boot/efi/netbootxyz/netboot.xyz.efi")

     

       
339
       
-
       
    '';

     

       
340
       
-
       
  };

     

       
0
       
 
       

     

       
341
       
 
       


     

       
342
       
-
       
  edk2-uefi-shell = makeTest {

     

       
343
       
-
       
    name = "systemd-boot-edk2-uefi-shell";

     

       
344
       
-
       
    meta.maintainers = with pkgs.lib.maintainers; [ iFreilicht ];

     

       
0
       
 
       

     

       
0
       
 
       

     

       
345
       
 
       


     

       
346
       
-
       
    nodes.machine =

     

       
347
       
-
       
      { ... }:

     

       
348
       
-
       
      {

     

       
349
       
-
       
        imports = [ common ];

     

       
350
       
-
       
        boot.loader.systemd-boot.edk2-uefi-shell.enable = true;

     

       
351
       
-
       
      };

     

       
352
       
 
       


     

       
353
       
-
       
    testScript = ''

     

       
354
       
-
       
      machine.succeed("test -e /boot/loader/entries/edk2-uefi-shell.conf")

     

       
355
       
-
       
      machine.succeed("test -e /boot/efi/edk2-uefi-shell/shell.efi")

     

       
356
       
-
       
    '';

     

       
357
       
-
       
  };

     

       
0
       
 
       

     

       
358
       
 
       


     

       
359
       
-
       
  windows = makeTest {

     

       
360
       
-
       
    name = "systemd-boot-windows";

     

       
361
       
-
       
    meta.maintainers = with pkgs.lib.maintainers; [ iFreilicht ];

     

       
0
       
 
       

     

       
0
       
 
       

     

       
362
       
 
       


     

       
363
       
-
       
    nodes.machine =

     

       
364
       
-
       
      { ... }:

     

       
365
       
-
       
      {

     

       
366
       
-
       
        imports = [ common ];

     

       
367
       
-
       
        boot.loader.systemd-boot.windows = {

     

       
368
       
-
       
          "7" = {

     

       
369
       
-
       
            efiDeviceHandle = "HD0c1";

     

       
370
       
-
       
            sortKey = "before_all_others";

     

       
371
       
-
       
          };

     

       
372
       
-
       
          "Ten".efiDeviceHandle = "FS0";

     

       
373
       
-
       
          "11" = {

     

       
374
       
-
       
            title = "Title with-_-punctuation ...?!";

     

       
375
       
-
       
            efiDeviceHandle = "HD0d4";

     

       
376
       
-
       
            sortKey = "zzz";

     

       
0
       
 
       

     

       
377
       
 
       
          };

     

       
378
       
 
       
        };

     

       
379
       
-
       
      };

     

       
380
       
 
       


     

       
381
       
-
       
    testScript = ''

     

       
382
       
-
       
      machine.succeed("test -e /boot/efi/edk2-uefi-shell/shell.efi")

     

       
383
       
 
       


     

       
384
       
-
       
      machine.succeed("test -e /boot/loader/entries/windows_7.conf")

     

       
385
       
-
       
      machine.succeed("test -e /boot/loader/entries/windows_Ten.conf")

     

       
386
       
-
       
      machine.succeed("test -e /boot/loader/entries/windows_11.conf")

     

       
387
       
 
       


     

       
388
       
-
       
      machine.succeed("grep 'efi /efi/edk2-uefi-shell/shell.efi' /boot/loader/entries/windows_7.conf")

     

       
389
       
-
       
      machine.succeed("grep 'efi /efi/edk2-uefi-shell/shell.efi' /boot/loader/entries/windows_Ten.conf")

     

       
390
       
-
       
      machine.succeed("grep 'efi /efi/edk2-uefi-shell/shell.efi' /boot/loader/entries/windows_11.conf")

     

       
391
       
 
       


     

       
392
       
-
       
      machine.succeed("grep 'HD0c1:EFI\\\\Microsoft\\\\Boot\\\\Bootmgfw.efi' /boot/loader/entries/windows_7.conf")

     

       
393
       
-
       
      machine.succeed("grep 'FS0:EFI\\\\Microsoft\\\\Boot\\\\Bootmgfw.efi' /boot/loader/entries/windows_Ten.conf")

     

       
394
       
-
       
      machine.succeed("grep 'HD0d4:EFI\\\\Microsoft\\\\Boot\\\\Bootmgfw.efi' /boot/loader/entries/windows_11.conf")

     

       
395
       
 
       


     

       
396
       
-
       
      machine.succeed("grep 'sort-key before_all_others' /boot/loader/entries/windows_7.conf")

     

       
397
       
-
       
      machine.succeed("grep 'sort-key o_windows_Ten' /boot/loader/entries/windows_Ten.conf")

     

       
398
       
-
       
      machine.succeed("grep 'sort-key zzz' /boot/loader/entries/windows_11.conf")

     

       
399
       
 
       


     

       
400
       
-
       
      machine.succeed("grep 'title Windows 7' /boot/loader/entries/windows_7.conf")

     

       
401
       
-
       
      machine.succeed("grep 'title Windows Ten' /boot/loader/entries/windows_Ten.conf")

     

       
402
       
-
       
      machine.succeed('grep "title Title with-_-punctuation ...?!" /boot/loader/entries/windows_11.conf')

     

       
403
       
-
       
    '';

     

       
404
       
-
       
  };

     

       
0
       
 
       

     

       
405
       
 
       


     

       
406
       
-
       
  memtestSortKey = makeTest {

     

       
407
       
-
       
    name = "systemd-boot-memtest-sortkey";

     

       
408
       
-
       
    meta.maintainers = with pkgs.lib.maintainers; [ julienmalka ];

     

       
0
       
 
       

     

       
0
       
 
       

     

       
409
       
 
       


     

       
410
       
-
       
    nodes.machine =

     

       
411
       
-
       
      { pkgs, lib, ... }:

     

       
412
       
-
       
      {

     

       
413
       
-
       
        imports = [ common ];

     

       
414
       
-
       
        boot.loader.systemd-boot.memtest86.enable = true;

     

       
415
       
-
       
        boot.loader.systemd-boot.memtest86.sortKey = "apple";

     

       
416
       
-
       
      };

     

       
417
       
-
       


     

       
418
       
-
       
    testScript = ''

     

       
419
       
-
       
      machine.succeed("test -e /boot/loader/entries/memtest86.conf")

     

       
420
       
-
       
      machine.succeed("test -e /boot/efi/memtest86/memtest.efi")

     

       
421
       
-
       
      machine.succeed("grep 'sort-key apple' /boot/loader/entries/memtest86.conf")

     

       
422
       
-
       
    '';

     

       
423
       
-
       
  };

     

       
424
       
-
       


     

       
425
       
-
       
  entryFilenameXbootldr = makeTest {

     

       
426
       
-
       
    name = "systemd-boot-entry-filename-xbootldr";

     

       
427
       
-
       
    meta.maintainers = with pkgs.lib.maintainers; [ sdht0 ];

     

       
428
       
-
       


     

       
429
       
-
       
    nodes.machine =

     

       
430
       
-
       
      { pkgs, lib, ... }:

     

       
431
       
-
       
      {

     

       
432
       
-
       
        imports = [ commonXbootldr ];

     

       
433
       
-
       
        boot.loader.systemd-boot.memtest86.enable = true;

     

       
434
       
-
       
      };

     

       
435
       
-
       


     

       
436
       
-
       
    testScript =

     

       
437
       
-
       
      { nodes, ... }:

     

       
438
       
-
       
      ''

     

       
439
       
-
       
        ${customDiskImage nodes}

     

       
440
       
-
       


     

       
441
       
-
       
        machine.start()

     

       
442
       
-
       
        machine.wait_for_unit("multi-user.target")

     

       
443
       
 
       


     

       
444
       
-
       
        machine.succeed("test -e /efi/EFI/systemd/systemd-bootx64.efi")

     

       
445
       
 
       
        machine.succeed("test -e /boot/loader/entries/memtest86.conf")

     

       
446
       
-
       
        machine.succeed("test -e /boot/EFI/memtest86/memtest.efi")

     

       
0
       
 
       

     

       
447
       
 
       
      '';

     

       
448
       
-
       
  };

     

       
0
       
 
       

     

       
449
       
 
       


     

       
450
       
-
       
  extraEntries = makeTest {

     

       
451
       
-
       
    name = "systemd-boot-extra-entries";

     

       
452
       
-
       
    meta.maintainers = with pkgs.lib.maintainers; [ julienmalka ];

     

       
0
       
 
       

     

       
0
       
 
       

     

       
453
       
 
       


     

       
454
       
-
       
    nodes.machine =

     

       
455
       
-
       
      { pkgs, lib, ... }:

     

       
456
       
-
       
      {

     

       
457
       
-
       
        imports = [ common ];

     

       
458
       
-
       
        boot.loader.systemd-boot.extraEntries = {

     

       
459
       
-
       
          "banana.conf" = ''

     

       
460
       
-
       
            title banana

     

       
461
       
-
       
          '';

     

       
462
       
 
       
        };

     

       
463
       
-
       
      };

     

       
464
       
 
       


     

       
465
       
-
       
    testScript = ''

     

       
466
       
-
       
      machine.succeed("test -e /boot/loader/entries/banana.conf")

     

       
467
       
-
       
      machine.succeed("test -e /boot/efi/nixos/.extra-files/loader/entries/banana.conf")

     

       
468
       
-
       
    '';

     

       
469
       
-
       
  };

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
470
       
 
       


     

       
471
       
-
       
  extraFiles = makeTest {

     

       
472
       
-
       
    name = "systemd-boot-extra-files";

     

       
473
       
-
       
    meta.maintainers = with pkgs.lib.maintainers; [ julienmalka ];

     

       
0
       
 
       

     

       
0
       
 
       

     

       
474
       
 
       


     

       
475
       
-
       
    nodes.machine =

     

       
476
       
-
       
      { pkgs, lib, ... }:

     

       
477
       
-
       
      {

     

       
478
       
-
       
        imports = [ common ];

     

       
479
       
-
       
        boot.loader.systemd-boot.extraFiles = {

     

       
480
       
-
       
          "efi/fruits/tomato.efi" = pkgs.netbootxyz-efi;

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
481
       
 
       
        };

     

       
482
       
-
       
      };

     

       
483
       
 
       


     

       
484
       
-
       
    testScript = ''

     

       
485
       
-
       
      machine.succeed("test -e /boot/efi/fruits/tomato.efi")

     

       
486
       
-
       
      machine.succeed("test -e /boot/efi/nixos/.extra-files/efi/fruits/tomato.efi")

     

       
487
       
-
       
    '';

     

       
488
       
-
       
  };

     

       
489
       
-
       


     

       
490
       
-
       
  switch-test = makeTest {

     

       
491
       
-
       
    name = "systemd-boot-switch-test";

     

       
492
       
-
       
    meta.maintainers = with pkgs.lib.maintainers; [ julienmalka ];

     

       
493
       
 
       


     

       
494
       
-
       
    nodes = {

     

       
495
       
-
       
      inherit common;

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
496
       
 
       


     

       
497
       
-
       
      machine =

     

       
498
       
-
       
        { pkgs, nodes, ... }:

     

       
499
       
 
       
        {

     

       
500
       
 
       
          imports = [ common ];

     

       
501
       
 
       
          boot.loader.systemd-boot.extraFiles = {

     

       
502
       
 
       
            "efi/fruits/tomato.efi" = pkgs.netbootxyz-efi;

     

       
503
       
 
       
          };

     

       
504
       
-
       


     

       
505
       
-
       
          # These are configs for different nodes, but we'll use them here in `machine`

     

       
506
       
-
       
          system.extraDependencies = [

     

       
507
       
-
       
            nodes.common.system.build.toplevel

     

       
508
       
-
       
            nodes.with_netbootxyz.system.build.toplevel

     

       
509
       
-
       
          ];

     

       
510
       
 
       
        };

     

       
511
       
 
       


     

       
512
       
-
       
      with_netbootxyz =

     

       
513
       
-
       
        { pkgs, ... }:

     

       
514
       
-
       
        {

     

       
515
       
-
       
          imports = [ common ];

     

       
516
       
-
       
          boot.loader.systemd-boot.netbootxyz.enable = true;

     

       
517
       
-
       
        };

     

       
518
       
-
       
    };

     

       
519
       
-
       


     

       
520
       
-
       
    testScript =

     

       
521
       
-
       
      { nodes, ... }:

     

       
522
       
-
       
      let

     

       
523
       
-
       
        originalSystem = nodes.machine.system.build.toplevel;

     

       
524
       
-
       
        baseSystem = nodes.common.system.build.toplevel;

     

       
525
       
-
       
        finalSystem = nodes.with_netbootxyz.system.build.toplevel;

     

       
526
       
-
       
      in

     

       
527
       
-
       
      ''

     

       
528
       
 
       
        machine.succeed("test -e /boot/efi/fruits/tomato.efi")

     

       
529
       
 
       
        machine.succeed("test -e /boot/efi/nixos/.extra-files/efi/fruits/tomato.efi")

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
530
       
 
       


     

       
531
       
-
       
        with subtest("remove files when no longer needed"):

     

       
532
       
-
       
            machine.succeed("${baseSystem}/bin/switch-to-configuration boot")

     

       
533
       
-
       
            machine.fail("test -e /boot/efi/fruits/tomato.efi")

     

       
534
       
-
       
            machine.fail("test -d /boot/efi/fruits")

     

       
535
       
-
       
            machine.succeed("test -d /boot/efi/nixos/.extra-files")

     

       
536
       
-
       
            machine.fail("test -e /boot/efi/nixos/.extra-files/efi/fruits/tomato.efi")

     

       
537
       
-
       
            machine.fail("test -d /boot/efi/nixos/.extra-files/efi/fruits")

     

       
538
       
 
       


     

       
539
       
-
       
        with subtest("files are added back when needed again"):

     

       
540
       
-
       
            machine.succeed("${originalSystem}/bin/switch-to-configuration boot")

     

       
541
       
-
       
            machine.succeed("test -e /boot/efi/fruits/tomato.efi")

     

       
542
       
-
       
            machine.succeed("test -e /boot/efi/nixos/.extra-files/efi/fruits/tomato.efi")

     

       
543
       
 
       


     

       
544
       
-
       
        with subtest("simultaneously removing and adding files works"):

     

       
545
       
-
       
            machine.succeed("${finalSystem}/bin/switch-to-configuration boot")

     

       
546
       
-
       
            machine.fail("test -e /boot/efi/fruits/tomato.efi")

     

       
547
       
-
       
            machine.fail("test -e /boot/efi/nixos/.extra-files/efi/fruits/tomato.efi")

     

       
548
       
-
       
            machine.succeed("test -e /boot/loader/entries/netbootxyz.conf")

     

       
549
       
-
       
            machine.succeed("test -e /boot/efi/netbootxyz/netboot.xyz.efi")

     

       
550
       
-
       
            machine.succeed("test -e /boot/efi/nixos/.extra-files/loader/entries/netbootxyz.conf")

     

       
551
       
-
       
            machine.succeed("test -e /boot/efi/nixos/.extra-files/efi/netbootxyz/netboot.xyz.efi")

     

       
552
       
-
       
      '';

     

       
553
       
-
       
  };

     

       
554
       
 
       


     

       
555
       
-
       
  garbage-collect-entry = makeTest {

     

       
556
       
-
       
    name = "systemd-boot-garbage-collect-entry";

     

       
557
       
-
       
    meta.maintainers = with pkgs.lib.maintainers; [ julienmalka ];

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
558
       
 
       


     

       
559
       
-
       
    nodes = {

     

       
560
       
-
       
      inherit common;

     

       
561
       
-
       
      machine =

     

       
562
       
-
       
        { pkgs, nodes, ... }:

     

       
563
       
-
       
        {

     

       
564
       
-
       
          imports = [ common ];

     

       
0
       
 
       

     

       
565
       
 
       


     

       
566
       
-
       
          # These are configs for different nodes, but we'll use them here in `machine`

     

       
567
       
-
       
          system.extraDependencies = [

     

       
568
       
-
       
            nodes.common.system.build.toplevel

     

       
569
       
-
       
          ];

     

       
570
       
-
       
        };

     

       
571
       
-
       
    };

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
572
       
 
       


     

       
573
       
-
       
    testScript =

     

       
574
       
-
       
      { nodes, ... }:

     

       
575
       
-
       
      let

     

       
576
       
-
       
        baseSystem = nodes.common.system.build.toplevel;

     

       
577
       
-
       
      in

     

       
578
       
-
       
      ''

     

       
579
       
-
       
        machine.succeed("nix-env -p /nix/var/nix/profiles/system --set ${baseSystem}")

     

       
580
       
-
       
        machine.succeed("nix-env -p /nix/var/nix/profiles/system --delete-generations 1")

     

       
581
       
-
       
        machine.succeed("${baseSystem}/bin/switch-to-configuration boot")

     

       
582
       
-
       
        machine.fail("test -e /boot/loader/entries/nixos-generation-1.conf")

     

       
583
       
-
       
        machine.succeed("test -e /boot/loader/entries/nixos-generation-2.conf")

     

       
584
       
-
       
      '';

     

       
585
       
-
       
  };

     

       
0
       
 
       

     

       
586
       
 
       


     

       
587
       
-
       
  no-bootspec = makeTest {

     

       
588
       
-
       
    name = "systemd-boot-no-bootspec";

     

       
589
       
-
       
    meta.maintainers = with pkgs.lib.maintainers; [ julienmalka ];

     

       
0
       
 
       

     

       
0
       
 
       

     

       
590
       
 
       


     

       
591
       
-
       
    nodes.machine = {

     

       
592
       
-
       
      imports = [ common ];

     

       
593
       
-
       
      boot.bootspec.enable = false;

     

       
594
       
-
       
    };

     

       
595
       
 
       


     

       
596
       
-
       
    testScript = ''

     

       
597
       
-
       
      machine.start()

     

       
598
       
-
       
      machine.wait_for_unit("multi-user.target")

     

       
599
       
-
       
    '';

     

       
600
       
-
       
  };

     

       
0
       
 
       

     

       
601
       
 
       
}

     

···

       
1
       
 
       
{

     

       
2
       
+
       
  runTest,

     

       
3
       
+
       
  runTestOn,

     

       
4
       
+
       
  ...

     

       
5
       
 
       
}:

     

       
6
       
 
       


     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
7
       
 
       
let

     

       
8
       
+
       
  common =

     

       
9
       
+
       
    { pkgs, ... }:

     

       
10
       
+
       
    {

     

       
11
       
+
       
      virtualisation.useBootLoader = true;

     

       
12
       
+
       
      virtualisation.useEFIBoot = true;

     

       
13
       
+
       
      boot.loader.systemd-boot.enable = true;

     

       
14
       
+
       
      boot.loader.efi.canTouchEfiVariables = true;

     

       
15
       
+
       
      environment.systemPackages = [ pkgs.efibootmgr ];

     

       
16
       
+
       
      system.switch.enable = true;

     

       
17
       
+
       
    };

     

       
18
       
 
       


     

       
19
       
 
       
  commonXbootldr =

     

       
20
       
 
       
    {

     
···

       
31
       
 
       
        partitionTableType = "efixbootldr";

     

       
32
       
 
       
        touchEFIVars = true;

     

       
33
       
 
       
        installBootLoader = true;

     

       
34
       
+
       
        # Don't copy the channel to avoid rebuilding this image, and all tests

     

       
35
       
+
       
        # that use it, every time that nixpkgs changes

     

       
36
       
+
       
        copyChannel = false;

     

       
37
       
 
       
      };

     

       
38
       
 
       
    in

     

       
39
       
 
       
    {

     
···

       
92
       
 
       
  '';

     

       
93
       
 
       
in

     

       
94
       
 
       
{

     

       
95
       
+
       
  basic = runTest (

     

       
96
       
+
       
    { lib, ... }:

     

       
97
       
+
       
    {

     

       
98
       
+
       
      name = "systemd-boot";

     

       
99
       
+
       
      meta.maintainers = with lib.maintainers; [

     

       
100
       
+
       
        danielfullmer

     

       
101
       
+
       
        julienmalka

     

       
102
       
+
       
      ];

     

       
103
       
 
       


     

       
104
       
+
       
      nodes.machine = common;

     

       
105
       
 
       


     

       
106
       
+
       
      testScript = ''

     

       
107
       
+
       
        machine.start()

     

       
108
       
+
       
        machine.wait_for_unit("multi-user.target")

     

       
109
       
 
       


     

       
110
       
+
       
        machine.succeed("test -e /boot/loader/entries/nixos-generation-1.conf")

     

       
111
       
+
       
        machine.succeed("grep 'sort-key nixos' /boot/loader/entries/nixos-generation-1.conf")

     

       
112
       
 
       


     

       
113
       
+
       
        # Ensure we actually booted using systemd-boot

     

       
114
       
+
       
        # Magic number is the vendor UUID used by systemd-boot.

     

       
115
       
+
       
        machine.succeed(

     

       
116
       
+
       
            "test -e /sys/firmware/efi/efivars/LoaderEntrySelected-4a67b082-0a4c-41cf-b6c7-440b29bb8c4f"

     

       
117
       
+
       
        )

     

       
118
       
 
       


     

       
119
       
+
       
        # "bootctl install" should have created an EFI entry

     

       
120
       
+
       
        machine.succeed('efibootmgr | grep "Linux Boot Manager"')

     

       
121
       
+
       
      '';

     

       
122
       
+
       
    }

     

       
123
       
+
       
  );

     

       
124
       
 
       


     

       
125
       
 
       
  # Test that systemd-boot works with secure boot

     

       
126
       
+
       
  secureBoot = runTest (

     

       
127
       
+
       
    { pkgs, lib, ... }:

     

       
128
       
+
       
    {

     

       
129
       
+
       
      name = "systemd-boot-secure-boot";

     

       
130
       
 
       


     

       
131
       
+
       
      nodes.machine =

     

       
132
       
+
       
        { pkgs, ... }:

     

       
133
       
+
       
        {

     

       
134
       
+
       
          imports = [ common ];

     

       
135
       
+
       
          environment.systemPackages = [ pkgs.sbctl ];

     

       
136
       
+
       
          virtualisation.useSecureBoot = true;

     

       
137
       
+
       
        };

     

       
138
       
 
       


     

       
139
       
+
       
      testScript =

     

       
140
       
+
       
        { nodes, ... }:

     

       
141
       
+
       
        let

     

       
142
       
+
       
          efiArch = pkgs.stdenv.hostPlatform.efiArch;

     

       
143
       
+
       
        in

     

       
144
       
+
       
        ''

     

       
145
       
+
       
          machine.start(allow_reboot=True)

     

       
146
       
+
       
          machine.wait_for_unit("multi-user.target")

     

       
147
       
 
       


     

       
148
       
+
       
          machine.succeed("sbctl create-keys")

     

       
149
       
+
       
          machine.succeed("sbctl enroll-keys --yes-this-might-brick-my-machine")

     

       
150
       
+
       
          machine.succeed('sbctl sign /boot/EFI/systemd/systemd-boot${efiArch}.efi')

     

       
151
       
+
       
          machine.succeed('sbctl sign /boot/EFI/BOOT/BOOT${lib.toUpper efiArch}.EFI')

     

       
152
       
+
       
          machine.succeed('sbctl sign /boot/EFI/nixos/*${nodes.machine.system.boot.loader.kernelFile}.efi')

     

       
153
       
 
       


     

       
154
       
+
       
          machine.reboot()

     

       
155
       
 
       


     

       
156
       
+
       
          assert "Secure Boot: enabled (user)" in machine.succeed("bootctl status")

     

       
157
       
+
       
        '';

     

       
158
       
+
       
    }

     

       
159
       
+
       
  );

     

       
160
       
 
       


     

       
161
       
+
       
  basicXbootldr = runTest (

     

       
162
       
+
       
    { lib, ... }:

     

       
163
       
+
       
    {

     

       
164
       
+
       
      name = "systemd-boot-xbootldr";

     

       
165
       
+
       
      meta.maintainers = with lib.maintainers; [ sdht0 ];

     

       
166
       
 
       


     

       
167
       
+
       
      nodes.machine = commonXbootldr;

     

       
168
       
 
       


     

       
169
       
+
       
      testScript =

     

       
170
       
+
       
        { nodes, ... }:

     

       
171
       
+
       
        ''

     

       
172
       
+
       
          ${customDiskImage nodes}

     

       
173
       
 
       


     

       
174
       
+
       
          machine.start()

     

       
175
       
+
       
          machine.wait_for_unit("multi-user.target")

     

       
176
       
 
       


     

       
177
       
+
       
          machine.succeed("test -e /efi/EFI/systemd/systemd-bootx64.efi")

     

       
178
       
+
       
          machine.succeed("test -e /boot/loader/entries/nixos-generation-1.conf")

     

       
179
       
 
       


     

       
180
       
+
       
          # Ensure we actually booted using systemd-boot

     

       
181
       
+
       
          # Magic number is the vendor UUID used by systemd-boot.

     

       
182
       
+
       
          machine.succeed(

     

       
183
       
+
       
              "test -e /sys/firmware/efi/efivars/LoaderEntrySelected-4a67b082-0a4c-41cf-b6c7-440b29bb8c4f"

     

       
184
       
+
       
          )

     

       
185
       
 
       


     

       
186
       
+
       
          # "bootctl install" should have created an EFI entry

     

       
187
       
+
       
          machine.succeed('efibootmgr | grep "Linux Boot Manager"')

     

       
188
       
+
       
        '';

     

       
189
       
+
       
    }

     

       
190
       
+
       
  );

     

       
191
       
 
       


     

       
192
       
 
       
  # Check that specialisations create corresponding boot entries.

     

       
193
       
+
       
  specialisation = runTest (

     

       
194
       
+
       
    { pkgs, lib, ... }:

     

       
195
       
+
       
    {

     

       
196
       
+
       
      name = "systemd-boot-specialisation";

     

       
197
       
+
       
      meta.maintainers = with lib.maintainers; [

     

       
198
       
+
       
        lukegb

     

       
199
       
+
       
        julienmalka

     

       
200
       
+
       
      ];

     

       
201
       
 
       


     

       
202
       
+
       
      nodes.machine =

     

       
203
       
+
       
        { pkgs, lib, ... }:

     

       
204
       
+
       
        {

     

       
205
       
+
       
          imports = [ common ];

     

       
206
       
+
       
          specialisation.something.configuration = {

     

       
207
       
+
       
            boot.loader.systemd-boot.sortKey = "something";

     

       
208
       
 
       


     

       
209
       
+
       
            # Since qemu will dynamically create a devicetree blob when starting

     

       
210
       
+
       
            # up, it is not straight forward to create an export of that devicetree

     

       
211
       
+
       
            # blob without knowing before-hand all the flags we would pass to qemu

     

       
212
       
+
       
            # (we would then be able to use `dumpdtb`). Thus, the following config

     

       
213
       
+
       
            # will not boot, but it does allow us to assert that the boot entry has

     

       
214
       
+
       
            # the correct contents.

     

       
215
       
+
       
            boot.loader.systemd-boot.installDeviceTree = pkgs.stdenv.hostPlatform.isAarch64;

     

       
216
       
+
       
            hardware.deviceTree.name = "dummy.dtb";

     

       
217
       
+
       
            hardware.deviceTree.package = lib.mkForce (

     

       
218
       
+
       
              pkgs.runCommand "dummy-devicetree-package" { } ''

     

       
219
       
+
       
                mkdir -p $out

     

       
220
       
+
       
                cp ${pkgs.emptyFile} $out/dummy.dtb

     

       
221
       
+
       
              ''

     

       
222
       
+
       
            );

     

       
223
       
+
       
          };

     

       
224
       
 
       
        };

     

       
0
       
 
       

     

       
225
       
 
       


     

       
226
       
+
       
      testScript =

     

       
227
       
+
       
        { nodes, ... }:

     

       
228
       
+
       
        ''

     

       
229
       
+
       
          machine.start()

     

       
230
       
+
       
          machine.wait_for_unit("multi-user.target")

     

       
231
       
 
       


     

       
232
       
+
       
          machine.succeed(

     

       
233
       
+
       
              "test -e /boot/loader/entries/nixos-generation-1-specialisation-something.conf"

     

       
234
       
+
       
          )

     

       
235
       
+
       
          machine.succeed(

     

       
236
       
+
       
              "grep -q 'title NixOS (something)' /boot/loader/entries/nixos-generation-1-specialisation-something.conf"

     

       
237
       
+
       
          )

     

       
238
       
+
       
          machine.succeed(

     

       
239
       
+
       
              "grep 'sort-key something' /boot/loader/entries/nixos-generation-1-specialisation-something.conf"

     

       
240
       
+
       
          )

     

       
241
       
+
       
        ''

     

       
242
       
+
       
        + pkgs.lib.optionalString pkgs.stdenv.hostPlatform.isAarch64 ''

     

       
243
       
+
       
          machine.succeed(

     

       
244
       
+
       
              r"grep 'devicetree /EFI/nixos/[a-z0-9]\{32\}.*dummy' /boot/loader/entries/nixos-generation-1-specialisation-something.conf"

     

       
245
       
+
       
          )

     

       
246
       
+
       
        '';

     

       
247
       
+
       
    }

     

       
248
       
+
       
  );

     

       
249
       
 
       


     

       
250
       
 
       
  # Boot without having created an EFI entry--instead using default "/EFI/BOOT/BOOTX64.EFI"

     

       
251
       
+
       
  fallback = runTest (

     

       
252
       
+
       
    { pkgs, lib, ... }:

     

       
253
       
+
       
    {

     

       
254
       
+
       
      name = "systemd-boot-fallback";

     

       
255
       
+
       
      meta.maintainers = with lib.maintainers; [

     

       
256
       
+
       
        danielfullmer

     

       
257
       
+
       
        julienmalka

     

       
258
       
+
       
      ];

     

       
259
       
 
       


     

       
260
       
+
       
      nodes.machine =

     

       
261
       
+
       
        { pkgs, lib, ... }:

     

       
262
       
+
       
        {

     

       
263
       
+
       
          imports = [ common ];

     

       
264
       
+
       
          boot.loader.efi.canTouchEfiVariables = lib.mkForce false;

     

       
265
       
+
       
        };

     

       
266
       
 
       


     

       
267
       
+
       
      testScript = ''

     

       
268
       
+
       
        machine.start()

     

       
269
       
+
       
        machine.wait_for_unit("multi-user.target")

     

       
270
       
 
       


     

       
271
       
+
       
        machine.succeed("test -e /boot/loader/entries/nixos-generation-1.conf")

     

       
272
       
 
       


     

       
273
       
+
       
        # Ensure we actually booted using systemd-boot

     

       
274
       
+
       
        # Magic number is the vendor UUID used by systemd-boot.

     

       
275
       
+
       
        machine.succeed(

     

       
276
       
+
       
            "test -e /sys/firmware/efi/efivars/LoaderEntrySelected-4a67b082-0a4c-41cf-b6c7-440b29bb8c4f"

     

       
277
       
+
       
        )

     

       
278
       
 
       


     

       
279
       
+
       
        # "bootctl install" should _not_ have created an EFI entry

     

       
280
       
+
       
        machine.fail('efibootmgr | grep "Linux Boot Manager"')

     

       
281
       
+
       
      '';

     

       
282
       
+
       
    }

     

       
283
       
+
       
  );

     

       
284
       
 
       


     

       
285
       
+
       
  update = runTest (

     

       
286
       
+
       
    { lib, ... }:

     

       
287
       
+
       
    {

     

       
288
       
+
       
      name = "systemd-boot-update";

     

       
289
       
+
       
      meta.maintainers = with lib.maintainers; [

     

       
290
       
+
       
        danielfullmer

     

       
291
       
+
       
        julienmalka

     

       
292
       
+
       
      ];

     

       
293
       
 
       


     

       
294
       
+
       
      nodes.machine = common;

     

       
295
       
 
       


     

       
296
       
+
       
      testScript = ''

     

       
297
       
+
       
        machine.succeed("mount -o remount,rw /boot")

     

       
298
       
 
       


     

       
299
       
+
       
        def switch():

     

       
300
       
+
       
            # Replace version inside sd-boot with something older. See magic[] string in systemd src/boot/efi/boot.c

     

       
301
       
+
       
            machine.succeed(

     

       
302
       
+
       
              """

     

       
303
       
+
       
              find /boot -iname '*boot*.efi' -print0 | \

     

       
304
       
+
       
              xargs -0 -I '{}' sed -i 's/#### LoaderInfo: systemd-boot .* ####/#### LoaderInfo: systemd-boot 000.0-1-notnixos ####/' '{}'

     

       
305
       
+
       
              """

     

       
306
       
+
       
            )

     

       
307
       
+
       
            return machine.succeed("/run/current-system/bin/switch-to-configuration boot 2>&1")

     

       
308
       
 
       


     

       
309
       
+
       
        output = switch()

     

       
310
       
+
       
        assert "updating systemd-boot from 000.0-1-notnixos to " in output, "Couldn't find systemd-boot update message"

     

       
311
       
+
       
        assert 'to "/boot/EFI/systemd/systemd-bootx64.efi"' in output, "systemd-boot not copied to to /boot/EFI/systemd/systemd-bootx64.efi"

     

       
312
       
+
       
        assert 'to "/boot/EFI/BOOT/BOOTX64.EFI"' in output, "systemd-boot not copied to to /boot/EFI/BOOT/BOOTX64.EFI"

     

       
313
       
 
       


     

       
314
       
+
       
        with subtest("Test that updating works with lowercase bootx64.efi"):

     

       
315
       
+
       
            machine.succeed(

     

       
316
       
+
       
                # Move to tmp file name first, otherwise mv complains the new location is the same

     

       
317
       
+
       
                "mv /boot/EFI/BOOT/BOOTX64.EFI /boot/EFI/BOOT/bootx64.efi.new",

     

       
318
       
+
       
                "mv /boot/EFI/BOOT/bootx64.efi.new /boot/EFI/BOOT/bootx64.efi",

     

       
319
       
+
       
            )

     

       
320
       
+
       
            output = switch()

     

       
321
       
+
       
            assert "updating systemd-boot from 000.0-1-notnixos to " in output, "Couldn't find systemd-boot update message"

     

       
322
       
+
       
            assert 'to "/boot/EFI/systemd/systemd-bootx64.efi"' in output, "systemd-boot not copied to to /boot/EFI/systemd/systemd-bootx64.efi"

     

       
323
       
+
       
            assert 'to "/boot/EFI/BOOT/BOOTX64.EFI"' in output, "systemd-boot not copied to to /boot/EFI/BOOT/BOOTX64.EFI"

     

       
324
       
+
       
      '';

     

       
325
       
+
       
    }

     

       
326
       
+
       
  );

     

       
327
       
 
       


     

       
328
       
+
       
  memtest86 = runTestOn [ "x86_64-linux" ] (

     

       
329
       
+
       
    { lib, ... }:

     

       
330
       
+
       
    {

     

       
331
       
 
       
      name = "systemd-boot-memtest86";

     

       
332
       
+
       
      meta.maintainers = with lib.maintainers; [ julienmalka ];

     

       
333
       
 
       


     

       
334
       
 
       
      nodes.machine =

     

       
335
       
 
       
        { pkgs, lib, ... }:

     
···

       
342
       
 
       
        machine.succeed("test -e /boot/loader/entries/memtest86.conf")

     

       
343
       
 
       
        machine.succeed("test -e /boot/efi/memtest86/memtest.efi")

     

       
344
       
 
       
      '';

     

       
345
       
+
       
    }

     

       
346
       
+
       
  );

     

       
347
       
 
       


     

       
348
       
+
       
  netbootxyz = runTest (

     

       
349
       
+
       
    { lib, ... }:

     

       
350
       
+
       
    {

     

       
351
       
+
       
      name = "systemd-boot-netbootxyz";

     

       
352
       
+
       
      meta.maintainers = with lib.maintainers; [ julienmalka ];

     

       
353
       
 
       


     

       
354
       
+
       
      nodes.machine =

     

       
355
       
+
       
        { pkgs, lib, ... }:

     

       
356
       
+
       
        {

     

       
357
       
+
       
          imports = [ common ];

     

       
358
       
+
       
          boot.loader.systemd-boot.netbootxyz.enable = true;

     

       
359
       
+
       
        };

     

       
360
       
 
       


     

       
361
       
+
       
      testScript = ''

     

       
362
       
+
       
        machine.succeed("test -e /boot/loader/entries/netbootxyz.conf")

     

       
363
       
+
       
        machine.succeed("test -e /boot/efi/netbootxyz/netboot.xyz.efi")

     

       
364
       
+
       
      '';

     

       
365
       
+
       
    }

     

       
366
       
+
       
  );

     

       
367
       
 
       


     

       
368
       
+
       
  edk2-uefi-shell = runTest (

     

       
369
       
+
       
    { lib, ... }:

     

       
370
       
+
       
    {

     

       
371
       
+
       
      name = "systemd-boot-edk2-uefi-shell";

     

       
372
       
+
       
      meta.maintainers = with lib.maintainers; [ iFreilicht ];

     

       
373
       
 
       


     

       
374
       
+
       
      nodes.machine =

     

       
375
       
+
       
        { ... }:

     

       
376
       
+
       
        {

     

       
377
       
+
       
          imports = [ common ];

     

       
378
       
+
       
          boot.loader.systemd-boot.edk2-uefi-shell.enable = true;

     

       
379
       
+
       
        };

     

       
380
       
 
       


     

       
381
       
+
       
      testScript = ''

     

       
382
       
+
       
        machine.succeed("test -e /boot/loader/entries/edk2-uefi-shell.conf")

     

       
383
       
+
       
        machine.succeed("test -e /boot/efi/edk2-uefi-shell/shell.efi")

     

       
384
       
+
       
      '';

     

       
385
       
+
       
    }

     

       
386
       
+
       
  );

     

       
387
       
 
       


     

       
388
       
+
       
  windows = runTest (

     

       
389
       
+
       
    { lib, ... }:

     

       
390
       
+
       
    {

     

       
391
       
+
       
      name = "systemd-boot-windows";

     

       
392
       
+
       
      meta.maintainers = with lib.maintainers; [ iFreilicht ];

     

       
393
       
 
       


     

       
394
       
+
       
      nodes.machine =

     

       
395
       
+
       
        { ... }:

     

       
396
       
+
       
        {

     

       
397
       
+
       
          imports = [ common ];

     

       
398
       
+
       
          boot.loader.systemd-boot.windows = {

     

       
399
       
+
       
            "7" = {

     

       
400
       
+
       
              efiDeviceHandle = "HD0c1";

     

       
401
       
+
       
              sortKey = "before_all_others";

     

       
402
       
+
       
            };

     

       
403
       
+
       
            "Ten".efiDeviceHandle = "FS0";

     

       
404
       
+
       
            "11" = {

     

       
405
       
+
       
              title = "Title with-_-punctuation ...?!";

     

       
406
       
+
       
              efiDeviceHandle = "HD0d4";

     

       
407
       
+
       
              sortKey = "zzz";

     

       
408
       
+
       
            };

     

       
409
       
 
       
          };

     

       
410
       
 
       
        };

     

       
0
       
 
       

     

       
411
       
 
       


     

       
412
       
+
       
      testScript = ''

     

       
413
       
+
       
        machine.succeed("test -e /boot/efi/edk2-uefi-shell/shell.efi")

     

       
414
       
 
       


     

       
415
       
+
       
        machine.succeed("test -e /boot/loader/entries/windows_7.conf")

     

       
416
       
+
       
        machine.succeed("test -e /boot/loader/entries/windows_Ten.conf")

     

       
417
       
+
       
        machine.succeed("test -e /boot/loader/entries/windows_11.conf")

     

       
418
       
 
       


     

       
419
       
+
       
        machine.succeed("grep 'efi /efi/edk2-uefi-shell/shell.efi' /boot/loader/entries/windows_7.conf")

     

       
420
       
+
       
        machine.succeed("grep 'efi /efi/edk2-uefi-shell/shell.efi' /boot/loader/entries/windows_Ten.conf")

     

       
421
       
+
       
        machine.succeed("grep 'efi /efi/edk2-uefi-shell/shell.efi' /boot/loader/entries/windows_11.conf")

     

       
422
       
 
       


     

       
423
       
+
       
        machine.succeed("grep 'HD0c1:EFI\\\\Microsoft\\\\Boot\\\\Bootmgfw.efi' /boot/loader/entries/windows_7.conf")

     

       
424
       
+
       
        machine.succeed("grep 'FS0:EFI\\\\Microsoft\\\\Boot\\\\Bootmgfw.efi' /boot/loader/entries/windows_Ten.conf")

     

       
425
       
+
       
        machine.succeed("grep 'HD0d4:EFI\\\\Microsoft\\\\Boot\\\\Bootmgfw.efi' /boot/loader/entries/windows_11.conf")

     

       
426
       
 
       


     

       
427
       
+
       
        machine.succeed("grep 'sort-key before_all_others' /boot/loader/entries/windows_7.conf")

     

       
428
       
+
       
        machine.succeed("grep 'sort-key o_windows_Ten' /boot/loader/entries/windows_Ten.conf")

     

       
429
       
+
       
        machine.succeed("grep 'sort-key zzz' /boot/loader/entries/windows_11.conf")

     

       
430
       
 
       


     

       
431
       
+
       
        machine.succeed("grep 'title Windows 7' /boot/loader/entries/windows_7.conf")

     

       
432
       
+
       
        machine.succeed("grep 'title Windows Ten' /boot/loader/entries/windows_Ten.conf")

     

       
433
       
+
       
        machine.succeed('grep "title Title with-_-punctuation ...?!" /boot/loader/entries/windows_11.conf')

     

       
434
       
+
       
      '';

     

       
435
       
+
       
    }

     

       
436
       
+
       
  );

     

       
437
       
 
       


     

       
438
       
+
       
  memtestSortKey = runTest (

     

       
439
       
+
       
    { lib, ... }:

     

       
440
       
+
       
    {

     

       
441
       
+
       
      name = "systemd-boot-memtest-sortkey";

     

       
442
       
+
       
      meta.maintainers = with lib.maintainers; [ julienmalka ];

     

       
443
       
 
       


     

       
444
       
+
       
      nodes.machine =

     

       
445
       
+
       
        { pkgs, lib, ... }:

     

       
446
       
+
       
        {

     

       
447
       
+
       
          imports = [ common ];

     

       
448
       
+
       
          boot.loader.systemd-boot.memtest86.enable = true;

     

       
449
       
+
       
          boot.loader.systemd-boot.memtest86.sortKey = "apple";

     

       
450
       
+
       
        };

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
451
       
 
       


     

       
452
       
+
       
      testScript = ''

     

       
453
       
 
       
        machine.succeed("test -e /boot/loader/entries/memtest86.conf")

     

       
454
       
+
       
        machine.succeed("test -e /boot/efi/memtest86/memtest.efi")

     

       
455
       
+
       
        machine.succeed("grep 'sort-key apple' /boot/loader/entries/memtest86.conf")

     

       
456
       
 
       
      '';

     

       
457
       
+
       
    }

     

       
458
       
+
       
  );

     

       
459
       
 
       


     

       
460
       
+
       
  entryFilenameXbootldr = runTest (

     

       
461
       
+
       
    { lib, ... }:

     

       
462
       
+
       
    {

     

       
463
       
+
       
      name = "systemd-boot-entry-filename-xbootldr";

     

       
464
       
+
       
      meta.maintainers = with lib.maintainers; [ sdht0 ];

     

       
465
       
 
       


     

       
466
       
+
       
      nodes.machine =

     

       
467
       
+
       
        { pkgs, lib, ... }:

     

       
468
       
+
       
        {

     

       
469
       
+
       
          imports = [ commonXbootldr ];

     

       
470
       
+
       
          boot.loader.systemd-boot.memtest86.enable = true;

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
471
       
 
       
        };

     

       
0
       
 
       

     

       
472
       
 
       


     

       
473
       
+
       
      testScript =

     

       
474
       
+
       
        { nodes, ... }:

     

       
475
       
+
       
        ''

     

       
476
       
+
       
          ${customDiskImage nodes}

     

       
477
       
+
       


     

       
478
       
+
       
          machine.start()

     

       
479
       
+
       
          machine.wait_for_unit("multi-user.target")

     

       
480
       
+
       


     

       
481
       
+
       
          machine.succeed("test -e /efi/EFI/systemd/systemd-bootx64.efi")

     

       
482
       
+
       
          machine.succeed("test -e /boot/loader/entries/memtest86.conf")

     

       
483
       
+
       
          machine.succeed("test -e /boot/EFI/memtest86/memtest.efi")

     

       
484
       
+
       
        '';

     

       
485
       
+
       
    }

     

       
486
       
+
       
  );

     

       
487
       
 
       


     

       
488
       
+
       
  extraEntries = runTest (

     

       
489
       
+
       
    { lib, ... }:

     

       
490
       
+
       
    {

     

       
491
       
+
       
      name = "systemd-boot-extra-entries";

     

       
492
       
+
       
      meta.maintainers = with lib.maintainers; [ julienmalka ];

     

       
493
       
 
       


     

       
494
       
+
       
      nodes.machine =

     

       
495
       
+
       
        { pkgs, lib, ... }:

     

       
496
       
+
       
        {

     

       
497
       
+
       
          imports = [ common ];

     

       
498
       
+
       
          boot.loader.systemd-boot.extraEntries = {

     

       
499
       
+
       
            "banana.conf" = ''

     

       
500
       
+
       
              title banana

     

       
501
       
+
       
            '';

     

       
502
       
+
       
          };

     

       
503
       
 
       
        };

     

       
0
       
 
       

     

       
504
       
 
       


     

       
505
       
+
       
      testScript = ''

     

       
506
       
+
       
        machine.succeed("test -e /boot/loader/entries/banana.conf")

     

       
507
       
+
       
        machine.succeed("test -e /boot/efi/nixos/.extra-files/loader/entries/banana.conf")

     

       
508
       
+
       
      '';

     

       
509
       
+
       
    }

     

       
510
       
+
       
  );

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
511
       
 
       


     

       
512
       
+
       
  extraFiles = runTest (

     

       
513
       
+
       
    { lib, ... }:

     

       
514
       
+
       
    {

     

       
515
       
+
       
      name = "systemd-boot-extra-files";

     

       
516
       
+
       
      meta.maintainers = with lib.maintainers; [ julienmalka ];

     

       
517
       
 
       


     

       
518
       
+
       
      nodes.machine =

     

       
519
       
+
       
        { pkgs, lib, ... }:

     

       
520
       
 
       
        {

     

       
521
       
 
       
          imports = [ common ];

     

       
522
       
 
       
          boot.loader.systemd-boot.extraFiles = {

     

       
523
       
 
       
            "efi/fruits/tomato.efi" = pkgs.netbootxyz-efi;

     

       
524
       
 
       
          };

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
525
       
 
       
        };

     

       
526
       
 
       


     

       
527
       
+
       
      testScript = ''

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
528
       
 
       
        machine.succeed("test -e /boot/efi/fruits/tomato.efi")

     

       
529
       
 
       
        machine.succeed("test -e /boot/efi/nixos/.extra-files/efi/fruits/tomato.efi")

     

       
530
       
+
       
      '';

     

       
531
       
+
       
    }

     

       
532
       
+
       
  );

     

       
533
       
 
       


     

       
534
       
+
       
  switch-test = runTest (

     

       
535
       
+
       
    { lib, ... }:

     

       
536
       
+
       
    {

     

       
537
       
+
       
      name = "systemd-boot-switch-test";

     

       
538
       
+
       
      meta.maintainers = with lib.maintainers; [ julienmalka ];

     

       
0
       
 
       

     

       
0
       
 
       

     

       
539
       
 
       


     

       
540
       
+
       
      nodes = {

     

       
541
       
+
       
        inherit common;

     

       
0
       
 
       

     

       
0
       
 
       

     

       
542
       
 
       


     

       
543
       
+
       
        machine =

     

       
544
       
+
       
          { pkgs, nodes, ... }:

     

       
545
       
+
       
          {

     

       
546
       
+
       
            imports = [ common ];

     

       
547
       
+
       
            boot.loader.systemd-boot.extraFiles = {

     

       
548
       
+
       
              "efi/fruits/tomato.efi" = pkgs.netbootxyz-efi;

     

       
549
       
+
       
            };

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
550
       
 
       


     

       
551
       
+
       
            # These are configs for different nodes, but we'll use them here in `machine`

     

       
552
       
+
       
            system.extraDependencies = [

     

       
553
       
+
       
              nodes.common.system.build.toplevel

     

       
554
       
+
       
              nodes.with_netbootxyz.system.build.toplevel

     

       
555
       
+
       
            ];

     

       
556
       
+
       
          };

     

       
557
       
 
       


     

       
558
       
+
       
        with_netbootxyz =

     

       
559
       
+
       
          { pkgs, ... }:

     

       
560
       
+
       
          {

     

       
561
       
+
       
            imports = [ common ];

     

       
562
       
+
       
            boot.loader.systemd-boot.netbootxyz.enable = true;

     

       
563
       
+
       
          };

     

       
564
       
+
       
      };

     

       
565
       
 
       


     

       
566
       
+
       
      testScript =

     

       
567
       
+
       
        { nodes, ... }:

     

       
568
       
+
       
        let

     

       
569
       
+
       
          originalSystem = nodes.machine.system.build.toplevel;

     

       
570
       
+
       
          baseSystem = nodes.common.system.build.toplevel;

     

       
571
       
+
       
          finalSystem = nodes.with_netbootxyz.system.build.toplevel;

     

       
572
       
+
       
        in

     

       
573
       
+
       
        ''

     

       
574
       
+
       
          machine.succeed("test -e /boot/efi/fruits/tomato.efi")

     

       
575
       
+
       
          machine.succeed("test -e /boot/efi/nixos/.extra-files/efi/fruits/tomato.efi")

     

       
576
       
+
       


     

       
577
       
+
       
          with subtest("remove files when no longer needed"):

     

       
578
       
+
       
              machine.succeed("${baseSystem}/bin/switch-to-configuration boot")

     

       
579
       
+
       
              machine.fail("test -e /boot/efi/fruits/tomato.efi")

     

       
580
       
+
       
              machine.fail("test -d /boot/efi/fruits")

     

       
581
       
+
       
              machine.succeed("test -d /boot/efi/nixos/.extra-files")

     

       
582
       
+
       
              machine.fail("test -e /boot/efi/nixos/.extra-files/efi/fruits/tomato.efi")

     

       
583
       
+
       
              machine.fail("test -d /boot/efi/nixos/.extra-files/efi/fruits")

     

       
584
       
+
       


     

       
585
       
+
       
          with subtest("files are added back when needed again"):

     

       
586
       
+
       
              machine.succeed("${originalSystem}/bin/switch-to-configuration boot")

     

       
587
       
+
       
              machine.succeed("test -e /boot/efi/fruits/tomato.efi")

     

       
588
       
+
       
              machine.succeed("test -e /boot/efi/nixos/.extra-files/efi/fruits/tomato.efi")

     

       
589
       
+
       


     

       
590
       
+
       
          with subtest("simultaneously removing and adding files works"):

     

       
591
       
+
       
              machine.succeed("${finalSystem}/bin/switch-to-configuration boot")

     

       
592
       
+
       
              machine.fail("test -e /boot/efi/fruits/tomato.efi")

     

       
593
       
+
       
              machine.fail("test -e /boot/efi/nixos/.extra-files/efi/fruits/tomato.efi")

     

       
594
       
+
       
              machine.succeed("test -e /boot/loader/entries/netbootxyz.conf")

     

       
595
       
+
       
              machine.succeed("test -e /boot/efi/netbootxyz/netboot.xyz.efi")

     

       
596
       
+
       
              machine.succeed("test -e /boot/efi/nixos/.extra-files/loader/entries/netbootxyz.conf")

     

       
597
       
+
       
              machine.succeed("test -e /boot/efi/nixos/.extra-files/efi/netbootxyz/netboot.xyz.efi")

     

       
598
       
+
       
        '';

     

       
599
       
+
       
    }

     

       
600
       
+
       
  );

     

       
601
       
+
       


     

       
602
       
+
       
  garbage-collect-entry = runTest (

     

       
603
       
+
       
    { lib, ... }:

     

       
604
       
+
       
    {

     

       
605
       
+
       
      name = "systemd-boot-garbage-collect-entry";

     

       
606
       
+
       
      meta.maintainers = with lib.maintainers; [ julienmalka ];

     

       
607
       
+
       


     

       
608
       
+
       
      nodes = {

     

       
609
       
+
       
        inherit common;

     

       
610
       
+
       
        machine =

     

       
611
       
+
       
          { pkgs, nodes, ... }:

     

       
612
       
+
       
          {

     

       
613
       
+
       
            imports = [ common ];

     

       
614
       
+
       


     

       
615
       
+
       
            # These are configs for different nodes, but we'll use them here in `machine`

     

       
616
       
+
       
            system.extraDependencies = [

     

       
617
       
+
       
              nodes.common.system.build.toplevel

     

       
618
       
+
       
            ];

     

       
619
       
+
       
          };

     

       
620
       
+
       
      };

     

       
621
       
 
       


     

       
622
       
+
       
      testScript =

     

       
623
       
+
       
        { nodes, ... }:

     

       
624
       
+
       
        let

     

       
625
       
+
       
          baseSystem = nodes.common.system.build.toplevel;

     

       
626
       
+
       
        in

     

       
627
       
+
       
        ''

     

       
628
       
+
       
          machine.succeed("nix-env -p /nix/var/nix/profiles/system --set ${baseSystem}")

     

       
629
       
+
       
          machine.succeed("nix-env -p /nix/var/nix/profiles/system --delete-generations 1")

     

       
630
       
+
       
          machine.succeed("${baseSystem}/bin/switch-to-configuration boot")

     

       
631
       
+
       
          machine.fail("test -e /boot/loader/entries/nixos-generation-1.conf")

     

       
632
       
+
       
          machine.succeed("test -e /boot/loader/entries/nixos-generation-2.conf")

     

       
633
       
+
       
        '';

     

       
634
       
+
       
    }

     

       
635
       
+
       
  );

     

       
636
       
 
       


     

       
637
       
+
       
  no-bootspec = runTest (

     

       
638
       
+
       
    { lib, ... }:

     

       
639
       
+
       
    {

     

       
640
       
+
       
      name = "systemd-boot-no-bootspec";

     

       
641
       
+
       
      meta.maintainers = with lib.maintainers; [ julienmalka ];

     

       
642
       
 
       


     

       
643
       
+
       
      nodes.machine = {

     

       
644
       
+
       
        imports = [ common ];

     

       
645
       
+
       
        boot.bootspec.enable = false;

     

       
646
       
+
       
      };

     

       
647
       
 
       


     

       
648
       
+
       
      testScript = ''

     

       
649
       
+
       
        machine.start()

     

       
650
       
+
       
        machine.wait_for_unit("multi-user.target")

     

       
651
       
+
       
      '';

     

       
652
       
+
       
    }

     

       
653
       
+
       
  );

     

       
654
       
 
       
}