public async Task HandleDeleteDroid_WithNonExistantSerialNumber_ThrowsDroidNotFoundException()
        {
            // Arrange
            var droidHandler = new DroidHandler(_repoMock.Object, _repoArmMock.Object, _quoteMock.Object, _encryptionMock.Object);
            var deleteDroid  = new DeleteDroid(_serialNumber);
            var armIdList    = new List <ArmId>
            {
                Guid.NewGuid()
            };

            _repoArmMock
            .Setup(repo => repo.DeleteAsync(armIdList, It.IsAny <object>()))
            .Returns(Task.FromResult(true));
            var actions = DeleteArmListAction.CreateNew(armIdList, _repoArmMock.Object.DeleteAsync);

            _repoMock
            .Setup(repo => repo.DeleteAsync(_serialNumber, actions))
            .Returns(Task.FromResult(false));

            // Act
            var exception = await Record.ExceptionAsync(
                () => droidHandler.HandleAsync(deleteDroid));

            // Assert
            exception.Should().BeOfType <DroidNotFoundException>();
        }
Esempio n. 2
0
        public async Task <bool> DeleteAsync(DroidId serialNumber, DeleteArmListAction previousActions)
        {
            if (!await previousActions.Action(previousActions.SerialNumbers, null).ConfigureAwait(false))
            {
                return(false);
            }

            if (!await DeleteInternalAsync(serialNumber).ConfigureAwait(false))
            {
                return(false);
            }

            return(true);
        }
        public async Task DeleteDroidTransaction_WithArmsWithoutDroid_ReturnsFalse()
        {
            // Arrange
            var droidIdWithoutDroid = Guid.Parse("9e3cf3eb-e866-47cf-8cb6-951ac9b27d8a");

            var(droidListBefore, _) = await _repo.GetAllPagedAsync(0, _nbOfDroids);

            var actions = DeleteArmListAction.CreateNew(new List <ArmId>(), _repoArm.DeleteAsync);

            // Act
            await _repo.DeleteAsync(droidIdWithoutDroid, actions);

            // Assert
            var(droidListAfter, _) = await _repo.GetAllPagedAsync(0, _nbOfDroids);

            droidListBefore.Should().HaveCount(_nbOfDroids);
            droidListAfter.Should().HaveCount(_nbOfDroids);
        }
        public async Task DeleteDroidTransaction_WithDroidWithoutArms_ReturnsTrue()
        {
            // Arrange
            var droidIdWithoutArms = Guid.Parse("c50e2592-0a71-4ff6-90ce-052cca08598d");

            var(droidListBefore, _) = await _repo.GetAllPagedAsync(0, _nbOfDroids);

            var actions = DeleteArmListAction.CreateNew(new List <ArmId>(), _repoArm.DeleteAsync);

            // Act
            await _repo.DeleteAsync(droidIdWithoutArms, actions);

            // Assert
            var(droidListAfter, _) = await _repo.GetAllPagedAsync(0, _nbOfDroids);

            droidListBefore.Should().HaveCount(_nbOfDroids);
            droidListAfter.Should().HaveCount(_nbOfDroids - 1);
        }
        public async Task <bool> DeleteAsync(DroidId serialNumber, DeleteArmListAction previousActions)
        {
            using (var transaction = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled))
                using (var connection = _connectionProvider())
                {
                    if (!await previousActions.Action(previousActions.SerialNumbers, connection))
                    {
                        return(false);
                    }

                    if ((await ExecuteDeleteAsync(serialNumber, connection)) > 0)
                    {
                        transaction.Complete();
                        return(true);
                    }
                }

            return(false);
        }
        public async Task DeleteDroid_WithValidSerialNumber_ReturnsTrue()
        {
            // Arrange
            var(droidListBefore, _) = await _repo.GetAllPagedAsync(0, _nbOfDroids).ConfigureAwait(false);

            var armIdList = new List <ArmId>
            {
                _existingArmId
            };
            var actions = DeleteArmListAction.CreateNew(armIdList, _repoArm.DeleteAsync);

            // Act
            await _repo.DeleteAsync(_existingDroidId, actions);

            //Assert
            var(droidListAfter, _) = await _repo.GetAllPagedAsync(0, _nbOfDroids);

            droidListBefore.Should().HaveCount(_nbOfDroids);
            droidListAfter.Should().HaveCount(_nbOfDroids - 1);
        }
        public async Task DeleteDroidTransaction_WithDroidWithInvalidSerialNumber_ReturnsFalse()
        {
            // Arrange
            _connection
            .SetupDapperAsync(x => x.ExecuteAsync(It.IsAny <string>(), null, null, null, null))
            .ReturnsAsync(0);
            var armIdList = new List <ArmId>
            {
                Guid.NewGuid()
            };

            _repoArm.Setup(repo => repo.DeleteAsync(armIdList, It.IsAny <IDbConnection>())).ReturnsAsync(false);

            var actions = DeleteArmListAction.CreateNew(armIdList, _repoArm.Object.DeleteAsync);

            // Act
            var result = await _repo.DeleteAsync(Guid.NewGuid(), actions);

            // Assert
            _repoArm.Verify(repo => repo.DeleteAsync(armIdList, It.IsAny <IDbConnection>()), Times.Once);
            result.Should().BeFalse();
        }