kaui 2.1.0 → 3.0.1

data/test/functional/kaui/admin_tenants_controller_test.rb

@@ -1,352 +0,0 @@
-require 'test_helper'
-
-class Kaui::AdminTenantsControllerTest < Kaui::FunctionalTestHelper
-
-  test 'should get new' do
-    post :new
-    assert_response :success
-  end
-
-  test 'should get create' do
-    now = Time.now.to_s
-    post :create, :tenant => {:name => 'Goldorak_' + now, :api_key => '12345_' + now, :api_secret => 'ItH@st0beComplic@ted'}, :create_tenant => true
-    assert_response 302
-  end
-
-  test 'should get index' do
-    get :index
-    assert_response :success
-  end
-
-  test 'should get show with allowed user' do
-    tenant = Kaui::Tenant.new
-    tenant.name = 'foo'
-    tenant.api_key = 'api_key'
-    tenant.api_secret = 'api_secret'
-    tenant.kb_tenant_id = 'kb_tenant_id'
-    tenant.save!
-
-     # Add an allowed user that will verify that we can only
-    au = Kaui::AllowedUser.find_by_kb_username('admin')
-    au.kaui_tenants << tenant
-
-    get :show, :id => tenant.id
-    assert_response :success
-  end
-
-  test 'should get show with NO allowed user' do
-    tenant = Kaui::Tenant.new
-    tenant.name = 'foo'
-    tenant.api_key = 'api_key'
-    tenant.api_secret = 'api_secret'
-    tenant.kb_tenant_id = 'kb_tenant_id'
-    tenant.save!
-
-    get :show, :id => tenant.id
-    assert_response 200
-  end
-
-  test 'should upload catalog' do
-    tenant = create_kaui_tenant
-    post :upload_catalog, :id => tenant.id, :catalog => fixture_file_upload('catalog-v1.xml')
-
-    assert_redirected_to admin_tenant_path(tenant.id)
-    assert_equal 'Catalog was successfully uploaded', flash[:notice]
-  end
-
-  test 'should upload overdue config' do
-    tenant = create_kaui_tenant
-    post :upload_overdue_config, :id => tenant.id, :overdue => fixture_file_upload('overdue-v1.xml')
-
-    assert_redirected_to admin_tenant_path(tenant.id)
-    assert_equal 'Overdue config was successfully uploaded', flash[:notice]
-  end
-
-  test 'should upload invoice template' do
-    tenant = create_kaui_tenant
-    post :upload_invoice_template, :id => tenant.id, :invoice_template => fixture_file_upload('invoice_template-v1.html')
-
-    assert_redirected_to admin_tenant_path(tenant.id)
-    assert_equal 'Invoice template was successfully uploaded', flash[:notice]
-  end
-
-  test 'should upload invoice translation' do
-    tenant = create_kaui_tenant
-    post :upload_invoice_translation, :id => tenant.id, :invoice_translation => fixture_file_upload('invoice_translation_fr-v1.properties'), :translation_locale => 'fr_FR'
-
-    assert_redirected_to admin_tenant_path(tenant.id)
-    assert_equal 'Invoice translation was successfully uploaded', flash[:notice]
-  end
-
-  test 'should upload catalog translation' do
-    tenant = create_kaui_tenant
-    post :upload_catalog_translation, :id => tenant.id, :catalog_translation => fixture_file_upload('catalog_translation_fr-v1.properties'), :translation_locale => 'fr_FR'
-
-    assert_redirected_to admin_tenant_path(tenant.id)
-    assert_equal 'Catalog translation was successfully uploaded', flash[:notice]
-  end
-
-  test 'should upload plugin config' do
-    tenant = create_kaui_tenant
-
-    stripe_yml = YAML.load_file(File.join(self.class.fixture_path, 'stripe.yml'))[:stripe]
-    stripe_yml.stringify_keys!
-    stripe_yml.each { |k, v| stripe_yml[k] = v.to_s }
-    post :upload_plugin_config, :id => tenant.id, :plugin_name => 'killbill-stripe', :plugin_key => 'stripe', :plugin_type => 'ruby', :plugin_properties => stripe_yml
-
-    assert_redirected_to admin_tenant_path(tenant.id, :active_tab => 'PluginConfig')
-    assert_equal 'Config for plugin was successfully uploaded', flash[:notice]
-  end
-
-  test 'should get new catalog' do
-    tenant = create_kaui_tenant
-
-    get :new_catalog, :id => tenant.id
-    assert_response :success
-    assert has_input_field('simple_plan_product_name')
-  end
-
-  test 'should get new plan currency' do
-    tenant = create_kaui_tenant
-
-    # retrieve plan id from catalog xml
-    catalog_xml = File.open(File.join(self.class.fixture_path, 'catalog-v1.xml'),'r'){|io| io.read}
-    doc = Nokogiri::XML(catalog_xml)
-    plan_id = doc.css('plan').first['name']
-
-    # upload catalog first
-    post :upload_catalog, :id => tenant.id, :catalog => fixture_file_upload('catalog-v1.xml')
-    assert_redirected_to admin_tenant_path(tenant.id)
-    assert_equal 'Catalog was successfully uploaded', flash[:notice]
-
-    get :new_plan_currency, :id => tenant.id, :plan_id => plan_id
-    assert_response :success
-    assert_equal get_value_from_input_field('simple_plan_plan_id'), plan_id
-
-    # test for invalid plan id
-    get :new_plan_currency, :id => tenant.id, :plan_id => 'DUMMY'
-    assert_response :redirect
-    assert_redirected_to admin_tenant_path(tenant.id)
-    assert_equal flash[:error], 'Plan id DUMMY was not found.'
-
-  end
-
-  test 'should create and delete a catalog' do
-    tenant = create_kaui_tenant
-
-    parameters = {
-      :id => tenant.id,
-      :simple_plan => {
-          :product_category => 'STANDALONE',
-          :product_name => 'Boat_Rental',
-          :plan_id => 'boat12345678910',
-          :amount => 10,
-          :currency => 'USD',
-          :billing_period => 'MONTHLY',
-          :trial_length => 0,
-          :trial_time_unit => 'UNLIMITED'
-      }
-    }
-    post :create_simple_plan, parameters
-    assert_response :redirect
-    expected_response_path = "/admin_tenants/#{tenant.id}"
-    assert_equal 'Catalog plan was successfully added', flash[:notice]
-    assert response_path.include?(expected_response_path), "#{response_path} is expected to contain #{expected_response_path}"
-
-
-    delete :delete_catalog, :id => tenant.id
-    assert_response :redirect
-
-    if !flash[:error].nil? && flash[:error].to_s.eql?('Failed to delete catalog: only available in KB 0.19+ versions')
-      assert response_path.include?('/admin_tenants'), "#{response_path} is expected to contain /admin_tenants"
-    else
-      assert_equal 'Catalog was successfully deleted', flash[:notice]
-      assert response_path.include?(expected_response_path), "#{response_path} is expected to contain #{expected_response_path}"
-    end
-
-  end
-
-  test 'should remove allowed user' do
-    tenant = create_kaui_tenant
-
-    au = Kaui::AllowedUser.new
-    au.kb_username = 'Voltron'
-    au.description = 'Defender of the Universe'
-    au.save!
-
-    parameters = {
-      :id => tenant.id,
-      :allowed_user => { :id => au.id }
-    }
-
-    delete :remove_allowed_user, parameters
-    assert_response :success
-  end
-
-  test 'should modify overdue config' do
-    tenant = create_kaui_tenant
-
-    parameters = {
-      :id => tenant.id,
-      :kill_bill_client_model_overdue => {
-        :states => { '0' => {
-          :name =>	'Overdue_test',
-          :external_message => 'Overdue_Test_Ya',
-          :is_block_changes =>	true,
-          :subscription_cancellation_policy => 'NONE',
-          :condition => {
-            :time_since_earliest_unpaid_invoice_equals_or_exceeds => 1,
-            :control_tag_inclusion =>	'NONE',
-            :control_tag_exclusion =>	'NONE',
-            :number_of_unpaid_invoices_equals_or_exceeds => 0,
-            :total_unpaid_invoice_balance_equals_or_exceeds => 0
-          }
-        }}
-      }
-    }
-
-    post :modify_overdue_config, parameters
-    assert_response :redirect
-    assert_redirected_to admin_tenant_path(tenant.id)
-    assert_equal 'Overdue config was successfully added', flash[:notice].to_s.strip
-  end
-
-  test 'should display catalog xml' do
-    effective_date = '2013-02-08T00:00:00+00:00'
-    tenant = create_kaui_tenant
-    post :upload_catalog, :id => tenant.id, :catalog => fixture_file_upload('catalog-v1.xml')
-
-    assert_redirected_to admin_tenant_path(tenant.id)
-    assert_equal 'Catalog was successfully uploaded', flash[:notice]
-
-    post :display_catalog_xml, :effective_date => effective_date, :id => tenant.id
-
-    doc = nil
-    assert_nothing_raised { doc = Nokogiri::XML(@response.body) { |config| config.strict } }
-
-    catalog = doc.xpath("//catalog")
-    expected_effective_date = Date.parse(catalog[0].search("effectiveDate").text)
-
-    assert_equal Date.parse(effective_date), expected_effective_date
-  end
-
-  test 'should display overdue xml' do
-    overdue_xml = File.open(File.join(self.class.fixture_path, 'overdue-v1.xml'),'r'){|io| io.read}
-    post :display_overdue_xml, :xml => overdue_xml
-
-    assert_equal @response.body, overdue_xml
-  end
-
-  test 'should get a catalog by effective date' do
-    effective_date = '2013-02-08T00:00:00+00:00'
-    tenant = create_kaui_tenant
-    post :upload_catalog, :id => tenant.id, :catalog => fixture_file_upload('catalog-v1.xml')
-
-    get :catalog_by_effective_date, :id => tenant.id, :effective_date => effective_date
-    assert_response :success
-
-    result = nil
-    assert_nothing_raised { result = JSON.parse(@response.body) }
-    assert_not_nil(result)
-    assert_equal 1, result['catalog'].size
-    assert_equal Date.parse(effective_date), Date.parse(result['catalog'][0]['version_date'])
-  end
-
-  test 'should add an allowed user' do
-    tenant = Kaui::Tenant.new
-    tenant.name = 'foo'
-    tenant.api_key = 'api_key'
-    tenant.api_secret = 'api_secret'
-    tenant.kb_tenant_id = 'kb_tenant_id'
-    tenant.save!
-
-    # create a new user
-    au = Kaui::AllowedUser.new(:kb_username => 'Hulk', :description => "He is green")
-    au.save
-
-    # add user to allowed list
-    parameters = {
-        :allowed_user => {:kb_username => au.kb_username},
-        :tenant_id => tenant.id
-    }
-    put :add_allowed_user, parameters
-    assert_redirected_to admin_tenant_path(tenant.id)
-    assert_equal 'Allowed user was successfully added', flash[:notice]
-
-    # try to add non existent user
-    parameters = {
-        :allowed_user => {:kb_username => 'Steve Rogers'},
-        :tenant_id => tenant.id
-    }
-    put :add_allowed_user, parameters
-    assert_redirected_to admin_tenant_path(tenant.id)
-    assert_equal "User #{parameters[:allowed_user][:kb_username]} does not exist!", flash[:error]
-
-  end
-
-  test 'should switch tenant' do
-    other_tenant = setup_and_create_test_tenant(1)
-    other_tenant_kaui = Kaui::Tenant.find_by_kb_tenant_id(other_tenant.tenant_id)
-
-    get :switch_tenant, :kb_tenant_id => other_tenant.tenant_id
-    assert_redirected_to admin_tenant_path(other_tenant_kaui.id)
-    assert_equal flash[:notice], "Tenant was switched to #{other_tenant_kaui.name}"
-
-    # switch back
-    tenant_kaui = Kaui::Tenant.find_by_kb_tenant_id(@tenant.tenant_id)
-    get :switch_tenant, :kb_tenant_id => @tenant.tenant_id
-    assert_redirected_to admin_tenant_path(tenant_kaui.id)
-    assert_equal flash[:notice], "Tenant was switched to #{tenant_kaui.name}"
-  end
-
-  test 'should download a catalog' do
-    effective_date = '2013-02-08T00:00:00+00:00'
-    tenant = create_kaui_tenant
-    post :upload_catalog, :id => tenant.id, :catalog => fixture_file_upload('catalog-v1.xml')
-
-    assert_redirected_to admin_tenant_path(tenant.id)
-    assert_equal 'Catalog was successfully uploaded', flash[:notice]
-
-    get :download_catalog_xml, :effective_date => effective_date, :id => tenant.id
-    assert_response :success
-    assert_equal 'application/xml', @response.header['Content-Type']
-    assert_equal "attachment; filename=\"catalog_#{effective_date}.xml\"", @response.header['Content-Disposition']
-
-    doc = nil
-    assert_nothing_raised { doc = Nokogiri::XML(@response.body) { |config| config.strict } }
-
-    catalog = doc.xpath("//catalog")
-    expected_effective_date = Date.parse(catalog[0].search("effectiveDate").text)
-
-    assert_equal Date.parse(effective_date), expected_effective_date
-  end
-
-  private
-
-  def create_kaui_tenant
-    post :create,
-         :tenant => {:name => SecureRandom.uuid.to_s, :api_key => SecureRandom.uuid.to_s, :api_secret => SecureRandom.uuid.to_s},
-         :create_tenant => true
-
-    tenant = Kaui::Tenant.last
-    assert_redirected_to admin_tenant_path(tenant.id)
-    assert_equal 'Tenant was successfully configured', flash[:notice]
-    tenant
-  end
-
-  def installed_plugins
-    installed_plugins = []
-    nodes_info = KillBillClient::Model::NodesInfo.nodes_info(build_options(@tenant, USERNAME, PASSWORD)) || []
-    plugins_info = nodes_info.first.plugins_info || []
-    plugins_info.each do |plugin|
-      next if plugin.plugin_key.nil? || plugin.version.nil?
-      next if installed_plugins.any? { |p| p[:plugin_name].eql?(plugin.plugin_name) }
-      installed_plugins << {
-          plugin_key: plugin.plugin_key,
-          plugin_name: plugin.plugin_name
-      }
-    end
-
-    installed_plugins
-  end
-end

