Skip to content

Commit 9c2dc74

Browse files
abhinavminhasabhinavminhas
committed
Addition - Execute Scalar Async
1 parent f744de3 commit 9c2dc74

File tree

10 files changed

+1311
-12
lines changed

10 files changed

+1311
-12
lines changed

‎QueryDB.Core.Tests/MSSQLTests.cs

Lines changed: 251 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -678,6 +678,92 @@ public void Test_MSSQL_ExecuteScalar_As_StringReturn_UnsupportedCommands()
678678

679679
#endregion
680680

681+
#region Execute Scalar Async Tests - << Task<string> ExecuteScalarAsync(string sqlStatement) >>
682+
683+
[TestMethod]
684+
[TestCategory(DB_TESTS), TestCategory(MSSQL_TESTS)]
685+
public async Task Test_MSSQL_ExecuteScalarAsync_As_StringReturn_Scalar_Queries()
686+
{
687+
var countOfRecords = Queries.MSSQLQueries.TestDB.ScalarQueries.Count_Of_Records;
688+
var max = Queries.MSSQLQueries.TestDB.ScalarQueries.Max;
689+
var min = Queries.MSSQLQueries.TestDB.ScalarQueries.Min;
690+
var sum = Queries.MSSQLQueries.TestDB.ScalarQueries.Sum;
691+
var avg = Queries.MSSQLQueries.TestDB.ScalarQueries.Avg;
692+
var singleValueSelect = Queries.MSSQLQueries.TestDB.ScalarQueries.Single_Value_Select;
693+
694+
var dbContext = new DBContext(DB.MSSQL, MSSQLConnectionString);
695+
696+
var count = await dbContext.ExecuteScalarAsync(countOfRecords);
697+
Assert.AreEqual("12", count);
698+
var maxValue = await dbContext.ExecuteScalarAsync(max);
699+
Assert.AreEqual("10000.00", maxValue);
700+
var minValue = await dbContext.ExecuteScalarAsync(min);
701+
Assert.AreEqual("3000.00", minValue);
702+
var sumValue = await dbContext.ExecuteScalarAsync(sum);
703+
Assert.AreEqual("161000.00", sumValue);
704+
var avgValue = await dbContext.ExecuteScalarAsync(avg);
705+
Assert.AreEqual("6520.000000", avgValue);
706+
var singleValue = await dbContext.ExecuteScalarAsync(singleValueSelect);
707+
Assert.AreEqual("2", singleValue);
708+
}
709+
710+
[TestMethod]
711+
[TestCategory(DB_TESTS), TestCategory(MSSQL_TESTS)]
712+
public async Task Test_MSSQL_ExecuteScalarAsync_As_StringReturn_DefaultValue()
713+
{
714+
var noValueReturned = Queries.MSSQLQueries.TestDB.ScalarQueries.No_Value_Returned;
715+
var dBNullValue = Queries.MSSQLQueries.TestDB.ScalarQueries.DB_Null_Value;
716+
717+
var dbContext = new DBContext(DB.MSSQL, MSSQLConnectionString);
718+
719+
var result = await dbContext .ExecuteScalarAsync(noValueReturned);
720+
Assert.IsInstanceOfType<string>(result);
721+
Assert.AreEqual("", result);
722+
723+
result = await dbContext.ExecuteScalarAsync(dBNullValue);
724+
Assert.IsInstanceOfType<string>(result);
725+
Assert.AreEqual(string.Empty, result);
726+
}
727+
728+
[TestMethod]
729+
[TestCategory(DB_TESTS), TestCategory(MSSQL_TESTS)]
730+
public async Task Test_MSSQL_ExecuteScalarAsync_As_StringReturn_UnsupportedCommands()
731+
{
732+
var sqlStatements = new List<string>
733+
{
734+
Queries.MSSQLQueries.TestDB.DDL.Create_Table,
735+
Queries.MSSQLQueries.TestDB.DDL.Alter_Table,
736+
Queries.MSSQLQueries.TestDB.DDL.Comment_Table,
737+
Queries.MSSQLQueries.TestDB.DDL.Truncate_Table,
738+
Queries.MSSQLQueries.TestDB.DDL.Drop_Table,
739+
740+
Queries.MSSQLQueries.TestDB.DML.InsertSql,
741+
Queries.MSSQLQueries.TestDB.DML.UpdateSql,
742+
Queries.MSSQLQueries.TestDB.DML.DeleteSql,
743+
744+
Queries.MSSQLQueries.TestDB.DCL.GrantSql_Command_Table_User,
745+
Queries.MSSQLQueries.TestDB.DCL.RevokeSql_Command_Table_User
746+
};
747+
748+
foreach (var sqlStatement in sqlStatements)
749+
{
750+
try
751+
{
752+
var dbContext = new DBContext(DB.MSSQL, MSSQLConnectionString);
753+
await dbContext.ExecuteScalarAsync(sqlStatement);
754+
Assert.Fail("No Exception");
755+
}
756+
catch (QueryDBException ex)
757+
{
758+
Assert.AreEqual("Only SELECT queries are supported here.", ex.Message);
759+
Assert.AreEqual("UnsupportedCommand", ex.ErrorType);
760+
Assert.AreEqual("'ExecuteScalar' only supports SELECT queries that have a scalar (single value) return.", ex.AdditionalInfo);
761+
}
762+
}
763+
}
764+
765+
#endregion
766+
681767
#region Execute Scalar Tests - << T ExecuteScalar<T>(string sqlStatement) >>
682768

