Written test cases for invoice and created ledger: model,exceptions and methods

Author: ppatidar2021

src/bitpay_sdk/client.py

@@ -2,16 +2,19 @@
 import json
 
 from .config import Config
-from .models.bill.bill import Bill
 from .tokens import Tokens
 from .models.facade import Facade
+from .models.bill.bill import Bill
 from .utils.rest_cli import RESTcli
+from .models.ledger.ledger import Ledger
 from .models.wallet.wallet import Wallet
 from .models.invoice.refund import Refund
 from .models.invoice.invoice import Invoice
+from .models.ledger.ledger_entry import LedgerEntry
 from .exceptions.bitpay_exception import BitPayException
 from .exceptions.bill_query_exception import BillQueryException
 from .exceptions.bill_update_exception import BillUpdateException
+from .exceptions.ledger_query_exception import LedgerQueryException
 from .exceptions.wallet_query_exception import WalletQueryException
 from .exceptions.refund_query_exception import RefundQueryException
 from .exceptions.bill_creation_exception import BillCreationException
@@ -58,6 +61,7 @@ def build_config_from_file(self, config_file_path: str):
                     json_data = json.loads(read_file.read())
                     self.__env = json_data['BitPayConfiguration']['Environment']
                     env_config = json_data["BitPayConfiguration"]["EnvConfig"][self.__env]
+                    read_file.close()
                 except Exception as e:
                     raise BitPayException("Error when reading configuration file", str(e))
 
@@ -455,4 +459,40 @@ def deliver_bill(self, bill_id: str, bill_token: str) -> bool:
             raise BillDeliveryException("failed to deserialize BitPay server response (Bill) : %s" % str(e))
         return bill
 
+    def get_ledger(self, currency: str, start_date: str, end_date: str) -> [Ledger]:
+        try:
+            params = {"token": self.get_access_token(Facade.Merchant)}
+
+            if currency:
+                params["currency"] = currency
+
+            if start_date:
+                params["startDate"] = start_date
+
+            if end_date:
+                params["endDate"] = end_date
+
+            response_json = self.__restcli.get("ledgers/%s" % currency, params)
+        except BitPayException as e:
+            raise LedgerQueryException("failed to serialize Ledger object :  %s" % str(e),
+                                       e.get_api_code())
+
+        try:
+            ledger = LedgerEntry(**response_json)
+        except Exception as e:
+            raise LedgerQueryException("failed to deserialize BitPay server response (Ledger) : %s" % str(e))
+        return ledger
+
+    def get_ledgers(self) -> [Ledger]:
+        try:
+            params = {"token": self.get_access_token(Facade.Merchant)}
+            response_json = self.__restcli.get("ledgers", params)
+        except BitPayException as e:
+            raise LedgerQueryException("failed to serialize Ledger object :  %s" % str(e),
+                                       e.get_api_code())
 
+        try:
+            ledgers = Ledger(**response_json)
+        except Exception as e:
+            raise LedgerQueryException("failed to deserialize BitPay server response (Ledger) : %s" % str(e))
+        return ledgers

src/bitpay_sdk/exceptions/ledger_exception.py

@@ -0,0 +1,15 @@
+from .bitpay_exception import BitPayException
+
+
+class LedgerException(BitPayException):
+    __bitpay_message = "An unexpected error occurred while trying to manage the ledger"
+    __bitpay_code = "BITPAY-LEDGER-GENERIC"
+    __api_code = ""
+
+    def __init__(self, message="", code=131, api_code="000000"):
+        message = self.__bitpay_code + ": " + self.__bitpay_message + ":" + message
+        self.__api_code = api_code
+        super().__init__(message, code)
+
+    def get_api_code(self):
+        return self.__api_code

src/bitpay_sdk/exceptions/ledger_query_exception.py

@@ -0,0 +1,15 @@
+from src.bitpay_sdk.exceptions.ledger_exception import LedgerException
+
+
+class LedgerQueryException(LedgerException):
+    __bitpay_message = "Failed to retrieve ledger"
+    __bitpay_code = "BITPAY-LEDGER-GET"
+    __api_code = ""
+
+    def __init__(self, message, code=132, api_code="000000"):
+        message = self.__bitpay_code + ": " + self.__bitpay_message + ":" + message
+        self.__api_code = api_code
+        super.__init__(message, code)
+
+    def get_api_code(self):
+        return self.__api_code

