コード例 #1
0
        public async Task GSTFreeOnlyTransactionIsMappedCorrectly()
        {
            // Arrange
            var       mockActionstepService = new Mock <IActionstepService>();
            const int taxCodeGSTFree        = 20;
            const int taxCodeGSTTaxable     = 30;

            mockActionstepService
            .Setup(a => a.Handle <ListDisbursementsResponse>(It.IsAny <CreateDisbursementsRequest>()))
            .Returns(Task.FromResult(new ListDisbursementsResponse()
            {
                Disbursements =
                {
                    new Disbursement()
                    {
                        Id          = 1,
                        Date        = new LocalDate(2020, 3, 10),
                        Description = "Description2",
                        Links       = { TaxCode = taxCodeGSTFree }
                    }
                }
            }));

            var handler = new CreateDisbursementsCommand.CreateDisbursementsCommandHandler(mockActionstepService.Object, new CreateDisbursementsCommand.Validator());
            CreateDisbursementsCommand request = CreateCommand(taxCodeGSTFree, taxCodeGSTTaxable);

            // Act
            var result = await handler.Handle(request, new CancellationToken());

            // Assert
            Assert.Equal(40, result.GlobalXTransactionId);
            Assert.Equal(1, result.GSTFreeDisbursementId);
            Assert.Null(result.GSTTaxableDisbursementId);
        }
コード例 #2
0
        public async Task <SendFirstTitlePolicyRequestResponse> SendPolicyRequestToFirstTitle([FromBody] SendFirstTitlePolicyRequestQuery request)
        {
            var currentUser = await _userManager.GetUserAsync(User);

            var firstTitleCredentials = await _mediator.Send(new FirstTitleCredentialsQuery()
            {
                AuthenticatedUser = currentUser
            });

            if (firstTitleCredentials == null)
            {
                throw new MissingFirstTitleCredentialsException(currentUser);
            }

            request.AuthenticatedUser     = currentUser;
            request.FirstTitleCredentials = firstTitleCredentials;

            var ftResponse = await _mediator.Send(request);

            var createDisbursementsCommand = new CreateDisbursementsCommand()
            {
                ActionstepOrg     = request.ActionstepOrg,
                MatterId          = request.MatterId,
                FirstTitlePrice   = ftResponse.Price,
                PolicyNumber      = ftResponse.PolicyNumber,
                AuthenticatedUser = currentUser
            };

            await _mediator.Send(createDisbursementsCommand);

            if (ftResponse.AttachmentPaths != null && ftResponse.AttachmentPaths.Length > 0)
            {
                for (var i = 0; i < ftResponse.AttachmentPaths.Length; i++)
                {
                    var fTAttachment = await _mediator.Send(new SavePolicyPDFToActionstepCommand()
                    {
                        AuthenticatedUser = currentUser,
                        ActionstepOrg     = request.ActionstepOrg,
                        MatterId          = request.MatterId,
                        FileName          = ftResponse.AttachmentPaths[i].FileName,
                        FilePath          = ftResponse.AttachmentPaths[i].FileUrl
                    });

                    ftResponse.AttachmentPaths[i] = fTAttachment;
                }
            }

            return(ftResponse);
        }
コード例 #3
0
        public async Task CanCreateDisbursements()
        {
            // Arrange
            var disbursementCreationDetails = new CreateDisbursementsCommand()
            {
                ActionstepMatterId    = 1,
                ActionstepOrgKey      = "OrgKey",
                TaxCodeIdNoGST        = 2,
                TaxCodeIdWithGST      = 3,
                Transaction           = CreateTestTransaction(),
                ActionstepUserId      = "4",
                MinimumMatterIdToSync = -1,
            };

            var durableOrchestrationContextMock = new Mock <IDurableOrchestrationContext>();

            durableOrchestrationContextMock.Setup(d => d.GetInput <CreateDisbursementsCommand>()).Returns(disbursementCreationDetails);
            durableOrchestrationContextMock.Setup(d => d.InstanceId).Returns(GlobalXTransactionSyncOrchestrator.InstancePrefix + disbursementCreationDetails.Transaction.TransactionId.ToString(CultureInfo.InvariantCulture));
            durableOrchestrationContextMock.Setup(d => d.CallActivityAsync <TransactionDisbursementRelationship>(
                                                      nameof(GlobalXTransactionSyncOrchestrator.CreateDisbursementsForTransaction),
                                                      It.IsAny <CreateDisbursementsCommand>()))
            .Returns(Task.FromResult(new TransactionDisbursementRelationship(disbursementCreationDetails.Transaction.TransactionId, "OrgKey", 1, 3, 2)));

            durableOrchestrationContextMock.Setup(d => d.CallActivityAsync <ActionstepMatterValidationResult>(
                                                      nameof(SharedActivities.ValidateActionstepMatter),
                                                      It.IsAny <ValidateActionstepMatterCommand>()))
            .ReturnsAsync(new ActionstepMatterValidationResult(MatterIdStatus.Valid, 1));

            var mediatorMock = new Mock <IMediator>();
            var transactionSyncOrchestrator = new GlobalXTransactionSyncOrchestrator(mediatorMock.Object, NullLogger <GlobalXTransactionSyncOrchestrator> .Instance);

            // Act
            var result = await transactionSyncOrchestrator.Run(durableOrchestrationContextMock.Object);

            // Assert
            durableOrchestrationContextMock.Verify(d => d.SetCustomStatus(null), Times.Once);
            Assert.Equal(1, result.GlobalXTransactionId);
            Assert.Equal(2, result.GSTFreeDisbursementId);
            Assert.Equal(3, result.GSTTaxableDisbursementId);
        }
