quaderno 1.14.0 → 1.15.1

data/test/unit/test_quaderno_invoices.rb

@@ -1,177 +0,0 @@
-require 'helper'
-
-class TestQuadernoInvoice < Test::Unit::TestCase
-  context 'A user with an authenticate token with invoices' do
-
-    setup do
-      Quaderno::Base.configure do |config|
-        config.auth_token = TEST_KEY
-        config.url = TEST_URL
-        config.api_version = nil
-      end
-    end
-
-    should 'get exception if pass wrong arguments' do
-      assert_raise ArgumentError do
-        VCR.use_cassette('all invoices') do
-          Quaderno::Invoice.all 1, 2, 3
-        end
-      end
-      assert_raise ArgumentError do
-        VCR.use_cassette('found invoice') do
-          Quaderno::Invoice.find
-        end
-      end
-    end
-
-    should 'get all invoices (populated db)' do
-      VCR.use_cassette('all invoices') do
-        invoices = Quaderno::Invoice.all
-        assert_not_nil invoices
-        assert_kind_of Array, invoices
-        invoices.each do |invoice|
-          assert_kind_of Quaderno::Invoice, invoice
-        end
-      end
-    end
-
-    should 'find a invoice' do
-      VCR.use_cassette('found invoice') do
-        invoices = Quaderno::Invoice.all
-        invoice = Quaderno::Invoice.find invoices.first.id
-        assert_kind_of Quaderno::Invoice, invoice
-        assert_equal invoices.first.id, invoice.id
-      end
-    end
-
-    should 'create a invoice' do
-      VCR.use_cassette('new invoice') do
-        contacts = Quaderno::Contact.all
-        invoice = Quaderno::Invoice.create(contact_id: contacts[0].id ,
-                                           contact_name: contacts[0].full_name,
-                                           currency: 'EUR',
-                                           items_attributes: [
-                                             {
-                                               description: 'Aircraft',
-                                               quantity: '1.0',
-                                               unit_price: '0.0'
-                                             }
-                                           ],
-                                           tags: 'tnt',
-                                           payment_details: '',
-                                           notes: '')
-        assert_kind_of Quaderno::Invoice, invoice
-        assert_equal contacts[0].id, invoice.contact.id
-        assert_equal 'Aircraft', invoice.items[0].description
-        Quaderno::Invoice.delete(invoice.id)
-      end
-    end
-
-    should 'update an invoice' do
-      VCR.use_cassette('updated invoice') do
-        contacts = Quaderno::Contact.all
-        invoice = Quaderno::Invoice.create(contact_id: contacts[0].id ,
-                                           contact_name: contacts[0].full_name,
-                                           currency: 'EUR',
-                                           items_attributes: [
-                                             {
-                                               description: 'Aircraft',
-                                               quantity: '1.0',
-                                               unit_price: '0.0'
-                                             }
-                                           ],
-                                           tags: 'tnt',
-                                           payment_details: '',
-                                           notes: '')
-        invoice = Quaderno::Invoice.update(invoice.id, payment_details: 'Show me the moneeeeeeeyy!!!!')
-        assert_kind_of Quaderno::Invoice, invoice
-        assert_equal 'Show me the moneeeeeeeyy!!!!', invoice.payment_details
-        Quaderno::Invoice.delete(invoice.id)
-      end
-    end
-
-    should 'delete an invoice' do
-        VCR.use_cassette('deleted invoice') do
-          contacts = Quaderno::Contact.all
-          invoice = Quaderno::Invoice.create(contact_id: contacts[0].id ,
-                                             contact_name: contacts[0].full_name,
-                                             currency: 'EUR',
-                                             items_attributes: [
-                                               {
-                                                 description: 'Aircraft',
-                                                 quantity: '1.0',
-                                                 unit_price: '0.0'
-                                               }
-                                             ],
-                                             tags: 'tnt',
-                                             payment_details: '',
-                                             notes: '')
-          Quaderno::Invoice.delete invoice.id
-          invoices = Quaderno::Invoice.all
-          assert_not_equal invoices.first.id, invoice.id
-        end
-    end
-
-    should 'deliver an invoice' do
-      VCR.use_cassette('delivered invoice') do
-        invoices = Quaderno::Invoice.all
-        rate_limit_before = Quaderno::Base.rate_limit_info
-        begin
-          rate_limit_after = invoices.first.deliver
-        rescue Quaderno::Exceptions::RequiredFieldsEmptyOrInvalid
-          rate_limit_after = { remaining: (rate_limit_before[:remaining] - 1) }
-        end
-        assert_equal rate_limit_before[:remaining]-1, rate_limit_after[:remaining]
-      end
-    end
-
-    should 'add a payment' do
-      VCR.use_cassette('paid invoice') do
-        invoices = Quaderno::Invoice.all
-        payment = invoices.first.add_payment(payment_method: 'cash', amount: 100000000)
-        assert_kind_of Quaderno::Payment, payment
-        assert_equal 'cash', payment.payment_method
-        assert_equal 10000000000, payment.amount_cents
-        assert_equal invoices.first.payments.last.id, payment.id
-      end
-    end
-
-    should 'remove a payment' do
-      VCR.use_cassette('unpay an invoice') do
-        invoices = Quaderno::Invoice.all
-        invoices.first.add_payment(payment_method: 'cash', amount: 100000000)
-        payment = invoices.first.payments.last
-        array_length = invoices.first.payments.length
-        invoices.first.remove_payment(payment.id) unless payment.nil?
-        assert_equal (array_length.zero? ? array_length : array_length-1), invoices.first.payments.length
-      end
-    end
-
-    should 'override version' do
-      Quaderno::Base.api_version = OLDEST_SUPPORTED_API_VERSION
-
-      VCR.use_cassette('create invoice on downgraded API') do
-        contacts = Quaderno::Contact.all
-        invoice = Quaderno::Invoice.create(contact_id: contacts[0].id ,
-                                           contact_name: contacts[0].full_name,
-                                           currency: 'EUR',
-                                           items_attributes: [
-                                             {
-                                               description: 'Aircraft',
-                                               quantity: '1.0',
-                                               unit_price: '0.0'
-                                             }
-                                           ],
-                                           tags: 'tnt',
-                                           payment_details: '',
-                                           notes: '')
-        assert invoice.total_cents.nil?
-        assert !invoice.total.nil?
-        assert_kind_of Quaderno::Invoice, invoice
-        assert_equal contacts[0].id, invoice.contact.id
-        assert_equal 'Aircraft', invoice.items[0].description
-        Quaderno::Invoice.delete(invoice.id)
-      end
-    end
-  end
-end