src/bitpay_sdk/models/currency.py

@@ -210,6 +210,91 @@ def is_valid(self, value):
     def __init__(self):
         pass
 
-    #  TODO: Add get set methods
+    def get_code(self):
+        return self.__code
 
-    
+    def set_code(self, code):
+        self.__code = code
+
+    def get_symbol(self):
+        return self.__symbol
+
+    def set_symbol(self, symbol):
+        self.__symbol = symbol
+
+    def get_precision(self):
+        return self.__precision
+
+    def set_precision(self, precision):
+        self.__precision = precision
+
+    def get_currently_settled(self):
+        return self.__currently_settled
+
+    def set_currently_settled(self, currently_settled):
+        self.__currently_settled = currently_settled
+
+    def get_name(self):
+        return self.__name
+
+    def set_name(self, name):
+        self.__name = name
+
+    def get_plural(self):
+        return self.__plural
+
+    def set_plural(self, plural):
+        self.__plural = plural
+
+    def get_alts(self):
+        return self.__alts
+
+    def set_alts(self, alts):
+        self.__alts = alts
+
+    def get_minimum(self):
+        return self.__minimum
+
+    def set_minimum(self, minimum):
+        self.__minimum = minimum
+
+    def get_sanctioned(self):
+        return self.__sanctioned
+
+    def set_sanctioned(self, sanctioned):
+        self.__sanctioned = sanctioned
+
+    def get_decimals(self):
+        return self.__decimals
+
+    def set_decimals(self, decimals):
+        self.__decimals = decimals
+
+    def get_payout_fields(self):
+        return self.__payout_fields
+
+    def set_payout_fields(self, payout_fields):
+        self.__payout_fields = payout_fields
+
+    def get_settlement_minimum(self):
+        return self.__settlement_minimum
+
+    def set_settlement_minimum(self, settlement_minimum):
+        self.__settlement_minimum = settlement_minimum
+
+    def to_json(self):
+        data = {
+            "code": self.get_code(),
+            "symbol": self.get_symbol(),
+            "precision": self.get_precision(),
+            "currentlySettled": self.get_currently_settled(),
+            "name": self.get_name(),
+            "plural": self.get_plural(),
+            "alts": self.get_alts(),
+            "minimum": self.get_minimum(),
+            "sanctioned": self.get_sanctioned(),
+            "decimals": self.get_decimals(),
+            "payoutFields": self.get_payout_fields(),
+            "settlementMinimum": self.get_settlement_minimum(),
+        }
+        return data

src/bitpay_sdk/models/invoice/buyer.py

@@ -79,3 +79,18 @@ def get_notify(self):
 
     def set_notify(self, notify):
         self.__notify = notify
+
+    def to_json(self):
+        data = {
+            "name": self.get_name(),
+            "address1": self.get_address1(),
+            "address2": self.get_address2(),
+            "locality": self.get_locality(),
+            "region": self.get_region(),
+            "postalCode": self.get_postal_code(),
+            "country": self.get_country(),
+            "email": self.get_email(),
+            "phone": self.get_phone(),
+            "notify": self.get_notify(),
+        }
+        return data

src/bitpay_sdk/models/invoice/invoice.py

@@ -67,17 +67,17 @@ class Invoice(object):
     __display_amount_paid = None
     __exchange_rates = None
 
-    # Newly added on January 7
-    __payment_string = None  # added
-    __verification_link = None  # added
-    __buyer_email = None  # added
-    __merchant_name = None  # added
+    __payment_string = None
+    __verification_link = None
+    __buyer_email = None
+    __merchant_name = None
     __forced_buyer_selected_wallet = None
     __forced_buyer_selected_transaction_currency = None
-    __itemized_details = ItemizedDetails()  # added but have doubt in set method
-    __universal_codes = UniversalCodes()  # added
+    __itemized_details = ItemizedDetails()
+    __universal_codes = UniversalCodes()
     __is_cancelled = None
     __bitpay_id_required = None
