Esempio n. 1
0
        public async Task MapsAllLinksAfterMandateImportHasBeenSubmitted()
        {
            // given
            var subject       = new MandateImportEntriesClient(_clientConfiguration);
            var mandateImport = await _resourceFactory.CreateMandateImport();

            var mandateImportEntry = await _resourceFactory.CreateMandateImportEntryFor(mandateImport, "first-record");

            var mandateImportsClient = new MandateImportsClient(_clientConfiguration);
            await mandateImportsClient.SubmitAsync(mandateImport.Id);

            var request = new GetMandateImportEntriesRequest
            {
                MandateImport = mandateImport.Id
            };

            // when
            var result = (await subject.GetPageAsync(request)).Items.ToList();

            // then
            Assert.That(result.Any(), Is.True);
            Assert.That(result[0].Links, Is.Not.Null);
            Assert.That(result[0].Links.Customer, Is.Not.Null);
            Assert.That(result[0].Links.CustomerBankAccount, Is.Not.Null);
            Assert.That(result[0].Links.Mandate, Is.Not.Null);
            Assert.That(result[0].Links.MandateImport, Is.Not.Null.And.EqualTo(mandateImport.Id));
        }
        internal async Task <MandateImport> CreateMandateImport()
        {
            var request = new CreateMandateImportRequest
            {
                Scheme = "bacs",
            };

            var mandateImportsClient = new MandateImportsClient(_clientConfiguration);

            return((await mandateImportsClient.CreateAsync(request)).Item);
        }
        public void IdIsNullOrWhiteSpaceThrows(string id)
        {
            // given
            var subject = new MandateImportsClient(_clientConfiguration);

            // when
            AsyncTestDelegate test = () => subject.ForIdAsync(id);

            // then
            var ex = Assert.ThrowsAsync <ArgumentException>(test);

            Assert.That(ex.ParamName, Is.EqualTo(nameof(id)));
        }
        public async Task CallsCancelMandateImportEndpoint()
        {
            // given
            var subject = new MandateImportsClient(_clientConfiguration);
            var id      = "IM12345678";

            // when
            await subject.CancelAsync(id);

            // then
            _httpTest
            .ShouldHaveCalled("https://api.gocardless.com/mandate_imports/IM12345678/actions/cancel")
            .WithVerb(HttpMethod.Post);
        }
        public async Task CallsCreateMandateImportEndpoint()
        {
            // given
            var subject = new MandateImportsClient(_clientConfiguration);

            var request = new CreateMandateImportRequest();

            // when
            await subject.CreateAsync(request);

            // then
            _httpTest
            .ShouldHaveCalled("https://api.gocardless.com/mandate_imports")
            .WithVerb(HttpMethod.Post);
        }
        public void CreateMandateImportRequestIsNullThrows()
        {
            // given
            var subject = new MandateImportsClient(_clientConfiguration);

            CreateMandateImportRequest request = null;

            // when
            AsyncTestDelegate test = () => subject.CreateAsync(request);

            // then
            var ex = Assert.ThrowsAsync <ArgumentNullException>(test);

            Assert.That(ex.ParamName, Is.EqualTo(nameof(request)));
        }
        public async Task SubmitsMandateImport()
        {
            // given
            var subject       = new MandateImportsClient(_clientConfiguration);
            var mandateImport = await _resourceFactory.CreateMandateImport();

            // when
            var result = await subject.SubmitAsync(mandateImport.Id);

            // then
            Assert.That(result.Item, Is.Not.Null);
            Assert.That(result.Item.Id, Is.Not.Null.And.EqualTo(mandateImport.Id));
            Assert.That(result.Item.CreatedAt, Is.Not.Null.And.EqualTo(mandateImport.CreatedAt));
            Assert.That(result.Item.Scheme, Is.Not.Null.And.EqualTo(mandateImport.Scheme));
            Assert.That(result.Item.Status, Is.Not.Null.And.Not.EqualTo(mandateImport.Status));
        }
        public async Task CreatesMandateImport()
        {
            // given
            var subject = new MandateImportsClient(_clientConfiguration);

            var request = new CreateMandateImportRequest
            {
                Scheme = Scheme.Bacs,
            };

            // when
            var result = await subject.CreateAsync(request);

            // then
            Assert.That(result.Item, Is.Not.Null);
            Assert.That(result.Item.Id, Is.Not.Null);
            Assert.That(result.Item.CreatedAt, Is.Not.Null.And.Not.EqualTo(default(DateTimeOffset)));
            Assert.That(result.Item.Scheme, Is.EqualTo(request.Scheme));
            Assert.That(result.Item.Status, Is.Not.Null);
        }
Esempio n. 9
0
        public GoCardlessClient(ClientConfiguration configuration)
        {
            _configuration = configuration;

            BankDetailsLookups    = new BankDetailsLookupsClient(configuration);
            CreditorBankAccounts  = new CreditorBankAccountsClient(configuration);
            Creditors             = new CreditorsClient(configuration);
            CustomerBankAccounts  = new CustomerBankAccountsClient(configuration);
            CustomerNotifications = new CustomerNotificationsClient(configuration);
            Customers             = new CustomersClient(configuration);
            Events = new EventsClient(configuration);
            MandateImportEntries = new MandateImportEntriesClient(configuration);
            MandateImports       = new MandateImportsClient(configuration);
            MandatePdfs          = new MandatePdfsClient(configuration);
            Mandates             = new MandatesClient(configuration);
            Payments             = new PaymentsClient(configuration);
            PayoutItems          = new PayoutItemsClient(configuration);
            Payouts       = new PayoutsClient(configuration);
            RedirectFlows = new RedirectFlowsClient(configuration);
            Refunds       = new RefundsClient(configuration);
            Subscriptions = new SubscriptionsClient(configuration);
        }