kaui 0.6.6 → 0.7.0

data/test/integration/kaui/navigation_test.rb

@@ -0,0 +1,43 @@
+require 'test_helper'
+
+module Kaui
+  class NavigationTest < IntegrationTestHelper
+
+    test 'Browse one account' do
+      get BASE_PATH
+      assert_redirected_to SIGN_IN_PATH
+
+      # Verify log-in
+      post_via_redirect SIGN_IN_PATH, {:user => {:kb_username => USERNAME, :password => PASSWORD}}
+      assert_equal BASE_PATH + '/', path
+      assert_equal 'Signed in successfully.', flash[:notice]
+
+      # User goes to search for the account
+      get ACCOUNTS_PATH
+      assert_response :success
+
+      # Assumes he found it on the listing
+      get ACCOUNTS_PATH + '/' + @account.account_id
+      assert_response :success
+      check_no_flash_error
+      assert_not_nil assigns(:tags)
+      assert_not_nil assigns(:account_emails)
+      assert_not_nil assigns(:overdue_state)
+      assert_not_nil assigns(:payment_methods)
+      assert_not_nil assigns(:bundles)
+
+      # He now clicks on the timeline link
+      get ACCOUNT_TIMELINE_PATH + '/' + @account.account_id
+      assert_response :success
+      check_no_flash_error
+      assert_not_nil assigns(:account)
+      assert_not_nil assigns(:timeline)
+
+      # Verify log-out
+      delete_via_redirect SIGN_OUT_PATH
+      assert_equal SIGN_IN_PATH, path
+      assert_equal 'You need to sign in or sign up before continuing.', flash[:alert]
+    end
+  end
+end
+

data/test/killbill_test_helper.rb

