Пример #1
0
        protected async Task <SubjectEvent> GetSubjectEvent(string subjectId)
        {
            SubjectEventsResponse subjectEventsResponse = await DefaultApi.WorkflowsClient().GetSubjectEvents(subjectId);

            subjectEventsResponse.ShouldNotBeNull();
            subjectEventsResponse.Events.Count.ShouldBe(1);

            SubjectEvent paymentApprovedEvent =
                subjectEventsResponse.Events.FirstOrDefault(x => x.Type.Equals("payment_approved"));

            paymentApprovedEvent.ShouldNotBeNull();

            return(paymentApprovedEvent);
        }
Пример #2
0
        public async Task ShouldGetSubjectEvents()
        {
            SubjectEventsResponse subjectEventsResponse = new SubjectEventsResponse();

            _apiClient.Setup(apiClient =>
                             apiClient.Get <SubjectEventsResponse>("workflows" + "/events/subject/subject_id", _authorization,
                                                                   CancellationToken.None))
            .ReturnsAsync(() => subjectEventsResponse);

            IWorkflowsClient workflowsClient = new WorkflowsClient(_apiClient.Object, _configuration.Object);

            var response = await workflowsClient.GetSubjectEvents("subject_id");

            response.ShouldNotBeNull();
        }
        public async Task ShouldGetActionInvocations()
        {
            var createWorkflowResponse = await CreateWorkflow();

            PaymentResponse payment = await MakeCardPayment();

            SubjectEventsResponse subjectEventsResponse =
                await Retriable(async() => await DefaultApi.WorkflowsClient().GetSubjectEvents(payment.Id));

            subjectEventsResponse.ShouldNotBeNull();
            subjectEventsResponse.Events.ShouldNotBeEmpty();
            subjectEventsResponse.Events[0].Id.ShouldNotBeNull();

            var getWorkflowResponseUpdated =
                await DefaultApi.WorkflowsClient().GetWorkflow(createWorkflowResponse.Id);

            getWorkflowResponseUpdated.ShouldNotBeNull();
            getWorkflowResponseUpdated.Actions.ShouldNotBeEmpty();

            var actionId = getWorkflowResponseUpdated.Actions[0].Id;
            var eventId  = subjectEventsResponse.Events[0].Id;

            var actionInvocations =
                await DefaultApi.WorkflowsClient().GetActionInvocations(eventId, actionId);

            actionInvocations.ShouldNotBeNull();
            actionInvocations.Status.ShouldBe(WorkflowActionStatus.Pending);
            actionInvocations.ActionType.ShouldBe(WorkflowActionType.Webhook);
            actionInvocations.EventId.ShouldBe(eventId);
            actionInvocations.WorkflowId.ShouldBe(createWorkflowResponse.Id);
            actionInvocations.WorkflowActionId.ShouldBe(actionId);
            actionInvocations.ActionInvocations.ShouldNotBeNull();
            actionInvocations.ActionInvocations.ShouldNotBeEmpty();

            foreach (WorkflowActionInvocation actionInvocationsActionInvocation in actionInvocations.ActionInvocations)
            {
                actionInvocationsActionInvocation.Final.ShouldNotBeNull();
                actionInvocationsActionInvocation.Retry.ShouldNotBeNull();
                actionInvocationsActionInvocation.Succeeded.ShouldNotBeNull();
                actionInvocationsActionInvocation.Timestamp.ShouldNotBeNull();
                actionInvocationsActionInvocation.InvocationId.ShouldNotBeNullOrEmpty();
                actionInvocationsActionInvocation.Result.ShouldNotBeEmpty();
            }
        }
        public async Task ShouldGetSubjectEventAndEvents()
        {
            await CreateWorkflow();

            PaymentResponse paymentResponse = await MakeCardPayment(true);

            SubjectEventsResponse subjectEventsResponse =
                await Retriable(async() => await DefaultApi.WorkflowsClient().GetSubjectEvents(paymentResponse.Id),
                                HasTwoEvents);

            subjectEventsResponse.ShouldNotBeNull();
            subjectEventsResponse.Events.Count.ShouldBe(2);

            SubjectEvent paymentApprovedEvent =
                subjectEventsResponse.Events.FirstOrDefault(x => x.Type.Equals("payment_approved"));

            paymentApprovedEvent.ShouldNotBeNull();
            paymentApprovedEvent.Id.ShouldNotBeNullOrEmpty();
            paymentApprovedEvent.Timestamp.ShouldNotBeNullOrEmpty();
            paymentApprovedEvent.GetLink("self").ShouldNotBeNull();

            SubjectEvent paymentCapturedEvent =
                subjectEventsResponse.Events.FirstOrDefault(x => x.Type.Equals("payment_captured"));

            paymentCapturedEvent.ShouldNotBeNull();
            paymentCapturedEvent.Id.ShouldNotBeNullOrEmpty();
            paymentCapturedEvent.Timestamp.ShouldNotBeNullOrEmpty();
            paymentCapturedEvent.GetLink("self").ShouldNotBeNull();

            GetEventResponse getEventResponse = await DefaultApi.WorkflowsClient().GetEvent(paymentCapturedEvent.Id);

            getEventResponse.ShouldNotBeNull();
            getEventResponse.Id.ShouldNotBeNull();
            getEventResponse.Timestamp.ShouldNotBeNull();
            getEventResponse.Version.ShouldNotBeNull();
            getEventResponse.Data.ShouldNotBeNull();
        }
 private static bool HasTwoEvents(SubjectEventsResponse obj)
 {
     return(obj.Events.Count == 2);
 }