private NewNode New()
{
Token <TokenType> t = GetNextToken();
Assertion.AreEqual(TokenType.New, t.TokenType, "Should be new keyword.");
t = GetNextToken();
if (t.TokenType != TokenType.Left_Square_Bracket)
{
ExceptionHelper.ThrowExpectToken(TokenType.Left_Square_Bracket, t.Position);
}
Node typeNode = Obj();
Assertion.IsTrue(typeNode is ClassQualifierNode, "First object should be class qualifi node.");
ParamListNode paramList = ValueList();
t = GetNextToken();
if (t.TokenType != TokenType.Right_Square_Bracket)
{
ExceptionHelper.ThrowExpectToken(TokenType.Right_Square_Bracket, t.Position);
}
return(new NewNode(typeNode, paramList));
}
private void CanNotFoundUserWithAnInvalidId()
{
const int invalidId = 1234;
User userFoundById = _userService.FindByIdLazyMode(invalidId);
Assertion.AreEqual(0, userFoundById.Id);
}
private void CanInsertMoreThanOnePermission()
{
_permissionService.Insert(_permissionBuilder.Build());
_permissionService.Insert(_permissionBuilder.Build());
_permissionService.Insert(_permissionBuilder.Build());
Assertion.AreEqual(3, _permissionService.FindAll().Count);
}
private RegexNode Regex()
{
Token <TokenType> t = GetNextToken();
Assertion.AreEqual(TokenType.Regex, t.TokenType, "Should be regex keyword.");
t = GetNextToken();
if (t.TokenType != TokenType.Left_Square_Bracket)
{
ExceptionHelper.ThrowExpectToken(TokenType.Left_Square_Bracket, t.Position);
}
t = GetNextToken();
if (t.TokenType != TokenType.String)
{
ExceptionHelper.ThrowExpectToken(TokenType.String, t.Position);
}
RegexNode regex = new RegexNode(t);
t = GetNextToken();
if (t.TokenType != TokenType.Right_Square_Bracket)
{
ExceptionHelper.ThrowExpectToken(TokenType.Right_Square_Bracket, t.Position);
}
return(regex);
}
private void CanInsertAUserTest()
{
Assertion.AreEqual(0, _userService.FindAll().Count);
_userService.Insert(new UserBuilder().Build());
Assertion.AreEqual(1, _userService.FindAll().Count);
}
private void CanInsertMoreThanAGroup()
{
_groupService.Insert(_groupBuilder.Build());
_groupService.Insert(_groupBuilder.Build());
_groupService.Insert(_groupBuilder.Build());
Assertion.AreEqual(3, _groupService.FindAll().Count);
}
private void InsertUserDoesNotInsertAnIdiomTest()
{
Assertion.AreEqual(0, _idiomService.FindAll().Count);
_userService.Insert(new UserBuilder().Build());
Assertion.AreEqual(0, _idiomService.FindAll().Count);
}
private void CanInsertMoreThanOneUserTest()
{
_userService.Insert(new UserBuilder().Build());
_userService.Insert(new UserBuilder().Build());
_userService.Insert(new UserBuilder().Build());
Assertion.AreEqual(3, _userService.FindAll().Count);
}
private void CanDeleteAPermission()
{
int insertedIdiomId = _permissionService.Insert(_permissionBuilder.Build());
Assertion.AreEqual(1, _permissionService.FindAll().Count);
_permissionService.DeleteById(insertedIdiomId);
Assertion.AreEqual(0, _permissionService.FindAll().Count);
}
private void CanInsertMoreThanOneIdiom()
{
Assertion.AreEqual(0, _idiomService.FindAll().Count);
_idiomService.Insert(_idiomBuilder.Build());
_idiomService.Insert(_idiomBuilder.Build());
_idiomService.Insert(_idiomBuilder.Build());
Assertion.AreEqual(3, _idiomService.FindAll().Count);
}
private void CanDeleteAnIdiom()
{
Assertion.AreEqual(0, _idiomService.FindAll().Count);
int insertedIdiomId = _idiomService.Insert(_idiomBuilder.Build());
Assertion.AreEqual(1, _idiomService.FindAll().Count);
_idiomService.DeleteById(insertedIdiomId);
Assertion.AreEqual(0, _idiomService.FindAll().Count);
}
private void CanInsertAGroupWithNotInsertedPermissions()
{
Group aGroup = _groupBuilder
.WithPermissions(new MCollection <Permission> {
_permissionBuilder.Build()
})
.Build();
int insertedId = _groupService.Insert(aGroup);
Group insertedGroup = _groupService.FindById(insertedId);
Assertion.AreEqual(1, insertedGroup.Permissions.Count);
}
private void ExecuteQueryTest()
{
_database.ExecuteInsert(SqlCreateDummyTable, (command, newProperty) => {});
_database.ExecuteInsert("INSERT INTO DUMMY(DUMMY1, DUMMY2) VALUES ('D', 4)", (command, newProperty) => {});
_database.ExecuteInsert("INSERT INTO DUMMY(DUMMY1, DUMMY2) VALUES ('E', 5)", (command, newProperty) => {});
var dbRows = _database.ExecuteNativeQuery("SELECT * FROM DUMMY;", (command, newParameter) => { });
Assertion.AreEqual(2, dbRows.Count);
Assertion.AreEqual(2, dbRows[0].Columns.Count);
}
private void FindByIdLazyModeTest()
{
const string aDescription = "aDescription";
Permission aPermission = _permissionBuilder
.WithDescription(aDescription)
.Build();
int insertedPermissionId = _permissionService.Insert(aPermission);
Permission aPermissionFound = _permissionService.FindByIdLazyMode(insertedPermissionId);
Assertion.AreEqual(aDescription, aPermissionFound.Description);
}
private void FindByIdLazyModeIsLazy()
{
Idiom anIdiom = new IdiomBuilder().Build();
int anInsertedIdiomId = _idiomService.Insert(anIdiom);
Idiom anInsertedIdiom = _idiomService.FindByIdLazyMode(anInsertedIdiomId);
User aUser = new UserBuilder().WithIdiom(anInsertedIdiom).Build();
int insertedUserId = _userService.Insert(aUser);
User anInsertedUser = _userService.FindByIdLazyMode(insertedUserId);
Assertion.AreEqual("", anInsertedUser.Idiom.Description);
}
private void InsertUserWithInsertedGroupsTest()
{
Assertion.AreEqual(0, _groupService.FindAll().Count);
_groupService.Insert(new GroupBuilder().Build());
_groupService.Insert(new GroupBuilder().Build());
User aUser = new UserBuilder().WithGroups(_groupService.FindAll()).Build();
int insertedUserId = _userService.Insert(aUser);
User insertedUser = _userService.FindById(insertedUserId);
Assertion.AreEqual(2, insertedUser.Groups.Count);
}
private void InsertUserWithInsertedPermissionsTest()
{
Assertion.AreEqual(0, _permissionService.FindAll().Count);
_permissionService.Insert(new PermissionBuilder().Build());
_permissionService.Insert(new PermissionBuilder().Build());
User aUser = new UserBuilder().WithPermissions(_permissionService.FindAll()).Build();
int insertedUserId = _userService.Insert(aUser);
User insertedUser = _userService.FindById(insertedUserId);
Assertion.AreEqual(2, insertedUser.Permissions.Count);
}
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 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 InsertUserWithNonInsertedGroupsTest()
{
Assertion.AreEqual(0, _groupService.FindAll().Count);
User aUser = new UserBuilder()
.WithGroups(new MCollection <Group> {
new GroupBuilder().Build(),
new GroupBuilder().Build(),
new GroupBuilder().Build()
})
.Build();
int insertedUserId = _userService.Insert(aUser);
User insertedUser = _userService.FindById(insertedUserId);
Assertion.AreEqual(3, insertedUser.Groups.Count);
}
private void InsertUserWithNonInsertedPermissionsTest()
{
Assertion.AreEqual(0, _permissionService.FindAll().Count);
User aUser = new UserBuilder()
.WithPermissions(new MCollection <Permission> {
new PermissionBuilder().Build(),
new PermissionBuilder().Build(),
new PermissionBuilder().Build()
})
.Build();
int insertedUserId = _userService.Insert(aUser);
User insertedUser = _userService.FindById(insertedUserId);
Assertion.AreEqual(3, insertedUser.Permissions.Count);
}
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 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);
}
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 CanTransformAResultSetWithMoreThanOneItemTest()
{
DbRow dbRow1 = new DbRow();
dbRow1.Columns.Add(new DbColumn(typeof(string), "aColumn", null));
DbRow dbRow2 = new DbRow();
dbRow2.Columns.Add(new DbColumn(typeof(string), "aColumn", null));
IMCollection <DbRow> dbRows = new MCollection <DbRow> {
dbRow1, dbRow2
};
IResultTransformer <DummyClassToBeTransformed> resultTransformer = new ResultTransformer <DummyClassToBeTransformed>(dbRows);
Assertion.AreEqual(2, resultTransformer.Transform().Count);
}
private void CanFindUserWithAValidId()
{
const string aFirstName = "Marcelo";
const string aLastName = "Cabezas";
const string anEmail = "*****@*****.**";
User user = new UserBuilder()
.WithFirstName(aFirstName)
.WithLastName(aLastName)
.WithEmail(anEmail)
.Build();
int insertedId = _userService.Insert(user);
User userFoundById = _userService.FindByIdLazyMode(insertedId);
Assertion.AreEqual(aFirstName, userFoundById.FirstName);
Assertion.AreEqual(user.LastName, userFoundById.LastName);
Assertion.AreEqual(user.Email, userFoundById.Email);
}
public void OnlyFailures1()
{
var log = new Log(true);
var context = new StackTraceContext(GetType());
log.Add(Assertion.AreEqual(1, 1, context));
log.Add(Assertion.AreEqual(1, 1, context));
log.Add(Assertion.AreEqual(1, 2, context));
log.Add(Assertion.AreEqual(1, 1, context));
log.Add(Assertion.AreEqual(1, 2, context));
AreEqual(5, log.Count);
AreEqual(2, log.Failures);
IsFalse(log);
foreach (var assertion in log)
{
IsFalse(assertion);
}
}
private Node Array()
{
Token <TokenType> t = GetNextToken();
Assertion.AreEqual(TokenType.Array, t.TokenType, "Should be array keyword.");
t = GetNextToken();
if (t.TokenType != TokenType.Left_Square_Bracket)
{
ExceptionHelper.ThrowExpectToken(TokenType.Left_Square_Bracket, t.Position);
}
Node result = null;
Node node = Value();
Token <TokenType> separator = PeekNextToken();
switch (separator.TokenType)
{
case TokenType.Comma:
GetNextToken(); //Get the comma
var list = ValueList();
list.InsertNodeAtHead(node);
result = new ArrayNode((List <Node>)list.Values);
break;
case TokenType.Colon:
GetNextToken(); //Get Colon
var end = Value();
result = new AutoIntArrayNode(node, end);
break;
default:
ExceptionHelper.ThrowUnexpectedToken(separator.TokenType, separator.Position);
break;
}
t = GetNextToken();
if (t.TokenType != TokenType.Right_Square_Bracket)
{
ExceptionHelper.ThrowExpectToken(TokenType.Right_Square_Bracket, t.Position);
}
return(result);
}
public void Add(int a, int b)
{
var log = new Log(false);
var context = new StackTraceContext(GetType());
log.Add(Assertion.AreEqual(a, a, context));
log.Add(Assertion.AreEqual(a, a, context));
log.Add(Assertion.AreEqual(a, b, context));
AreEqual(3, log.Count);
if (a == b)
{
IsTrue(log);
}
else
{
AreEqual(1, log.Failures);
IsFalse(log);
}
}
private void FindByIdTest()
{
const string aDescription = "description";
Permission permission1 = _permissionBuilder.Build();
Permission permission2 = _permissionBuilder.Build();
Group aGroup = _groupBuilder
.WithDescription(aDescription)
.WithPermissions(new MCollection <Permission> {
permission1, permission2
})
.Build();
int insertedGroupId = _groupService.Insert(aGroup);
Group foundByIdLazyMode = _groupService.FindById(insertedGroupId);
Assertion.AreEqual(1, _groupService.FindAll().Count);
Assertion.AreEqual(aDescription, foundByIdLazyMode.Description);
Assertion.AreEqual(2, foundByIdLazyMode.Permissions.Count);
}