+    __rate_refresh_time = None
 
     def __init__(self, price=None, currency=None, **kwargs):
 
@@ -89,7 +89,13 @@ def __init__(self, price=None, currency=None, **kwargs):
                 if key in ["buyer", "buyerProvidedInfo", "shopper", "supportedTransactionCurrencies", "minerFees",
                            "refundInfo", "universalCodes", "itemizedDetails"]:
                     klass = globals()[key[0].upper() + key[1:]]
-                    value = klass(**value)
+
+                    if isinstance(value, list):
+                        value = []
+                        for obj in value:
+                            value.append(klass(**obj))
+                    else:
+                        value = klass(**value)
                 getattr(self, 'set_%s' % change_camel_case_to_snake_case(key))(value)
             except AttributeError as e:
                 print(e)
@@ -190,10 +196,10 @@ def get_payment_display_totals(self):
     def set_payment_display_totals(self, payment_display_totals):
         self.__payment_display_totals = payment_display_totals
 
-    def get_payment_display_subtotals(self):
+    def get_payment_display_sub_totals(self):
         return self.__payment_display_subtotals
 
-    def set_payment_display_subtotals(self, payment_display_subtotals):
+    def set_payment_display_sub_totals(self, payment_display_subtotals):
         self.__payment_display_subtotals = payment_display_subtotals
 
     def get_payment_codes(self):
@@ -226,10 +232,10 @@ def get_auto_redirect(self):
     def set_auto_redirect(self, auto_redirect):
         self.__auto_redirect = auto_redirect
 
-    def get_json_paypro_required(self):
+    def get_json_pay_pro_required(self):
         return self.__json_paypro_required
 
-    def set_json_paypro_required(self, json_paypro_required):
+    def set_json_pay_pro_required(self, json_paypro_required):
         self.__json_paypro_required = json_paypro_required
 
     def get_id(self):
@@ -448,6 +454,12 @@ def get_bitpay_id_required(self):
     def set_bitpay_id_required(self, bitpay_id_required):
         self.__bitpay_id_required = bitpay_id_required
 
+    def get_rate_refresh_time(self):
+        return self.__rate_refresh_time
+
+    def set_rate_refresh_time(self, rate_refresh_time):
+        self.__rate_refresh_time = rate_refresh_time
+
     def get_universal_codes(self):
         return self.__universal_codes
 

src/bitpay_sdk/models/invoice/supported_transaction_currencies.py

@@ -7,6 +7,7 @@ class SupportedTransactionCurrencies(object):
     __eth = SupportedTransactionCurrency()
     __usdc = SupportedTransactionCurrency()
     __gusd = SupportedTransactionCurrency()
+    __busd = SupportedTransactionCurrency()
     __pax = SupportedTransactionCurrency()
     __xrp = SupportedTransactionCurrency()
     __doge = SupportedTransactionCurrency()
@@ -15,7 +16,7 @@ class SupportedTransactionCurrencies(object):
     def __init__(self, **kwargs):
         for key, value in kwargs.items():
             try:
-                if key in ["BTC", "BCH", "ETH", "USDC", "GUSD", "PAX", "XRP", "DOGE", "LTC"]:
+                if key in ["BTC", "BCH", "ETH", "USDC", "GUSD", "BUSD", "PAX", "XRP", "DOGE", "LTC"]:
                     value = SupportedTransactionCurrency(**value)
                 getattr(self, 'set_%s' % key.lower())(value)
             except AttributeError as e:
@@ -51,6 +52,12 @@ def get_gusd(self):
     def set_gusd(self, gusd: SupportedTransactionCurrency):
         self.__gusd = gusd
 
+    def get_busd(self):
+        return self.__busd
+
+    def set_busd(self, busd: SupportedTransactionCurrency):
+        self.__busd = busd
+
     def get_pax(self):
         return self.__pax
 
@@ -82,6 +89,7 @@ def to_json(self):
             "eth": self.get_eth(),
             "usdc": self.get_usdc(),
             "gusd": self.get_gusd(),
+            "busd": self.get_busd(),
             "pax": self.get_pax(),
             "xrp": self.get_xrp(),
             "doge": self.get_doge(),