lob 5.1.2 → 6.0.5

data/__tests__/Api/Address.unit.rb

@@ -0,0 +1,210 @@
+# Address.unit.rb
+
+include Lob
+$:.unshift File.expand_path("../../lib/openapi_client", File.dirname(__FILE__))
+require 'api/addresses_api'
+require 'models/address'
+require 'models/address_editable'
+
+
+RSpec.describe "AddressesApi" do
+
+    it "can be instantiated" do
+        addressApiMock = double("ApiClient")
+        addressApi = AddressesApi.new(addressApiMock)
+
+        expect(addressApi).not_to be_nil
+        expect(addressApi).to be_a_kind_of(AddressesApi)
+    end
+
+    describe "Create" do
+        it "handles errors returned by the api" do
+            addressApiMock = double("ApiClient")
+            addressApi = AddressesApi.new(addressApiMock)
+            addressEditable = AddressEditable.new
+
+            allow(addressApi).to receive(:create).and_raise("exception thrown in create test")
+            begin
+                response = addressApi.create(addressEditable)
+            rescue => err
+                expect(err.message).to eq("exception thrown in create test")
+            end
+        end
+
+        it "creates a new address" do
+            addressApiMock = double("ApiClient")
+            addressApi = AddressesApi.new(addressApiMock)
+            addressEditable = AddressEditable.new
+            fakeAddress = Address.new
+
+            fakeAddress.id = "adr_fakeid"
+            allow(addressApi).to receive(:create) { fakeAddress }
+            response = addressApi.create(addressEditable)
+
+            expect(response).to eq(fakeAddress)
+            expect(response.id).to eq(fakeAddress.id)
+        end
+    end
+
+    describe "Get" do
+        it "handles errors returned by the api" do
+            addressApiMock = double("ApiClient")
+            addressApi = AddressesApi.new(addressApiMock)
+
+            allow(addressApi).to receive(:get).and_raise("exception thrown in get test")
+            begin
+                response = addressApi.get("adr_fakeId")
+            rescue => err
+                expect(err.message).to eq("exception thrown in get test")
+            end
+        end
+
+        it "retrieves an address" do
+            addressApiMock = double("ApiClient")
+            addressApi = AddressesApi.new(addressApiMock)
+            fakeAddress = Address.new
+
+            fakeAddress.id = "adr_fakeid"
+            allow(addressApi).to receive(:get) { fakeAddress }
+            response = addressApi.get(fakeAddress.id)
+
+            expect(response).to eq(fakeAddress)
+            expect(response.id).to eq(fakeAddress.id)
+        end
+    end
+
+    describe "List" do
+        it "handles errors returned by the api" do
+            addressApiMock = double("ApiClient")
+            addressApi = AddressesApi.new(addressApiMock)
+            addressEditable = AddressEditable.new
+
+            allow(addressApi).to receive(:list).and_raise("exception thrown in get test")
+            begin
+                response = addressApi.list()
+            rescue => err
+                expect(err.message).to eq("exception thrown in get test")
+            end
+        end
+
+        it "lists addresses" do
+            addressApiMock = double("ApiClient")
+            addressApi = AddressesApi.new(addressApiMock)
+            addressEditable = AddressEditable.new
+            fakeAddresses = Array.new(2) { Address.new }
+
+            fakeAddresses[0].id = "adr_fakeid"
+            allow(addressApi).to receive(:list) { fakeAddresses }
+            response = addressApi.list()
+
+            expect(response.length()).to eq(2)
+            expect(response).to eq(fakeAddresses)
+            expect(response[0].id).to eq(fakeAddresses[0].id)
+        end
+
+        it "lists addresses with a limit parameter" do
+            addressApiMock = double("ApiClient")
+            addressApi = AddressesApi.new(addressApiMock)
+            addressEditable = AddressEditable.new
+            fakeAddresses = Array.new(2) { Address.new }
+
+            fakeAddresses[0].id = "adr_fakeid"
+            allow(addressApi).to receive(:list) { fakeAddresses }
+            response = addressApi.list(limit: 10)
+
+            expect(response.length()).to eq(2)
+            expect(response).to eq(fakeAddresses)
+            expect(response[0].id).to eq(fakeAddresses[0].id)
+        end
+
+        it "lists addresses with a before parameter" do
+            addressApiMock = double("ApiClient")
+            addressApi = AddressesApi.new(addressApiMock)
+            addressEditable = AddressEditable.new
+            fakeAddresses = Array.new(2) { Address.new }
+
+            fakeAddresses[0].id = "adr_fakeid"
+            allow(addressApi).to receive(:list) { fakeAddresses }
+            response = addressApi.list(before: 'before')
+
+            expect(response.length()).to eq(2)
+            expect(response).to eq(fakeAddresses)
+            expect(response[0].id).to eq(fakeAddresses[0].id)
+        end
+
+        it "lists addresses with a after parameter" do
+            addressApiMock = double("ApiClient")
+            addressApi = AddressesApi.new(addressApiMock)
+            addressEditable = AddressEditable.new
+            fakeAddresses = Array.new(2) { Address.new }
+
+            fakeAddresses[0].id = "adr_fakeid"
+            allow(addressApi).to receive(:list) { fakeAddresses }
+            response = addressApi.list(after: 'after')
+
+            expect(response.length()).to eq(2)
+            expect(response).to eq(fakeAddresses)
+            expect(response[0].id).to eq(fakeAddresses[0].id)
+        end
+
+        it "lists addresses with a date created parameter" do
+            addressApiMock = double("ApiClient")
+            addressApi = AddressesApi.new(addressApiMock)
+            addressEditable = AddressEditable.new
+            fakeAddresses = Array.new(2) { Address.new }
+
+            dateFilter  = { gt: "2020-01-01", lt: "2020-01-31T12" };
+            fakeAddresses[0].id = "adr_fakeid"
+            allow(addressApi).to receive(:list) { fakeAddresses }
+            response = addressApi.list(date_created: dateFilter)
+
+            expect(response.length()).to eq(2)
+            expect(response).to eq(fakeAddresses)
+            expect(response[0].id).to eq(fakeAddresses[0].id)
+        end
+
+        it "lists addresses with a metadata parameter" do
+            addressApiMock = double("ApiClient")
+            addressApi = AddressesApi.new(addressApiMock)
+            addressEditable = AddressEditable.new
+            fakeAddresses = Array.new(2) { Address.new }
+
+            metadata  = { fakeMetadata: "fakemetadata" }
+            fakeAddresses[0].id = "adr_fakeid"
+            allow(addressApi).to receive(:list) { fakeAddresses }
+            response = addressApi.list(metadata: metadata)
+
+            expect(response.length()).to eq(2)
+            expect(response).to eq(fakeAddresses)
+            expect(response[0].id).to eq(fakeAddresses[0].id)
+        end
+    end
+
+    describe "Delete" do
+        it "handles errors returned by the api" do
+            addressApiMock = double("ApiClient")
+            addressApi = AddressesApi.new(addressApiMock)
+            addressEditable = AddressEditable.new
+
+            allow(addressApi).to receive(:delete).and_raise("exception thrown in delete test")
+            begin
+                response = addressApi.delete(addressEditable)
+            rescue => err
+                expect(err.message).to eq("exception thrown in delete test")
+            end
+        end
+
+        it "deletes an address" do
+            addressApiMock = double("ApiClient")
+            addressApi = AddressesApi.new(addressApiMock)
+            fakeAddressDeletion = AddressDeletion.new
+
+            fakeAddressDeletion.deleted = true
+            allow(addressApi).to receive(:delete) { fakeAddressDeletion }
+            response = addressApi.delete("adr_fakeId")
+
+            expect(response).to eq(fakeAddressDeletion)
+            expect(response.deleted).to eq(true)
+        end
+    end
+  end

