public async Task ExecuteReaderAsync_WithAllParametersSet_ExecutesAndReturnsExpectedResult()
{
SqlProgram <string, int, decimal, bool> readerTest =
await SqlProgram <string, int, decimal, bool> .Create((Connection)DifferentLocalDatabaseConnectionString, "spUltimateSproc");
Task <dynamic> result = readerTest.ExecuteReaderAsync(
c =>
{
c.SetParameter("@stringParam", AString);
c.SetParameter("@intParam", AInt);
c.SetParameter("@decimalParam", ADecimal);
c.SetParameter("@boolParam", ABool);
},
async(reader, token) =>
{
if (await reader.ReadAsync(token))
{
return(CreateDatabaseResult(reader));
}
throw new Exception("Critical Test Error");
});
Assert.IsNotNull(result);
result.Wait();
Assert.AreEqual(AString, result.Result.Name);
Assert.AreEqual(AInt, result.Result.Age);
Assert.AreEqual(ADecimal, result.Result.Balance);
Assert.AreEqual(ABool, result.Result.IsValued);
}
public async Task ExecuteReaderAsync_WithOutputParameters_ExecutesSuccessfully()
{
SqlProgram <int, Out <int>, Out <int> > program =
await SqlProgram <int, Out <int>, Out <int> > .Create((Connection)LocalDatabaseConnectionString, "spOutputParameters");
const int inputVal = 123;
const int inputOutputVal = 321;
Out <int> inputOutput = new Out <int>(inputOutputVal);
Out <int> output = new Out <int>();
string result = await program.ExecuteReaderAsync(
async (reader, token) =>
{
Assert.IsTrue(await reader.ReadAsync());
string res = reader.GetString(0);
Assert.IsFalse(await reader.ReadAsync());
Assert.IsFalse(await reader.NextResultAsync());
return(res);
},
inputVal,
inputOutput,
output);
Assert.AreEqual("<foo>bar</foo>", result);
Assert.IsNull(inputOutput.OutputError, inputOutput.OutputError?.Message);
Assert.IsNull(output.OutputError, output.OutputError?.Message);
Assert.AreEqual(inputOutputVal * 2, inputOutput.OutputValue.Value);
Assert.AreEqual(inputVal, output.OutputValue.Value);
}
public async Task ExecuteReaderAsync_WithManualDisposal_ExecutesAndAllowsStreaming()
{
SqlProgram <byte[]> readerTest =
await SqlProgram <byte[]> .Create((Connection)DifferentLocalDatabaseConnectionString, "spTakeByteArray");
byte[] data = Encoding.UTF8.GetBytes(AString);
string resultString;
using (Stream stream = await readerTest.ExecuteReaderAsync(
async(reader, disposable, token) =>
{
if (await reader.ReadAsync(token))
{
return((Stream) new CloseableStream(reader.GetStream(0), disposable));
}
throw new Exception("Critical Test Error");
},
data).ConfigureAwait(false))
{
Assert.IsNotNull(stream);
using (StreamReader reader = new StreamReader(stream, Encoding.UTF8))
resultString = reader.ReadToEnd();
}
Assert.AreEqual(AString, resultString);
}
public async Task ExecuteReaderAsync_ExecutesAndReturnsExpectedResult()
{
SqlProgram readerTest = await SqlProgram.Create((Connection)DifferentLocalDatabaseConnectionString, "spUltimateSproc");
Task readerTask = readerTest.ExecuteReaderAsync();
Assert.IsNotNull(readerTask);
}
public async Task TestSqlProgram_ExecuteReaderAsync()
{
int rowCount = 0;
// ReSharper disable once PossibleNullReferenceException
await Task.WhenAll(
Enumerable.Range(0, Loops)
.Select(
async _ =>
{
SqlProgram <string, int, decimal, bool> program =
await
DatabasesConfiguration.Active.GetSqlProgram <string, int, decimal, bool>(
"test",
ReturnsTableProcedureName,
"@stringParam",
"@intParam",
"@decimalParam",
"@boolParam",
true);
Assert.IsNotNull(program);
await program.ExecuteReaderAsync(
async(dataReader, cancellationToken) =>
{
Assert.IsNotNull(dataReader);
Assert.IsNotNull(cancellationToken);
while (await dataReader.ReadAsync(cancellationToken))
{
// Operation modes
Interlocked.Increment(ref rowCount);
Assert.AreEqual("system", dataReader.GetString(0), "Strings are not equal");
Assert.AreEqual(-1, dataReader.GetInt32(1), "Ints are not equal");
Assert.AreEqual(100M, dataReader.GetDecimal(2), "decimals are not equal");
Assert.AreEqual(true, dataReader.GetBoolean(3), "bools are not equal");
}
// ReSharper disable once PossibleNullReferenceException
await dataReader.NextResultAsync(cancellationToken);
// ReSharper disable once PossibleNullReferenceException
while (await dataReader.ReadAsync(cancellationToken))
{
// Guids
Interlocked.Increment(ref rowCount);
}
},
"system",
-1,
100M,
true);
}));
Assert.AreEqual(Loops, rowCount, "Loop count and row count should be equal");
}
public async Task ExecuteReaderAsync_WithManualDisposal_Timeouts()
{
TimeSpan commandTimeout = TimeSpan.FromSeconds(1);
SqlProgram <int> timeoutTest =
await
SqlProgram <int> .Create(
(Connection)DifferentLocalDatabaseConnectionString,
"spTimeoutTest",
defaultCommandTimeout : commandTimeout);
// Expose all the properties from the inner lambda.
dynamic result = await timeoutTest.ExecuteReaderAsync(
(reader, disposable, token) =>
Task.FromResult(new { Reader = reader, Disposable = disposable, Token = token }),
10)
.ConfigureAwait(false);
}
public async Task Test_DatabaseProgramCall_ParamOrderNotImportant_WrongOrderExecutesSuccessfully()
{
int rowCount = 0;
SqlProgram <int, string, decimal, bool> program =
await
DatabasesConfiguration.Active.GetSqlProgram <int, string, decimal, bool>(
"test",
ReturnsTableProcedureName,
"@intParam",
"@stringParam",
"@decimalParam",
"@boolParam",
true);
Assert.IsNotNull(program);
await program.ExecuteReaderAsync(
async (dataReader, cancellationToken) =>
{
Assert.IsNotNull(dataReader);
Assert.IsNotNull(cancellationToken);
while (await dataReader.ReadAsync(cancellationToken))
{
// Operation modes
Interlocked.Increment(ref rowCount);
Assert.AreEqual("system", dataReader.GetString(0), "Strings are not equal");
Assert.AreEqual(-1, dataReader.GetInt32(1), "Ints are not equal");
Assert.AreEqual(100M, dataReader.GetDecimal(2), "decimals are not equal");
Assert.AreEqual(true, dataReader.GetBoolean(3), "bools are not equal");
}
// ReSharper disable once PossibleNullReferenceException
await dataReader.NextResultAsync(cancellationToken);
// ReSharper disable once PossibleNullReferenceException
while (await dataReader.ReadAsync(cancellationToken))
{
// Guids
Interlocked.Increment(ref rowCount);
}
},
-1,
"system",
100M,
true);
}
public async Task ExecuteReaderAsync_WithReturnType_ExecutesAndReturnsExpectedResult()
{
SqlProgram readerTest =
await SqlProgram.Create((Connection)DifferentLocalDatabaseConnectionString, "spUltimateSproc");
Task <dynamic> result = readerTest.ExecuteReaderAsync(
async(reader, token) =>
{
if (await reader.ReadAsync(token))
{
return(CreateDatabaseResult(reader));
}
throw new Exception("Critical Test Error");
});
Assert.IsNotNull(result);
// Read the sproc defaults.
Assert.AreEqual("A Test String", result.Result.Name);
Assert.AreEqual(5, result.Result.Age);
Assert.AreEqual(200.15M, result.Result.Balance);
Assert.AreEqual(false, result.Result.IsValued);
}