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); }