data/test/unit/test_quaderno_items.rb

@@ -1,84 +0,0 @@
-require 'helper'
-
-class TestQuadernoItem < Test::Unit::TestCase
-  context 'A user with an authenticate token with items' do
-
-    setup do
-      Quaderno::Base.configure do |config|
-        config.auth_token = TEST_KEY
-        config.url = TEST_URL
-        config.api_version = nil
-      end
-    end
-
-    should 'get exception if pass wrong arguments' do
-      assert_raise ArgumentError do
-        VCR.use_cassette('all items') do
-          Quaderno::Item.all 1, 2, 3
-        end
-      end
-      assert_raise ArgumentError do
-        VCR.use_cassette('found item') do
-          Quaderno::Item.find
-        end
-      end
-    end
-
-    should 'get all items (populated db)' do
-      VCR.use_cassette('all items') do
-        items = Quaderno::Item.all
-        assert_not_nil items
-        assert_kind_of Array, items
-        items.each do |item|
-          assert_kind_of Quaderno::Item, item
-        end
-      end
-    end
-
-    should 'find an item' do
-      VCR.use_cassette('found item') do
-        new_item = Quaderno::Item.create(code: Time.now.to_i.to_s, name: 'Test_Skynet', unit_cost: 21.00)
-        item = Quaderno::Item.find new_item.id
-
-        assert_kind_of Quaderno::Item, item
-        assert_equal new_item.id, item.id
-      end
-    end
-
-    should 'create an item' do
-      VCR.use_cassette('new item') do
-        item = Quaderno::Item.create(code: '000000', name: 'Test_Skynet', unit_cost: 21.00)
-        assert_kind_of Quaderno::Item, item
-        assert_equal '000000', item.code
-        assert_equal 'Test_Skynet', item.name
-      end
-    end
-
-    should 'update an item' do
-      VCR.use_cassette('updated item') do
-        new_item = Quaderno::Item.create(code: Time.now.to_i.to_s, name: 'Test_Skynet', unit_cost: 21.00)
-        item = Quaderno::Item.update(new_item.id, name: 'Test_OCP')
-
-        assert_kind_of Quaderno::Item, item
-        assert_equal 'Test_OCP', item.name
-      end
-    end
-
-    should 'delete a item' do
-      VCR.use_cassette('deleted item') do
-        items_before = Quaderno::Item.all
-        item_id = items_before.last.id
-        Quaderno::Item.delete item_id
-        items_after = Quaderno::Item.all
-        assert_equal (items_before.length - items_after.length), 1
-      end
-    end
-
-    should 'know the rate limit' do
-      VCR.use_cassette('rate limit') do
-        rate_limit_info = Quaderno::Base.rate_limit_info
-        assert_operator rate_limit_info[:remaining], :< ,2000
-      end
-    end
-  end
-end