data/test/functional/kaui/audit_logs_controller_test.rb

@@ -1,71 +0,0 @@
-require 'test_helper'
-require 'nokogiri'
-
-class Kaui::AuditLogsControllerTest < Kaui::FunctionalTestHelper
-  OBJECT_WITH_HISTORY = %w[ACCOUNT ACCOUNT_EMAIL CUSTOM_FIELD PAYMENT_ATTEMPT PAYMENT PAYMENT_METHOD TRANSACTION TAG]
-
-  test 'should list all account audit logs' do
-    new_account = create_account(@tenant)
-
-    get :index, :account_id => new_account.account_id
-    assert_response :success
-    audit_logs_from_response = get_value_from_input_field('audit-logs').gsub!('&quot;','"');
-    assert_not_nil audit_logs_from_response
-    audit_logs = JSON.parse(audit_logs_from_response)
-    assert_equal 1, audit_logs.count
-    assert_equal 'ACCOUNT', audit_logs[0][2]
-    assert_equal 'INSERT', audit_logs[0][3]
-  end
-
-  test 'should get audit logs with history' do
-    new_account = create_account(@tenant)
-    add_a_note(new_account)
-    create_payment_method(true, new_account, @tenant)
-    create_payment(nil, new_account, @tenant)
-
-    get :index, :account_id => new_account.account_id
-    assert_response :success
-    audit_logs_from_response = get_value_from_input_field('audit-logs').gsub!('&quot;','"');
-    assert_not_nil audit_logs_from_response
-    audit_logs = JSON.parse(audit_logs_from_response)
-
-    audit_logs.each do |audit_log|
-      if OBJECT_WITH_HISTORY.include?(audit_log[2])
-        anchor = Nokogiri::HTML(audit_log[1]).css('a')
-        get :history, :account_id => new_account.account_id, :object_id => anchor[0]['data-object-id'], :object_type => audit_log[2]
-        assert_response :success
-
-        audit_logs_with_history = JSON.parse(@response.body)['audits']
-
-        if audit_log[2] == 'ACCOUNT'
-          assert_equal 3, audit_logs_with_history.count
-          assert_equal 'INSERT', audit_logs_with_history[0]['changeType']
-          assert_nil audit_logs_with_history[0]['history']['notes']
-          assert_equal 'UPDATE', audit_logs_with_history[1]['changeType']
-          assert_not_nil audit_logs_with_history[1]['history']['notes']
-          assert_equal 'UPDATE', audit_logs_with_history[1]['changeType']
-          assert_not_nil audit_logs_with_history[2]['history']['paymentMethodId']
-        elsif audit_log[2] == 'PAYMENT'
-          assert_equal 2, audit_logs_with_history.count
-          assert_equal 'INSERT', audit_logs_with_history[0]['changeType']
-          assert_equal 'UPDATE', audit_logs_with_history[1]['changeType']
-        elsif audit_log[2] == 'PAYMENT_METHOD'
-          assert_equal 1, audit_logs_with_history.count
-          assert_equal 'INSERT', audit_logs_with_history[0]['changeType']
-        elsif audit_log[2] == 'TRANSACTION'
-          assert_equal 2, audit_logs_with_history.count
-          assert_equal 'INSERT', audit_logs_with_history[0]['changeType']
-          assert_equal 'UPDATE', audit_logs_with_history[1]['changeType']
-        end
-
-      end
-    end
-
-  end
-
-  private
-  def add_a_note(account)
-    account.notes = 'I am a note'
-    account.update(false, 'Kaui log test', nil, nil, build_options(@tenant, USERNAME, PASSWORD))
-  end
-end

