nixpkgs/nixos/tests/powerdns-admin.nix

# Test powerdns-admin
{ system ? builtins.currentSystem
, config ? { }
, pkgs ? import ../.. { inherit system config; }
}:

with import ../lib/testing-python.nix { inherit system pkgs; };
with pkgs.lib;
let
  defaultConfig = ''
    BIND_ADDRESS = '127.0.0.1'
    PORT = 8000
    CAPTCHA_ENABLE = False
  '';

  makeAppTest = name: configs: makeTest {
    name = "powerdns-admin-${name}";
    meta = with pkgs.lib.maintainers; {
      maintainers = [ Flakebi zhaofengli ];
    };

    nodes.server = { pkgs, config, ... }: mkMerge ([
      {
        services.powerdns-admin = {
          enable = true;
          secretKeyFile = "/etc/powerdns-admin/secret";
          saltFile = "/etc/powerdns-admin/salt";
        };
        # It's insecure to have secrets in the world-readable nix store, but this is just a test
        environment.etc."powerdns-admin/secret".text = "secret key";
        environment.etc."powerdns-admin/salt".text = "salt";
        environment.systemPackages = [
          (pkgs.writeShellScriptBin "run-test" config.system.build.testScript)
        ];
      }
    ] ++ configs);

    testScript = ''
      server.wait_for_unit("powerdns-admin.service")
      server.wait_until_succeeds("run-test", timeout=10)
    '';
  };

  matrix = {
    backend = {
      mysql = {
        services.powerdns-admin = {
          config = ''
            ${defaultConfig}
            SQLALCHEMY_DATABASE_URI = 'mysql://powerdnsadmin@/powerdnsadmin?unix_socket=/run/mysqld/mysqld.sock'
          '';
        };
        systemd.services.powerdns-admin = {
          after = [ "mysql.service" ];
          serviceConfig.BindPaths = "/run/mysqld";
        };

        services.mysql = {
          enable = true;
          package = pkgs.mariadb;
          ensureDatabases = [ "powerdnsadmin" ];
          ensureUsers = [
            {
              name = "powerdnsadmin";
              ensurePermissions = {
                "powerdnsadmin.*" = "ALL PRIVILEGES";
              };
            }
          ];
        };
      };
      postgresql = {
        services.powerdns-admin = {
          config = ''
            ${defaultConfig}
            SQLALCHEMY_DATABASE_URI = 'postgresql://powerdnsadmin@/powerdnsadmin?host=/run/postgresql'
          '';
        };
        systemd.services.powerdns-admin = {
          after = [ "postgresql.service" ];
          serviceConfig.BindPaths = "/run/postgresql";
        };

        services.postgresql = {
          enable = true;
          ensureDatabases = [ "powerdnsadmin" ];
          ensureUsers = [
            {
              name = "powerdnsadmin";
              ensurePermissions = {
                "DATABASE powerdnsadmin" = "ALL PRIVILEGES";
              };
            }
          ];
        };
      };
    };
    listen = {
      tcp = {
        services.powerdns-admin.extraArgs = [ "-b" "127.0.0.1:8000" ];
        system.build.testScript = ''
          set -euxo pipefail
          curl -sSf http://127.0.0.1:8000/

          # Create account to check that the database migrations ran
          csrf_token="$(curl -sSfc session http://127.0.0.1:8000/register | grep _csrf_token | cut -d\" -f6)"
          # Outputs 'Redirecting' if successful
          curl -sSfb session http://127.0.0.1:8000/register \
            -F "_csrf_token=$csrf_token" \
            -F "firstname=first" \
            -F "lastname=last" \
            -F "email=a@example.com" \
            -F "username=user" \
            -F "password=password" \
            -F "rpassword=password" | grep Redirecting

          # Login
          # Outputs 'Redirecting' if successful
          curl -sSfb session http://127.0.0.1:8000/login \
            -F "_csrf_token=$csrf_token" \
            -F "username=user" \
            -F "password=password" | grep Redirecting

          # Check that we are logged in, this redirects to /admin/setting/pdns if we are
          curl -sSfb session http://127.0.0.1:8000/dashboard/ | grep /admin/setting
        '';
      };
      unix = {
        services.powerdns-admin.extraArgs = [ "-b" "unix:/run/powerdns-admin/http.sock" ];
        system.build.testScript = ''
          curl -sSf --unix-socket /run/powerdns-admin/http.sock http://somehost/
        '';
      };
    };
  };
in
with matrix; {
  postgresql = makeAppTest "postgresql" [ backend.postgresql listen.tcp ];
  mysql = makeAppTest "mysql" [ backend.mysql listen.tcp ];
  unix-listener = makeAppTest "unix-listener" [ backend.postgresql listen.unix ];
}