public async Task GetAllIncludingTasksAsync()
        {
            using (var scope = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled))
            {
                var conn = databaseOptions.GetDbConnection;
                userDapper     = new UserRepository(conn);
                taskToDoDapper = new TaskToDoRepository(conn);

                var user1 = await userDapper.AddAsync(userBuilder.CreateUser());

                var user2 = await userDapper.AddAsync(userBuilder.CreateUser());

                var task1 = await taskToDoDapper.AddRangeAsync(taskToDoBuilder.CreateTaskToDoListWithUser(1, user1.Id));

                var task2 = await taskToDoDapper.AddRangeAsync(taskToDoBuilder.CreateTaskToDoListWithUser(2, user2.Id));

                var result = await userDapper.GetAllIncludingTasksAsync();

                var result1 = result.OrderBy(u => u.Id).FirstOrDefault();
                var result2 = result.OrderBy(u => u.Id).LastOrDefault();

                Assert.AreEqual(result1.Id, user1.Id);
                Assert.AreEqual(result2.Id, user2.Id);

                Assert.AreEqual(result1.TasksToDo.Count(), 1);
                Assert.AreEqual(result2.TasksToDo.Count(), 2);
            }
        }
 public void Inicializa()
 {
     userEntityFramework     = new UserRepository(dbContext);
     taskToDoEntityFramework = new TaskToDoRepository(dbContext);
     builder     = new UserBuilder();
     transaction = dbContext.Database.BeginTransaction();
 }
Exemple #3
0
        public void Inicializa()
        {
            var conn = databaseOptions.GetDbConnection;

            conn.Open();
            transaction     = conn.BeginTransaction();
            userDapper      = new UserRepository(conn, transaction);
            taskToDoDapper  = new TaskToDoRepository(conn, transaction);
            userBuilder     = new UserBuilder();
            taskToDoBuilder = new TaskToDoBuilder();
        }
Exemple #4
0
        public async Task GetByIdIncludingUserAsync()
        {
            using (var scope = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled))
            {
                var conn = databaseOptions.GetDbConnection;
                userDapper     = new UserRepository(conn);
                taskToDoDapper = new TaskToDoRepository(conn);

                var user = await userDapper.AddAsync(userBuilder.CreateUser());

                var task = await taskToDoDapper.AddAsync(taskToDoBuilder.CreateTaskToDoWithUser(user.Id));

                var result = await taskToDoDapper.GetByIdIncludingUserAsync(task.Id);

                Assert.AreEqual(result.UserId, user.Id);
            }
        }
 public TaskToDoService(ITaskToDoRepository repository) : base(repository)
 {
     _repository = repository;
 }