data/test/functional/kaui/bundle_tags_controller_test.rb

@@ -1,23 +0,0 @@
-require 'test_helper'
-
-class Kaui::BundleTagsControllerTest < Kaui::FunctionalTestHelper
-
-  test 'should handle Kill Bill errors when getting edit screen' do
-    get :edit, :account_id => @account.account_id
-    assert_redirected_to account_path(@account.account_id)
-    assert_equal 'Required parameter missing: bundle_id', flash[:error]
-
-    bundle_id = SecureRandom.uuid.to_s
-    get :edit, :account_id => @account.account_id, :bundle_id => bundle_id
-    assert_redirected_to account_path(@account.account_id)
-    assert_equal "Error while communicating with the Kill Bill server: Object id=#{bundle_id} type=BUNDLE doesn't exist!", flash[:error]
-  end
-
-  test 'should get edit' do
-    get :edit, :account_id => @account.account_id, :bundle_id => @bundle.bundle_id
-    assert_response 200
-    assert_not_nil assigns(:bundle_id)
-    assert_not_nil assigns(:tag_names)
-    assert_not_nil assigns(:available_tags)
-  end
-end

data/test/functional/kaui/bundles_controller_test.rb

@@ -1,130 +0,0 @@
-require 'test_helper'
-
-class Kaui::BundlesControllerTest < Kaui::FunctionalTestHelper
-
-  test 'should be redirected if an invalid account id was specified in index screen' do
-    account_id = SecureRandom.uuid.to_s
-    get :index, :account_id => account_id
-    assert_redirected_to account_path(account_id)
-    assert_equal "Error while communicating with the Kill Bill server: Object id=#{account_id} type=ACCOUNT doesn't exist!", flash[:error]
-  end
-
-  test 'should get index with existing tags' do
-
-    tag_definition_ids = []
-    def1 = create_tag_definition(SecureRandom.uuid.to_s[0..19], @tenant);
-    tag_definition_ids << def1
-    tag_definition_ids << def1
-    def2 = create_tag_definition(SecureRandom.uuid.to_s[0..19], @tenant);
-    tag_definition_ids << def2
-
-    add_tags(@bundle, tag_definition_ids, @tenant);
-    get :index, :account_id => @bundle.account_id
-    assert_response 200
-    assert_not_nil assigns(:account)
-    assert_not_nil assigns(:bundles)
-    assert_not_nil assigns(:tags_per_bundle)
-    assert_equal 2, assigns(:tags_per_bundle)[@bundle.bundle_id].size
-  end
-
-  test 'should handle Kill Bill errors during transfer' do
-    post :do_transfer, :id => @bundle.bundle_id
-    assert_redirected_to home_path
-    assert_equal 'Required parameter missing: new_account_key', flash[:error]
-
-    new_account_key = SecureRandom.uuid.to_s
-    post :do_transfer, :id => @bundle.bundle_id, :new_account_key => new_account_key
-    assert_redirected_to home_path
-    assert_equal "Error while communicating with the Kill Bill server: Object id=#{new_account_key} type=ACCOUNT doesn't exist!", flash[:error]
-
-    bundle_id = SecureRandom.uuid.to_s
-    post :do_transfer, :id => bundle_id, :new_account_key => @account2.external_key
-    assert_redirected_to home_path
-    assert_equal "Error while communicating with the Kill Bill server: Object id=#{bundle_id} type=BUNDLE doesn't exist!", flash[:error]
-  end
-
-  test 'should get transfer' do
-    get :transfer, :id => @bundle.bundle_id
-    assert_response 200
-    assert_not_nil assigns(:bundle_id)
-  end
-
-  test 'should transfer bundle default policy' do
-    check_bundle_owner(@account.account_id)
-
-    post :do_transfer,
-         :id => @bundle.bundle_id,
-         :new_account_key => @account2.external_key
-    assert_redirected_to account_bundles_path(@account2.account_id)
-    assert_equal 'Bundle was successfully transferred', flash[:notice]
-
-    check_bundle_owner(@account2.account_id)
-  end
-
-  test 'should transfer bundle immediately' do
-    check_bundle_owner(@account.account_id)
-
-    post :do_transfer,
-         :id => @bundle.bundle_id,
-         :new_account_key => @account2.external_key,
-         :billing_policy => 'IMMEDIATE'
-    assert_redirected_to account_bundles_path(@account2.account_id)
-    assert_equal 'Bundle was successfully transferred', flash[:notice]
-
-    check_bundle_owner(@account2.account_id)
-  end
-
-  test 'should expose restful endpoint' do
-    get :restful_show, :id => @bundle.bundle_id
-    assert_redirected_to account_bundles_path(@bundle.account_id)
-
-    get :restful_show, :id => @bundle.external_key
-    assert_redirected_to account_bundles_path(@bundle.account_id)
-  end
-
-  test 'should get pause_resume ' do
-    get :pause_resume, :id => @bundle.bundle_id
-    assert_response :success
-    assert has_input_field('pause_requested_date')
-    assert has_input_field('resume_requested_date')
-  end
-
-  test 'should put bundle on pause and resume' do
-    expected_response_path = "/accounts/#{@account.account_id}/bundles"
-    bundle = create_bundle(@account, @tenant)
-
-    # put bundle on pause
-    put :do_pause_resume, :id => bundle.bundle_id,:account_id => @account.account_id, :pause_requested_date => DateTime.now.strftime('%F')
-    assert_response :redirect
-    assert_equal 'Bundle was successfully paused', flash[:notice]
-    # validate redirect path
-    assert response_path.include?(expected_response_path), "#{response_path} is expected to contain #{expected_response_path}"
-
-    # resume bundle on pause
-    put :do_pause_resume, :id => bundle.bundle_id,:account_id => @account.account_id, :resume_requested_date => DateTime.now.strftime('%F')
-    assert_response :redirect
-    assert_equal 'Bundle was successfully resumed', flash[:notice]
-    # validate redirect path
-    assert response_path.include?(expected_response_path), "#{response_path} is expected to contain #{expected_response_path}"
-
-  end
-
-  private
-
-  def create_tag_definition(tag_definition_name, tenant, username = USERNAME, password = PASSWORD, reason = nil, comment = nil)
-    input = Kaui::TagDefinition.new(tag_definition_name)
-    input.name = tag_definition_name
-    input.description = 'something'
-    input.applicable_object_types = ['BUNDLE']
-    tag_def = input.create(username, reason, comment, build_options(tenant, username, password))
-    tag_def.id
-  end
-
-  def add_tags(bundle, tag_definition_ids, tenant, username = USERNAME, password = PASSWORD, reason = nil, comment = nil)
-    bundle.set_tags(tag_definition_ids, username, reason, comment, build_options(tenant, username, password))
-  end
-
-  def check_bundle_owner(new_owner)
-    assert_equal new_owner, Kaui::Bundle.find_by_external_key(@bundle.external_key, false, options).account_id
-  end
-end