data/test/unit/test_quaderno_receipts.rb

@@ -1,156 +0,0 @@
-require 'helper'
-
-class TestQuadernoReceipt < Test::Unit::TestCase
-  context 'A user with an authenticate token with receipts' do
-
-    setup do
-      Quaderno::Base.configure do |config|
-        config.auth_token = TEST_KEY
-        config.url = TEST_URL
-        config.api_version = nil
-      end
-    end
-
-    should 'get exception if pass wrong arguments' do
-      assert_raise ArgumentError do
-        VCR.use_cassette('all receipts') do
-          Quaderno::Receipt.all 1, 2, 3
-        end
-      end
-      assert_raise ArgumentError do
-        VCR.use_cassette('found receipt') do
-          Quaderno::Receipt.find
-        end
-      end
-    end
-
-    should 'get all receipts (populated db)' do
-      VCR.use_cassette('all receipts') do
-        receipts = Quaderno::Receipt.all
-        assert_not_nil receipts
-        assert_kind_of Array, receipts
-        receipts.each do |receipt|
-          assert_kind_of Quaderno::Receipt, receipt
-        end
-      end
-    end
-
-    should 'find a receipt' do
-      VCR.use_cassette('found receipt') do
-        receipts = Quaderno::Receipt.all
-        receipt = Quaderno::Receipt.find receipts.first.id
-        assert_kind_of Quaderno::Receipt, receipt
-        assert_equal receipts.first.id, receipt.id
-      end
-    end
-
-    should 'create a receipt' do
-      VCR.use_cassette('new receipt') do
-        contact = Quaderno::Contact.create(first_name: 'Test customer')
-        receipt = Quaderno::Receipt.create(contact_id: contact.id ,
-                                           currency: 'EUR',
-                                           items_attributes: [
-                                             {
-                                               description: 'Aircraft',
-                                               quantity: '1.0',
-                                               unit_price: '0.0'
-                                             }
-                                           ],
-                                           tags: 'tnt',
-                                           payment_method: :cash,
-                                           notes: '')
-        assert_kind_of Quaderno::Receipt, receipt
-        assert_equal contact.id, receipt.contact.id
-        assert_equal 'Aircraft', receipt.items[0].description
-        Quaderno::Receipt.delete(receipt.id)
-        Quaderno::Contact.delete(contact.id)
-      end
-    end
-
-    should 'update an receipt' do
-      VCR.use_cassette('updated receipt') do
-        contact = Quaderno::Contact.create(first_name: 'Test customer')
-        receipt = Quaderno::Receipt.create(contact_id: contact.id ,
-                                           currency: 'EUR',
-                                           items_attributes: [
-                                             {
-                                               description: 'Aircraft',
-                                               quantity: '1.0',
-                                               unit_price: '0.0'
-                                             }
-                                           ],
-                                           tags: 'tnt',
-                                           payment_method: :cash,
-                                           notes: '')
-        receipt = Quaderno::Receipt.update(receipt.id, notes: 'Show me the moneeeeeeeyy!!!!')
-        assert_kind_of Quaderno::Receipt, receipt
-        assert_equal 'Show me the moneeeeeeeyy!!!!', receipt.notes
-        Quaderno::Receipt.delete(receipt.id)
-        Quaderno::Contact.delete(contact.id)
-      end
-    end
-
-    should 'delete an receipt' do
-        VCR.use_cassette('deleted receipt') do
-          contact = Quaderno::Contact.create(first_name: 'Test customer')
-          receipt = Quaderno::Receipt.create(contact_id: contact.id ,
-                                             currency: 'EUR',
-                                             items_attributes: [
-                                               {
-                                                 description: 'Aircraft',
-                                                 quantity: '1.0',
-                                                 unit_price: '0.0'
-                                               }
-                                             ],
-                                             tags: 'tnt',
-                                             payment_method: :cash,
-                                             notes: '')
-          Quaderno::Receipt.delete receipt.id
-          Quaderno::Contact.delete(contact.id)
-
-          receipts = Quaderno::Receipt.all
-          assert_not_equal receipts.first.id, receipt.id
-        end
-    end
-
-    should 'deliver an receipt' do
-      VCR.use_cassette('delivered receipt') do
-        receipts = Quaderno::Receipt.all
-        rate_limit_before = Quaderno::Base.rate_limit_info
-        begin
-          rate_limit_after = receipts.first.deliver
-        rescue Quaderno::Exceptions::RequiredFieldsEmptyOrInvalid
-          rate_limit_after = { remaining: (rate_limit_before[:remaining] - 1) }
-        end
-        assert_equal rate_limit_before[:remaining]-1, rate_limit_after[:remaining]
-      end
-    end
-
-    should 'override version' do
-      Quaderno::Base.api_version = OLDEST_SUPPORTED_API_VERSION
-
-      VCR.use_cassette('create receipt on downgraded API') do
-        contact = Quaderno::Contact.create(first_name: 'Test customer')
-        receipt = Quaderno::Receipt.create(contact_id: contact.id ,
-                                           currency: 'EUR',
-                                           items_attributes: [
-                                             {
-                                               description: 'Aircraft',
-                                               quantity: '1.0',
-                                               unit_price: '0.0'
-                                             }
-                                           ],
-                                           tags: 'tnt',
-                                           payment_method: :cash,
-                                           notes: '')
-        assert receipt.total_cents.nil?
-        assert !receipt.total.nil?
-        assert_kind_of Quaderno::Receipt, receipt
-        assert_equal contact.id, receipt.contact.id
-        assert_equal 'Aircraft', receipt.items[0].description
-        Quaderno::Receipt.delete(receipt.id)
-        Quaderno::Contact.delete(contact.id)
-      end
-    end
-  end
-end

