lob 5.4.5 → 6.0.0.pre.rc

data/__tests__/Api/BankAccount.unit.rb

@@ -0,0 +1,244 @@
+# BankAccount.unit.rb
+
+include OpenapiClient
+$:.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 }
+
+            DATE_FILTER  = { gt: "2020-01-01", lt: "2020-01-31T12" };
+            fakeBankAccounts[0].id = "bank_fakeId"
+            allow(bankAccountApi).to receive(:list) { fakeBankAccounts }
+            response = bankAccountApi.list(date_created: DATE_FILTER)
+
+            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 OpenapiClient
+$:.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

data/__tests__/Api/Card.unit.rb

@@ -0,0 +1,183 @@
+# Card.unit.rb
+
+include OpenapiClient
+$:.unshift File.expand_path("../../lib/openapi_client", File.dirname(__FILE__))
+
+RSpec.describe "CardsApi" do
+
+    it "can be instantiated" do
+        cardApiMock = double("ApiClient")
+        cardApi = CardsApi.new(cardApiMock)
+
+        expect(cardApi).not_to be_nil
+        expect(cardApi).to be_a_kind_of(CardsApi)
+    end
+
+    describe "Create" do
+        it "handles errors returned by the api" do
+            cardApiMock = double("ApiClient")
+            cardApi = CardsApi.new(cardApiMock)
+            cardEditable = CardEditable.new
+
+            allow(cardApi).to receive(:create).and_raise("exception thrown in create test")
+            begin
+                response = cardApi.create(cardEditable)
+            rescue => err
+                expect(err.message).to eq("exception thrown in create test")
+            end
+        end
+
+        it "creates a new card" do
+            cardApiMock = double("ApiClient")
+            cardApi = CardsApi.new(cardApiMock)
+            cardEditable = CardEditable.new
+            fakeCard = Card.new
+
+            fakeCard.id = "card_fakeId"
+            allow(cardApi).to receive(:create) { fakeCard }
+            response = cardApi.create(cardEditable)
+
+            expect(response).to eq(fakeCard)
+            expect(response.id).to eq(fakeCard.id)
+        end
+    end
+
+    describe "Get" do
+        it "handles errors returned by the api" do
+            cardApiMock = double("ApiClient")
+            cardApi = CardsApi.new(cardApiMock)
+            cardEditable = CardEditable.new
+
+            allow(cardApi).to receive(:get).and_raise("exception thrown in get test")
+            begin
+                response = cardApi.get("card_fakeId")
+            rescue => err
+                expect(err.message).to eq("exception thrown in get test")
+            end
+        end
+
+        it "retrieves an card" do
+            cardApiMock = double("ApiClient")
+            cardApi = CardsApi.new(cardApiMock)
+            cardEditable = CardEditable.new
+            fakeCard = Card.new
+
+            fakeCard.id = "card_fakeId"
+            allow(cardApi).to receive(:get) { fakeCard }
+            response = cardApi.get(fakeCard.id)
+
+            expect(response).to eq(fakeCard)
+            expect(response.id).to eq(fakeCard.id)
+        end
+    end
+
+    describe "List" do
+        it "handles errors returned by the api" do
+            cardApiMock = double("ApiClient")
+            cardApi = CardsApi.new(cardApiMock)
+            cardEditable = CardEditable.new
+
+            allow(cardApi).to receive(:list).and_raise("exception thrown in get test")
+            begin
+                response = cardApi.list()
+            rescue => err
+                expect(err.message).to eq("exception thrown in get test")
+            end
+        end
+
+        [
+            [nil, nil, nil, nil, nil],
+            ["limit", 2, nil, nil, nil],
+            ["before", nil, "before", nil, nil],
+            ["after", nil, nil, "after", nil],
+            ["include", nil, nil, nil, Array.new(1, "total_count")]
+        ].each do |which_param, limit, before, after, include_param|
+            it "lists cards #{which_param && ("with " + which_param + " param")}" do
+                args = {}
+                if limit then
+                    args["limit"] = limit
+                end
+
+                if before then
+                    args["before"] = before
+                end
+
+                if after then
+                    args["after"] = after
+                end
+
+                if include_param then
+                    args["include"] = include_param
+                end
+
+                cardApiMock = double("ApiClient")
+                cardApi = CardsApi.new(cardApiMock)
+                cardEditable = CardEditable.new
+                fakeCards = Array.new(2) { Card.new }
+
+                fakeCards[0].id = "card_fakeId"
+                allow(cardApi).to receive(:list) { fakeCards }
+                response = cardApi.list(args)
+
+                expect(response.length()).to eq(2)
+                expect(response).to eq(fakeCards)
+                expect(response[0].id).to eq(fakeCards[0].id)
+            end
+        end
+    end
+
+    describe "Update" do
+        it "handles errors returned by the api" do
+            cardApiMock = double("ApiClient")
+            cardApi = CardsApi.new(cardApiMock)
+
+            allow(cardApi).to receive(:update).and_raise("exception thrown in update test")
+            begin
+                response = cardApi.update("card_fakeId", nil)
+            rescue => err
+                expect(err.message).to eq("exception thrown in update test")
+            end
+        end
+
+        it "updates an card" do
+            cardApiMock = double("ApiClient")
+            cardApi = CardsApi.new(cardApiMock)
+            cardUpdatable = CardEditable.new
+            fakeCard = Card.new
+
+            fakeCard.id = "card_fakeId"
+            allow(cardApi).to receive(:update) { fakeCard }
+            response = cardApi.update(fakeCard.id, cardUpdatable)
+
+            expect(response).to eq(fakeCard)
+            expect(response.id).to eq(fakeCard.id)
+        end
+    end
+
+    describe "Delete" do
+        it "handles errors returned by the api" do
+            cardApiMock = double("ApiClient")
+            cardApi = CardsApi.new(cardApiMock)
+
+            allow(cardApi).to receive(:delete).and_raise("exception thrown in delete test")
+            begin
+                response = cardApi.delete("card_fakeId")
+            rescue => err
+                expect(err.message).to eq("exception thrown in delete test")
+            end
+        end
+
+        it "deletes a card" do
+            cardApiMock = double("ApiClient")
+            cardApi = CardsApi.new(cardApiMock)
+            cardDeletion = CardDeletion.new
+
+            cardDeletion.deleted = true
+            allow(cardApi).to receive(:delete) { cardDeletion }
+            response = cardApi.delete("card_fakeId")
+
+            expect(response).to eq(cardDeletion)
+            expect(response.deleted).to eq(true)
+        end
+    end
+end

