public async Task ExecuteNonQueryAllAsync_WithOutputParametersAndMultiOut_ExecutesSuccessfully()
{
SqlProgram <int, Out <int>, Out <int> > program =
await SqlProgram <int, Out <int>, Out <int> > .Create(
new LoadBalancedConnection(LocalDatabaseConnectionString, LocalDatabaseCopyConnectionString),
"spOutputParameters");
const int inputVal = 123;
const int inputOutputVal = 321;
MultiOut <int> inputOutput = new MultiOut <int>(inputOutputVal);
MultiOut <int> output = new MultiOut <int>();
int[] nonQueryResult = (await program.ExecuteNonQueryAllAsync(inputVal, inputOutput, output)).ToArray();
Assert.AreEqual(2, nonQueryResult.Length);
Assert.IsTrue(nonQueryResult.All(i => i == -1));
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);
Assert.IsTrue(inputOutput.All(o => o.OutputValue.Value == inputOutputVal * 2));
Assert.IsTrue(output.All(o => o.OutputValue.Value == inputVal));
}
public async Task Constructor_WithDefaults_SetsCommandTimeoutToThirtySeconds()
{
SqlProgram program = await SqlProgram.Create((Connection)LocalDatabaseConnectionString, "spNonQuery");
Assert.IsNotNull(program);
Assert.AreEqual(TimeSpan.FromSeconds(30), program.DefaultCommandTimeout);
}
public async Task ExecuteReader_ExecutesSuccessfully()
{
SqlProgram readerTest = await SqlProgram.Create((Connection)DifferentLocalDatabaseConnectionString,
name : "spUltimateSproc");
readerTest.ExecuteReader();
}
public async Task ExecuteXmlReaderAsync_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>();
XElement result = await program.ExecuteXmlReaderAsync(
async (reader, token) => XElement.Load(reader),
inputVal,
inputOutput,
output);
Assert.AreEqual("<foo>bar</foo>", result.ToString());
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 ExecuteReader_WithEnumerableKeyValuePairParameter_ReturnsTwoColumnTableMatchingTheParameterTypes()
{
SqlProgram <IEnumerable <KeyValuePair <int, string> > > tableTypeTest =
await SqlProgram <IEnumerable <KeyValuePair <int, string> > > .Create((Connection)DifferentLocalDatabaseConnectionString, "spTakesKvpTable");
string str1 = Random.RandomString(10, false);
string str2 = Random.RandomString(10, false);
string str3 = Random.RandomString(10, false);
IDictionary <int, string> result = tableTypeTest.ExecuteReader(
reader =>
{
IDictionary <int, string> resultSet = new Dictionary <int, string>();
while (reader.Read())
{
resultSet.Add(reader.GetValue <int>(0), reader.GetValue <string>(1));
}
return(resultSet);
},
new Dictionary <int, string>
{
{ 0, str1 },
{ 1, str2 },
{ 2, str3 }
});
Assert.AreEqual(3, result.Count);
Assert.AreEqual(str1, result[0]);
Assert.AreEqual(str2, result[1]);
Assert.AreEqual(str3, result[2]);
}
public async Task ExecuteXmlReaderAllAsync_WithOutputParametersAndMultiOut_ExecutesSuccessfully()
{
SqlProgram <int, Out <int>, Out <int> > program =
await SqlProgram <int, Out <int>, Out <int> > .Create(
new LoadBalancedConnection(LocalDatabaseConnectionString, LocalDatabaseCopyConnectionString),
"spOutputParameters");
const int inputVal = 123;
const int inputOutputVal = 321;
MultiOut <int> inputOutput = new MultiOut <int>(inputOutputVal);
MultiOut <int> output = new MultiOut <int>();
XElement[] result = (await program.ExecuteXmlReaderAllAsync(
async(reader, token) => XElement.Load(reader),
inputVal,
inputOutput,
output)).ToArray();
Assert.AreEqual(2, result.Length);
Assert.IsTrue(result.All(i => i.ToString() == "<foo>bar</foo>"));
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);
Assert.IsTrue(inputOutput.All(o => o.OutputValue.Value == inputOutputVal * 2));
Assert.IsTrue(output.All(o => o.OutputValue.Value == inputVal));
}
public async Task ExecuteNonQuery_WithTupleParameterAndOtherParameters_ExecutesSuccessfully()
{
SqlProgram <IEnumerable <Tuple <string, string, string, DateTime, short?> >, int, DateTime> tableTypeTest =
await SqlProgram <IEnumerable <Tuple <string, string, string, DateTime, short?> >, int, DateTime> .Create(
(Connection)DifferentLocalDatabaseConnectionString, "spTakesTupleTablePlusTwo");
List <TestType> myList =
new List <TestType>
{
new TestType
{
Name = Random.RandomString(100),
Body = Random.RandomString(500),
Email = Random.RandomString(100),
Created = DateTime.Today,
LoginId = null
}
};
int nonQueryResult =
tableTypeTest.ExecuteNonQuery(
myList.ToTuple(e => e.Name, e => e.Body, e => e.Email, e => e.Created, e => e.LoginId),
Random.RandomInt32());
Assert.AreEqual(-1, nonQueryResult);
}
public async Task ExecuteScalarAll_WithOutputParametersAndMultiOut_ExecutesSuccessfully()
{
SqlProgram <int, Out <int>, Out <int> > program =
await SqlProgram <int, Out <int>, Out <int> > .Create(
new LoadBalancedConnection(LocalDatabaseConnectionString, LocalDatabaseCopyConnectionString),
"spOutputParameters");
const int inputVal = 123;
const int inputOutputVal = 321;
MultiOut <int> inputOutput = new MultiOut <int>(inputOutputVal);
MultiOut <int> output = new MultiOut <int>();
string[] scalarResult = program.ExecuteScalarAll <string>(inputVal, inputOutput, output).ToArray();
Assert.AreEqual(2, scalarResult.Length);
Assert.IsTrue(scalarResult.All(i => i == "<foo>bar</foo>"));
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);
Assert.IsTrue(inputOutput.All(o => o.OutputValue.Value == inputOutputVal * 2));
Assert.IsTrue(output.All(o => o.OutputValue.Value == inputVal));
}
public async Task ExecuteReader_WithReturnResultSet_ExecutesSuccessfully()
{
SqlProgram readerTest = await SqlProgram.Create((Connection)DifferentLocalDatabaseConnectionString,
name : "spUltimateSproc");
dynamic result = readerTest.ExecuteReader <dynamic>(
reader =>
{
Assert.IsTrue(reader.Read());
var res = new
{
Name = reader.GetValue <string>(0),
Age = reader.GetValue <int>(1),
Balance = reader.GetValue <decimal>(2),
IsValued = reader.GetValue <bool>(3)
};
Assert.IsFalse(reader.Read());
Assert.IsFalse(reader.NextResult());
return(res);
});
Assert.IsNotNull(result);
// Read the sproc defaults.
Assert.AreEqual("A Test String", result.Name);
Assert.AreEqual(5, result.Age);
Assert.AreEqual(200.15M, result.Balance);
Assert.AreEqual(false, result.IsValued);
}
public async Task ExecuteReader_WithSerializableObjectParameter_ReturnsByteArray()
{
SqlProgram <TestSerializableObject> serializeObjectTest = await SqlProgram <TestSerializableObject> .Create((Connection)DifferentLocalDatabaseConnectionString, "spTakeByteArray");
TestSerializableObject objecToSerialize = new TestSerializableObject {
String1 = Random.RandomString(), String2 = Random.RandomString()
};
serializeObjectTest.ExecuteReader(
reader =>
{
Assert.IsTrue(reader.Read());
Assert.IsInstanceOfType(reader.GetValue(0), typeof(byte[]));
// Deserialize object
TestSerializableObject deserializedObject =
(TestSerializableObject)reader.GetObjectByName(reader.GetName(0));
// Check we don't have same object instance.
Assert.IsFalse(ReferenceEquals(objecToSerialize, deserializedObject));
// Check equality of object instances using equality method.
Assert.AreEqual(objecToSerialize, deserializedObject);
},
objecToSerialize);
}
public async Task ExecuteXmlReaderAsync_WithNoParameters_ExecuteReturnsExpectedString()
{
SqlProgram program = await SqlProgram.Create((Connection)DifferentLocalDatabaseConnectionString, name : "spReturnsXml");
XElement result = await program.ExecuteXmlReaderAsync(async (reader, token) => XElement.Load(reader));
Assert.AreEqual("<foo>bar</foo>", result.ToString());
}
public async Task Constructor_WithInvalidProgramName_ThrowsLoggingException()
{
SqlProgram <int> timeoutTest = await SqlProgram <int> .Create(
(Connection)DifferentLocalDatabaseConnectionString,
"invalidProgramName");
Assert.IsNotNull(timeoutTest);
}
private void initProgram()
{
//初始化新增模版里程序下拉列表
string sql = "SELECT PROGRAM_CODE,PROGRAM_NAME FROM CODE_PROGRAM WHERE COMPANY_CODE = '" + theCompanyCode + "'";
SqlProgram.SelectCommand = sql;
SqlProgram.DataBind();
}
public async Task ExecuteNonQuery_WithMoreNullableDateTimeParameterSetToNull_ExecutesSuccessfully()
{
var nullableTypesTest =
await SqlProgram <int, DateTime?, DateTime?, DateTime?, DateTime?, int?, int?, int?> .Create((Connection)DifferentLocalDatabaseConnectionString, "spLoadsOfNullables");
nullableTypesTest.ExecuteNonQuery(1, null, null, null, null, null, null, 1);
Assert.IsNotNull(nullableTypesTest);
}
public async Task ExecuteNonQuery_WithNullableDateTimeParameterSetToNull_ExecutesSuccessfully()
{
SqlProgram <string, int?, decimal, bool, DateTime?> nullableTypesTest =
await SqlProgram <string, int?, decimal, bool, DateTime?> .Create((Connection)DifferentLocalDatabaseConnectionString, "spUltimateSproc");
nullableTypesTest.ExecuteNonQuery(Random.RandomString(20), Random.RandomInt32(), decimal.Zero, true, null);
Assert.IsNotNull(nullableTypesTest);
}
public async Task ExecuteNonQuery_ExecutesSuccessfully()
{
SqlProgram nonQueryTest = await SqlProgram.Create((Connection)LocalDatabaseConnectionString, name : "spNonQuery");
int nonQueryResult = nonQueryTest.ExecuteNonQuery();
Assert.AreEqual(-1, nonQueryResult);
}
public async Task ExecuteScalar_WithNoParameters_ExecuteReturnsExpectedString()
{
SqlProgram program = await SqlProgram.Create((Connection)DifferentLocalDatabaseConnectionString, name : "spReturnsScalar");
string scalarResult = program.ExecuteScalar <string>();
Assert.AreEqual("HelloWorld", scalarResult);
}
public async Task ExecuteNonQueryAsync_PassNullToNonOptionalParameter()
{
SqlProgram <XElement> program =
await SqlProgram <XElement> .Create((Connection)DifferentLocalDatabaseConnectionString, "spTakesXml");
// ReSharper disable once RedundantArgumentDefaultValue, ArgumentsStyleLiteral
await program.ExecuteNonQueryAsync(p1Value : null);
}
public async Task Test_UnmappedProgram_RunsAndReturnsExpectedResult()
{
DatabasesConfiguration configuration = DatabasesConfiguration.Active;
SqlProgram unmappedProgram = await configuration.GetSqlProgram("test2", "spReturnsScalar");
Assert.AreEqual("spReturnsScalar", unmappedProgram.Name);
Assert.AreEqual("HelloWorld", await unmappedProgram.ExecuteScalarAsync <string>());
}
public async Task ExecuteNonQuery_WithEnumerableIntParameter_ExecutesSuccessfully()
{
SqlProgram <IEnumerable <int> > tableTypeTest =
await SqlProgram <IEnumerable <int> > .Create((Connection)DifferentLocalDatabaseConnectionString, "spTakesIntTable");
int nonQueryResult = tableTypeTest.ExecuteNonQuery(new[] { 1, 2, 3, 4 });
Assert.AreEqual(-1, nonQueryResult);
}
/// <summary>
/// Initializes a new instance of the <see cref="SqlProgramExecutionException"/> class.
/// </summary>
/// <param name="sqlProgram">The executing SQL program.</param>
/// <param name="innerException">The inner exception.</param>
internal SqlProgramExecutionException([NotNull] SqlProgram sqlProgram, [NotNull] Exception innerException)
: base(
new LogContext()
.Set(_prefixReservation, ProgramNameContextKey, sqlProgram.Name),
innerException,
() => Resources.SqlProgramExecutionException_ErrorOccurredDuringExecution,
sqlProgram.Name,
innerException.Message)
{
}
public async Task ExecuteReaderAll_ExecutesSuccessfully()
{
SqlProgram readerTest =
await SqlProgram.Create(connection : new LoadBalancedConnection(LocalDatabaseConnectionString, LocalDatabaseCopyConnectionString),
name : "spNonQuery");
readerTest.ExecuteReaderAll();
// Can't really do any assertions here so test is just that it doesn't throw an exception.
}
