private void InsertRelationshipWithPersistedPermissions(IMCollection <Permission> permissions, int groupId)
{
InsertPermissionsRelationship(
permissions.Filter(permission =>
new PersistedState().CanHandle(permission)),
groupId);
}
private void InsertRelationshipWithPersistedGroups(IMCollection <Group> groups, int insertedUserId)
{
InsertGroupsRelationship(
groups.Filter(permission =>
new PersistedState().CanHandle(permission)),
insertedUserId);
}
public void ExecuteTests()
{
IMCollection <Action> testMethods = Tests();
if (Predefined.IsEmpty(testMethods))
{
_logger.Log("[IGNORED] " + this + " There are no tests to be executed here...");
return;
}
if (IgnoreSuite())
{
_logger.Log("[IGNORED] " + this + " This suite is marked to be ignored");
return;
}
testMethods.ForEach(testMethod => {
try
{
SetUp();
testMethod();
OnSucceedTest(testMethod);
}
catch (Exception e)
{
OnFailedTest(testMethod);
_logger.Error(e.Message);
}
CleanUp();
});
}
public override IMCollection <User> FindAll()
{
const string query = "SELECT id, first_name, last_name FROM _user";
IMCollection <DbRow> dbRows = Database.ExecuteNativeQuery(query, (command, newParameter) => { });
ResultTransformer <User> transformer = new ResultTransformer <User>(dbRows);
return(transformer.Transform());
}
public override IMCollection <Group> FindAll()
{
const string query = "SELECT id, description FROM _group";
IMCollection <DbRow> dbRows = Database.ExecuteNativeQuery(query, (command, newParameter) => { });
ResultTransformer <Group> transformer = new ResultTransformer <Group>(dbRows);
return(transformer.Transform());
}
private void InsertRelationshipWithNonPersistedPermissions(IMCollection <Permission> permissions, int groupId)
{
IMCollection <Permission> permissionsNotInserted =
permissions.Filter(permission => new NotPersistedState().CanHandle(permission));
IMCollection <Permission> justInsertedPermissions = new PermissionDao().Insert(permissionsNotInserted);
InsertPermissionsRelationship(justInsertedPermissions, groupId);
}
private void InsertRelationshipWithNonPersistedGroups(IMCollection <Group> groups, int insertedUserId)
{
IMCollection <Group> groupsNotInserted =
groups.Filter(group => new NotPersistedState().CanHandle(group));
IMCollection <Group> justInsertedGroups = new GroupDao().Insert(groupsNotInserted);
InsertGroupsRelationship(justInsertedGroups, insertedUserId);
}
public void ExecuteSuites()
{
IMCollection <ITestSuite> suites = GetTestSuites();
PrepareSuite(statisticsService => {
suites.ForEach(suite => {
RunSuite(suite, statisticsService);
});
});
}
public override Group FindByIdLazyMode(int anId)
{
const string queryGroup = "SELECT id, description FROM _group WHERE id=@ID";
IMCollection <DbRow> dbRows = Database.ExecuteNativeQuery(queryGroup, (command, newParameter) =>
{
command.Parameters.Add(newParameter("@ID", DbType.Int32));
command.Parameters["@ID"].Value = anId;
});
ResultTransformer <Group> transformerGroup = new ResultTransformer <Group>(dbRows);
Group aGroup = transformerGroup.Transform().GetFirstOrDefault(new Group());
return(aGroup);
}
public override User FindByIdLazyMode(int anId)
{
const string query = "SELECT id, first_name, last_name, email, idiom_id FROM _user WHERE id=@ID";
IMCollection <DbRow> dbRows = Database.ExecuteNativeQuery(query, (command, newParameter) =>
{
command.Parameters.Add(newParameter("@ID", DbType.Int32));
command.Parameters["@ID"].Value = anId;
});
ResultTransformer <User> transformer = new ResultTransformer <User>(dbRows);
return(transformer.Transform().GetFirstOrDefault(new User()));
}
public override Permission FindByIdLazyMode(int anId)
{
const string query = "SELECT id, description FROM permission WHERE id=@ID";
IMCollection <DbRow> dbRows = Database.ExecuteNativeQuery(query, (command, newParameter) =>
{
command.Parameters.Add(newParameter("@ID", DbType.Int32));
command.Parameters["@ID"].Value = anId;
});
ResultTransformer <Permission> transformer = new ResultTransformer <Permission>(dbRows);
return(transformer.Transform().GetFirstOrDefault(new Permission()));
}
public IMCollection <Permission> Insert(IMCollection <Permission> permissions)
{
IMCollection <Permission> insertedPermissions = new MCollection <Permission>();
permissions.ForEach(permission =>
{
int permissionId = Insert(permission);
insertedPermissions.Add(new Permission
{
Id = permissionId, Description = permission.Description
});
});
return(insertedPermissions);
}
public IMCollection <Group> Insert(IMCollection <Group> groups)
{
IMCollection <Group> insertedPermissions = new MCollection <Group>();
groups.ForEach(group =>
{
int groupId = Insert(group);
insertedPermissions.Add(new Group()
{
Id = groupId, Description = group.Description, Permissions = group.Permissions
});
});
return(insertedPermissions);
}
private IMCollection <Group> FindGroupsByUserIdLazyMode(int aUserId)
{
const string queryUserPermission = "SELECT g.id, g.description "
+ "FROM user_group ug "
+ "join _GROUP g on ug.group_id=g.id "
+ "WHERE ug.user_id=@USER_ID ";
IMCollection <DbRow> dbGroupRows = Database.ExecuteNativeQuery(queryUserPermission, (command, newParameter) =>
{
command.Parameters.Add(newParameter("@USER_ID", DbType.Int32));
command.Parameters["@USER_ID"].Value = aUserId;
});
ResultTransformer <Group> transformerPermission = new ResultTransformer <Group>(dbGroupRows);
return(transformerPermission.Transform());
}
private IMCollection <Permission> FindPermissionsByGroupIdLazyMode(int aGroupId)
{
const string queryGroupPermission = "SELECT p.id, p.description "
+ "FROM group_permission gp "
+ "join PERMISSION p on gp.permission_id=p.id "
+ "WHERE gp.group_id=@GROUP_ID ";
IMCollection <DbRow> dbPermissionRows = Database.ExecuteNativeQuery(queryGroupPermission, (command, newParameter) =>
{
command.Parameters.Add(newParameter("@GROUP_ID", DbType.Int32));
command.Parameters["@GROUP_ID"].Value = aGroupId;
});
ResultTransformer <Permission> transformerPermission = new ResultTransformer <Permission>(dbPermissionRows);
return(transformerPermission.Transform());
}
public Logger(Type sourceClass)
{
_sourceClass = sourceClass;
_printers = new MCollection <IPrintable> {
new ConsolePrinter(),
new FilePrinter()
};
_loggers = new MCollection <ILoggable> {
new Info(),
// new Debug(),
new Error()
};
}
private void InsertPermissionsRelationship(IMCollection <Permission> permissions, int groupId)
{
permissions.ForEach(permission =>
{
const string queryGroupPermission = "INSERT INTO group_permission (group_id, permission_id) " +
"VALUES (@GROUP_ID, @PERMISSION_ID)";
Database.ExecuteSimpleInsert(queryGroupPermission, (command, newParameter) =>
{
command.Parameters.Add(newParameter("@GROUP_ID", DbType.Int32));
command.Parameters["@GROUP_ID"].Value = groupId;
command.Parameters.Add(newParameter("@PERMISSION_ID", DbType.Int32));
command.Parameters["@PERMISSION_ID"].Value = permission.Id;
});
}
);
}
private void CanTransformWithNullableValuesTest()
{
DbRow dbRow = new DbRow();
dbRow.Columns.Add(new DbColumn(typeof(string), "aColumn", null));
IMCollection <DbRow> dbRows = new MCollection <DbRow> {
dbRow
};
IResultTransformer <DummyClassToBeTransformed> resultTransformer = new ResultTransformer <DummyClassToBeTransformed>(dbRows);
IMCollection <DummyClassToBeTransformed> transformed = resultTransformer.Transform();
Assertion.AreEqual(1, transformed.Count);
Assertion.AreEqual(null, transformed[0].AName);
}
private void InsertGroupsRelationship(IMCollection <Group> groups, int userId)
{
groups.ForEach(group =>
{
const string queryGroupPermission = "INSERT INTO user_group (user_id, group_id) " +
"VALUES (@USER_ID, @GROUP_ID)";
Database.ExecuteSimpleInsert(queryGroupPermission, (command, newParameter) =>
{
command.Parameters.Add(newParameter("@USER_ID", DbType.Int32));
command.Parameters["@USER_ID"].Value = userId;
command.Parameters.Add(newParameter("@GROUP_ID", DbType.Int32));
command.Parameters["@GROUP_ID"].Value = group.Id;
});
}
);
}
private void CanTransformIgnoringUnderscoreInColumnNameTest()
{
const string columnName = "A_NAME";
DbRow dbRow = new DbRow();
dbRow.Columns.Add(new DbColumn(typeof(string), columnName, DummyStringValue));
IMCollection <DbRow> dbRows = new MCollection <DbRow> {
dbRow
};
IResultTransformer <DummyClassToBeTransformed> resultTransformer = new ResultTransformer <DummyClassToBeTransformed>(dbRows);
IMCollection <DummyClassToBeTransformed> transformed = resultTransformer.Transform();
Assertion.AreEqual(DummyStringValue, transformed[0].AName);
}
private void CanTransformAnIntTypeTest()
{
const string columnName = "aInt";
DbRow dbRow = new DbRow();
dbRow.Columns.Add(new DbColumn(typeof(int), columnName, DummyIntValue));
IMCollection <DbRow> dbRows = new MCollection <DbRow> {
dbRow
};
IResultTransformer <DummyClassToBeTransformed> resultTransformer = new ResultTransformer <DummyClassToBeTransformed>(dbRows);
IMCollection <DummyClassToBeTransformed> transformed = resultTransformer.Transform();
Assertion.AreEqual(DummyIntValue, transformed[0].AInt);
}
private void CanTransformABigIntegerTypeTest()
{
const string columnName = "aBigInteger";
DbRow dbRow = new DbRow();
dbRow.Columns.Add(new DbColumn(typeof(BigInteger), columnName, _dummyBigIntegerValue));
IMCollection <DbRow> dbRows = new MCollection <DbRow> {
dbRow
};
IResultTransformer <DummyClassToBeTransformed> resultTransformer = new ResultTransformer <DummyClassToBeTransformed>(dbRows);
IMCollection <DummyClassToBeTransformed> transformed = resultTransformer.Transform();
Assertion.AreEqual(_dummyBigIntegerValue, transformed[0].ABigInteger);
}
private void CanTransformWithNotRecognizedColumnsTest()
{
const string dummyColumnName = "dummyName";
DbRow dbRow = new DbRow();
dbRow.Columns.Add(new DbColumn(typeof(string), dummyColumnName, DummyStringValue));
IMCollection <DbRow> dbRows = new MCollection <DbRow> {
dbRow
};
IResultTransformer <DummyClassToBeTransformed> resultTransformer = new ResultTransformer <DummyClassToBeTransformed>(dbRows);
IMCollection <DummyClassToBeTransformed> transformed = resultTransformer.Transform();
Assertion.AreEqual(null, transformed[0].AName);
}
public GroupBuilder WithPermissions(IMCollection <Permission> permissions)
{
_permissions = permissions;
return(this);
}
public IConfiguration ToHandleTestConfiguration(IMCollection <string> args)
{
return(Executors.Filter(configuration => configuration.CanHandle(args)).GetFirst());
}
public static bool IsEmpty <T>(IMCollection <T> e)
{
return(e?.Count == 0);
}
public UserBuilder WithGroups(IMCollection <Group> groups)
{
_groups = groups;
return(this);
}
public bool CanHandle(IMCollection <string> tests)
{
return(tests.IsEmpty());
}
public SuiteRunner(string module, IEnumerable <string> tests)
{
_configuration = new MCollection <string>().From(tests);
_module = module;
}
public TestStatisticsService()
{
_testCasesStatistics = new MCollection <ITestCaseState>();
}
