feat: initial project commit

src/Process.Tests/CommandTests.cs

@@ -0,0 +1,271 @@
+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));
+		});
+	}
+}