kaui 2.1.0 → 2.2.1

data/test/functional/kaui/tag_definitions_controller_test.rb

@@ -1,29 +0,0 @@
-require 'test_helper'
-
-class Kaui::TagDefinitionsControllerTest < Kaui::FunctionalTestHelper
-
-  test 'should list tag definitions' do
-    get :index
-    assert_response 200
-  end
-
-  test 'should add and destroy tag definition' do
-    get :new
-    assert_response 200
-    assert_not_nil assigns(:tag_definition)
-
-    tag_definition = SecureRandom.uuid[0..5]
-    post :create,
-         :tag_definition => {
-             :name        => tag_definition,
-             :description => SecureRandom.uuid,
-             :applicable_object_types => {"0" => "ACCOUNT"}
-         }
-    assert_redirected_to tag_definitions_path
-    assert_equal 'Tag definition successfully created', flash[:notice]
-
-    delete :destroy, :id => assigns(:tag_definition).id
-    assert_redirected_to tag_definitions_path
-    assert_equal 'Tag definition successfully deleted', flash[:notice]
-  end
-end

data/test/functional/kaui/tags_controller_test.rb

@@ -1,21 +0,0 @@
-require 'test_helper'
-
-class Kaui::TagsControllerTest < Kaui::FunctionalTestHelper
-
-  test 'should get index' do
-    get :index
-    assert_response 200
-  end
-
-  test 'should list tags' do
-    # Test pagination
-    get :pagination, :format => :json
-    verify_pagination_results!
-  end
-
-  test 'should search tags' do
-    # Test search
-    get :pagination, :search => {:search => 'foo'}, :format => :json
-    verify_pagination_results!
-  end
-end

data/test/functional/kaui/tenants_controller_test.rb

@@ -1,60 +0,0 @@
-require 'test_helper'
-
-class Kaui::TenantsControllerTest < Kaui::FunctionalTestHelperNoSetup
-
-  setup do
-    # Do nothing and let the test initialize with correct # tenants
-  end
-
-  teardown do
-    # Do nothing and let the test initialize with correct # tenants
-  end
-
-  #
-  # We don't configure the tenants in 'kaui_tenants' and don't set KillBillClient.api_key
-  #
-  test 'should get index with 0 tenant with NO KillBillClient.api_key set' do
-    setup_functional_test(0, false)
-    get :index, :use_route => 'kaui'
-    # Sign-up flow
-    assert_redirected_to new_admin_tenant_path
-  end
-
-  #
-  # We don't configure the tenants in 'kaui_tenants' but we set KillBillClient.api_key (default use case for non multi-tenant UI)
-  #
-  test 'should get index with 0 tenant with KillBillClient.api_key set' do
-    setup_functional_test(0)
-    get :index, :use_route => 'kaui'
-    assert_response 302
-    assert_redirected_to Kaui::IntegrationTestHelper::HOME_PATH
-    assert_equal 'Signed in successfully.', flash[:notice]
-  end
-
-  #
-  # We configure 1 tenant in 'kaui_tenants' (the one we created with Kill Bill) and verify we skip the tenant screen
-  #
-  test 'should get index with 1 tenant' do
-    setup_functional_test(1)
-    get :index, :use_route => 'kaui'
-    assert_includes (200..399), response.code.to_i
-    assert_equal 'Signed in successfully.', flash[:notice]
-  end
-
-  #
-  # We configure 2 tenants in 'kaui_tenants' (the one we created with Kill Bill and another one) and verify we land on the view for the
-  # user to chose his tenant.
-  #
-  test 'should get index with 2 tenant' do
-    setup_functional_test(2)
-    get :index, :use_route => 'kaui'
-    assert_response :success
-    assert_equal 'Signed in successfully.', flash[:notice]
-  end
-
-  test 'should select a tenant' do
-    setup_functional_test
-    post :select_tenant, :kb_tenant_id => session[:kb_tenant_id]
-    assert_redirected_to Kaui::IntegrationTestHelper::HOME_PATH
-  end
-end

data/test/functional/kaui/transactions_controller_test.rb