data/__tests__/Api/CardOrder.unit.rb

@@ -0,0 +1,89 @@
+# CardOrder.unit.rb
+
+include OpenapiClient
+$:.unshift File.expand_path("../../lib/openapi_client", File.dirname(__FILE__))
+
+RSpec.describe "CardOrdersApi" do
+
+    it "can be instantiated" do
+        cardOrderApiMock = double("ApiClient")
+        cardOrderApi = CardOrdersApi.new(cardOrderApiMock)
+
+        expect(cardOrderApi).not_to be_nil
+        expect(cardOrderApi).to be_a_kind_of(CardOrdersApi)
+    end
+
+    describe "Create" do
+        it "handles errors returned by the api" do
+            cardOrderApiMock = double("ApiClient")
+            cardOrderApi = CardOrdersApi.new(cardOrderApiMock)
+            cardOrderEditable = CardOrderEditable.new
+
+            allow(cardOrderApi).to receive(:create).and_raise("exception thrown in create test")
+            begin
+                response = cardOrderApi.create("card_fakeId", cardOrderEditable)
+            rescue => err
+                expect(err.message).to eq("exception thrown in create test")
+            end
+        end
+
+        it "creates a new card order" do
+            cardOrderApiMock = double("ApiClient")
+            cardOrderApi = CardOrdersApi.new(cardOrderApiMock)
+            cardOrderEditable = CardOrderEditable.new
+            fakeCardOrder = CardOrder.new
+
+            fakeCardOrder.id = "co_fakeId"
+            allow(cardOrderApi).to receive(:create) { fakeCardOrder }
+            response = cardOrderApi.create("card_fakeId", cardOrderEditable)
+
+            expect(response).to eq(fakeCardOrder)
+            expect(response.id).to eq(fakeCardOrder.id)
+        end
+    end
+
+    describe "Retrieve" do
+        it "handles errors returned by the api" do
+            cardOrderApiMock = double("ApiClient")
+            cardOrderApi = CardOrdersApi.new(cardOrderApiMock)
+            cardOrderEditable = CardOrderEditable.new
+
+            allow(cardOrderApi).to receive(:get).and_raise("exception thrown in get test")
+            begin
+                response = cardOrderApi.get(nil)
+            rescue => err
+                expect(err.message).to eq("exception thrown in get test")
+            end
+        end
+
+        [
+            [nil, nil, nil],
+            ["limit", 2, nil],
+            ["offset", nil, 1]
+        ].each do |which_param, limit, offset|
+            it "lists card orders #{which_param && ("with " + which_param + " param")}" do
+                args = {}
+                if limit then
+                    args["limit"] = limit
+                end
+
+                if offset then
+                    args["offset"] = offset
+                end
+
+                cardOrderApiMock = double("ApiClient")
+                cardOrderApi = CardOrdersApi.new(cardOrderApiMock)
+                cardOrderEditable = CardOrderEditable.new
+                fakeCardOrders = Array.new(2) { CardOrder.new }
+
+                fakeCardOrders[0].id = "co_fakeId"
+                allow(cardOrderApi).to receive(:get) { fakeCardOrders }
+                response = cardOrderApi.get("card_fakeId", args)
+
+                expect(response.length()).to eq(2)
+                expect(response).to eq(fakeCardOrders)
+                expect(response[0].id).to eq(fakeCardOrders[0].id)
+            end
+        end
+    end
+end