data/test/functional/kaui/chargebacks_controller_test.rb

@@ -1,42 +0,0 @@
-require 'test_helper'
-
-class Kaui::ChargebacksControllerTest < Kaui::FunctionalTestHelper
-
-  test 'should handle Kill Bill errors in new screen' do
-    payment_id = SecureRandom.uuid.to_s
-    get :new, :account_id => @account.account_id, :payment_id => payment_id
-    assert_redirected_to account_path(@account.account_id)
-    assert_equal "Error while communicating with the Kill Bill server: Object id=#{payment_id} type=PAYMENT doesn't exist!", flash[:error]
-  end
-
-  test 'should get new' do
-    get :new, :account_id => @account.account_id, :payment_id => @payment.payment_id
-    assert_response 200
-  end
-
-  test 'should handle Kill Bill errors during create' do
-    payment_id = SecureRandom.uuid.to_s
-    post :create,
-         :account_id => @account.account_id,
-         :chargeback => {
-             :payment_id => payment_id,
-             :amount => @payment.paid_amount_to_money.to_f,
-             :currency => @payment.currency
-         }
-    assert_template :new
-    assert_equal "Error while creating a new chargeback: Object id=#{payment_id} type=PAYMENT doesn't exist!", flash[:error]
-  end
-
-  test 'should create chargeback' do
-    post :create,
-         :account_id => @payment.account_id,
-         :chargeback => {
-             :payment_id => @payment.payment_id,
-             :amount => @payment.paid_amount_to_money.to_f,
-             :currency => @payment.currency
-         },
-         :cancel_all_subs => '1'
-    assert_redirected_to account_payment_path(@payment.account_id, @payment.payment_id)
-    assert_equal 'Chargeback created', flash[:notice]
-  end
-end