@@ -1,90 +0,0 @@
-require 'test_helper'
-
-class Kaui::TransactionsControllerTest < Kaui::FunctionalTestHelper
-
-  test 'should get restful endpoint' do
-    get :restful_show, :id => @payment.transactions[0].transaction_id
-    assert_response :redirect
-    expected_response_path = "/accounts/#{@payment.account_id}/payments/#{@payment.payment_id}"
-    assert response_path.include?(expected_response_path), "#{response_path} is expected to contain #{expected_response_path}"
-  end
-
-  test 'should get new' do
-    get :new,
-        :account_id => @account.account_id,
-        :payment_method_id => @payment_method.payment_method_id,
-        :payment_id => @payment.payment_id,
-        :amount => 12,
-        :currency => 'USD',
-        :transaction_type => 'CAPTURE'
-    assert_response 200
-    assert_equal get_value_from_input_field('account_id'), @account.account_id
-    assert_equal get_value_from_input_field('payment_method_id'), @payment_method.payment_method_id
-    assert has_input_field('transaction_transaction_id')
-
-
-    get :new, :account_id => @account.account_id,
-        :payment_method_id => @payment_method.payment_method_id, :transaction_id => @payment.transactions[0].transaction_id
-    assert_response :success
-    assert_equal get_value_from_input_field('account_id'), @account.account_id
-    assert_equal get_value_from_input_field('payment_method_id'), @payment_method.payment_method_id
-    assert_equal get_value_from_input_field('transaction_transaction_id'), @payment.transactions[0].transaction_id
-    assert_equal get_value_from_input_field('transaction_payment_id'), @payment.payment_id
-  end
-
-  test 'should create new transaction' do
-    payments = []
-    %w(AUTHORIZE AUTHORIZE PURCHASE PURCHASE CREDIT).each do |transaction_type|
-      post :create,
-           :account_id => @account.account_id,
-           :payment_method_id => @payment_method.payment_method_id,
-           :transaction => {
-               :payment_external_key => SecureRandom.uuid,
-               :amount => 12,
-               :currency => 'USD',
-               :transaction_type => transaction_type
-           }
-
-      payments << created_payment_id
-      assert_redirected_to account_payment_path(@account.account_id, payments[-1])
-      assert_equal 'Transaction successfully created', flash[:notice]
-    end
-
-    %w(CAPTURE VOID REFUND CHARGEBACK).each do |transaction_type|
-      payment_id = payments.shift
-      post :create,
-           :account_id => @account.account_id,
-           :transaction => {
-               :payment_id => payment_id,
-               :amount => 12,
-               :currency => 'USD',
-               :transaction_type => transaction_type
-           }
-      assert_redirected_to account_payment_path(@account.account_id, payment_id)
-      assert_equal 'Transaction successfully created', flash[:notice]
-    end
-  end
-
-  test 'should fix transaction state' do
-    payment = create_payment(nil,nil,@tenant)
-    parameters = {
-      :account_id => payment.account_id,
-      :transaction => {
-        :payment_id => payment.payment_id,
-        :transaction_id => payment.transactions[0].transaction_id,
-        :status => 'PENDING'
-      }
-    }
-
-    put :fix_transaction_state, parameters
-    assert_response :redirect
-    assert_redirected_to account_payment_path(payment.account_id,payment.payment_id)
-    assert_equal "Transaction successfully transitioned to #{parameters[:transaction][:status]}", flash[:notice]
-  end
-
-  private
-
-  def created_payment_id
-    response.header['Location'].split('/')[-1]
-  end
-end

data/test/integration/kaui/date_helper_integration_test.rb

@@ -1,16 +0,0 @@
-require 'test_helper'
-
-module Kaui
-  class DateHelperIntegrationTest < IntegrationTestHelper
-
-    include Kaui::DateHelper
-
-    test 'can get killbill server current time depending of time zone' do
-      current_time_fiji = current_time('America/Puerto_Rico',options)
-      utc_offset_fiji = '-0400'
-
-      assert_equal utc_offset_fiji, current_time_fiji.strftime('%z')
-    end
-
-  end
-end

data/test/integration/kaui/integration_test_helper.rb

@@ -1,32 +0,0 @@
-module Kaui
-  class IntegrationTestHelper < ActionDispatch::IntegrationTest
-
-    BASE_PATH     = '/kaui'
-    TENANTS_PATH  = '/kaui/tenants'
-    HOME_PATH     = '/kaui/home'
-    SIGN_IN_PATH  = BASE_PATH + '/users/sign_in'
-    SIGN_OUT_PATH = BASE_PATH + '/users/sign_out'
-    ACCOUNTS_PATH = BASE_PATH + '/accounts'
-
-    include KillbillTestHelper
-
-    # Called before every single test
-    setup do
-      setup_integration_test
-    end
-
-    # Called after every single test
-    teardown do
-      teardown_integration_test
-    end
-
-    protected
-
-    def setup_integration_test
-      setup_test_data
-    end
-
-    def teardown_integration_test
-    end
-  end
-end

data/test/integration/kaui/navigation_test.rb

