nixos/tests/non-default-filesystems.nix

   1 { system ? builtins.currentSystem
   2 , config ? { }
   3 , pkgs ? import ../.. { inherit system config; }
   4 }:
   5
   6 with import ../lib/testing-python.nix { inherit system pkgs; };
   7 with pkgs.lib;
   8 {
   9   bind = makeTest {
  10     name = "non-default-filesystem-bind";
  11
  12     nodes.machine = { ... }: {
  13       virtualisation.writableStore = false;
  14
  15       virtualisation.fileSystems."/test-bind-dir/bind" = {
  16         device = "/";
  17         neededForBoot = true;
  18         options = [ "bind" ];
  19       };
  20
  21       virtualisation.fileSystems."/test-bind-file/bind" = {
  22         depends = [ "/nix/store" ];
  23         device = builtins.toFile "empty" "";
  24         neededForBoot = true;
  25         options = [ "bind" ];
  26       };
  27     };
  28
  29     testScript = ''
  30       machine.wait_for_unit("multi-user.target")
  31     '';
  32   };
  33
  34   btrfs = makeTest
  35     {
  36       name = "non-default-filesystems-btrfs";
  37
  38       nodes.machine =
  39         { config, pkgs, lib, ... }:
  40         let
  41           disk = config.virtualisation.rootDevice;
  42         in
  43         {
  44           virtualisation.rootDevice = "/dev/vda";
  45           virtualisation.useDefaultFilesystems = false;
  46
  47           boot.initrd.availableKernelModules = [ "btrfs" ];
  48           boot.supportedFilesystems = [ "btrfs" ];
  49
  50           boot.initrd.postDeviceCommands = ''
  51             FSTYPE=$(blkid -o value -s TYPE ${disk} || true)
  52             if test -z "$FSTYPE"; then
  53               modprobe btrfs
  54               ${pkgs.btrfs-progs}/bin/mkfs.btrfs ${disk}
  55
  56               mkdir /nixos
  57               mount -t btrfs ${disk} /nixos
  58
  59               ${pkgs.btrfs-progs}/bin/btrfs subvolume create /nixos/root
  60               ${pkgs.btrfs-progs}/bin/btrfs subvolume create /nixos/home
  61
  62               umount /nixos
  63             fi
  64           '';
  65
  66           virtualisation.fileSystems = {
  67             "/" = {
  68               device = disk;
  69               fsType = "btrfs";
  70               options = [ "subvol=/root" ];
  71             };
  72
  73             "/home" = {
  74               device = disk;
  75               fsType = "btrfs";
  76               options = [ "subvol=/home" ];
  77             };
  78           };
  79         };
  80
  81       testScript = ''
  82         machine.wait_for_unit("multi-user.target")
  83
  84         with subtest("BTRFS filesystems are mounted correctly"):
  85           print("output of \"grep -E '/dev/vda' /proc/mounts\":\n" + machine.execute("grep -E '/dev/vda' /proc/mounts")[1])
  86           machine.succeed("grep -E '/dev/vda / btrfs rw,.*subvolid=[0-9]+,subvol=/root 0 0' /proc/mounts")
  87           machine.succeed("grep -E '/dev/vda /home btrfs rw,.*subvolid=[0-9]+,subvol=/home 0 0' /proc/mounts")
  88       '';
  89     };
  90
  91   erofs =
  92     let
  93       fsImage = "/tmp/non-default-filesystem.img";
  94     in
  95     makeTest {
  96       name = "non-default-filesystems-erofs";
  97
  98       meta.maintainers = with maintainers; [ nikstur ];
  99
 100       nodes.machine = _: {
 101         virtualisation.qemu.drives = [{
 102           name = "non-default-filesystem";
 103           file = fsImage;
 104         }];
 105
 106         virtualisation.fileSystems."/non-default" = {
 107           device = "/dev/vdb";
 108           fsType = "erofs";
 109           neededForBoot = true;
 110         };
 111       };
 112
 113       testScript = ''
 114         import subprocess
 115         import tempfile
 116
 117         with tempfile.TemporaryDirectory() as tmp_dir:
 118           with open(f"{tmp_dir}/filesystem", "w") as f:
 119               f.write("erofs")
 120
 121           subprocess.run([
 122             "${pkgs.erofs-utils}/bin/mkfs.erofs",
 123             "${fsImage}",
 124             tmp_dir,
 125           ])
 126
 127         machine.start()
 128         machine.wait_for_unit("default.target")
 129
 130         file_contents = machine.succeed("cat /non-default/filesystem")
 131         assert "erofs" in file_contents
 132       '';
 133     };
 134
 135   squashfs =
 136     let
 137       fsImage = "/tmp/non-default-filesystem.img";
 138     in
 139     makeTest {
 140       name = "non-default-filesystems-squashfs";
 141
 142       meta.maintainers = with maintainers; [ nikstur ];
 143
 144       nodes.machine = {
 145         virtualisation.qemu.drives = [{
 146           name = "non-default-filesystem";
 147           file = fsImage;
 148           deviceExtraOpts.serial = "non-default";
 149         }];
 150
 151         virtualisation.fileSystems."/non-default" = {
 152           device = "/dev/disk/by-id/virtio-non-default";
 153           fsType = "squashfs";
 154           neededForBoot = true;
 155         };
 156       };
 157
 158       testScript = ''
 159         import subprocess
 160
 161         with open("filesystem", "w") as f:
 162           f.write("squashfs")
 163
 164         subprocess.run([
 165           "${pkgs.squashfsTools}/bin/mksquashfs",
 166           "filesystem",
 167           "${fsImage}",
 168         ])
 169
 170         assert "squashfs" in machine.succeed("cat /non-default/filesystem")
 171       '';
 172     };
 173 }