data/__tests__/Api/BankAccount.unit.rb

@@ -0,0 +1,244 @@
+# BankAccount.unit.rb
+
+include Lob
+$:.unshift File.expand_path("../../lib/openapi_client", File.dirname(__FILE__))
+require 'api/bank_accounts_api'
+require 'models/bank_account'
+require 'models/bank_account_writable'
+
+
+RSpec.describe "BankAccountsApi" do
+
+    it "can be instantiated" do
+        bankAccountApiMock = double("ApiClient")
+        bankAccountApi = BankAccountsApi.new(bankAccountApiMock)
+
+        expect(bankAccountApi).not_to be_nil
+        expect(bankAccountApi).to be_a_kind_of(BankAccountsApi)
+    end
+
+    describe "Create" do
+        it "handles errors returned by the api" do
+            bankAccountApiMock = double("ApiClient")
+            bankAccountApi = BankAccountsApi.new(bankAccountApiMock)
+            bankAccountWritable = BankAccountWritable.new
+
+            allow(bankAccountApi).to receive(:create).and_raise("exception thrown in create test")
+            begin
+                response = bankAccountApi.create(bankAccountWritable)
+            rescue => err
+                expect(err.message).to eq("exception thrown in create test")
+            end
+        end
+
+        it "creates a new bank account" do
+            bankAccountApiMock = double("ApiClient")
+            bankAccountApi = BankAccountsApi.new(bankAccountApiMock)
+            bankAccountWritable = BankAccountWritable.new
+            fakeBankAccount = BankAccount.new
+
+            fakeBankAccount.id = "bank_fakeId"
+            allow(bankAccountApi).to receive(:create) { fakeBankAccount }
+            response = bankAccountApi.create(bankAccountWritable)
+
+            expect(response).to eq(fakeBankAccount)
+            expect(response.id).to eq(fakeBankAccount.id)
+        end
+    end
+
+    describe "Get" do
+        it "handles errors returned by the api" do
+            bankAccountApiMock = double("ApiClient")
+            bankAccountApi = BankAccountsApi.new(bankAccountApiMock)
+            bankAccountWritable = BankAccountWritable.new
+
+            allow(bankAccountApi).to receive(:get).and_raise("exception thrown in get test")
+            begin
+                response = bankAccountApi.get("bank_fakeId")
+            rescue => err
+                expect(err.message).to eq("exception thrown in get test")
+            end
+        end
+
+        it "retrieves an bank account" do
+            bankAccountApiMock = double("ApiClient")
+            bankAccountApi = BankAccountsApi.new(bankAccountApiMock)
+            bankAccountWritable = BankAccountWritable.new
+            fakeBankAccount = BankAccount.new
+
+            fakeBankAccount.id = "bank_fakeId"
+            allow(bankAccountApi).to receive(:get) { fakeBankAccount }
+            response = bankAccountApi.get(fakeBankAccount.id)
+
+            expect(response).to eq(fakeBankAccount)
+            expect(response.id).to eq(fakeBankAccount.id)
+        end
+    end
+
+    describe "List" do
+        it "handles errors returned by the api" do
+            bankAccountApiMock = double("ApiClient")
+            bankAccountApi = BankAccountsApi.new(bankAccountApiMock)
+            bankAccountWritable = BankAccountWritable.new
+
+            allow(bankAccountApi).to receive(:list).and_raise("exception thrown in get test")
+            begin
+                response = bankAccountApi.list()
+            rescue => err
+                expect(err.message).to eq("exception thrown in get test")
+            end
+        end
+
+        it "lists bank accounts" do
+            bankAccountApiMock = double("ApiClient")
+            bankAccountApi = BankAccountsApi.new(bankAccountApiMock)
+            bankAccountWritable = BankAccountWritable.new
+            fakeBankAccounts = Array.new(2) { BankAccount.new }
+
+            fakeBankAccounts[0].id = "bank_fakeId"
+            allow(bankAccountApi).to receive(:list) { fakeBankAccounts }
+            response = bankAccountApi.list()
+
+            expect(response.length()).to eq(2)
+            expect(bankAccountApi.list).to eq(fakeBankAccounts)
+            expect(response[0].id).to eq(fakeBankAccounts[0].id)
+        end
+
+        it "lists bank accounts with a limit parameter" do
+            bankAccountApiMock = double("ApiClient")
+            bankAccountApi = BankAccountsApi.new(bankAccountApiMock)
+            bankAccountWritable = BankAccountWritable.new
+            fakeBankAccounts = Array.new(2) { BankAccount.new }
+
+            fakeBankAccounts[0].id = "bank_fakeId"
+            allow(bankAccountApi).to receive(:list) { fakeBankAccounts }
+            response = bankAccountApi.list(limit: 10)
+
+            expect(response.length()).to eq(2)
+            expect(bankAccountApi.list).to eq(fakeBankAccounts)
+            expect(response[0].id).to eq(fakeBankAccounts[0].id)
+        end
+
+        it "lists bank accounts with a before parameter" do
+            bankAccountApiMock = double("ApiClient")
+            bankAccountApi = BankAccountsApi.new(bankAccountApiMock)
+            bankAccountWritable = BankAccountWritable.new
+            fakeBankAccounts = Array.new(2) { BankAccount.new }
+
+            fakeBankAccounts[0].id = "bank_fakeId"
+            allow(bankAccountApi).to receive(:list) { fakeBankAccounts }
+            response = bankAccountApi.list(before: 'before')
+
+            expect(response.length()).to eq(2)
+            expect(bankAccountApi.list).to eq(fakeBankAccounts)
+            expect(response[0].id).to eq(fakeBankAccounts[0].id)
+        end
+
+        it "lists bank accounts with a after parameter" do
+            bankAccountApiMock = double("ApiClient")
+            bankAccountApi = BankAccountsApi.new(bankAccountApiMock)
+            bankAccountWritable = BankAccountWritable.new
+            fakeBankAccounts = Array.new(2) { BankAccount.new }
+
+            fakeBankAccounts[0].id = "bank_fakeId"
+            allow(bankAccountApi).to receive(:list) { fakeBankAccounts }
+            response = bankAccountApi.list(after: 'after')
+
+            expect(response.length()).to eq(2)
+            expect(bankAccountApi.list).to eq(fakeBankAccounts)
+            expect(response[0].id).to eq(fakeBankAccounts[0].id)
+        end
+
+        it "lists bank accounts with a date created parameter" do
+            bankAccountApiMock = double("ApiClient")
+            bankAccountApi = BankAccountsApi.new(bankAccountApiMock)
+            bankAccountWritable = BankAccountWritable.new
+            fakeBankAccounts = Array.new(2) { BankAccount.new }
+
+            dateFilter  = { gt: "2020-01-01", lt: "2020-01-31T12" };
+            fakeBankAccounts[0].id = "bank_fakeId"
+            allow(bankAccountApi).to receive(:list) { fakeBankAccounts }
+            response = bankAccountApi.list(date_created: dateFilter)
+
+            expect(response.length()).to eq(2)
+            expect(bankAccountApi.list).to eq(fakeBankAccounts)
+            expect(response[0].id).to eq(fakeBankAccounts[0].id)
+        end
+
+        it "lists bank accounts with a metadata parameter" do
+            bankAccountApiMock = double("ApiClient")
+            bankAccountApi = BankAccountsApi.new(bankAccountApiMock)
+            bankAccountWritable = BankAccountWritable.new
+            fakeBankAccounts = Array.new(2) { BankAccount.new }
+
+            metadata  = { fakeMetadata: "fakemetadata" }
+            fakeBankAccounts[0].id = "bank_fakeId"
+            allow(bankAccountApi).to receive(:list) { fakeBankAccounts }
+            response = bankAccountApi.list(metadata: metadata)
+
+            expect(response.length()).to eq(2)
+            expect(bankAccountApi.list).to eq(fakeBankAccounts)
+            expect(response[0].id).to eq(fakeBankAccounts[0].id)
+        end
+    end
+
+    describe "Delete" do
+        it "handles errors returned by the api" do
+            bankAccountApiMock = double("ApiClient")
+            bankAccountApi = BankAccountsApi.new(bankAccountApiMock)
+            bankAccountWritable = BankAccountWritable.new
+
+            allow(bankAccountApi).to receive(:delete).and_raise("exception thrown in delete test")
+            begin
+                response = bankAccountApi.delete(bankAccountWritable)
+            rescue => err
+                expect(err.message).to eq("exception thrown in delete test")
+            end
+        end
+
+        it "deletes a bank account" do
+            bankAccountApiMock = double("ApiClient")
+            bankAccountApi = BankAccountsApi.new(bankAccountApiMock)
+            bankAccountWritable = BankAccountWritable.new
+            fakeBankAccount = BankAccount.new
+
+            fakeBankAccount.deleted = true
+            allow(bankAccountApi).to receive(:delete) { fakeBankAccount }
+            response = bankAccountApi.delete(bankAccountWritable)
+
+            expect(response).to eq(fakeBankAccount)
+            expect(response.deleted).to eq(true)
+        end
+    end
+
+    describe "Verify" do
+      it "handles errors returned by the api" do
+          bankAccountApiMock = double("ApiClient")
+          bankAccountApi = BankAccountsApi.new(bankAccountApiMock)
+          bankAccountVerify = BankAccountVerify.new
+
+          allow(bankAccountApi).to receive(:verify).and_raise("exception thrown in verification test")
+          begin
+              response = bankAccountApi.verify("bank_fakeId", bankAccountVerify)
+          rescue => err
+              expect(err.message).to eq("exception thrown in verification test")
+          end
+      end
+
+      it "verifies a bank account" do
+          bankAccountApiMock = double("ApiClient")
+          bankAccountApi = BankAccountsApi.new(bankAccountApiMock)
+          bankAccountVerify = BankAccountVerify.new
+          fakeBankAccount = BankAccount.new
+          fakeBankAccount.verified = true
+          fakeBankAccount.id = "bank_fakeId"
+
+          allow(bankAccountApi).to receive(:verify) { fakeBankAccount }
+          response = bankAccountApi.verify(fakeBankAccount.id, bankAccountVerify)
+
+          expect(response).to eq(fakeBankAccount)
+          expect(response.id).to eq(fakeBankAccount.id)
+          expect(response.verified).to eq(fakeBankAccount.verified)
+      end
+    end
+  end

