jail.nix/tests/spec/TestPrelude.hs
2025-12-16 08:50:53 -08:00

189 lines
5.1 KiB
Haskell

module TestPrelude
( (</>),
TestM,
buildNixDrvPath,
evalNixExpr,
forM,
forM_,
getTestDir,
i,
inTestM,
liftIO,
runNixDrv,
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.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
spawnNixDrv :: String -> TestM (Maybe Handle, Maybe Handle, Maybe Handle, ProcessHandle)
spawnNixDrv = liftIO . createProcess <=< mkNixDrvProccess
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; };
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