def test_Disputes_GetSettlementTransfer(self): self.refreshClientDisputes() dispute = None for d in self._clientDisputes: if (d.Status == DisputeStatus.CLOSED and d.DisputeType == DisputeType.NOT_CONTESTABLE): dispute = d break self.assertIsNotNone( dispute, 'Cannot test getting settlement transfer because there\'s no closed and not contestable disputes in the disputes list.' ) repudiationId = self.sdk.disputes.GetTransactions( dispute.Id, Pagination(1, 1))[0].Id repudiation = self.sdk.disputes.GetRepudiation(repudiationId) post = Settlement() post.AuthorId = repudiation.AuthorId post.DebitedFunds = Money(1, 'EUR') post.Fees = Money(0, 'EUR') transfer = self.sdk.disputes.CreateSettlementTransfer( post, repudiationId) self.assertIsNotNone(transfer) result = self.sdk.disputes.GetSettlementTransfer(transfer.Id) self.assertIsNotNone(result) self.assertIsNotNone(result.RepudiationId) self.assertEqual(result.RepudiationId, repudiation.Id)
def _getList (self, methodKey, pagination, responseClassName = None, entityId = None, filter = None, sorting = None): """Get list with entities object from API. param string methodKey Key with request data param pagination Pagination object param object responseClassName Name of entity class from response param int entityId Entity identifier param object filter Object to filter data param object sorting Object to sort data return object Response data """ urlMethod = self._buildUrl(methodKey, entityId) if pagination == None: pagination = Pagination() rest = RestTool(self._root, True) additionalUrlParams = {} if (filter != None): additionalUrlParams['filter'] = filter if (sorting != None): additionalUrlParams['sort'] = sorting.GetSortParameter() response = rest.Request(urlMethod, self._getRequestType(methodKey), None, pagination, additionalUrlParams) if responseClassName != None: return self._castResponseToEntity(response, responseClassName) return response
def test_Disputes_GetFilteredDisputeDocuments(self): now = int(time.time()) + 100 filterAfter = FilterTransactions() filterBefore = FilterTransactions() filterAfter.AfterDate = now filterBefore.BeforeDate = now pagination = Pagination() result1 = self.sdk.disputes.GetDocumentsForClient( pagination, filterAfter) result2 = self.sdk.disputes.GetDocumentsForClient( pagination, filterBefore) self.assertIsNotNone(result1) self.assertIsNotNone(result2) self.assertTrue(len(result1) == 0) self.assertTrue(len(result2) > 0) filterType = FilterTransactions() filterType.Type = result2[0].Type result3 = self.sdk.disputes.GetDocumentsForClient( pagination, filterType) self.assertIsNotNone(result3) self.assertTrue(len(result3) > 0) for dd in result3: self.assertTrue(dd.Type, result2[0].Type)
def test_KycDocuments_GetAll_SortByCreationDate(self): pagination = Pagination(1, 10) sorting = Sorting() sorting.AddField('CreationDate', SortDirection.DESC) list = self.sdk.kycdocuments.GetAll(pagination, sorting) self.assertTrue(list[0].CreationDate >= list[1].CreationDate)
def test_Hooks_All(self): hook = self.getJohnHook() pagination = Pagination(1, 1) list = self.sdk.hooks.GetAll(pagination) self.assertTrue(isinstance(list[0], Hook)) self.assertEqual(hook.Id, list[0].Id) self.assertEqual(pagination.Page, 1) self.assertEqual(pagination.ItemsPerPage, 1)
def test_Users_Transactions_SortByCreationDate(self): john = self.getJohn() self.getJohnsPayInCardDirect() self.getJohnsPayInCardDirect() pagination = Pagination(1, 10) sorting = Sorting() sorting.AddField('CreationDate', SortDirection.DESC) list = self.sdk.users.GetTransactions(john.Id, pagination, sorting) self.assertTrue(list[0].CreationDate > list[1].CreationDate)
def test_Users_GetKycDocuments(self): kycDocument = self.getUserKycDocument() user = self.getJohn() pagination = Pagination(1, 10) self.sdk.users.GetKycDocuments(user.Id, pagination) pagination.Page = pagination.TotalPages getKycDocuments = self.sdk.users.GetKycDocuments(user.Id, pagination) kycFromList = self.getEntityFromList(kycDocument.Id, getKycDocuments) self.assertIsInstance(kycFromList, KycDocument) self.assertEqualInputProps(kycDocument, kycFromList)
def test_KycDocuments_GetAll(self): kycDocument = self.getUserKycDocument() pagination = Pagination(1, 100) self.sdk.kycdocuments.GetAll(pagination) pagination.Page = pagination.TotalPages list = self.sdk.kycdocuments.GetAll(pagination) kycFromList = self.getEntityFromList(kycDocument.Id, list) self.assertTrue(isinstance(kycFromList, KycDocument)) self.assertEqualInputProps(kycDocument, kycFromList) self.assertEqual(pagination.ItemsPerPage, 100)
def test_Users_BankAccounts_SortByCreationDate(self): john = self.getJohn() self.getJohnsAccount() self._johnsAccount = None self.getJohnsAccount() pagination = Pagination(1, 10) sorting = Sorting() sorting.AddField('CreationDate', SortDirection.DESC) list = self.sdk.users.GetBankAccounts(john.Id, pagination, sorting) self.assertTrue(list[0].CreationDate >= list[1].CreationDate)
def refreshClientDisputes(self): sorting = Sorting() sorting.AddField("CreationDate", SortDirection.DESC) pagination = Pagination(1, 100) self._clientDisputes = self.sdk.disputes.GetAll( pagination, None, sorting) self.assertIsNotNone(self._clientDisputes, 'INITIALIZATION FAILURE - cannot test disputes') self.assertTrue( len(self._clientDisputes) > 0, 'INITIALIZATION FAILURE - cannot test disputes') return
def test_Clients_GetWalletTransactions(self): feesWallets = self.sdk.clients.GetWallets(FundsType.FEES, Pagination(1, 1)) creditWallets = self.sdk.clients.GetWallets(FundsType.CREDIT, Pagination(1, 1)) defaultWallets = self.sdk.clients.GetWallets(FundsType.DEFAULT, Pagination(1, 1)) if (feesWallets == None or len(feesWallets) == 0 or creditWallets == None or len(creditWallets) == 0 or defaultWallets == None or len(defaultWallets) == 0): self.assertTrue(False, "Cannot test getting client's wallet because there is no any wallet for client.") wallet = None result = None if (feesWallets != None and len(feesWallets) > 0): wallet = feesWallets[0] else: if (creditWallets != None and len(creditWallets) > 0): wallet = creditWallets[0] else: wallet = defaultWallets[0] result = self.sdk.clients.GetWalletTransactions(wallet.FundsType, wallet.Currency) self.assertIsNotNone(result) self.assertTrue(len(result) > 0)
def test_Wallets_Transactions(self): john = self.getJohn() wallet = self.getJohnsWallet() payIn = self.getJohnsPayInCardWeb() pagination = Pagination(1, 1) filter = FilterTransactions() filter.Type = TransactionType.PAYIN transactions = self.sdk.wallets.GetTransactions(wallet.Id, pagination, filter) self.assertEqual(len(transactions), 1) self.assertIsInstance(transactions[0], Transaction) self.assertEqual(transactions[0].AuthorId, john.Id) self.assertEqualInputProps(transactions[0], payIn)
def getJohnHook(self): if self._johnsHook == None: pagination = Pagination(1, 1) list = self.sdk.hooks.GetAll(pagination) if list[0] != None: self._johnsHook = list[0] else: hook = Hook() hook.EventType = EventType.PAYIN_NORMAL_CREATED hook.Url = 'http://test.com' self._johnsHook = self.sdk.hooks.Create(hook) return self._johnsHook
def test_Users_BankAccounts(self): john = self.getJohn() account = self.getJohnsAccount() pagination = Pagination(1, 12) list = self.sdk.users.GetBankAccounts(john.Id, pagination) self.assertIsInstance(list[0], BankAccount) self.assertEqual(account.Id, list[0].Id) self.assertEqualInputProps(account, list[0]) self.assertEqual(pagination.Page, 1) self.assertEqual(pagination.ItemsPerPage, 12) self.assertTrue(pagination.TotalPages > 0) self.assertTrue(pagination.TotalItems > 0)
def test_Disputes_SubmitDisputeDocument(self): self.refreshClientDisputes() dispute = None disputeDocument = None filter = FilterDisputeDocuments() filter.Status = DisputeDocumentStatus.CREATED for d in self._clientDisputes: if (d.Status == DisputeStatus.PENDING_CLIENT_ACTION or d.Status == DisputeStatus.REOPENED_PENDING_CLIENT_ACTION): dd = self.sdk.disputes.GetDocumentsForDispute( d.Id, Pagination(1, 1), filter)[0] if (dd != None): dispute = d disputeDocument = dd break if (dispute == None): for d in self._clientDisputes: if (d.Status == DisputeStatus.PENDING_CLIENT_ACTION or d.Status == DisputeStatus.REOPENED_PENDING_CLIENT_ACTION): documentPost = DisputeDocument() documentPost.Type = DisputeDocumentType.DELIVERY_PROOF disputeDocument = self.sdk.disputes.CreateDocument( documentPost, d.Id) self.assertIsNotNone( dispute, 'Cannot test submitting dispute\'s documents because there\'s no dispute with expected status in the disputes list.' ) self.assertIsNotNone( disputeDocument, 'Cannot test submitting dispute\'s documents because there\'s no dispute document that can be updated.' ) disputeDocumentPut = DisputeDocument() disputeDocumentPut.Id = disputeDocument.Id disputeDocumentPut.Status = DisputeDocumentStatus.VALIDATION_ASKED result = self.sdk.disputes.SubmitDisputeDocument( disputeDocumentPut, dispute.Id) self.assertIsNotNone(result) self.assertTrue(disputeDocument.Type == result.Type) self.assertTrue( result.Status == DisputeDocumentStatus.VALIDATION_ASKED)
def test_Wallets_Transactions_SortByCreationDate(self): wallet = self.getJohnsWallet() #create 2 pay-in objects self.getJohnsPayInCardWeb() self.getJohnsPayInCardWeb() sorting = Sorting() sorting.AddField('CreationDate', SortDirection.DESC) pagination = Pagination(1, 20) filter = FilterTransactions() filter.Type = TransactionType.PAYIN transactions = self.sdk.wallets.GetTransactions(wallet.Id, pagination, filter, sorting) self.assertTrue(transactions[0].CreationDate > transactions[1].CreationDate)
def test_Events_GetEvents_Page_Of_Type(self): self.pageLength = 3 pagination = Pagination(1, self.pageLength) filter = FilterTransactions() self.type = EventType.PAYIN_NORMAL_CREATED filter.EventType = self.type event = self.sdk.events.Get(pagination, filter) self.assertTrue(len(event) <= self.pageLength) if (len(event) > 0): self.assertEqual(event[0].EventType, self.type) if (len(event) > 1): self.assertEqual(event[1].EventType, self.type) if (len(event) > 2): self.assertEqual(event[2].EventType, self.type)
def test_Disputes_GetFilteredDisputes(self): now = int(time.time()) filterAfter = FilterTransactions() filterBefore = FilterTransactions() filterAfter.AfterDate = now filterBefore.BeforeDate = now pagination = Pagination() result1 = self.sdk.disputes.GetAll(pagination, filterAfter) result2 = self.sdk.disputes.GetAll(pagination, filterBefore) self.assertIsNotNone(result1) self.assertIsNotNone(result2) self.assertTrue(len(result1) == 0) self.assertTrue(len(result2) > 0)
def test_Mandates_Get_For_Bank_Account(self): user = self.getJohn() bankAccountId = self.getJohnsAccount().Id returnUrl = 'http://test.test' mandatePost = Mandate() mandatePost.BankAccountId = bankAccountId mandatePost.Culture = 'EN' mandatePost.ReturnURL = returnUrl mandateCreated = self.sdk.mandates.Create(mandatePost) sorting = Sorting() sorting.AddField("CreationDate", SortDirection.DESC) mandates = self.sdk.mandates.GetForBankAccount(user.Id, bankAccountId, Pagination(), sorting) self.assertIsNotNone(mandates) self.assertIsNotNone(mandates[0]) self.assertTrue(mandateCreated.Id == mandates[0].Id)
def test_Disputes_GetTransactions(self): self.refreshClientDisputes() dispute = None for d in self._clientDisputes: if (d.DisputeType == DisputeType.NOT_CONTESTABLE): dispute = d break self.assertIsNotNone( dispute, 'Cannot test getting dispute\'s transactions because there\'s no not contestable dispute in the disputes list.' ) pagination = Pagination(1, 10) transactions = self.sdk.disputes.GetTransactions( dispute.Id, pagination) self.assertIsNotNone(transactions) self.assertTrue(len(transactions) > 0)
def test_Disputes_GetDisputesForWallet(self): self.refreshClientDisputes() dispute = None for d in self._clientDisputes: if (d.InitialTransactionId != None): dispute = d break self.assertIsNotNone( dispute, 'Cannot test getting disputes for wallet because there\'s no dispute with transaction ID in the disputes list.' ) walletId = self.sdk.payIns.Get( dispute.InitialTransactionId).CreditedWalletId pagination = Pagination(1, 10) disputes = self.sdk.disputes.GetDisputesForWallet(walletId, pagination) self.assertIsNotNone(disputes) self.assertTrue(len(disputes) > 0)
""" ## run some test #import tests.testapiusers #t = tests.testapiusers.Test_ApiUsers() #t.test_Users_GetNatural() from mangopaysdk.mangopayapi import MangoPayApi from mangopaysdk.types.pagination import Pagination api = MangoPayApi() # test client credentials api.Config.ClientID = 'sdk-unit-tests' api.Config.ClientPassword = '******' # optionally reuse token from previous requests (unless expired) token = api.authenticationManager.CreateToken() api.OAuthToken = token # GET USERS LIST: GET /users pagination = Pagination(1, 8) users = api.users.GetAll(pagination) # display result on screen print(users) # optionally store token for future requests (unless expires) print(api.OAuthToken) input('...')
def test_Clients_GetWallets(self): feesWallets = self.sdk.clients.GetWallets(FundsType.FEES, Pagination(1, 1)) creditWallets = self.sdk.clients.GetWallets(FundsType.CREDIT, Pagination(1, 1)) self.assertIsNotNone(feesWallets) self.assertIsNotNone(creditWallets)
def test_stadnardUseToken(self): self.sdk.users.GetAll(Pagination(1, 2)) token = self.sdk.OAuthTokenManager.GetToken() self.sdk.users.GetAll(Pagination(1, 2)) self.assertEqual(token.access_token, self.sdk.OAuthTokenManager.GetToken().access_token)
def test_isTokenLeaking(self): api = self.buildNewMangoPayApi() self.sdk.users.GetAll(Pagination(1, 2)) token1 = self.sdk.OAuthTokenManager.GetToken() token2 = api.OAuthTokenManager.GetToken() self.assertEqual(token1.access_token, token2.access_token)