495 lines
11 KiB
Nix
495 lines
11 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
|
|
'';
|
|
};
|
|
}
|