Exemple #1
0
        public async Task EditAsync_ShouldEditACard()
        {
            using (var db = new ATMContext(TestOptions.TestDbContextOptions <ATMContext>()))
            {
                // Arrange
                var initCards = ACTION_RESULTS;
                await db.AddRangeAsync(initCards);

                await db.SaveChangesAsync();

                IRepository <UserActionResult> repository = new DBUserActionResultRepository(db);

                var expectedCards = await repository.GetAllAsync();

                var cardToEdit = expectedCards.First();
                expectedCards.Remove(cardToEdit);

                cardToEdit.WithdrawalAmount += 1.00M;
                expectedCards.Add(cardToEdit);

                // Act
                await repository.EditAsync(cardToEdit);

                var result = await repository.GetAllAsync();

                // Assert

                var actualCards = Assert.IsAssignableFrom <List <UserActionResult> >(result);
                Assert.Equal(
                    expectedCards.OrderBy(x => x.Id).Select(x => (id: x.Id, cid: x.CreditCardId, time: x.TimeStamp, operationCode: x.OperationCode, withdrawal: x.WithdrawalAmount)),
                    actualCards.OrderBy(x => x.Id).Select(x => (id: x.Id, cid: x.CreditCardId, time: x.TimeStamp, operationCode: x.OperationCode, withdrawal: x.WithdrawalAmount)));
            }
        }
Exemple #2
0
        public async Task AddAsync_ShouldAddANewAction()
        {
            using (var db = new ATMContext(TestOptions.TestDbContextOptions <ATMContext>()))
            {
                // Arrange
                var expectedDbAction = ACTION_NOT_IN_SEEDING_ACTIONS;
                var initActions      = ACTION_RESULTS;
                if (initActions.Exists(a => a.Id == expectedDbAction.Id))
                {
                    throw new InvalidOperationException($"Seeding actions already contain the action that is not supposed to be there: {expectedDbAction}");
                }
                await db.AddRangeAsync(initActions);

                await db.SaveChangesAsync();

                IRepository <UserActionResult> repository = new DBUserActionResultRepository(db);

                var expectedActions = await repository.GetAllAsync();

                expectedActions.Add(expectedDbAction);

                // Act
                await repository.AddAsync(expectedDbAction);

                var result = await repository.GetAllAsync();

                // Assert

                var actualActions = Assert.IsAssignableFrom <List <UserActionResult> >(result);
                Assert.Equal(
                    expectedActions.OrderBy(x => x.Id).Select(x => (id: x.Id, cid: x.CreditCardId, time: x.TimeStamp, operationCode: x.OperationCode, withdrawal: x.WithdrawalAmount)),
                    actualActions.OrderBy(x => x.Id).Select(x => (id: x.Id, cid: x.CreditCardId, time: x.TimeStamp, operationCode: x.OperationCode, withdrawal: x.WithdrawalAmount)));
            }
        }
Exemple #3
0
        public async Task AddAsync_ShouldAddANewCard()
        {
            using (var db = new ATMContext(TestOptions.TestDbContextOptions <ATMContext>()))
            {
                // Arrange
                var expectedDbCard = SampleData.CARD_NOT_ON_THE_LIST;
                var initCards      = SampleData.CREDITCARDS;
                if (initCards.Exists(cc => cc.Id == expectedDbCard.Id || cc.Number == expectedDbCard.Number))
                {
                    throw new InvalidOperationException($"Seeding cards already contain the card that is not supposed to be there: {expectedDbCard}");
                }
                await db.AddRangeAsync(initCards);

                await db.SaveChangesAsync();

                IRepository <CreditCard> repository = new DbCreditCardRepository(db);

                var expectedCards = await repository.GetAllAsync();

                expectedCards.Add(expectedDbCard);

                // Act
                await repository.AddAsync(expectedDbCard);

                var result = await repository.GetAllAsync();

                // Assert

                var actualCards = Assert.IsAssignableFrom <List <CreditCard> >(result);
                Assert.Equal(
                    expectedCards.OrderBy(x => x.Id).Select(x => (id: x.Id, number: x.Number, pin: x.Pin, balance: x.Balance, isValid: x.IsValid)),
                    actualCards.OrderBy(x => x.Id).Select(x => (id: x.Id, number: x.Number, pin: x.Pin, balance: x.Balance, isValid: x.IsValid)));
            }
        }