コード例 #4
0
        public async Task CanManuallyResumeFromCreateDisbursementsFailure()
        {
            // Arrange
            var disbursementCreationDetails = new CreateDisbursementsCommand()
            {
                ActionstepMatterId = 1,
                ActionstepOrgKey   = "OrgKey",
                TaxCodeIdNoGST     = 2,
                TaxCodeIdWithGST   = 3,
                Transaction        = CreateTestTransaction(),
                ActionstepUserId   = "4"
            };

            var durableOrchestrationContextMock = new Mock <IDurableOrchestrationContext>();

            durableOrchestrationContextMock.Setup(d => d.GetInput <CreateDisbursementsCommand>()).Returns(disbursementCreationDetails);
            durableOrchestrationContextMock.Setup(d => d.InstanceId).Returns(GlobalXTransactionSyncOrchestrator.InstancePrefix + disbursementCreationDetails.Transaction.TransactionId.ToString(CultureInfo.InvariantCulture));

            durableOrchestrationContextMock.Setup(d => d.CallActivityAsync <ActionstepMatterValidationResult>(
                                                      nameof(SharedActivities.ValidateActionstepMatter),
                                                      It.IsAny <ValidateActionstepMatterCommand>()))
            .ReturnsAsync(new ActionstepMatterValidationResult(MatterIdStatus.Valid, 1));

            // Fail on the first attempt. This will be fixed later and retried.
            durableOrchestrationContextMock.Setup(d => d.CallActivityAsync <TransactionDisbursementRelationship>(
                                                      nameof(GlobalXTransactionSyncOrchestrator.CreateDisbursementsForTransaction),
                                                      disbursementCreationDetails))
            .Throws <Exception>();

            var timerTask      = new Task <object>(() => new object());
            var retryEventTask = new Task <object>(() => new object());

            // Uses Moq because FakeItEasy doesn't support faking generic types with in parameters:
            // https://github.com/FakeItEasy/FakeItEasy/issues/1382
            durableOrchestrationContextMock.Setup(d => d.CreateTimer <Object>(It.IsAny <DateTime>(), It.IsAny <It.IsAnyType>(), It.IsAny <CancellationToken>())).Returns(timerTask);
            durableOrchestrationContextMock.Setup(d => d.WaitForExternalEvent <Object>(Events.RetryFailedActivityEvent)).Returns(retryEventTask);

            var mediatorMock = new Mock <IMediator>();
            var transactionSyncOrchestrator = new GlobalXTransactionSyncOrchestrator(mediatorMock.Object, NullLogger <GlobalXTransactionSyncOrchestrator> .Instance);

            // Act
            var orchestrationTask = transactionSyncOrchestrator.Run(durableOrchestrationContextMock.Object);

            // - Update mock so it works now
            durableOrchestrationContextMock.Setup(d => d.CallActivityAsync <TransactionDisbursementRelationship>(
                                                      nameof(GlobalXTransactionSyncOrchestrator.CreateDisbursementsForTransaction),
                                                      It.IsAny <CreateDisbursementsCommand>()))
            .Returns(Task.FromResult(new TransactionDisbursementRelationship(disbursementCreationDetails.Transaction.TransactionId, "OrgKey", 1, 3, 2)));


            // - Simulate raising of retry event by completing retryEventTask
            retryEventTask.Start();

            // - Wait for orchestration to finish
            var result = await orchestrationTask;

            // Assert
            durableOrchestrationContextMock.Verify(d => d.SetCustomStatus("Exception of type 'System.Exception' was thrown."), Moq.Times.Once);
            durableOrchestrationContextMock.Verify(d => d.SetCustomStatus(null), Moq.Times.Once);
            Assert.Equal(1, result.GlobalXTransactionId);
            Assert.Equal(2, result.GSTFreeDisbursementId);
            Assert.Equal(3, result.GSTTaxableDisbursementId);
        }