@@ -0,0 +1,143 @@
+module Kaui
+  module KillbillTestHelper
+
+    USERNAME = 'admin'
+    PASSWORD = 'password'
+
+    #
+    # Rails helpers
+    #
+
+    def check_no_flash_error
+      unless flash.now.nil?
+        assert_nil flash.now[:alert], 'Found flash alert: ' + flash.now[:alert].to_s
+        assert_nil flash.now[:error], 'Found flash error: ' + flash.now[:error].to_s
+      end
+      assert_nil flash[:alert]
+      assert_nil flash[:error]
+    end
+
+    #
+    # Kill Bill specific helpers
+    #
+
+    def setup_test_data
+      @tenant            = create_tenant
+      @account           = create_account(@tenant)
+      @account2          = create_account(@tenant)
+      @bundle            = create_bundle(@account, @tenant)
+      @payment_method    = create_payment_method(true, @account, @tenant)
+      @invoice_item      = create_charge(@account, @tenant)
+      @cba               = create_cba(@invoice_item.invoice_id, @account, @tenant)
+      @paid_invoice_item = create_charge(@account, @tenant)
+      @payment           = create_payment(@paid_invoice_item, @account, @tenant)
+    end
+
+    # Return a new test account
+    def create_account(tenant = nil, username = USERNAME, password = PASSWORD, user = 'Kaui test', reason = nil, comment = nil)
+      tenant       = create_tenant if tenant.nil?
+      external_key = SecureRandom.uuid.to_s
+
+      account                          = KillBillClient::Model::Account.new
+      account.name                     = 'Kaui'
+      account.external_key             = external_key
+      account.email                    = 'kill@bill.com'
+      account.currency                 = 'USD'
+      account.time_zone                = 'UTC'
+      account.address1                 = '5, ruby road'
+      account.address2                 = 'Apt 4'
+      account.postal_code              = 10293
+      account.company                  = 'KillBill, Inc.'
+      account.city                     = 'SnakeCase'
+      account.state                    = 'Awesome'
+      account.country                  = 'LalaLand'
+      account.locale                   = 'fr_FR'
+      account.is_notified_for_invoices = false
+
+      account.create(user, reason, comment, build_options(tenant, username, password))
+    end
+
+    # Return the created bundle
+    def create_bundle(account = nil, tenant = nil, username = USERNAME, password = PASSWORD, user = 'Kaui test', reason = nil, comment = nil)
+      tenant  = create_tenant(user, reason, comment) if tenant.nil?
+      account = create_account(tenant, username, password, user, reason, comment) if account.nil?
+
+      entitlement = KillBillClient::Model::Subscription.new(:account_id       => account.account_id,
+                                                            :external_key     => SecureRandom.uuid,
+                                                            :product_name     => 'Sports', # Sports, so we can add addons
+                                                            :product_category => 'BASE',
+                                                            :billing_period   => 'MONTHLY',
+                                                            :price_list       => 'DEFAULT')
+      entitlement = entitlement.create(user, reason, comment, build_options(tenant, username, password))
+
+      KillBillClient::Model::Bundle.find_by_id(entitlement.bundle_id, build_options(tenant, username, password))
+    end
+
+    # Return a new test payment method
+    def create_payment_method(set_default = false, account = nil, tenant = nil, username = USERNAME, password = PASSWORD, user = 'Kaui test', reason = nil, comment = nil)
+      account = create_account(tenant, username, password, user, reason, comment) if account.nil?
+
+      payment_method = Kaui::PaymentMethod.new(:account_id => account.account_id, :plugin_name => '__EXTERNAL_PAYMENT__', :is_default => set_default)
+      payment_method.create(user, reason, comment, build_options(tenant, username, password))
+    end
+
+    # Return the created external charge
+    def create_charge(account = nil, tenant = nil, username = USERNAME, password = PASSWORD, user = 'Kaui test', reason = nil, comment = nil)
+      tenant  = create_tenant(user, reason, comment) if tenant.nil?
+      account = create_account(tenant, username, password, user, reason, comment) if account.nil?
+
+      invoice_item            = KillBillClient::Model::InvoiceItem.new
+      invoice_item.account_id = account.account_id
+      invoice_item.currency   = account.currency
+      invoice_item.amount     = 123.98
+
+      invoice_item.create(user, reason, comment, build_options(tenant, username, password))
+    end
+
+    # Return the created credit
+    def create_cba(invoice_id = nil, account = nil, tenant = nil, username = USERNAME, password = PASSWORD, user = 'Kaui test', reason = nil, comment = nil)
+      tenant  = create_tenant(user, reason, comment) if tenant.nil?
+      account = create_account(tenant, username, password, user, reason, comment) if account.nil?
+
+      credit = KillBillClient::Model::Credit.new(:invoice_id => invoice_id, :account_id => account.account_id, :credit_amount => 23.22)
+      credit = credit.create(user, reason, comment, build_options(tenant, username, password))
+
+      invoice = KillBillClient::Model::Invoice.find_by_id_or_number(credit.invoice_id, true, 'NONE', build_options(tenant, username, password))
+      invoice.items.find { |ii| ii.amount == -credit.credit_amount }
+    end
+
+    def create_payment(invoice_item = nil, account = nil, tenant = nil, username = USERNAME, password = PASSWORD, user = 'Kaui test', reason = nil, comment = nil)
+      tenant       = create_tenant(user, reason, comment) if tenant.nil?
+      account      = create_account(tenant, username, password, user, reason, comment) if account.nil?
+      invoice_item = create_charge(account, tenant, username, password, user, reason, comment) if invoice_item.nil?
+
+      payment = Kaui::InvoicePayment.new({:account_id => account.account_id, :target_invoice_id => invoice_item.invoice_id, :purchased_amount => invoice_item.amount})
+      payment.create(true, user, reason, comment, build_options(tenant, username, password))
+    end
+
+    # Return a new test tenant
+    def create_tenant(user = 'Kaui test', reason = nil, comment = nil)
+      api_key    = SecureRandom.uuid.to_s
+      api_secret = 'S4cr3333333t!!!!!!lolz'
+
+      tenant            = KillBillClient::Model::Tenant.new
+      tenant.api_key    = api_key
+      tenant.api_secret = api_secret
+
+      tenant.create(user, reason, comment, build_options)
+    end
+
+    def build_options(tenant = nil, username = USERNAME, password = PASSWORD)
+      {
+          :api_key    => tenant.nil? ? nil : tenant.api_key,
+          :api_secret => tenant.nil? ? nil : tenant.api_secret,
+          :username   => username,
+          :password   => password
+      }
+    end
+
+    def options
+      build_options(@tenant)
+    end
+  end
+end

