271 lines
No EOL
11 KiB
C#
271 lines
No EOL
11 KiB
C#
namespace Geekeey.Extensions.Process.Tests;
|
|
|
|
[TestFixture]
|
|
internal sealed class CommandTests
|
|
{
|
|
[Test]
|
|
public void New_Command_Defaults()
|
|
{
|
|
var cmd = new Command("foo");
|
|
|
|
Assert.Multiple(() =>
|
|
{
|
|
Assert.That(cmd.TargetFilePath, Is.EqualTo("foo"));
|
|
Assert.That(cmd.Arguments, Is.Empty);
|
|
Assert.That(cmd.WorkingDirPath, Is.EqualTo(Directory.GetCurrentDirectory()));
|
|
Assert.That(cmd.EnvironmentVariables, Is.Empty);
|
|
Assert.That(cmd.Validation, Is.EqualTo(CommandExitBehaviour.ZeroExitCode));
|
|
Assert.That(cmd.StandardInputPipe, Is.EqualTo(PipeSource.Null));
|
|
Assert.That(cmd.StandardOutputPipe, Is.EqualTo(PipeTarget.Null));
|
|
Assert.That(cmd.StandardErrorPipe, Is.EqualTo(PipeTarget.Null));
|
|
});
|
|
}
|
|
|
|
[Test]
|
|
public void New_Command_WithTargetFile()
|
|
{
|
|
var cmd = new Command("foo");
|
|
var modified = cmd.WithTargetFile("bar");
|
|
|
|
Assert.Multiple(() =>
|
|
{
|
|
Assert.That(modified.TargetFilePath, Is.EqualTo("bar"));
|
|
Assert.That(modified.Arguments, Is.EqualTo(cmd.Arguments));
|
|
Assert.That(modified.WorkingDirPath, Is.EqualTo(cmd.WorkingDirPath));
|
|
Assert.That(modified.EnvironmentVariables, Is.EqualTo(cmd.EnvironmentVariables));
|
|
Assert.That(modified.Validation, Is.EqualTo(cmd.Validation));
|
|
Assert.That(modified.StandardInputPipe, Is.EqualTo(cmd.StandardInputPipe));
|
|
Assert.That(modified.StandardOutputPipe, Is.EqualTo(cmd.StandardOutputPipe));
|
|
Assert.That(modified.StandardErrorPipe, Is.EqualTo(cmd.StandardErrorPipe));
|
|
|
|
Assert.That(cmd.TargetFilePath, Is.Not.EqualTo("bar"));
|
|
});
|
|
}
|
|
|
|
[Test]
|
|
public void New_Command_WithArguments()
|
|
{
|
|
var cmd = new Command("foo").WithArguments("xxx");
|
|
var modified = cmd.WithArguments("abc def");
|
|
|
|
Assert.Multiple(() =>
|
|
{
|
|
Assert.That(modified.TargetFilePath, Is.EqualTo(cmd.TargetFilePath));
|
|
Assert.That(modified.Arguments, Is.EqualTo("abc def"));
|
|
Assert.That(modified.WorkingDirPath, Is.EqualTo(cmd.WorkingDirPath));
|
|
Assert.That(modified.EnvironmentVariables, Is.EqualTo(cmd.EnvironmentVariables));
|
|
Assert.That(modified.Validation, Is.EqualTo(cmd.Validation));
|
|
Assert.That(modified.StandardInputPipe, Is.EqualTo(cmd.StandardInputPipe));
|
|
Assert.That(modified.StandardOutputPipe, Is.EqualTo(cmd.StandardOutputPipe));
|
|
Assert.That(modified.StandardErrorPipe, Is.EqualTo(cmd.StandardErrorPipe));
|
|
|
|
Assert.That(cmd.Arguments, Is.Not.EqualTo("abc def"));
|
|
});
|
|
}
|
|
|
|
[Test]
|
|
public void New_Command_WithArguments_Array()
|
|
{
|
|
var cmd = new Command("foo").WithArguments("xxx");
|
|
var modified = cmd.WithArguments(["abc", "def"]);
|
|
|
|
Assert.Multiple(() =>
|
|
{
|
|
Assert.That(modified.TargetFilePath, Is.EqualTo(cmd.TargetFilePath));
|
|
Assert.That(modified.Arguments, Is.EqualTo("abc def"));
|
|
Assert.That(modified.WorkingDirPath, Is.EqualTo(cmd.WorkingDirPath));
|
|
Assert.That(modified.EnvironmentVariables, Is.EqualTo(cmd.EnvironmentVariables));
|
|
Assert.That(modified.Validation, Is.EqualTo(cmd.Validation));
|
|
Assert.That(modified.StandardInputPipe, Is.EqualTo(cmd.StandardInputPipe));
|
|
Assert.That(modified.StandardOutputPipe, Is.EqualTo(cmd.StandardOutputPipe));
|
|
Assert.That(modified.StandardErrorPipe, Is.EqualTo(cmd.StandardErrorPipe));
|
|
|
|
Assert.That(cmd.Arguments, Is.Not.EqualTo("abc def"));
|
|
});
|
|
}
|
|
|
|
[Test]
|
|
public void New_Command_WithArguments_Builder()
|
|
{
|
|
var cmd = new Command("foo").WithArguments("xxx");
|
|
var modified = cmd.WithArguments(args => args
|
|
.Add("-a")
|
|
.Add("foo bar")
|
|
.Add("\"foo\\\\bar\"")
|
|
.Add(3.14)
|
|
.Add(["foo", "bar"])
|
|
.Add([-10, 12.12]));
|
|
|
|
Assert.Multiple(() =>
|
|
{
|
|
Assert.That(modified.TargetFilePath, Is.EqualTo(cmd.TargetFilePath));
|
|
Assert.That(modified.Arguments, Is.EqualTo("-a \"foo bar\" \"\\\"foo\\\\bar\\\"\" 3.14 foo bar -10 12.12"));
|
|
Assert.That(modified.WorkingDirPath, Is.EqualTo(cmd.WorkingDirPath));
|
|
Assert.That(modified.EnvironmentVariables, Is.EqualTo(cmd.EnvironmentVariables));
|
|
Assert.That(modified.Validation, Is.EqualTo(cmd.Validation));
|
|
Assert.That(modified.StandardInputPipe, Is.EqualTo(cmd.StandardInputPipe));
|
|
Assert.That(modified.StandardOutputPipe, Is.EqualTo(cmd.StandardOutputPipe));
|
|
Assert.That(modified.StandardErrorPipe, Is.EqualTo(cmd.StandardErrorPipe));
|
|
|
|
Assert.That(cmd.Arguments, Is.Not.EqualTo("-a \"foo bar\" \"\\\"foo\\\\bar\\\"\" 3.14 foo bar -10 12.12"));
|
|
});
|
|
}
|
|
|
|
[Test]
|
|
public void New_Command_WithWorkingDirectory()
|
|
{
|
|
var cmd = new Command("foo").WithWorkingDirectory("xxx");
|
|
var modified = cmd.WithWorkingDirectory("new");
|
|
|
|
Assert.Multiple(() =>
|
|
{
|
|
Assert.That(modified.TargetFilePath, Is.EqualTo(cmd.TargetFilePath));
|
|
Assert.That(modified.Arguments, Is.EqualTo(cmd.Arguments));
|
|
Assert.That(modified.WorkingDirPath, Is.EqualTo("new"));
|
|
Assert.That(modified.EnvironmentVariables, Is.EqualTo(cmd.EnvironmentVariables));
|
|
Assert.That(modified.Validation, Is.EqualTo(cmd.Validation));
|
|
Assert.That(modified.StandardInputPipe, Is.EqualTo(cmd.StandardInputPipe));
|
|
Assert.That(modified.StandardOutputPipe, Is.EqualTo(cmd.StandardOutputPipe));
|
|
Assert.That(modified.StandardErrorPipe, Is.EqualTo(cmd.StandardErrorPipe));
|
|
|
|
Assert.That(cmd.WorkingDirPath, Is.Not.EqualTo("new"));
|
|
});
|
|
}
|
|
|
|
[Test]
|
|
public void New_Command_WithEnvironmentVariables()
|
|
{
|
|
var cmd = new Command("foo").WithEnvironmentVariables(e => e.Set("xxx", "xxx"));
|
|
var vars = new Dictionary<string, string?> { ["name"] = "value", ["key"] = "door" };
|
|
var modified = cmd.WithEnvironmentVariables(vars);
|
|
|
|
Assert.Multiple(() =>
|
|
{
|
|
Assert.That(modified.TargetFilePath, Is.EqualTo(cmd.TargetFilePath));
|
|
Assert.That(modified.Arguments, Is.EqualTo(cmd.Arguments));
|
|
Assert.That(modified.WorkingDirPath, Is.EqualTo(cmd.WorkingDirPath));
|
|
Assert.That(modified.EnvironmentVariables, Is.EqualTo(vars));
|
|
Assert.That(modified.Validation, Is.EqualTo(cmd.Validation));
|
|
Assert.That(modified.StandardInputPipe, Is.EqualTo(cmd.StandardInputPipe));
|
|
Assert.That(modified.StandardOutputPipe, Is.EqualTo(cmd.StandardOutputPipe));
|
|
Assert.That(modified.StandardErrorPipe, Is.EqualTo(cmd.StandardErrorPipe));
|
|
|
|
Assert.That(cmd.EnvironmentVariables, Is.Not.EqualTo(vars));
|
|
});
|
|
}
|
|
|
|
[Test]
|
|
public void New_Command_WithEnvironmentVariables_Builder()
|
|
{
|
|
var cmd = new Command("foo").WithEnvironmentVariables(e => e.Set("xxx", "xxx"));
|
|
var modified = cmd.WithEnvironmentVariables(env => env
|
|
.Set("name", "value")
|
|
.Set("key", "door")
|
|
.Set(new Dictionary<string, string?> { ["zzz"] = "yyy", ["aaa"] = "bbb" }));
|
|
|
|
Assert.Multiple(() =>
|
|
{
|
|
var vars = new Dictionary<string, string?>
|
|
{
|
|
["name"] = "value", ["key"] = "door", ["zzz"] = "yyy", ["aaa"] = "bbb"
|
|
};
|
|
Assert.That(modified.TargetFilePath, Is.EqualTo(cmd.TargetFilePath));
|
|
Assert.That(modified.Arguments, Is.EqualTo(cmd.Arguments));
|
|
Assert.That(modified.WorkingDirPath, Is.EqualTo(cmd.WorkingDirPath));
|
|
Assert.That(modified.EnvironmentVariables, Is.EqualTo(vars));
|
|
Assert.That(modified.Validation, Is.EqualTo(cmd.Validation));
|
|
Assert.That(modified.StandardInputPipe, Is.EqualTo(cmd.StandardInputPipe));
|
|
Assert.That(modified.StandardOutputPipe, Is.EqualTo(cmd.StandardOutputPipe));
|
|
Assert.That(modified.StandardErrorPipe, Is.EqualTo(cmd.StandardErrorPipe));
|
|
|
|
Assert.That(cmd.EnvironmentVariables, Is.Not.EqualTo(vars));
|
|
});
|
|
}
|
|
|
|
[Test]
|
|
public void New_Command_WithValidation()
|
|
{
|
|
var cmd = new Command("foo").WithValidation(CommandExitBehaviour.ZeroExitCode);
|
|
var modified = cmd.WithValidation(CommandExitBehaviour.None);
|
|
|
|
Assert.Multiple(() =>
|
|
{
|
|
Assert.That(modified.TargetFilePath, Is.EqualTo(cmd.TargetFilePath));
|
|
Assert.That(modified.Arguments, Is.EqualTo(cmd.Arguments));
|
|
Assert.That(modified.WorkingDirPath, Is.EqualTo(cmd.WorkingDirPath));
|
|
Assert.That(modified.EnvironmentVariables, Is.EqualTo(cmd.EnvironmentVariables));
|
|
Assert.That(modified.Validation, Is.EqualTo(CommandExitBehaviour.None));
|
|
Assert.That(modified.StandardInputPipe, Is.EqualTo(cmd.StandardInputPipe));
|
|
Assert.That(modified.StandardOutputPipe, Is.EqualTo(cmd.StandardOutputPipe));
|
|
Assert.That(modified.StandardErrorPipe, Is.EqualTo(cmd.StandardErrorPipe));
|
|
|
|
Assert.That(cmd.Validation, Is.Not.EqualTo(CommandExitBehaviour.None));
|
|
});
|
|
}
|
|
|
|
[Test]
|
|
public void New_Command_WithStandardInputPipe()
|
|
{
|
|
var cmd = new Command("foo").WithStandardInputPipe(PipeSource.Null);
|
|
var pipeSource = PipeSource.FromStream(Stream.Null);
|
|
var modified = cmd.WithStandardInputPipe(pipeSource);
|
|
|
|
Assert.Multiple(() =>
|
|
{
|
|
Assert.That(modified.TargetFilePath, Is.EqualTo(cmd.TargetFilePath));
|
|
Assert.That(modified.Arguments, Is.EqualTo(cmd.Arguments));
|
|
Assert.That(modified.WorkingDirPath, Is.EqualTo(cmd.WorkingDirPath));
|
|
Assert.That(modified.EnvironmentVariables, Is.EqualTo(cmd.EnvironmentVariables));
|
|
Assert.That(modified.Validation, Is.EqualTo(cmd.Validation));
|
|
Assert.That(modified.StandardInputPipe, Is.EqualTo(pipeSource));
|
|
Assert.That(modified.StandardOutputPipe, Is.EqualTo(cmd.StandardOutputPipe));
|
|
Assert.That(modified.StandardErrorPipe, Is.EqualTo(cmd.StandardErrorPipe));
|
|
|
|
Assert.That(cmd.StandardInputPipe, Is.Not.EqualTo(pipeSource));
|
|
});
|
|
}
|
|
|
|
[Test]
|
|
public void New_Command_WithStandardOutputPipe()
|
|
{
|
|
var cmd = new Command("foo").WithStandardOutputPipe(PipeTarget.Null);
|
|
var pipeTarget = PipeTarget.ToStream(Stream.Null);
|
|
var modified = cmd.WithStandardOutputPipe(pipeTarget);
|
|
|
|
Assert.Multiple(() =>
|
|
{
|
|
Assert.That(modified.TargetFilePath, Is.EqualTo(cmd.TargetFilePath));
|
|
Assert.That(modified.Arguments, Is.EqualTo(cmd.Arguments));
|
|
Assert.That(modified.WorkingDirPath, Is.EqualTo(cmd.WorkingDirPath));
|
|
Assert.That(modified.EnvironmentVariables, Is.EqualTo(cmd.EnvironmentVariables));
|
|
Assert.That(modified.Validation, Is.EqualTo(cmd.Validation));
|
|
Assert.That(modified.StandardInputPipe, Is.EqualTo(cmd.StandardInputPipe));
|
|
Assert.That(modified.StandardOutputPipe, Is.EqualTo(pipeTarget));
|
|
Assert.That(modified.StandardErrorPipe, Is.EqualTo(cmd.StandardErrorPipe));
|
|
|
|
Assert.That(cmd.StandardOutputPipe, Is.Not.EqualTo(pipeTarget));
|
|
});
|
|
}
|
|
|
|
[Test]
|
|
public void New_Command_WithStandardErrorPipe()
|
|
{
|
|
var cmd = new Command("foo").WithStandardErrorPipe(PipeTarget.Null);
|
|
var pipeTarget = PipeTarget.ToStream(Stream.Null);
|
|
var modified = cmd.WithStandardErrorPipe(pipeTarget);
|
|
|
|
Assert.Multiple(() =>
|
|
{
|
|
Assert.That(modified.TargetFilePath, Is.EqualTo(cmd.TargetFilePath));
|
|
Assert.That(modified.Arguments, Is.EqualTo(cmd.Arguments));
|
|
Assert.That(modified.WorkingDirPath, Is.EqualTo(cmd.WorkingDirPath));
|
|
Assert.That(modified.EnvironmentVariables, Is.EqualTo(cmd.EnvironmentVariables));
|
|
Assert.That(modified.Validation, Is.EqualTo(cmd.Validation));
|
|
Assert.That(modified.StandardInputPipe, Is.EqualTo(cmd.StandardInputPipe));
|
|
Assert.That(modified.StandardOutputPipe, Is.EqualTo(cmd.StandardOutputPipe));
|
|
Assert.That(modified.StandardErrorPipe, Is.EqualTo(pipeTarget));
|
|
|
|
Assert.That(cmd.StandardErrorPipe, Is.Not.EqualTo(pipeTarget));
|
|
});
|
|
}
|
|
} |