683769
[TestMethod]
@@ -843,6 +929,171 @@ public void Test_MSSQL_ExecuteScalar_As_TypedReturn_UnsupportedCommands()
843929

844930
#endregion
845931

932+
#region Execute Scalar Async Tests - << Task<T> ExecuteScalarAsync<T>(string sqlStatement) >>
933+
934+
[TestMethod]
935+
[TestCategory(DB_TESTS), TestCategory(MSSQL_TESTS)]
936+
public async Task Test_MSSQL_ExecuteScalarAsync_As_TypedReturn_Scalar_Queries()
937+
{
938+
var countOfRecords = Queries.MSSQLQueries.TestDB.ScalarQueries.Count_Of_Records;
939+
var max = Queries.MSSQLQueries.TestDB.ScalarQueries.Max;
940+
var min = Queries.MSSQLQueries.TestDB.ScalarQueries.Min;
941+
var sum = Queries.MSSQLQueries.TestDB.ScalarQueries.Sum;
942+
var avg = Queries.MSSQLQueries.TestDB.ScalarQueries.Avg;
943+
var singleValueSelect = Queries.MSSQLQueries.TestDB.ScalarQueries.Single_Value_Select;
944+
945+
var dbContext = new DBContext(DB.MSSQL, MSSQLConnectionString);
946+
947+
var count = await dbContext.ExecuteScalarAsync<int>(countOfRecords);
948+
Assert.AreEqual(12, count);
949+
var maxValue = await dbContext.ExecuteScalarAsync<float>(max);
950+
Assert.AreEqual(10000.00, maxValue);
951+
var minValue = await dbContext.ExecuteScalarAsync<float>(min);
952+
Assert.AreEqual(3000.00, minValue);
953+
var sumValue = await dbContext.ExecuteScalarAsync<float>(sum);
954+
Assert.AreEqual(161000.00, sumValue);
955+
var avgValue = await dbContext.ExecuteScalarAsync<decimal>(avg);
956+
Assert.AreEqual((decimal)6520.000000, avgValue);
957+
var singleValue = await dbContext.ExecuteScalarAsync<string>(singleValueSelect);
958+
Assert.AreEqual("2", singleValue);
959+
}
960+
961+
[TestMethod]
962+
[TestCategory(DB_TESTS), TestCategory(MSSQL_TESTS)]
963+
public async Task Test_MSSQL_ExecuteScalarAsync_As_TypedReturn_DefaultValue()
964+
{
965+
var dBNullValue = Queries.MSSQLQueries.TestDB.ScalarQueries.DB_Null_Value;
966+
967+
var dbContext = new DBContext(DB.MSSQL, MSSQLConnectionString);
968+
969+
dynamic result = await dbContext.ExecuteScalarAsync<int>(dBNullValue);
970+
Assert.IsInstanceOfType<int>(result);
971+
Assert.AreEqual(default(int), result);
972+
973+
result = await dbContext.ExecuteScalarAsync<long>(dBNullValue);
974+
Assert.IsInstanceOfType<long>(result);
975+
Assert.AreEqual(default(long), result);
976+
977+
result = await dbContext.ExecuteScalarAsync<short>(dBNullValue);
978+
Assert.IsInstanceOfType<short>(result);
979+
Assert.AreEqual(default(short), result);
980+
981+
result = await dbContext.ExecuteScalarAsync<uint>(dBNullValue);
982+
Assert.IsInstanceOfType<uint>(result);
983+
Assert.AreEqual(default(uint), result);
984+
985+
result = await dbContext.ExecuteScalarAsync<ulong>(dBNullValue);
986+
Assert.IsInstanceOfType<ulong>(result);
987+
Assert.AreEqual(default(ulong), result);
988+
989+
result = await dbContext.ExecuteScalarAsync<ushort>(dBNullValue);
990+
Assert.IsInstanceOfType<ushort>(result);
991+
Assert.AreEqual(default(ushort), result);
992+
993+
result = await dbContext.ExecuteScalarAsync<decimal>(dBNullValue);
994+
Assert.IsInstanceOfType<decimal>(result);
995+
Assert.AreEqual(default(decimal), result);
996+
997+
result = await dbContext.ExecuteScalarAsync<double>(dBNullValue);
998+
Assert.IsInstanceOfType<double>(result);
999+
Assert.AreEqual(default(double), result);
1000+
1001+
result = await dbContext.ExecuteScalarAsync<float>(dBNullValue);
1002+
Assert.IsInstanceOfType<float>(result);
1003+
Assert.AreEqual(default(float), result);
1004+
1005+
result = await dbContext.ExecuteScalarAsync<byte>(dBNullValue);
1006+
Assert.IsInstanceOfType<byte>(result);
1007+
Assert.AreEqual(default(byte), result);
1008+
1009+
result = await dbContext.ExecuteScalarAsync<bool>(dBNullValue);
1010+
Assert.IsInstanceOfType<bool>(result);
1011+
Assert.AreEqual(default(bool), result);
1012+
1013+
result = await dbContext.ExecuteScalarAsync<DateTime>(dBNullValue);
1014+
Assert.IsInstanceOfType<DateTime>(result);
1015+
Assert.AreEqual(default(DateTime), result);
1016+
1017+
result = await dbContext.ExecuteScalarAsync<Guid>(dBNullValue);
1018+
Assert.IsInstanceOfType<Guid>(result);
1019+
Assert.AreEqual(default(Guid), result);
1020+
1021+
result = await dbContext.ExecuteScalarAsync<string>(dBNullValue);
1022+
Assert.IsNull(result);
1023+
Assert.AreEqual(default(string), result);
1024+
1025+
result = await dbContext.ExecuteScalarAsync<int?>(dBNullValue);
1026+
Assert.IsNull(result);
1027+
Assert.AreEqual(default(int?), result);
1028+
1029+
result = await dbContext.ExecuteScalarAsync<long?>(dBNullValue);
1030+
Assert.IsNull(result);
1031+
Assert.AreEqual(default(long?), result);
1032+
1033+
result = await dbContext.ExecuteScalarAsync<short?>(dBNullValue);
1034+
Assert.IsNull(result);
1035+
Assert.AreEqual(default(short?), result);
1036+
1037+
result = await dbContext.ExecuteScalarAsync<decimal?>(dBNullValue);
1038+
Assert.IsNull(result);
1039+
Assert.AreEqual(default(decimal?), result);
1040+
1041+
result = await dbContext.ExecuteScalarAsync<double?>(dBNullValue);
1042+
Assert.IsNull(result);
1043+
Assert.AreEqual(default(double?), result);
1044+
1045+
result = await dbContext.ExecuteScalarAsync<float?>(dBNullValue);
1046+
Assert.IsNull(result);
1047+
Assert.AreEqual(default(float?), result);
1048+
1049+
result = await dbContext.ExecuteScalarAsync<bool?>(dBNullValue);
1050+
Assert.IsNull(result);
1051+
Assert.AreEqual(default(bool?), result);
1052+
1053+
result = await dbContext.ExecuteScalarAsync<DateTime?>(dBNullValue);
1054+
Assert.IsNull(result);
1055+
Assert.AreEqual(default(DateTime?), result);
1056+
}
1057+
1058+
[TestMethod]
1059+
[TestCategory(DB_TESTS), TestCategory(MSSQL_TESTS)]
1060+
public async Task Test_MSSQL_ExecuteScalarAsync_As_TypedReturn_UnsupportedCommands()
1061+
{
1062+
var sqlStatements = new List<string>
1063+
{
1064+
Queries.MSSQLQueries.TestDB.DDL.Create_Table,
1065+
Queries.MSSQLQueries.TestDB.DDL.Alter_Table,
1066+
Queries.MSSQLQueries.TestDB.DDL.Comment_Table,
1067+
Queries.MSSQLQueries.TestDB.DDL.Truncate_Table,
1068+
Queries.MSSQLQueries.TestDB.DDL.Drop_Table,
1069+
1070+
Queries.MSSQLQueries.TestDB.DML.InsertSql,
1071+
Queries.MSSQLQueries.TestDB.DML.UpdateSql,
1072+
Queries.MSSQLQueries.TestDB.DML.DeleteSql,
1073+
1074+
Queries.MSSQLQueries.TestDB.DCL.GrantSql_Command_Table_User,
1075+
Queries.MSSQLQueries.TestDB.DCL.RevokeSql_Command_Table_User
1076+
};
1077+
1078+
foreach (var sqlStatement in sqlStatements)
1079+
{
1080+
try
1081+
{
1082+
var dbContext = new DBContext(DB.MSSQL, MSSQLConnectionString);
1083+
await dbContext.ExecuteScalarAsync<string>(sqlStatement);
1084+
Assert.Fail("No Exception");
1085+
}
1086+
catch (QueryDBException ex)
1087+
{
1088+
Assert.AreEqual("Only SELECT queries are supported here.", ex.Message);
1089+
Assert.AreEqual("UnsupportedCommand", ex.ErrorType);
1090+
Assert.AreEqual("'ExecuteScalar' only supports SELECT queries that have a scalar (single value) return.", ex.AdditionalInfo);
1091+
}
1092+
}
1093+
}
1094+
1095+
#endregion
1096+
8461097
#region Execute Command Tests - << int ExecuteCommand(string sqlStatement) >>
8471098

8481099
[TestMethod]

0 commit comments

Comments
 (0)