Exemple #4
0
        public async Task EditAsync_ShouldEditACard()
        {
            using (var db = new ATMContext(TestOptions.TestDbContextOptions <ATMContext>()))
            {
                // Arrange
                var initCards = SampleData.CREDITCARDS;
                await db.AddRangeAsync(initCards);

                await db.SaveChangesAsync();

                IRepository <CreditCard> repository = new DbCreditCardRepository(db);

                var expectedCards = await repository.GetAllAsync();

                var cardToEdit = expectedCards.First();
                expectedCards.Remove(cardToEdit);

                cardToEdit.Balance -= 1.00M;
                expectedCards.Add(cardToEdit);

                // Act
                await repository.EditAsync(cardToEdit);

                var result = await repository.GetAllAsync();

                // Assert

                var actualCards = Assert.IsAssignableFrom <List <CreditCard> >(result);
                Assert.Equal(
                    expectedCards.OrderBy(x => x.Id).Select(x => (id: x.Id, number: x.Number, pin: x.Pin, balance: x.Balance, isValid: x.IsValid)),
                    actualCards.OrderBy(x => x.Id).Select(x => (id: x.Id, number: x.Number, pin: x.Pin, balance: x.Balance, isValid: x.IsValid)));
            }
        }
Exemple #5
0
        public async Task AddAsync_ShouldNotAddAAction()
        {
            using (var db = new ATMContext(TestOptions.TestDbContextOptions <ATMContext>()))
            {
                // Arrange
                var expectedAction = ACTION_RESULTS.First();
                await db.AddRangeAsync(ACTION_RESULTS);

                await db.SaveChangesAsync();

                IRepository <UserActionResult> repository = new DBUserActionResultRepository(db);
                var expectedActions = await repository.GetAllAsync();

                // Act
                Func <Task> action = async() => await repository.AddAsync(expectedAction);

                // Assert
                await Assert.ThrowsAsync <ArgumentException>(action);
            }
        }
Exemple #6
0
        public async Task GetBuIdAsync_ShouldReturnNoAction()
        {
            using (var db = new ATMContext(TestOptions.TestDbContextOptions <ATMContext>()))
            {
                // Arrange
                await db.AddRangeAsync(ACTION_RESULTS);

                await db.SaveChangesAsync();

                UserActionResult expectedDbAction = null;
                int actionId = db.ActionResults.OrderBy(x => x.Id).Last().Id + 1;
                IRepository <UserActionResult> repository = new DBUserActionResultRepository(db);

                // Act
                var result = await repository.GetByIdAsync(actionId);

                // Assert
                Assert.Equal(expectedDbAction, result);
            }
        }
Exemple #7
0
        public async Task GetBuIdAsync_ShouldReturnNoCard()
        {
            using (var db = new ATMContext(TestOptions.TestDbContextOptions <ATMContext>()))
            {
                // Arrange
                await db.AddRangeAsync(SampleData.CREDITCARDS);

                await db.SaveChangesAsync();

                CreditCard expectedDbCard           = null;
                int        cardId                   = db.CreditCards.OrderBy(x => x.Id).Last().Id + 1;
                IRepository <CreditCard> repository = new DbCreditCardRepository(db);

                // Act
                var result = await repository.GetByIdAsync(cardId);

                // Assert
                Assert.Equal(expectedDbCard, result);
            }
        }
Exemple #8
0
        public async Task GetBuIdAsync_ShouldReturnAAction()
        {
            using (var db = new ATMContext(TestOptions.TestDbContextOptions <ATMContext>()))
            {
                // Arrange
                var expectedAction = ACTION_RESULTS.First();
                await db.AddRangeAsync(ACTION_RESULTS);

                await db.SaveChangesAsync();

                var expectedDbAction = ACTION_RESULTS.First();
                int actionId         = expectedDbAction.Id;
                IRepository <UserActionResult> repository = new DBUserActionResultRepository(db);

                // Act
                var result = await repository.GetByIdAsync(actionId);

                // Assert
                Assert.Equal(expectedDbAction, result);
            }
        }
