commit bbfdc6ce4d312b56aa57b38f23c88d339430b38c · pyrox.dev/nixpkgs

+31 -32
nixos/tests/podman/default.nix
···

       1
       1
       -
       # This test runs podman and checks if simple container starts

     

       2
       2
       -
       

     

       3
       1
        
       import ../make-test-python.nix (

     

       4
       2
        
         { pkgs, lib, ... }: {

     

       5
       3
        
           name = "podman";

     
···

       8
       6
        
           };

     

       9
       7
        
       

     

       10
       8
        
           nodes = {

     

       11
       11
       -
             podman =

     

       12
       12
       -
               { pkgs, ... }:

     

       13
       13
       -
               {

     

       14
       14
       -
                 virtualisation.podman.enable = true;

     

       9
       9
       +
             podman = { pkgs, ... }: {

     

       10
       10
       +
               virtualisation.podman.enable = true;

     

       15
       11
        
       

     

       16
       16
       -
                 # To test docker socket support

     

       17
       17
       -
                 virtualisation.podman.dockerSocket.enable = true;

     

       18
       18
       -
                 environment.systemPackages = [

     

       19
       19
       -
                   pkgs.docker-client

     

       20
       20
       -
                 ];

     

       12
       12
       +
               users.users.alice = {

     

       13
       13
       +
                 isNormalUser = true;

     

       14
       14
       +
               };

     

       15
       15
       +
             };

     

       16
       16
       +
             docker = { pkgs, ... }: {

     

       17
       17
       +
               virtualisation.podman.enable = true;

     

       18
       18
       +
       

     

       19
       19
       +
               virtualisation.podman.dockerSocket.enable = true;

     

       21
       20
        
       

     

       22
       22
       -
                 users.users.alice = {

     

       23
       23
       -
                   isNormalUser = true;

     

       24
       24
       -
                   home = "/home/alice";

     

       25
       25
       -
                   description = "Alice Foobar";

     

       26
       26
       -
                   extraGroups = [ "podman" ];

     

       27
       27
       -
                 };

     

       21
       21
       +
               environment.systemPackages = [

     

       22
       22
       +
                 pkgs.docker-client

     

       23
       23
       +
               ];

     

       28
       24
        
       

     

       29
       29
       -
                 users.users.mallory = {

     

       30
       30
       -
                   isNormalUser = true;

     

       31
       31
       -
                   home = "/home/mallory";

     

       32
       32
       -
                   description = "Mallory Foobar";

     

       33
       33
       -
                 };

     

       25
       25
       +
               users.users.alice = {

     

       26
       26
       +
                 isNormalUser = true;

     

       27
       27
       +
                 extraGroups = [ "podman" ];

     

       28
       28
       +
               };

     

       34
       29
        
       

     

       30
       30
       +
               users.users.mallory = {

     

       31
       31
       +
                 isNormalUser = true;

     

       35
       32
        
               };

     

       33
       33
       +
             };

     

       36
       34
        
           };

     

       37
       35
        
       

     

       38
       36
        
           testScript = ''

     
···

       45
       43
        
       

     

       46
       44
        
       

     

       47
       45
        
             podman.wait_for_unit("sockets.target")

     

       46
       46
       +
             docker.wait_for_unit("sockets.target")

     

       48
       47
        
             start_all()

     

       49
       48
        
       

     

       50
       49
        
             with subtest("Run container as root with runc"):

     
···

       120
       119
        
                 assert pid == "2"

     

       121
       120
        
       

     

       122
       121
        
             with subtest("A podman member can use the docker cli"):

     

       123
       123
       -
                 podman.succeed(su_cmd("docker version"))

     

       122
       122
       +
                 docker.succeed(su_cmd("docker version"))

     

       124
       123
        
       

     

       125
       124
        
             with subtest("Run container via docker cli"):

     

       126
       126
       -
                 podman.succeed("docker network create default")

     

       127
       127
       -
                 podman.succeed("tar cv --files-from /dev/null | podman import - scratchimg")

     

       128
       128
       -
                 podman.succeed(

     

       125
       125
       +
                 docker.succeed("docker network create default")

     

       126
       126
       +
                 docker.succeed("tar cv --files-from /dev/null | podman import - scratchimg")

     

       127
       127
       +
                 docker.succeed(

     

       129
       128
        
                   "docker run -d --name=sleeping -v /nix/store:/nix/store -v /run/current-system/sw/bin:/bin localhost/scratchimg /bin/sleep 10"

     

       130
       129
        
                 )

     

       131
       131
       -
                 podman.succeed("docker ps | grep sleeping")

     

       132
       132
       -
                 podman.succeed("podman ps | grep sleeping")

     

       133
       133
       -
                 podman.succeed("docker stop sleeping")

     

       134
       134
       -
                 podman.succeed("docker rm sleeping")

     

       135
       135
       -
                 podman.succeed("docker network rm default")

     

       130
       130
       +
                 docker.succeed("docker ps | grep sleeping")

     

       131
       131
       +
                 docker.succeed("podman ps | grep sleeping")

     

       132
       132
       +
                 docker.succeed("docker stop sleeping")

     

       133
       133
       +
                 docker.succeed("docker rm sleeping")

     

       134
       134
       +
                 docker.succeed("docker network rm default")

     

       136
       135
        
       

     

       137
       136
        
             with subtest("A podman non-member can not use the docker cli"):

     

       138
       138
       -
                 podman.fail(su_cmd("docker version", user="mallory"))

     

       137
       137
       +
                 docker.fail(su_cmd("docker version", user="mallory"))

     

       139
       138
        
       

     

       140
       139
        
             # TODO: add docker-compose test

     

       141
       140