public override string DumpSchema()
{
var mysqldHome = Path.GetDirectoryName(MySqld);
var mysqldump = Path.Combine(mysqldHome, "mysqldump");
if (Platform.IsWindows)
{
mysqldump += ".exe";
}
if (!File.Exists(mysqldump))
{
throw new InvalidOperationException(
$"Unable to find mysqldump at {mysqldump}"
);
}
using (var io = new ProcessIO(
mysqldump,
"-u", "root",
"--password="******"-h", "localhost",
"-P", Port.ToString(),
SchemaName))
{
return(string.Join("\n", io.StandardOutput));
}
}
public override string DumpSchema()
{
// TODO: rather query INFORMATION_SCHEMA and do the work internally
var mysqldHome = Path.GetDirectoryName(MySqld);
// ReSharper disable once AssignNullToNotNullAttribute
var mysqldump = Path.Combine(mysqldHome, "mysqldump");
if (Platform.IsWindows)
{
mysqldump += ".exe";
}
if (!File.Exists(mysqldump))
{
throw new InvalidOperationException(
$"Unable to find mysqldump at {mysqldump}"
);
}
using var io = new ProcessIO(
mysqldump,
"-u", "root",
$"--password={Settings.Options.RootUserPassword}",
"-h", "localhost",
"-P", Port.ToString(),
SchemaName);
return(string.Join("\n", io.StandardOutput));
}
public void ShouldBeAbleToReadFromStdOut()
{
// Arrange
// Act
using (var io = new ProcessIO("echo", "moo"))
{
var lines = io.StandardOutput.ToArray().Select(l => l.Trim());
// Assert
Expect(lines).To.Equal(new[] { "moo" });
}
}
private static string FindFirstMySqlServiceName()
{
using var io = ProcessIO.Start("sc", "query", "state=", "all");
return(io.StandardOutput
.FirstOrDefault(
l =>
{
var lower = l.ToLower();
return lower.StartsWith("service_name") &&
lower.Contains("mysql");
})?.Split(':').Last().Trim());
}
private static int Run(
string program,
params string[] args)
{
using var io = new ProcessIO(
program,
args.And("-n", TestServiceName));
io.StandardOutput.ForEach(line =>
Console.WriteLine($"stdout: {line}")
);
io.StandardError.ForEach(
line => Console.WriteLine($"stderr: {line}")
);
return(io.ExitCode);
}
public void ShouldBeAbleToRunInDifferentDirectory()
{
// Arrange
using var tempFolder = new AutoTempFolder();
var tempFilePath = Path.Combine(tempFolder.Path, "data.txt");
var expected = GetRandomString(32);
File.WriteAllText(tempFilePath, expected);
// Act
using var io = ProcessIO.In(tempFolder.Path).Start("cat", "data.txt");
// Assert
var lines = io.StandardOutput.ToArray().Select(l => l.Trim());
Expect(lines)
.To.Equal(new[] { expected });
}
public void ShouldBeAbleToReadFromStdErr()
{
// Arrange
using var tempFolder = new AutoTempFolder();
var fileName = Path.Combine(tempFolder.Path, "test.bat");
File.WriteAllText(fileName, "echo moo 1>&2");
// Act
using var io = new ProcessIO(fileName);
Expect(io.StartException)
.To.Be.Null();
var lines = io.StandardError.ToArray().Select(l => l.Trim());
// Assert
Expect(lines).To.Equal(new[] { "moo" });
}
public void ShouldBeAbleToInjectEnvironmentVariables()
{
// Arrange
var expected = GetRandomAlphaString(4);
var envVar = GetRandomAlphaString(4);
// Act
using var io = ProcessIO
.WithEnvironmentVariable(envVar, expected)
.Start("pwsh", "-Command", $"Write-Host $env:{envVar}");
// Assert
var lines = io.StandardOutput.ToArray().Trim();
Expect(lines)
.To.Equal(new[] { expected });
}
public async Task <CommandResult> RunCommandAsync(RemoteCommandArgs commandArgs)
{
var io = new ProcessIO(this.logEmitter);
RemoteCommand remoteCommand = RemoteCommand.Create(this.container, io, commandArgs.Command, commandArgs);
TaskCommandResult taskResult = await remoteCommand.InvokeAsync();
var result = new CommandResult
{
ExitCode = taskResult.ExitCode,
StdOut = taskResult.Stdout,
StdErr = taskResult.Stderr,
};
return(result);
}
private IContainerProcess Run(IWebSocketEventSender websocket, ProcessSpec processSpec)
{
try
{
var processIO = new ProcessIO(websocket);
var process = container.Run(processSpec, processIO);
websocket.SendEvent("pid", process.Id.ToString());
return(process);
}
catch (Exception e)
{
websocket.SendEvent("error", e.Message);
websocket.Close(System.Net.WebSockets.WebSocketCloseStatus.InternalServerError, e.Message);
return(null);
}
}
private void EnsureServiceNotRunning(string name, string exe)
{
// big hammer to enforce service non-existence at exit
// attempt stop
using var stop = new ProcessIO("sc", "stop", name);
stop.StandardOutput.ForEach(Log);
stop.StandardError.ForEach(Log);
// delete service
using var delete = new ProcessIO("sc", "delete", name);
delete.StandardOutput.ForEach(Log);
delete.StandardError.ForEach(Log);
// kill remaining process
var proc = Process.GetProcesses()
.Where(p =>
{
try
{
return(p.StartInfo.FileName.Equals(exe, StringComparison.OrdinalIgnoreCase));
}
catch
{
return(false);
}
})
.ToArray();
proc.ForEach(p =>
{
try
{
p.Kill();
}
catch
{
// may already be dead
}
});
void Log(string s)
{
Console.WriteLine(s);
}
}
public void ShouldNotBreakGivenNullEnvironment()
{
// Arrange
using var folder = new AutoTempFolder();
var expected = GetRandomAlphaString(4);
var envVar = GetRandomAlphaString(4);
// Act
using var io = ProcessIO
.In(folder.Path)
.WithEnvironment(null)
.WithEnvironmentVariable(envVar, expected)
.Start("pwsh", "-Command", $"Write-Host $env:{envVar}");
// Assert
var lines = io.StandardOutput.ToArray().Trim();
Expect(lines)
.To.Equal(new[] { expected });
}
public static List <Process> Test(string path, string name)
{
var processes = new List <Process>();
var outdir = Path.Combine(OutputDir, name);
if (Directory.Exists(outdir))
{
//Directory.Delete(outdir, true);
foreach (var file in new DirectoryInfo(outdir).EnumerateFiles("*.out"))
{
try
{
file.Delete();
}
catch
{
Console.WriteLine("FUU");
}
}
}
else
{
Directory.CreateDirectory(outdir);
}
for (var i = 0; i < Executables.Count; i++)
{
var _in = new Win32.FILE(path);
var _out = new Win32.FILE(Path.Combine(outdir, $"{name}_{Executables[i].Name}.out"));
var io = new ProcessIO(_in, _out);
var psi = new ProcessStartInfo
{
StartSuspended = false,
StdIO = io,
Executable = Executables[i].FullName
}; // TotalTimeLimit = MaxTime
var p = new Process(psi);
processes.Add(p);
p.Start();
}
return(processes);
}
public void ShouldBeAbleToReadFromStdOut()
{
if (!Platform.IsWindows)
{
Assert.Ignore("This test uses a win32 commandline for testing");
return;
}
// Arrange
// Act
using var io = new ProcessIO(
"cmd", "/c", "echo", "moo"
);
Expect(io.StartException)
.To.Be.Null();
var lines = io.StandardOutput.ToArray().Select(l => l.Trim());
// Assert
Expect(lines).To.Equal(new[] { "moo" });
}
private void EnsureTestServiceIsNotInstalled()
{
// attempts to stop and uninstall all found test service instances
var serviceNames = new List <string>();
using var io = ProcessIO.Start("sc", "query", "type=", "service", "state=", "all");
serviceNames.AddRange(
io.StandardOutput
.Select(line => line.Trim())
.Where(line => line.StartsWith("SERVICE_NAME"))
.Select(line => string.Join(":", line.Split(':').Skip(1)).Trim())
.Where(serviceName => serviceName.StartsWith("test-service-"))
.ToArray()
);
serviceNames.ForEach(serviceName =>
{
TryDo(() => Run("sc", "stop", serviceName));
TryDo(() => Run("sc", "delete", serviceName));
});
}
private static string FindPathForService(string mysqlServiceName)
{
using var io = ProcessIO.Start("sc", "qc", mysqlServiceName);
var commandLine = io.StandardOutput
.FirstOrDefault(line => line.Trim().StartsWith("BINARY_PATH_NAME"))
?.Split(':')
.Skip(1)
.JoinWith(":").Trim();
if (commandLine == null)
{
return(null);
}
if (commandLine.StartsWith("\""))
{
var nextQuote = commandLine.IndexOf("\"", 2, StringComparison.InvariantCulture);
return(commandLine.Substring(1, nextQuote - 1));
}
return(commandLine.Split(' ').First());
}
public void ShouldBeAbleToInjectEnvironmentVariablesAndCustomWorkingFolder4()
{
// Arrange
using var folder = new AutoTempFolder();
var expected = GetRandomAlphaString(4);
var envVar = GetRandomAlphaString(4);
var dict = new Dictionary <string, string>()
{
[envVar] = expected
};
// Act
using var io = ProcessIO
.In(folder.Path)
.WithEnvironment(dict)
.Start("pwsh", "-Command", $"Write-Host $env:{envVar}");
// Assert
var lines = io.StandardOutput.ToArray().Trim();
Expect(lines)
.To.Equal(new[] { expected });
}
private IContainerProcess Run(IWebSocketEventSender websocket, ProcessSpec processSpec)
{
try
{
var processIO = new ProcessIO(websocket);
var process = container.Run(processSpec, processIO);
websocket.SendEvent("pid", process.Id.ToString());
return process;
}
catch (Exception e)
{
websocket.SendEvent("error", e.Message);
websocket.Close(System.Net.WebSockets.WebSocketCloseStatus.InternalServerError, e.Message);
return null;
}
}
