core/pkgs/build-support/writers/test.nix
2024-05-13 11:34:52 -04:00

420 lines
10 KiB
Nix

{ haskellPackages
, lib
, nodePackages
, perlPackages
, python3Packages
, runCommand
, testers
, writers
, writeText
}:
# If you are reading this, you can test these writers by running: nix-build . -A tests.writers
let
inherit (lib) getExe recurseIntoAttrs;
inherit (writers)
makeFSharpWriter
writeBash
writeBashBin
writeDash
writeDashBin
writeFish
writeFishBin
writeFSharp
writeHaskell
writeHaskellBin
writeJS
writeJSBin
writeJSON
writeLua
writeNu
writePerl
writePerlBin
writePyPy3
writePython3
writePython3Bin
writeRuby
writeRust
writeRustBin
writeText
writeTOML
writeYAML
;
expectSuccess = test:
runCommand "run-${test.name}" {} ''
if [[ "$(${test})" != success ]]; then
echo 'test ${test.name} failed'
exit 1
fi
touch $out
'';
expectSuccessBin = test:
runCommand "run-${test.name}" {} ''
if [[ "$(${getExe test})" != success ]]; then
echo 'test ${test.name} failed'
exit 1
fi
touch $out
'';
expectDataEqual = { file, expected }:
let
expectedFile = writeText "${file.name}-expected" expected;
in
testers.testEqualContents { expected = expectedFile; actual = file; assertion = "${file.name} matches"; };
in
recurseIntoAttrs {
bin = recurseIntoAttrs {
bash = expectSuccessBin (writeBashBin "test-writers-bash-bin" ''
if [[ "test" == "test" ]]; then echo "success"; fi
'');
dash = expectSuccessBin (writeDashBin "test-writers-dash-bin" ''
test '~' = '~' && echo 'success'
'');
fish = expectSuccessBin (writeFishBin "test-writers-fish-bin" ''
if test "test" = "test"
echo "success"
end
'');
rust = expectSuccessBin (writeRustBin "test-writers-rust-bin" {} ''
fn main(){
println!("success")
}
'');
haskell = expectSuccessBin (writeHaskellBin "test-writers-haskell-bin" { libraries = [ haskellPackages.acme-default ]; } ''
import Data.Default
int :: Int
int = def
main :: IO ()
main = case int of
18871 -> putStrLn $ id "success"
_ -> print "fail"
'');
js = expectSuccessBin (writeJSBin "test-writers-js-bin" { libraries = [ nodePackages.semver ]; } ''
var semver = require('semver');
if (semver.valid('1.2.3')) {
console.log('success')
} else {
console.log('fail')
}
'');
perl = expectSuccessBin (writePerlBin "test-writers-perl-bin" { libraries = [ perlPackages.boolean ]; } ''
use boolean;
print "success\n" if true;
'');
python3 = expectSuccessBin (writePython3Bin "test-writers-python3-bin" { libraries = [ python3Packages.pyyaml ]; } ''
import yaml
y = yaml.safe_load("""
- test: success
""")
print(y[0]['test'])
'');
# Commented out because of this issue: https://github.com/NixOS/nixpkgs/issues/39356
#pypy2 = expectSuccessBin (writePyPy2Bin "test-writers-pypy2-bin" { libraries = [ pypy2Packages.enum ]; } ''
# from enum import Enum
#
# class Test(Enum):
# a = "success"
#
# print Test.a
#'');
#pypy3 = expectSuccessBin (writePyPy3Bin "test-writers-pypy3-bin" { libraries = [ pypy3Packages.pyyaml ]; } ''
# import yaml
#
# y = yaml.safe_load("""
# - test: success
# """)
# print(y[0]['test'])
#'');
# Could not test this because of external package issues :(
#lua = writeLuaBin "test-writers-lua-bin" { libraries = [ pkgs.luaPackages.say ]; } ''
# s = require("say")
# s:set_namespace("en")
# s:set('money', 'I have %s dollars')
# s:set('wow', 'So much money!')
# print(s('money', {1000})) -- I have 1000 dollars
# s:set_namespace("fr") -- switch to french!
# s:set('wow', "Tant d'argent!")
# print(s('wow')) -- Tant d'argent!
# s:set_namespace("en") -- switch back to english!
# print(s('wow')) -- So much money!
#'';
#ruby = expectSuccessBin (writeRubyBin "test-writers-ruby-bin" { libraries = [ rubyPackages.rubocop ]; } ''
#puts "This should work!"
#'');
};
simple = recurseIntoAttrs {
bash = expectSuccess (writeBash "test-writers-bash" ''
if [[ "test" == "test" ]]; then echo "success"; fi
'');
dash = expectSuccess (writeDash "test-writers-dash" ''
test '~' = '~' && echo 'success'
'');
fish = expectSuccess (writeFish "test-writers-fish" ''
if test "test" = "test"
echo "success"
end
'');
nu = expectSuccess (writeNu "test-writers-nushell" ''
echo "success"
'');
haskell = expectSuccess (writeHaskell "test-writers-haskell" { libraries = [ haskellPackages.acme-default ]; } ''
import Data.Default
int :: Int
int = def
main :: IO ()
main = case int of
18871 -> putStrLn $ id "success"
_ -> print "fail"
'');
js = expectSuccess (writeJS "test-writers-js" { libraries = [ nodePackages.semver ]; } ''
var semver = require('semver');
if (semver.valid('1.2.3')) {
console.log('success')
} else {
console.log('fail')
}
'');
perl = expectSuccess (writePerl "test-writers-perl" { libraries = [ perlPackages.boolean ]; } ''
use boolean;
print "success\n" if true;
'');
python3 = expectSuccess (writePython3 "test-writers-python3" { libraries = [ python3Packages.pyyaml ]; } ''
import yaml
y = yaml.safe_load("""
- test: success
""")
print(y[0]['test'])
'');
# Commented out because of this issue: https://github.com/NixOS/nixpkgs/issues/39356
#pypy2 = expectSuccessBin (writePyPy2Bin "test-writers-pypy2-bin" { libraries = [ pypy2Packages.enum ]; } ''
# from enum import Enum
#
# class Test(Enum):
# a = "success"
#
# print Test.a
#'');
#pypy3 = expectSuccessBin (writePyPy3Bin "test-writers-pypy3-bin" { libraries = [ pypy3Packages.pyyaml ]; } ''
# import yaml
#
# y = yaml.safe_load("""
# - test: success
# """)
# print(y[0]['test'])
#'');
fsharp = expectSuccess (makeFSharpWriter {
libraries = { fetchNuGet }: [
(fetchNuGet { pname = "FSharp.SystemTextJson"; version = "0.17.4"; sha256 = "1bplzc9ybdqspii4q28l8gmfvzpkmgq5l1hlsiyg2h46w881lwg2"; })
(fetchNuGet { pname = "System.Text.Json"; version = "4.6.0"; sha256 = "0ism236hwi0k6axssfq58s1d8lihplwiz058pdvl8al71hagri39"; })
];
} "test-writers-fsharp" ''
#r "nuget: FSharp.SystemTextJson, 0.17.4"
module Json =
open System.Text.Json
open System.Text.Json.Serialization
let options = JsonSerializerOptions()
options.Converters.Add(JsonFSharpConverter())
let serialize<'a> (o: 'a) = JsonSerializer.Serialize<'a>(o, options)
let deserialize<'a> (str: string) = JsonSerializer.Deserialize<'a>(str, options)
type Letter = A | B
let a = {| Hello = Some "World"; Letter = A |}
if a |> Json.serialize |> Json.deserialize |> (=) a
then "success"
else "failed"
|> printfn "%s"
'');
#pypy2NoLibs = expectSuccess (writePyPy2 "test-writers-pypy2-no-libs" {} ''
# print("success")
#'');
python3NoLibs = expectSuccess (writePython3 "test-writers-python3-no-libs" {} ''
print("success")
'');
pypy3NoLibs = expectSuccess (writePyPy3 "test-writers-pypy3-no-libs" {} ''
print("success")
'');
fsharpNoNugetDeps = expectSuccess (writeFSharp "test-writers-fsharp-no-nuget-deps" ''
printfn "success"
'');
luaNoLibs = expectSuccess (writeLua "test-writers-lua-no-libs" {} ''
print("success")
'');
rubyNoLibs = expectSuccess (writeRuby "test-writers-ruby-no-libs" {} ''
puts "success"
'');
};
path = recurseIntoAttrs {
bash = expectSuccess (writeBash "test-writers-bash-path" (writeText "test" ''
if [[ "test" == "test" ]]; then echo "success"; fi
''));
haskell = expectSuccess (writeHaskell "test-writers-haskell-path" { libraries = [ haskellPackages.acme-default ]; } (writeText "test" ''
import Data.Default
int :: Int
int = def
main :: IO ()
main = case int of
18871 -> putStrLn $ id "success"
_ -> print "fail"
''));
};
data = {
json = expectDataEqual {
file = writeJSON "data.json" { hello = "world"; };
expected = ''
{
"hello": "world"
}
'';
};
toml = expectDataEqual {
file = writeTOML "data.toml" { hello = "world"; };
expected = ''
hello = "world"
'';
};
yaml = expectDataEqual {
file = writeYAML "data.yaml" { hello = "world"; };
expected = "hello: world\n";
};
};
wrapping = recurseIntoAttrs {
bash-bin = expectSuccessBin (
writeBashBin "test-writers-wrapping-bash-bin"
{
makeWrapperArgs = [
"--set"
"ThaigerSprint"
"Thailand"
];
}
''
if [[ "$ThaigerSprint" == "Thailand" ]]; then
echo "success"
fi
''
);
bash = expectSuccess (
writeBash "test-writers-wrapping-bash"
{
makeWrapperArgs = [
"--set"
"ThaigerSprint"
"Thailand"
];
}
''
if [[ "$ThaigerSprint" == "Thailand" ]]; then
echo "success"
fi
''
);
python = expectSuccess (
writePython3 "test-writers-wrapping-python"
{
makeWrapperArgs = [
"--set"
"ThaigerSprint"
"Thailand"
];
}
''
import os
if os.environ.get("ThaigerSprint") == "Thailand":
print("success")
''
);
rust = expectSuccess (
writeRust "test-writers-wrapping-rust"
{
makeWrapperArgs = [
"--set"
"ThaigerSprint"
"Thailand"
];
}
''
fn main(){
if std::env::var("ThaigerSprint").unwrap() == "Thailand" {
println!("success")
}
}
''
);
no-empty-wrapper = let
bin = writeBashBin "bin" { makeWrapperArgs = []; } ''true'';
in runCommand "run-test-writers-wrapping-no-empty-wrapper" {} ''
ls -A ${bin}/bin
if [ $(ls -A ${bin}/bin | wc -l) -eq 1 ]; then
touch $out
else
echo "Error: Empty wrapper was created" >&2
exit 1
fi
'';
};
}