data/test/unit/test_quaderno_tax.rb

@@ -1,46 +0,0 @@
-require 'helper'
-
-class TestQuadernoTax < Test::Unit::TestCase
-  context 'A user with an authenticate token with webhooks' do
-
-    setup do
-      Quaderno::Base.configure do |config|
-        config.auth_token = TEST_KEY
-        config.url = TEST_URL
-        config.api_version = nil
-      end
-    end
-
-    should 'raise exception if pass wrong arguments' do
-      assert_raise ArgumentError do
-        Quaderno::Tax.calculate 1, 2, 3
-      end
-    end
-
-    should 'raise exception if token is wrong' do
-      VCR.use_cassette('wrong token') do
-        assert_raise Quaderno::Exceptions::InvalidSubdomainOrToken do
-          Quaderno::Base.auth_token = '7h15154f4k370k3n'
-          Quaderno::Tax.calculate(country: 'ES', postal_code: '08080')
-        end
-      end
-    end
-
-    should 'calculate tax' do
-      VCR.use_cassette('validate valid VAT number') do
-        vat_number_valid = Quaderno::Tax.validate_vat_number('IE', 'IE6388047V')
-        assert vat_number_valid
-      end
-
-       VCR.use_cassette('validate invalid VAT number') do
-        vat_number_valid = Quaderno::Tax.validate_vat_number('IE', 'IE6388047X')
-        assert !vat_number_valid
-      end
-    end
-
-    should 'validate VAT number' do
-      VCR.use_cassette('calculate tax') do
-      end
-    end
-  end
-end