quaderno 1.13.2 → 1.17.0

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

data/test/unit/test_quaderno_webhooks.rb

@@ -1,93 +0,0 @@
-require 'helper'
-
-class TestQuadernoWebhook < 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 'get exception if pass wrong arguments' do
-      assert_raise ArgumentError do
-        VCR.use_cassette('all webhooks') do
-          Quaderno::Webhook.all 1, 2, 3
-        end
-      end
-      assert_raise ArgumentError do
-        VCR.use_cassette('found webhook') do
-          Quaderno::Webhook.find
-        end
-      end
-    end
-
-    should 'get all webhooks (populated db)' do
-      VCR.use_cassette('all webhooks') do
-      	webhook_1 = Quaderno::Webhook.create(url: 'http://google.com', events_types: ['invoice.created', 'invoice.updated'])
-        webhook_2 = Quaderno::Webhook.create(url: 'http://quadernoapp.com', events_types: ['expense.created', 'expense.updated', 'contact.deleted'])
-        webhooks = Quaderno::Webhook.all
-        assert_not_nil webhooks
-        assert_kind_of Array, webhooks
-        webhooks.each do |webhook|
-          assert_kind_of Quaderno::Webhook, webhook
-        end
-        Quaderno::Webhook.delete webhook_1.id
-        Quaderno::Webhook.delete webhook_2.id
-      end
-    end
-
-    should 'find a webhook' do
-      VCR.use_cassette('found webhook') do
-        webhook = Quaderno::Webhook.create(url: 'http://quadernoapp.com', events_types: ['invoice.created', 'expense.updated'])
-        webhooks = Quaderno::Webhook.all
-        assert_kind_of Quaderno::Webhook, webhook
-        assert_equal webhooks.last.id, webhook.id
-        Quaderno::Webhook.delete webhook.id
-      end
-    end
-
-    should 'create a webhook' do
-      VCR.use_cassette('new webhook') do
-        webhook = Quaderno::Webhook.create(url: 'http://quadernoapp.com', events_types: ['invoice.created', 'expense.updated'])
-        assert_kind_of Quaderno::Webhook, webhook
-        assert_equal 'http://quadernoapp.com', webhook.url
-        assert_equal ['invoice.created', 'expense.updated'], webhook.events_types
-        Quaderno::Webhook.delete webhook.id
-      end
-    end
-
-    should 'update a webhook' do
-      VCR.use_cassette('updated webhook') do
-      	Quaderno::Webhook.create(url: 'http://quadernoapp.com', events_types: ['invoice.created', 'expense.updated'])
-        webhooks = Quaderno::Webhook.all
-        webhook = Quaderno::Webhook.update(webhooks.last.id, events_types: ['invoice.created', 'invoice.updated', 'contact.deleted'])
-        assert_kind_of Quaderno::Webhook, webhook
-        assert_equal ['invoice.created', 'invoice.updated', 'contact.deleted'], webhook.events_types
-        Quaderno::Webhook.delete webhook.id
-      end
-    end
-
-    should 'delete a webhook' do
-        VCR.use_cassette('deleted webhook') do
-          webhook_1 = Quaderno::Webhook.create(url: 'http://google.com', events_types: ['invoice.created', 'expense.updated'])
-          webhook_2 = Quaderno::Webhook.create(url: 'http://quadernoapp.com', events_types: ['invoice.created', 'expense.updated'])
-          webhooks_before = Quaderno::Webhook.all
-          webhook_id = webhooks_before.last.id
-          Quaderno::Webhook.delete webhook_id
-          webhooks_after = Quaderno::Webhook.all
-          assert_not_equal webhooks_after.last.id, webhook_id
-          Quaderno::Webhook.delete webhooks_after.last.id
-        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