Exemple #9
0
        public async Task GetAllAsync_ShouldReturnSeedingActions()
        {
            using (var db = new ATMContext(TestOptions.TestDbContextOptions <ATMContext>()))
            {
                // Arrange
                var expectedResults = ACTION_RESULTS;
                await db.AddRangeAsync(expectedResults);

                await db.SaveChangesAsync();

                IRepository <UserActionResult> repository = new DBUserActionResultRepository(db);

                // Act
                var result = await repository.GetAllAsync();

                // Assert
                var actualMessages = Assert.IsAssignableFrom <List <UserActionResult> >(result);
                Assert.Equal(
                    expectedResults.OrderBy(x => x.Id).Select(x => (id: x.Id, cid: x.CreditCardId, time: x.TimeStamp, operationCode: x.OperationCode, withdrawal: x.WithdrawalAmount)),
                    actualMessages.OrderBy(x => x.Id).Select(x => (id: x.Id, cid: x.CreditCardId, time: x.TimeStamp, operationCode: x.OperationCode, withdrawal: x.WithdrawalAmount)));
            }
        }
Exemple #10
0
        public async Task GetBuIdAsync_ShouldReturnACard()
        {
            using (var db = new ATMContext(TestOptions.TestDbContextOptions <ATMContext>()))
            {
                // Arrange
                var expectedCard = SampleData.CREDITCARDS.First();
                await db.AddRangeAsync(SampleData.CREDITCARDS);

                await db.SaveChangesAsync();

                var expectedDbCard = await db.CreditCards.Where(x => x.Number == expectedCard.Number).FirstAsync();

                int cardId = expectedDbCard.Id;
                IRepository <CreditCard> repository = new DbCreditCardRepository(db);

                // Act
                var result = await repository.GetByIdAsync(cardId);

                // Assert
                Assert.Equal(expectedDbCard, result);
            }
        }
Exemple #11
0
        public async Task AddAsync_ShouldNotAddACard()
        {
            using (var db = new ATMContext(TestOptions.TestDbContextOptions <ATMContext>()))
            {
                // Arrange
                var expectedCard = SampleData.CREDITCARDS.First();
                await db.AddRangeAsync(SampleData.CREDITCARDS);

                await db.SaveChangesAsync();

                var expectedDbCard = await db.CreditCards.Where(x => x.Number == expectedCard.Number).FirstAsync();

                IRepository <CreditCard> repository = new DbCreditCardRepository(db);
                var expectedCards = await repository.GetAllAsync();

                // Act
                Func <Task> action = async() => await repository.AddAsync(expectedDbCard);

                // Assert
                await Assert.ThrowsAsync <ArgumentException>(action);
            }
        }
Exemple #12
0
        public async Task EditAsync_ShouldNotEdit()
        {
            using (var db = new ATMContext(TestOptions.TestDbContextOptions <ATMContext>()))
            {
                // Arrange
                var cardToEdit = ACTION_NOT_IN_SEEDING_ACTIONS;
                var initCards  = ACTION_RESULTS;
                if (initCards.Exists(cc => cc.Id == cardToEdit.Id))
                {
                    throw new InvalidOperationException($"Seeding cards already contain the card that is not supposed to be there: {cardToEdit}");
                }
                await db.AddRangeAsync(initCards);

                await db.SaveChangesAsync();

                IRepository <UserActionResult> repository = new DBUserActionResultRepository(db);

                // Act
                Func <Task> action = async() => await repository.EditAsync(cardToEdit);

                // Assert
                await Assert.ThrowsAsync <ArgumentException>(action);
            }
        }
Exemple #13
0
        public async Task EditAsync_ShouldNotEdit()
        {
            using (var db = new ATMContext(TestOptions.TestDbContextOptions <ATMContext>()))
            {
                // Arrange
                var cardToEdit = SampleData.CARD_NOT_ON_THE_LIST;
                var initCards  = SampleData.CREDITCARDS;
                if (initCards.Exists(cc => cc.Id == cardToEdit.Id || cc.Number == cardToEdit.Number))
                {
                    throw new InvalidOperationException($"Seeding cards already contain the card that is not supposed to be there: {cardToEdit}");
                }
                await db.AddRangeAsync(initCards);

                await db.SaveChangesAsync();

                IRepository <CreditCard> repository = new DbCreditCardRepository(db);

                // Act
                Func <Task> action = async() => await repository.EditAsync(cardToEdit);

                // Assert
                await Assert.ThrowsAsync <ArgumentException>(action);
            }
        }