data/test/functional/kaui/charges_controller_test.rb

@@ -1,60 +0,0 @@
-require 'test_helper'
-
-class Kaui::ChargesControllerTest < Kaui::FunctionalTestHelper
-
-  test 'should handle Kill Bill errors in new screen' do
-    invoice_id = SecureRandom.uuid.to_s
-    get :new, :account_id => @account.account_id, :invoice_id => invoice_id
-    assert_redirected_to account_path(@account.account_id)
-    assert_equal "Error while communicating with the Kill Bill server: Object id=#{invoice_id} type=INVOICE doesn't exist!", flash[:error]
-  end
-
-  test 'should get new for new invoice' do
-    get :new, :account_id => @account.account_id
-    assert_response 200
-  end
-
-  test 'should get new for existing invoice' do
-    get :new, :account_id => @account.account_id, :invoice_id => @invoice_item.invoice_id
-    assert_response 200
-  end
-
-  test 'should handle Kill Bill errors during creation' do
-    invoice_id = SecureRandom.uuid.to_s
-    post :create,
-         :account_id => @account.account_id,
-         :invoice_item => {
-             :invoice_id => invoice_id,
-             :amount => 5.34,
-             :currency => 'USD',
-             :description => SecureRandom.uuid
-         }
-    assert_redirected_to account_path(@account.account_id)
-    assert_equal "Error while communicating with the Kill Bill server: Object id=#{invoice_id} type=INVOICE doesn't exist!", flash[:error]
-  end
-
-  test 'should create charge' do
-    post :create,
-         :account_id => @account.account_id,
-         :invoice_item => {
-             :amount => 5.34,
-             :currency => 'USD',
-             :description => SecureRandom.uuid
-         }
-    assert_response :redirect
-    assert_equal 'Charge was successfully created', flash[:notice]
-  end
-
-  test 'should create charge for existing invoice' do
-    post :create,
-         :account_id => @account.account_id,
-         :invoice_item => {
-             :invoice_id => @invoice_item.invoice_id,
-             :amount => 5.34,
-             :currency => 'USD',
-             :description => SecureRandom.uuid
-         }
-    assert_redirected_to account_invoice_path(@account.account_id, @invoice_item.invoice_id)
-    assert_equal 'Charge was successfully created', flash[:notice]
-  end
-end