@@ -1,43 +0,0 @@
-require 'test_helper'
-
-module Kaui
-  class NavigationTest < IntegrationTestHelper
-
-    test 'Browse one account' do
-      get ACCOUNTS_PATH + '/' + @account.account_id
-      assert_redirected_to SIGN_IN_PATH
-
-      # Verify log-in and redirect to the original page
-      post SIGN_IN_PATH, :params => {:user => {:kb_username => USERNAME, :password => PASSWORD}}
-      assert_redirected_to ACCOUNTS_PATH + '/' + @account.account_id
-
-      # 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)
-
-      # He now clicks on the timeline link
-      get ACCOUNTS_PATH + '/' + @account.account_id + '/timeline'
-      assert_response :success
-      check_no_flash_error
-      assert_not_nil assigns(:account)
-
-      # Verify log-out
-      delete SIGN_OUT_PATH
-      assert_redirected_to BASE_PATH + '/'
-
-      get BASE_PATH
-      assert_redirected_to SIGN_IN_PATH
-      assert_equal 'You need to sign in before continuing.', flash[:alert]
-    end
-  end
-end
-

data/test/killbill_test_helper.rb

@@ -1,219 +0,0 @@
-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(nb_configured_tenants =  1, setup_tenant_key_secret = true)
-      @tenant            = setup_and_create_test_tenant(nb_configured_tenants)
-      @account           = create_account(@tenant)
-      @account2          = create_account(@tenant)
-      @bundle            = create_bundle(@account, @tenant)
-      @invoice_item      = create_charge(@account, @tenant)
-      @paid_invoice_item = create_charge(@account, @tenant, true)
-      @bundle_invoice    = @account.invoices(build_options(@tenant)).first
-      @payment_method    = create_payment_method(true, @account, @tenant)
-      @payment           = create_payment(@paid_invoice_item, @account, @tenant)
-
-      invoice_id_for_cba = create_charge(@account, @tenant).invoice_id
-      @cba               = create_cba(invoice_id_for_cba, @account, @tenant, true)
-      commit_invoice(invoice_id_for_cba, @tenant)
-
-      if setup_tenant_key_secret
-        KillBillClient.api_key = @tenant.api_key
-        KillBillClient.api_secret = @tenant.api_secret
-      else
-        KillBillClient.api_key = nil
-        KillBillClient.api_secret = nil
-      end
-      KillBillClient.username = USERNAME
-      KillBillClient.password = PASSWORD
-      @tenant
-    end
-
-    def setup_and_create_test_tenant(nb_configured_tenants)
-
-      # If we need to configure 0 tenant, we still create one with Kill Bill but add nothing in the kaui_tenants and kaui_allowed_users tables
-      if nb_configured_tenants == 0
-        return create_tenant
-      end
-
-      # Setup AllowedUser
-      au = Kaui::AllowedUser.find_or_create_by(kb_username: 'admin')
-
-      # Create the tenant with Kill Bill
-      all_tenants = []
-      test_tenant = nil
-      (1..nb_configured_tenants).each do |i|
-        cur_tenant = create_tenant
-        test_tenant = cur_tenant if test_tenant.nil?
-
-        t = Kaui::Tenant.new
-        t.kb_tenant_id = cur_tenant.tenant_id
-        t.name = SecureRandom.uuid.to_s
-        t.api_key = cur_tenant.api_key
-        t.api_secret = cur_tenant.api_secret
-        t.save
-        all_tenants << t
-      end
-
-      # setup kaui_tenants
-      all_tenants.each { |e| au.kaui_tenants  << e } if all_tenants.size > 0
-      test_tenant
-    end
-
-    # Return a new test account
-    def create_account(tenant = nil, username = USERNAME, password = PASSWORD, user = 'Kaui test', reason = nil, comment = nil, parent_account_id = 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.parent_account_id        = parent_account_id
-      account.is_payment_delegated_to_parent = !parent_account_id.nil?
-
-      account.create(user, reason, comment, build_options(tenant, username, password))
-    end
-
-    # Return the killbill server clock
-    def get_clock(tenant = nil)
-      tenant  = create_tenant(user, reason, comment) if tenant.nil?
-      Kaui::Admin.get_clock(nil, build_options(tenant, USERNAME, PASSWORD))
-    end
-
-    # reset killbill server clock
-    def reset_clock
-      Kaui::Admin.set_clock(nil, nil, 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, nil, false, 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(true, user, reason, comment, build_options(tenant, username, password))
-    end
-
-    # Return the created external charge
-    def create_charge(account = nil, tenant = nil, auto_commit=false, 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(auto_commit, user, reason, comment, build_options(tenant, username, password))
-    rescue
-      nil
-    end
-
-    # Return the created credit
-    def create_cba(invoice_id = nil, account = nil, tenant = nil,  auto_commit=false, 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, :amount => 23.22)
-      credit = credit.create(true, user, reason, comment, build_options(tenant, username, password)).first
-
-      invoice = KillBillClient::Model::Invoice.find_by_id(credit.invoice_id, 'NONE', build_options(tenant, username, password))
-      invoice.items.find { |ii| ii.amount == -credit.amount }
-    end
-
-    def commit_invoice(invoice_id, tenant, username = USERNAME, password = PASSWORD, user = 'Kaui test', reason = nil, comment = nil)
-      invoice = KillBillClient::Model::Invoice.find_by_id(invoice_id, 'NONE', build_options(tenant, username, password))
-      invoice.commit(user, reason, comment, build_options(tenant, username, password))
-    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, true, username, password, user, reason, comment) if invoice_item.nil?
-
-      assert_not_nil invoice_item
-
-      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 = tenant.create(true, user, reason, comment, build_options)
-
-      # Re-hydrate the secret, which is not returned
-      tenant.api_secret = api_secret
-
-      # Upload the default SpyCarAdvanced.xml catalog
-      catalog_xml = File.read("test/fixtures/SpyCarAdvanced.xml")
-      Kaui::AdminTenant.upload_catalog(catalog_xml, user, reason, comment, build_options(tenant))
-
-      tenant
-    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,22 +0,0 @@
-require 'simplecov'
-require 'pry'
-SimpleCov.start 'rails'
-
-# Configure the Rails Environment
-ENV['RAILS_ENV'] = 'test'
-
-require 'rails-controller-testing'
-Rails::Controller::Testing.install
-
-require File.expand_path('../dummy/config/environment.rb', __FILE__)
-require 'rails/test_help'
-
-Rails.backtrace_cleaner.remove_silencers!
-
-require 'multi_json'
-
-# Include helpers
-require 'killbill_test_helper'
-require 'functional/kaui/functional_test_helper_nosetup'
-require 'functional/kaui/functional_test_helper'
-require 'integration/kaui/integration_test_helper'

data/test/unit/helpers/kaui/admin_allowed_users_helper_test.rb

@@ -1,6 +0,0 @@
-require 'test_helper'
-
-module Kaui
-  class AdminAllowedUsersHelperTest < ActionView::TestCase
-  end
-end

data/test/unit/helpers/kaui/admin_tenants_helper_test.rb

@@ -1,6 +0,0 @@
-require 'test_helper'
-
-module Kaui
-  class AdminTenantsHelperTest < ActionView::TestCase
-  end
-end

data/test/unit/helpers/kaui/payment_method_helper_test.rb

@@ -1,17 +0,0 @@
-require 'test_helper'
-
-class PaymentMethodHelperTest < ActionView::TestCase
-
-  include Kaui::PaymentMethodHelper
-
-  test 'is_json?' do
-    assert !is_json?(5)
-    assert !is_json?('true')
-    assert !is_json?(false)
-    assert !is_json?("")
-    assert !is_json?(nil)
-    assert is_json?('[1, 2, 3]')
-    assert is_json?('{"value": "New", "onclick": "CreateNewDoc()"}')
-    assert !is_json?('{"value" => "New", "onclick": "CreateNewDoc()"}')
-  end
-end

data/test/unit/helpers/kaui/tenants_helper_test.rb

@@ -1,6 +0,0 @@
-require 'test_helper'
-
-module Kaui
-  class TenantsHelperTest < ActionView::TestCase
-  end
-end

data/test/unit/helpers/kaui/uuid_helper_test.rb

@@ -1,16 +0,0 @@
-require 'test_helper'
-
-class Kaui::UuidHelperTest < ActionView::TestCase
-
-  #include Kaui::UuidHelper
-
-  test 'can truncate' do
-    assert_equal '04bdf7b6-...-ab062d33c425', truncate_uuid('04bdf7b6-a95d-4a08-9990-ab062d33c425')
-  end
-
-  test 'can create a popover' do
-    object_id = SecureRandom.uuid
-    expected_markup = %{<span id="#{object_id}-popover" class="object-id-popover" data-id="#{object_id}" data-placement="right">#{truncate_uuid(object_id)}</span}
-    assert_dom_equal expected_markup, object_id_popover(object_id)
-  end
-end

data/test/unit/kaui/account_email_test.rb

@@ -1,19 +0,0 @@
-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,14 +0,0 @@
-require 'test_helper'
-
-class Kaui::AccountTest < ActiveSupport::TestCase
-
-  test 'can convert to money' do
-    account = Kaui::Account.new(:account_balance => 12.42, :account_cba => 54.32, :currency => 'USD')
-
-    assert_equal 1242, account.balance_to_money.cents
-    assert_equal 'USD', account.balance_to_money.currency.to_s
-
-    assert_equal 5432, account.cba_to_money.cents
-    assert_equal 'USD', account.cba_to_money.currency.to_s
-  end
-end