data/test/test_helper.rb

@@ -1,232 +1,15 @@
-require 'fakeweb'
+require 'simplecov'
+SimpleCov.start 'rails'
 
-# Configure Rails Environment
-ENV["RAILS_ENV"] = "test"
+# Configure the Rails Environment
+ENV['RAILS_ENV'] = 'test'
 
-require File.expand_path("../dummy/config/environment.rb",  __FILE__)
-require "rails/test_help"
-require 'securerandom'
+require File.expand_path('../dummy/config/environment.rb', __FILE__)
+require 'rails/test_help'
 
 Rails.backtrace_cleaner.remove_silencers!
 
-# Load support files
-Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each { |f| require f }
-
-# Load helpers
-Dir["#{File.dirname(__FILE__)}/unit/helpers/kaui/*.rb"].each { |f| require f }
-
-# Setup Kill Bill stubs
-FakeWeb.allow_net_connect = false
-FakeWeb.register_uri(:get, "http://127.0.0.1:8080/1.0/kb/security/subject", body: "{\"is_authenticated\":true}", :content_type => "application/json")
-FakeWeb.register_uri(:any, %r|http://127.0.0.1:8080|, body: "{}", :content_type => "application/json")
-
-# Include Devise helpers
-class ActionController::TestCase
-  include Devise::TestHelpers
-
-  setup do
-    @user = Kaui::User.create!({
-                                 :kb_tenant_id => "tenant_id_test",
-                                 :kb_username => "username_test",
-                                 :kb_session_id => "session_id_test"
-                               })
-    sign_in @user
-  end
-end
-
-module Kaui
-  class User < ActiveRecord::Base
-
-    private
-
-    def self.do_find_permissions(options = {})
-      ["*:*"]
-    end
-  end
-end
-
-# Mock killbill-server and serve data from the fixtures
-module Kaui::KillbillHelper
-  @@fixtures ||= {}
-
-  def self.get_account_by_key_with_balance_and_cba(key, options = {})
-    self.get_account_by_key(key, false, true, options)
-  end
-
-  def self.get_account(account_id, with_balance = false, with_balance_and_cba = false, options = {})
-    find_among_fixtures(Kaui::Account, account_id)
-  end
-
-  def self.get_account_emails(account_id, options = {})
-    []
-  end
-
-  def self.get_account_by_external_key(account_id, with_balance = false, with_balance_and_cba = false, options = {})
-    find_among_fixtures(Kaui::Account, account_id)
-  end
-
-  def self.get_overdue_state_for_account(account_id, options = {})
-    find_among_fixtures(Kaui::OverdueState, account_id)
-  end
-
-  def self.get_invoice(invoice_id, with_items = true, audit= "NONE", options = {})
-    find_among_fixtures(Kaui::Invoice, invoice_id)
-  end
-
-  def self.get_invoice_item(invoice_id, invoice_item_id, options = {})
-    find_among_fixtures(Kaui::InvoiceItem, invoice_item_id)
-  end
-
-  def self.get_bundle(bundle_id, options = {})
-    find_among_fixtures(Kaui::Bundle, bundle_id)
-  end
-
-  def self.get_payments(invoice_id, options = {})
-    []
-  end
-
-  def self.get_non_external_payment_methods(account_id, options = {})
-    []
-  end
-
-  def self.get_payment_methods(account_id, options = {})
-    []
-  end
-
-  def self.get_bundles_for_account(account_id, options = {})
-    []
-  end
-
-  def self.get_subscriptions_for_bundle(bundle_id, options = {})
-    []
-  end
-
-  def self.get_tags_for_account(account_id, included_deleted = false, audit = "NONE", options = {})
-    []
-  end
-
-  def self.get_tag_definitions(options = {})
-    find_all_among_fixtures(Kaui::TagDefinition)
-  end
-
-  def self.get_tag_definition(tag_definition_id, options = {})
-    find_among_fixtures(Kaui::TagDefinition, tag_definition_id, 'id')
-  end
-
-  def self.create_tag_definition(tag_definition, user, reason, comment, options = {})
-    tag_definition.id = SecureRandom.uuid
-    add_fixture(tag_definition, Kaui::TagDefinition)
-  end
-
-  def self.delete_tag_definition(tag_definition_id, user, reason, comment, options = {})
-    delete_fixture(Kaui::TagDefinition, tag_definition_id, 'id')
-  end
-
-  def self.find_among_fixtures(clazz, id, type_id=nil)
-    results = find_all_among_fixtures(clazz, id, type_id)
-    results.length > 0 ? results[0] : nil
-  end
-
-  def self.find_all_among_fixtures(clazz, id=nil, type_id=nil)
-    results = []
-    type = clazz.name.demodulize.underscore
-    type_id = "#{clazz.name.demodulize.camelize}Id".uncapitalize unless type_id
-    @@fixtures.each do |k,v|
-      next unless k == "#{type}s"
-      v.each do |w,u|
-        results << clazz.new(u.fixture) if u.fixture[type_id] == id or !id.present?
-      end
-    end
-
-    return results
-  end
-
-  def self.add_fixture(fixture, clazz)
-    type = clazz.name.demodulize.underscore
-    @@fixtures["#{type}s"].fixtures ||= {}
-    @@fixtures["#{type}s"].fixtures["auto_generated_fixture_#{rand(100)}"] = ActiveRecord::Fixture.new(fixture.to_hash, clazz)
-    fixture
-  end
-
-  def self.delete_fixture(clazz, id, type_id=nil)
-    type = clazz.name.demodulize.underscore
-    type_id = "#{clazz.name.demodulize.camelize}Id".uncapitalize unless type_id
-    @@fixtures.each do |k,v|
-      next unless k == "#{type}s"
-      v.each do |w,u|
-        v.fixtures.delete(w) if u.fixture[type_id] == id
-      end
-    end
-  end
-
-  def self.set_fixtures(f)
-    @@fixtures = f
-  end
-end
-
-class ActiveRecord::Fixtures
-  require 'json'
-
-  class File
-    def rows
-      return @rows if @rows
-
-      begin
-        # Note the .to_json! We want to enforce JSON-type data here,
-        # which is what we get over the network when querying Killbill
-        data = JSON.parse(YAML.load(render(IO.read(@file))).to_json)
-      rescue *RESCUE_ERRORS => error
-        raise Fixture::FormatError, "a YAML error occurred parsing #{@file}. Please note that YAML must be consistently indented using spaces. Tabs are not allowed. Please have a look at http://www.yaml.org/faq.html\nThe exact error was:\n  #{error.class}: #{error}", error.backtrace
-      end
-      # Skip validation since we modified the data
-      @rows = data ? data.to_a : []
-    end
-  end
-
-  # Monkey-patch the create_fixtures method not to rely on a database
-  def self.create_fixtures(fixtures_directory, table_names, class_names = {})
-    table_names = [table_names].flatten.map { |n| n.to_s }
-    table_names.each { |n|
-      class_names[n.tr('/', '_').to_sym] = n.classify if n.include?('/')
-    }
-
-    unless table_names.empty?
-      fixtures_map = {}
-      table_names.map do |path|
-        table_name = path.tr '/', '_'
-        fixtures_map[path] = ActiveRecord::Fixtures.new(nil,
-                                                        table_name,
-                                                        class_names[table_name.to_sym] || table_name.classify,
-                                                        ::File.join(fixtures_directory, path))
-      end
-
-      all_loaded_fixtures.update(fixtures_map)
-      cache_fixtures(nil, fixtures_map)
-
-      Kaui::KillbillHelper.set_fixtures fixtures_map
-    end
-    cached_fixtures(nil, table_names)
-  end
-end
-
-class ActiveRecord::Fixture
-  def find
-    @fixture
-  end
-end
-
-class String
-  def uncapitalize
-    self[0, 1].downcase + self[1..-1]
-  end
-end
-
-# See http://jira.codehaus.org/browse/JRUBY-6176
-module SecureRandom
-  def self.uuid
-    ary = self.random_bytes(16).unpack("NnnnnN")
-    ary[2] = (ary[2] & 0x0fff) | 0x4000
-    ary[3] = (ary[3] & 0x3fff) | 0x8000
-    "%08x-%04x-%04x-%04x-%04x%08x" % ary
-  end unless respond_to?(:uuid)
-end
+# Include helpers
+require 'killbill_test_helper'
+require 'functional/kaui/functional_test_helper'
+require 'integration/kaui/integration_test_helper'

data/test/unit/kaui/account_email_test.rb

@@ -0,0 +1,19 @@
+require 'test_helper'
+
+class Kaui::AccountEmailTest < ActiveSupport::TestCase
+
+  test 'can compare emails' do
+    email1 = Kaui::AccountEmail.new(:account_id => SecureRandom.uuid, :email => 'abc@bar.com')
+    email2 = Kaui::AccountEmail.new(:account_id => SecureRandom.uuid, :email => 'bcd@bar.com')
+    email3 = Kaui::AccountEmail.new(:account_id => SecureRandom.uuid, :email => nil)
+
+    assert_equal -1, email1 <=> email2
+    assert_equal 1, email2 <=> email1
+    assert_equal 0, email1 <=> email1
+    assert_equal 0, email2 <=> email2
+    assert_equal 0, email3 <=> email3
+    assert_equal 1, email1 <=> email3
+    assert_equal -1, email3 <=> email1
+    assert_equal -1, email1 <=> nil
+  end
+end

data/test/unit/kaui/account_test.rb

@@ -1,42 +1,14 @@
 require 'test_helper'
 
 class Kaui::AccountTest < ActiveSupport::TestCase
-  fixtures :accounts
 
-  test "can serialize from json" do
-    as_json = accounts(:pierre)
-    pierre = Kaui::Account.new(as_json)
+  test 'can convert to money' do
+    account = Kaui::Account.new(:account_balance => 12.42, :account_cba => 54.32, :currency => 'USD')
 
-    assert_equal as_json["accountId"], pierre.account_id
-    assert_equal as_json["address1"], pierre.address1
-    assert_equal as_json["address2"], pierre.address2
-    assert_equal as_json["company"], pierre.company
-    assert_equal as_json["country"], pierre.country
-    assert_equal as_json["currency"], pierre.currency
-    assert_equal as_json["email"], pierre.email
-    assert_equal as_json["externalKey"], pierre.external_key
-    assert_equal as_json["name"], pierre.name
-    assert_equal as_json["paymentMethodId"], pierre.payment_method_id
-    assert_equal as_json["phone"], pierre.phone
-    assert_equal as_json["state"], pierre.state
-    assert_equal as_json["timeZone"], pierre.timezone
-  end
-  
-  test "can read correct positive balance" do
-    as_json = accounts(:account_with_positive_balance)
-    t = Kaui::Account.new(as_json)
-    assert(t.balance > 0)
-  end
-
-  test "can read correct negative balance" do
-    as_json = accounts(:account_with_negative_balance)
-    t = Kaui::Account.new(as_json)
-    assert(t.balance < 0)
-  end
+    assert_equal 1242, account.balance_to_money.cents
+    assert_equal 'USD', account.balance_to_money.currency_as_string
 
-  test "can read correct zero balance" do
-    as_json = accounts(:account_with_zero_balance)
-    t = Kaui::Account.new(as_json)
-    assert(t.balance == 0)
+    assert_equal 5432, account.cba_to_money.cents
+    assert_equal 'USD', account.cba_to_money.currency_as_string
   end
-end
+end

data/test/unit/kaui/base_test.rb

@@ -2,58 +2,17 @@ require 'test_helper'
 
 class Kaui::BaseTest < ActiveSupport::TestCase
 
-  class Kaui::SomeKlass < Kaui::Base
-    define_attr :attribute_id
-
-    has_many :klasses, Kaui::SomeKlass
-  end
-
-  test "has_many association should return [] by default" do
-    klass = Kaui::SomeKlass.new
-    assert_equal [], klass.klasses
-  end
-
-  test "can serialize from hash" do
-    klass = Kaui::SomeKlass.new(:attribute_id => 12)
-    assert_equal 12, klass.attribute_id
-  end
-
-  test "can serialize from json" do
-    klass = Kaui::SomeKlass.new(:attributeId => 12)
-    assert_equal 12, klass.attribute_id
-  end
-
-  test "convert camelcase hash into snake case hash" do
-     # Happy path
-     new_hash = Kaui::Base.convert_hash_keys({:accountId=>12, :data_id=>14})
-     assert_equal 12, new_hash[:account_id]
-     assert_equal 14, new_hash[:data_id]
-     assert_nil new_hash[:accountId]
-
-     # Edge cases
-     assert_nil Kaui::Base.convert_hash_keys(nil)
-     assert_equal [], Kaui::Base.convert_hash_keys([])
-     assert_equal Hash.new, Kaui::Base.convert_hash_keys({})
-     assert_equal 1, Kaui::Base.convert_hash_keys(1)
-   end
-
-   test "convert nested snake case into camel case" do
-      new_hash = Kaui::Base.camelize({:account_id=>12, :my_nested_field=> {:not_good => 32}})
-      assert_equal 12, new_hash[:accountId]
-      assert_equal 32, new_hash[:myNestedField][:notGood]
-   end
-
-  test "can convert to money" do
+  test 'can convert to money' do
     # Happy path
-    ['GBP', 'MXN', 'BRL', 'EUR', 'AUD', 'USD', 'CAD', 'JPY'].each do |currency|
+    %w(GBP MXN BRL EUR AUD USD CAD JPY).each do |currency|
       money = Kaui::Base.to_money(12.42, currency)
       assert_equal 1242, money.cents
       assert_equal currency, money.currency.iso_code
     end
 
     # Edge cases
-    bad_money = Kaui::Base.to_money(12.42, "blahblah")
+    bad_money = Kaui::Base.to_money(12.42, 'blahblah')
     assert_equal 1242, bad_money.cents
-    assert_equal "USD", bad_money.currency.iso_code
+    assert_equal 'USD', bad_money.currency.iso_code
   end
-end
+end

data/test/unit/kaui/date_helper_test.rb

@@ -1,13 +1,14 @@
 require 'test_helper'
 
 class Kaui::DateHelperTest < ActiveSupport::TestCase
+
   include Kaui::DateHelper
 
-  test "can parse from string" do
-    assert_equal "2012-07-01", format_date("2012-07-01T12:55:44Z")
+  test 'can parse from string' do
+    assert_equal '2012-07-01', format_date('2012-07-01T12:55:44Z')
   end
 
-  test "can parse from date" do
-    assert_equal "2012-07-01", format_date(Date.new(2012, 7, 1))
+  test 'can parse from date' do
+    assert_equal '2012-07-01', format_date(Date.new(2012, 7, 1))
   end
-end
+end

data/test/unit/kaui/invoice_item_test.rb

@@ -1,23 +1,11 @@
 require 'test_helper'
 
 class Kaui::InvoiceItemTest < ActiveSupport::TestCase
-  fixtures :invoice_items
 
-  test "can serialize from json" do
-    as_json = invoice_items(:recurring_item_for_pierre)
-    invoice = Kaui::InvoiceItem.new(as_json)
+  test 'can convert to money' do
+    invoice_item = Kaui::InvoiceItem.new(:amount => 12.42, :currency => 'USD')
 
-    assert_equal as_json["invoiceItemId"], invoice.invoice_item_id
-    assert_equal as_json["invoiceId"], invoice.invoice_id
-    assert_equal as_json["accountId"], invoice.account_id
-    assert_equal as_json["bundleId"], invoice.bundle_id
-    assert_equal as_json["subscriptionId"], invoice.subscription_id
-    assert_equal as_json["planName"], invoice.plan_name
-    assert_equal as_json["phaseName"], invoice.phase_name
-    assert_equal as_json["description"], invoice.description
-    assert_equal as_json["startDate"], invoice.start_date
-    assert_equal as_json["endDate"], invoice.end_date
-    assert_equal as_json["amount"], invoice.amount
-    assert_equal as_json["currency"], invoice.currency
+    assert_equal 1242, invoice_item.amount_to_money.cents
+    assert_equal 'USD', invoice_item.amount_to_money.currency_as_string
   end
-end
+end

data/test/unit/kaui/invoice_payment_test.rb

@@ -0,0 +1,42 @@
+require 'test_helper'
+
+class Kaui::InvoicePaymentTest < ActiveSupport::TestCase
+
+  test 'can convert to money' do
+    payment = Kaui::InvoicePayment.new(:auth_amount      => 12.42,
+                                       :captured_amount  => 10.2,
+                                       :purchased_amount => 12,
+                                       :refunded_amount  => 9,
+                                       :credited_amount  => 5,
+                                       :currency         => 'USD')
+
+    assert_equal 1242, payment.auth_amount_to_money.cents
+    assert_equal 'USD', payment.auth_amount_to_money.currency_as_string
+
+    assert_equal 1020, payment.captured_amount_to_money.cents
+    assert_equal 'USD', payment.captured_amount_to_money.currency_as_string
+
+    assert_equal 1200, payment.purchased_amount_to_money.cents
+    assert_equal 'USD', payment.purchased_amount_to_money.currency_as_string
+
+    assert_equal 900, payment.refunded_amount_to_money.cents
+    assert_equal 'USD', payment.refunded_amount_to_money.currency_as_string
+
+    assert_equal 500, payment.credited_amount_to_money.cents
+    assert_equal 'USD', payment.credited_amount_to_money.currency_as_string
+
+    assert_equal 2220, payment.paid_amount_to_money.cents
+    assert_equal 'USD', payment.paid_amount_to_money.currency_as_string
+
+    assert_equal 1400, payment.returned_amount_to_money.cents
+    assert_equal 'USD', payment.returned_amount_to_money.currency_as_string
+  end
+
+  test 'can check for full refunds' do
+    assert Kaui::InvoicePayment.new(:purchased_amount => 10.2, :refunded_amount => 10.20, :currency => 'USD').is_fully_refunded?
+    assert !Kaui::InvoicePayment.new(:purchased_amount => 10.2, :refunded_amount => 9, :currency => 'USD').is_fully_refunded?
+
+    assert Kaui::InvoicePayment.new(:captured_amount => 10.2, :refunded_amount => 10.20, :currency => 'USD').is_fully_refunded?
+    assert !Kaui::InvoicePayment.new(:captured_amount => 10.2, :refunded_amount => 9, :currency => 'USD').is_fully_refunded?
+  end
+end