I have a few combinator ideas that I'd like to try adding but I still haven't fully fleshed them out yet. In order to reduce breaking people's setup, this introduces a new `experimental` flag on combinators that separates them on the docs website to let users know that their design may not be fully finalized yet.
244 lines
7.2 KiB
Haskell
244 lines
7.2 KiB
Haskell
module TestPrelude
|
|
( (</>),
|
|
TestM,
|
|
buildNixDrvPath,
|
|
evalNixExpr,
|
|
forM,
|
|
forM_,
|
|
getTestDir,
|
|
i,
|
|
inTestM,
|
|
liftIO,
|
|
runNixDrv,
|
|
runNixDrvWithExitCode,
|
|
runNixDrvWithinVm,
|
|
spawnNixDrv,
|
|
toNixString,
|
|
void,
|
|
withEnv,
|
|
lifted,
|
|
-- expectations
|
|
shouldEventuallyReturn,
|
|
shouldOutput,
|
|
shouldReturnTestM,
|
|
)
|
|
where
|
|
|
|
import Control.Concurrent (threadDelay)
|
|
import Control.Monad
|
|
import Control.Monad.Extra (mapMaybeM)
|
|
import Control.Monad.IO.Class (liftIO)
|
|
import Control.Monad.Reader (MonadIO, MonadReader, ReaderT, ask, asks, local, runReaderT)
|
|
import Data.Aeson qualified as Aeson
|
|
import Data.Function ((&))
|
|
import Data.List.Extra
|
|
import Data.Map qualified as Map
|
|
import Data.Maybe (fromJust)
|
|
import Data.String.Conversions
|
|
import Data.String.Interpolate (i)
|
|
import GHC.IO.Exception (ExitCode)
|
|
import GHC.IO.Handle (Handle)
|
|
import System.Environment (lookupEnv)
|
|
import System.FilePath ((</>))
|
|
import System.IO.Temp (withSystemTempDirectory)
|
|
import System.Process (CreateProcess, ProcessHandle, createProcess)
|
|
import System.Process qualified as Process
|
|
import Test.Hspec
|
|
import Test.Hspec.Core.Spec qualified
|
|
|
|
data Context = Context
|
|
{ tmpDir :: FilePath,
|
|
env :: Map.Map String String
|
|
}
|
|
|
|
newtype TestM a = TestM {testMReaderT :: ReaderT Context IO a}
|
|
deriving newtype
|
|
( Functor,
|
|
Applicative,
|
|
Monad,
|
|
MonadIO,
|
|
MonadReader Context
|
|
)
|
|
|
|
lifted :: ((a -> IO b) -> IO c) -> (a -> TestM b) -> TestM c
|
|
lifted io action = do
|
|
ctx <- ask
|
|
liftIO $ io $ flip runReaderT ctx . testMReaderT . action
|
|
|
|
lifted' :: (IO x -> IO y) -> TestM x -> TestM y
|
|
lifted' fn action = lifted (fn . ($ ())) (const action)
|
|
|
|
instance Example (TestM ()) where
|
|
type Arg (TestM ()) = Context
|
|
evaluateExample test _ hook _ = do
|
|
hook $ runReaderT $ testMReaderT test
|
|
pure $ Test.Hspec.Core.Spec.Result "" Test.Hspec.Core.Spec.Success
|
|
|
|
getTestDir :: TestM FilePath
|
|
getTestDir = asks tmpDir
|
|
|
|
inTestM :: SpecWith Context -> SpecWith ()
|
|
inTestM = aroundWith $ \action () -> do
|
|
withSystemTempDirectory "jail-nix-test" $ \tmpDir -> do
|
|
baseEnv <-
|
|
Map.fromList
|
|
<$> mapMaybeM
|
|
(\(name, getVal) -> ((name,) <$>) <$> getVal)
|
|
[ ("HOME", lookupEnv "HOME"),
|
|
("LANG", pure $ Just "en_US.UTF-8"),
|
|
("DBUS_SESSION_BUS_ADDRESS", lookupEnv "DBUS_SESSION_BUS_ADDRESS"),
|
|
("XDG_RUNTIME_DIR", lookupEnv "XDG_RUNTIME_DIR")
|
|
]
|
|
action $
|
|
Context
|
|
{ tmpDir,
|
|
env = baseEnv
|
|
}
|
|
|
|
toNixString :: String -> String
|
|
toNixString s =
|
|
s
|
|
& replace "\\" "\\\\"
|
|
& replace "\"" "\\\""
|
|
& replace "$" "\\$"
|
|
& ("\"" <>)
|
|
& (<> "\"")
|
|
|
|
withEnv :: String -> String -> TestM () -> TestM ()
|
|
withEnv name value = local $ \ctx -> ctx {env = Map.insert name value (env ctx)}
|
|
|
|
mkNixDrvProccess :: String -> TestM CreateProcess
|
|
mkNixDrvProccess nixDrvExpr = do
|
|
(exe :: String, drvPath :: FilePath) <-
|
|
evalNixExpr
|
|
[i| let d = #{nixDrvExpr}; in [(lib.getExe d) d.drvPath] |]
|
|
void $ buildNixDrvPath drvPath
|
|
env <- asks env
|
|
pure $
|
|
(Process.proc exe [])
|
|
{ Process.env = Just $ Map.toList env,
|
|
Process.std_in = Process.CreatePipe,
|
|
Process.std_out = Process.CreatePipe,
|
|
Process.std_err = Process.CreatePipe
|
|
}
|
|
|
|
runNixDrv :: String -> TestM String
|
|
runNixDrv = liftIO . flip Process.readCreateProcess "" <=< mkNixDrvProccess
|
|
|
|
runNixDrvWithExitCode :: String -> TestM (ExitCode, String, String)
|
|
runNixDrvWithExitCode = liftIO . flip Process.readCreateProcessWithExitCode "" <=< mkNixDrvProccess
|
|
|
|
spawnNixDrv :: String -> TestM (Maybe Handle, Maybe Handle, Maybe Handle, ProcessHandle)
|
|
spawnNixDrv = liftIO . createProcess <=< mkNixDrvProccess
|
|
|
|
runNixDrvWithinVm :: String -> String -> TestM String
|
|
runNixDrvWithinVm vmConfig nixDrvExpr = do
|
|
testDir <- getTestDir
|
|
testOutputFilePath <- (</> "test-output") <$> getTestDir
|
|
liftIO $ writeFile testOutputFilePath "---\n"
|
|
void $
|
|
runNixDrvWithExitCode
|
|
[i|
|
|
let
|
|
system = import <nixpkgs/nixos/lib/eval-config.nix> {
|
|
modules = [
|
|
({ pkgs, lib, ... }: {
|
|
system.stateVersion = "25.05";
|
|
virtualisation.vmVariant.virtualisation = {
|
|
graphics = false;
|
|
sharedDirectories.testOutput = { source = #{toNixString testDir}; target = #{toNixString testDir}; };
|
|
|
|
};
|
|
systemd.services.run-jail-nix-vm-test = {
|
|
wantedBy = [ "multi-user.target" ];
|
|
after = [ "network-online.target" ];
|
|
wants = [ "network-online.target" ];
|
|
environment = {
|
|
HOME = "/root";
|
|
};
|
|
script = let
|
|
jail-nix = import <jail-nix> {};
|
|
jail = jail-nix.extend { inherit pkgs; suppressExperimentalWarnings = true; };
|
|
testToRun = #{nixDrvExpr};
|
|
in ''
|
|
(
|
|
${lib.getExe testToRun} || echo 'Test failed'
|
|
) >${#{toNixString testOutputFilePath}} 2>&1
|
|
shutdown now
|
|
'';
|
|
serviceConfig.type = "oneshot";
|
|
};
|
|
})
|
|
#{vmConfig}
|
|
];
|
|
};
|
|
in sh ''
|
|
TMP_DIR=$(${pkgs.coreutils}/bin/mktemp -d)
|
|
NIX_DISK_IMAGE="$TMP_DIR/img" ${system.config.system.build.vm}/bin/run-nixos-vm
|
|
${pkgs.coreutils}/bin/rm -rf "$TMP_DIR"
|
|
''
|
|
|]
|
|
liftIO $ readFile testOutputFilePath
|
|
|
|
buildNixDrvPath :: FilePath -> TestM FilePath
|
|
buildNixDrvPath drvPath = do
|
|
liftIO $
|
|
Process.readProcess
|
|
"nix"
|
|
[ "build",
|
|
"--no-link",
|
|
"--print-out-paths",
|
|
drvPath <> "^*"
|
|
]
|
|
""
|
|
|
|
evalNixExpr :: (Aeson.FromJSON a) => String -> TestM a
|
|
evalNixExpr nixExpr = do
|
|
tmpDir <- getTestDir
|
|
liftIO $
|
|
writeFile
|
|
(tmpDir </> "test.nix")
|
|
[i|
|
|
let
|
|
pkgs = import <nixpkgs> {};
|
|
lib = pkgs.lib;
|
|
sh = script: (pkgs.writeShellApplication { name = "test-script"; text = script; });
|
|
jail-nix = import <jail-nix> {};
|
|
jail = jail-nix.extend { inherit pkgs; suppressExperimentalWarnings = true; };
|
|
in #{nixExpr}
|
|
|]
|
|
liftIO $
|
|
fromJust . Aeson.decode' . cs
|
|
<$> Process.readProcess
|
|
"nix"
|
|
[ "eval",
|
|
"--json",
|
|
"--file",
|
|
tmpDir </> "test.nix"
|
|
]
|
|
""
|
|
|
|
shouldOutput :: (HasCallStack) => String -> String -> TestM ()
|
|
shouldOutput nixDrvExpr expectedOutput = do
|
|
out <- runNixDrv nixDrvExpr
|
|
liftIO $ out `shouldBe` expectedOutput
|
|
|
|
shouldReturnTestM :: (HasCallStack, Show a, Eq a) => TestM a -> a -> TestM ()
|
|
shouldReturnTestM action expected = lifted' (`shouldReturn` expected) action
|
|
|
|
shouldEventuallyReturn :: (HasCallStack, Eq a, Show a) => TestM a -> a -> TestM ()
|
|
shouldEventuallyReturn action expected = go 0
|
|
where
|
|
delay = 20_000
|
|
maxRetries = 5_000_000 `div` delay
|
|
go :: Int -> TestM ()
|
|
go retryCount = do
|
|
result <- action
|
|
if result == expected
|
|
then pure ()
|
|
else do
|
|
if retryCount > maxRetries
|
|
then liftIO $ result `shouldBe` expected
|
|
else do
|
|
liftIO $ threadDelay delay
|
|
go $ retryCount + 1
|