data/__tests__/Api/BillingGroup.unit.rb

@@ -0,0 +1,170 @@
+# BillingGroup.unit.rb
+
+include Lob
+$:.unshift File.expand_path("../../lib/openapi_client", File.dirname(__FILE__))
+require 'api/billing_groups_api'
+require 'models/billing_group'
+require 'models/billing_group_editable'
+
+
+RSpec.describe "BillingGroupsApi" do
+
+    it "can be instantiated" do
+        billingGroupApiMock = double("ApiClient")
+        billingGroupApi = BillingGroupsApi.new(billingGroupApiMock)
+
+        expect(billingGroupApi).not_to be_nil
+        expect(billingGroupApi).to be_a_kind_of(BillingGroupsApi)
+    end
+
+    describe "Create" do
+        it "handles errors returned by the api" do
+            billingGroupApiMock = double("ApiClient")
+            billingGroupApi = BillingGroupsApi.new(billingGroupApiMock)
+            billingGroupEditable = BillingGroupEditable.new
+
+            allow(billingGroupApi).to receive(:create).and_raise("exception thrown in create test")
+            begin
+                response = billingGroupApi.create(billingGroupEditable)
+            rescue => err
+                expect(err.message).to eq("exception thrown in create test")
+            end
+        end
+
+        it "creates a new billing group" do
+            billingGroupApiMock = double("ApiClient")
+            billingGroupApi = BillingGroupsApi.new(billingGroupApiMock)
+            billingGroupEditable = BillingGroupEditable.new
+            fakeBillingGroup = BillingGroup.new
+
+            fakeBillingGroup.id = "bg_fakeId"
+            allow(billingGroupApi).to receive(:create) { fakeBillingGroup }
+            response = billingGroupApi.create(billingGroupEditable)
+
+            expect(response).to eq(fakeBillingGroup)
+            expect(response.id).to eq(fakeBillingGroup.id)
+        end
+    end
+
+    describe "Get" do
+        it "handles errors returned by the api" do
+            billingGroupApiMock = double("ApiClient")
+            billingGroupApi = BillingGroupsApi.new(billingGroupApiMock)
+            billingGroupEditable = BillingGroupEditable.new
+
+            allow(billingGroupApi).to receive(:get).and_raise("exception thrown in get test")
+            begin
+                response = billingGroupApi.get("bg_fakeId")
+            rescue => err
+                expect(err.message).to eq("exception thrown in get test")
+            end
+        end
+
+        it "retrieves an billing group" do
+            billingGroupApiMock = double("ApiClient")
+            billingGroupApi = BillingGroupsApi.new(billingGroupApiMock)
+            billingGroupEditable = BillingGroupEditable.new
+            fakeBillingGroup = BillingGroup.new
+
+            fakeBillingGroup.id = "bg_fakeId"
+            allow(billingGroupApi).to receive(:get) { fakeBillingGroup }
+            response = billingGroupApi.get(fakeBillingGroup.id)
+
+            expect(response).to eq(fakeBillingGroup)
+            expect(response.id).to eq(fakeBillingGroup.id)
+        end
+    end
+
+    describe "List" do
+        it "handles errors returned by the api" do
+            billingGroupApiMock = double("ApiClient")
+            billingGroupApi = BillingGroupsApi.new(billingGroupApiMock)
+            billingGroupEditable = BillingGroupEditable.new
+
+            allow(billingGroupApi).to receive(:list).and_raise("exception thrown in get test")
+            begin
+                response = billingGroupApi.list()
+            rescue => err
+                expect(err.message).to eq("exception thrown in get test")
+            end
+        end
+
+        [
+            [nil, nil, nil, nil, nil, nil, nil],
+            ["limit", 2, nil, nil, nil, nil, nil],
+            ["offset", nil, 1, nil, nil, nil, nil],
+            ["include", nil, nil, Array.new(1, "total_count"), nil, nil, nil],
+            ["date_created", nil, nil, nil, { gt: "2020-01-01", lt: "2020-01-31T12" }, nil, nil],
+            ["date_modified", nil, nil, nil, nil, { gt: "2020-01-01", lt: "2020-01-31T12" }, nil],
+            ["sort_by", nil, nil, nil, nil, nil, SortByDateModified.new(date_modified: "asc")],
+        ].each do |which_param, limit, offset, include_param, date_created, date_modified, sort_by_date_modified|
+            it "lists billing groups #{which_param && ("with " + which_param + " param")}" do
+                args = {}
+                if limit then
+                    args["limit"] = limit
+                end
+
+                if offset then
+                    args["offset"] = offset
+                end
+
+                if include_param then
+                    args["include"] = include_param
+                end
+
+                if date_created then
+                    args["date_created"] = date_created
+                end
+
+                if date_modified then
+                    args["date_modified"] = date_modified
+                end
+
+                if sort_by_date_modified then
+                    args["sort_by"] = sort_by_date_modified
+                end
+
+                billingGroupApiMock = double("ApiClient")
+                billingGroupApi = BillingGroupsApi.new(billingGroupApiMock)
+                billingGroupEditable = BillingGroupEditable.new
+                fakeBillingGroups = Array.new(2) { BillingGroup.new }
+
+                fakeBillingGroups[0].id = "bg_fakeId"
+                allow(billingGroupApi).to receive(:list) { fakeBillingGroups }
+                response = billingGroupApi.list(args)
+
+                expect(response.length()).to eq(2)
+                expect(response).to eq(fakeBillingGroups)
+                expect(response[0].id).to eq(fakeBillingGroups[0].id)
+            end
+        end
+    end
+
+    describe "Update" do
+        it "handles errors returned by the api" do
+            billingGroupApiMock = double("ApiClient")
+            billingGroupApi = BillingGroupsApi.new(billingGroupApiMock)
+
+            allow(billingGroupApi).to receive(:update).and_raise("exception thrown in update test")
+            begin
+                response = billingGroupApi.update("bg_fakeId", nil)
+            rescue => err
+                expect(err.message).to eq("exception thrown in update test")
+            end
+        end
+
+        it "updates an billing group" do
+            billingGroupApiMock = double("ApiClient")
+            billingGroupApi = BillingGroupsApi.new(billingGroupApiMock)
+            billingGroupUpdatable = BillingGroupEditable.new
+            fakeBillingGroup = BillingGroup.new
+
+            fakeBillingGroup.id = "bg_fakeId"
+            allow(billingGroupApi).to receive(:update) { fakeBillingGroup }
+            response = billingGroupApi.update(fakeBillingGroup.id, billingGroupUpdatable)
+
+            expect(response).to eq(fakeBillingGroup)
+            expect(response.id).to eq(fakeBillingGroup.id)
+        end
+    end
+end