kaui 2.1.0 → 3.0.1

data/test/functional/kaui/accounts_controller_test.rb

@@ -1,297 +0,0 @@
-require 'test_helper'
-
-class Kaui::AccountsControllerTest < Kaui::FunctionalTestHelper
-
-  test 'should get index' do
-    get :index
-    assert_response 200
-  end
-
-  test 'should get index one account' do
-    parameters = {
-      :fast => '1',
-      :q => @account.account_id
-    }
-
-    get :index, parameters
-    assert_response :redirect
-    assert_redirected_to account_path(@account.account_id)
-
-    parameters = {
-        :fast => '1',
-        :q => 'THIS_IS_NOT_FOUND_REDIRECT'
-    }
-
-    get :index, parameters
-    assert_response :redirect
-    assert_redirected_to home_path
-  end
-
-  test 'should list accounts' do
-    # Test pagination
-    get :pagination, :format => :json
-    verify_pagination_results!
-  end
-
-  test 'should search accounts' do
-    # Test search
-    get :pagination, :sSearch => 'foo', :format => :json
-    verify_pagination_results!
-  end
-
-  test 'should handle Kill Bill errors when showing account details' do
-    account_id = SecureRandom.uuid.to_s
-    get :show, :account_id => account_id
-    assert_redirected_to home_path
-    assert_equal "Error while communicating with the Kill Bill server: Object id=#{account_id} type=ACCOUNT doesn't exist!", flash[:error]
-  end
-
-  test 'should find account by id' do
-    get :show, :account_id => @account.account_id
-    assert_response 200
-    assert_not_nil assigns(:tags)
-    assert_not_nil assigns(:account_emails)
-    assert_not_nil assigns(:overdue_state)
-    assert_not_nil assigns(:payment_methods)
-  end
-
-  test 'should check that overdue state is Good' do
-    get :show, :account_id => @account.account_id
-    assert_response 200
-
-    overdue_status_proc_count = 0
-
-    assert_select 'table' do |tables|
-      tables.each do |table|
-        assert_select table, 'tr' do |rows|
-          rows.each do |row|
-            # find overdue status in the response
-           is_overdue_state = false
-            assert_select row, 'th' do |col|
-              is_overdue_state = col[0].text.eql?('Overdue status')
-            end
-
-            # if found
-            if is_overdue_state
-              overdue_status_proc_count += 1
-              assert_select row, 'td' do |col|
-                assert_select col, 'span' do |content|
-                  assert 'Good', content[0].text
-                  overdue_status_proc_count += 1 if content[0].text.eql?('Good')
-                end
-              end
-            end
-          end
-        end
-      end
-    end
-
-    # assert that overdue state is found with result equal to Good
-    assert overdue_status_proc_count, 2
-  end
-
-  test 'should handle Kill Bill errors when creating account' do
-    post :create
-    assert_redirected_to home_path
-    assert_equal 'Required parameter missing: account', flash[:error]
-
-    external_key = SecureRandom.uuid.to_s
-    post :create, :account => {:external_key => external_key}
-    assert_redirected_to account_path(assigns(:account).account_id)
-
-    post :create, :account => {:external_key => external_key}
-    assert_template :new
-    assert_equal "Error while creating account: Account already exists for key #{external_key}", flash[:error]
-  end
-
-  test 'should create account' do
-    get :new
-    assert_response 200
-    assert_not_nil assigns(:account)
-
-    post :create,
-         :account => {
-             :name => SecureRandom.uuid.to_s,
-             :external_key => SecureRandom.uuid.to_s,
-             :email => SecureRandom.uuid.to_s + '@example.com',
-             :time_zone => '-06:00',
-             :country => 'AR',
-             :is_migrated => '1'
-         }
-    assert_redirected_to account_path(assigns(:account).account_id)
-    assert_equal 'Account was successfully created', flash[:notice]
-
-    assert_equal '-06:00', assigns(:account).time_zone
-    assert_equal 'AR', assigns(:account).country
-    assert assigns(:account).is_migrated
-  end
-
-  test 'should update account' do
-    get :edit, :account_id => @account.account_id
-    assert_response 200
-    assert_not_nil assigns(:account)
-
-    latest_account_attributes = assigns(:account).to_hash
-    put :update,
-        :account_id => @account.account_id,
-        :account => latest_account_attributes.merge({
-            :name => SecureRandom.uuid.to_s,
-            :email => SecureRandom.uuid.to_s + '@example.com'
-        })
-    assert_redirected_to account_path(assigns(:account).account_id)
-    assert_equal 'Account successfully updated', flash[:notice]
-  end
-
-  test 'should be redirected if no payment_method_id is specified when setting default payment method' do
-    put :set_default_payment_method, :account_id => @account.account_id
-    assert_redirected_to account_path(@account.account_id)
-    assert_equal 'Required parameter missing: payment_method_id', flash[:error]
-  end
-
-  test 'should handle Kill Bill errors when setting default payment method' do
-    account_id = SecureRandom.uuid.to_s
-    put :set_default_payment_method, :account_id => account_id, :payment_method_id => @payment_method.payment_method_id
-    assert_redirected_to home_path
-    assert_equal "Error while communicating with the Kill Bill server: Object id=#{account_id} type=ACCOUNT doesn't exist!", flash[:error]
-  end
-
-  test 'should set default payment method' do
-    put :set_default_payment_method, :account_id => @account.account_id, :payment_method_id => @payment_method.payment_method_id
-    assert_response 302
-  end
-
-  test 'should handle Kill Bill errors when paying all invoices' do
-    account_id = SecureRandom.uuid.to_s
-    post :pay_all_invoices, :account_id => account_id
-    assert_redirected_to home_path
-    assert_equal "Error while communicating with the Kill Bill server: Object id=#{account_id} type=ACCOUNT doesn't exist!", flash[:error]
-  end
-
-  test 'should pay all invoices' do
-    post :pay_all_invoices, :account_id => @account.account_id, :is_external_payment => true
-    assert_response 302
-  end
-
-  test 'should trigger invoice' do
-    account = create_account(@tenant)
-    bundle = create_bundle(account, @tenant)
-
-    parameters = {
-      :account_id => account.account_id,
-      :dry_run => '0'
-    }
-
-    post :trigger_invoice, parameters
-    assert_equal 'Nothing to generate for target date today', flash[:notice]
-    assert_redirected_to account_path(account.account_id)
-
-    today_next_month = (Date.parse(@kb_clock['localDate']) + 31).to_s
-    # generate a dry run invoice
-    parameters = {
-      :account_id => account.account_id,
-      :dry_run => '1',
-      :target_date => today_next_month
-    }
-
-    post :trigger_invoice, parameters
-    assert_response :success
-    assert_select 'table tbody tr:first' do
-      assert_select 'td:first', "sports-monthly-evergreen"
-      assert_select 'td:nth-child(4)', bundle.subscriptions.first.subscription_id
-    end
-
-
-    # persist it
-    parameters[:dry_run] = '0'
-    post :trigger_invoice, parameters
-    assert_response :redirect
-    assert_match(/Generated invoice.*for target date.*/, flash[:notice])
-    a_tag = (/<a.href="(?<href>.*?)">/).match(@response.body)
-    assert_redirected_to a_tag[:href]
-  end
-
-  test 'should get next_invoice_date' do
-    get :next_invoice_date, :account_id => @account.account_id
-    assert_not_nil @response.body
-  end
-
-  test 'should validate external key if found' do
-    get :validate_external_key, :external_key => 'foo'
-    assert_response :success
-    assert_equal JSON[@response.body]['is_found'], false
-
-    external_key = SecureRandom.uuid.to_s
-    post :create, :account => {:external_key => external_key}
-    assert_redirected_to account_path(get_redirected_account_id)
-
-    get :validate_external_key, :external_key => external_key
-    assert_response :success
-    assert_equal JSON[@response.body]['is_found'], true
-  end
-
-  test 'should link and un-link to parent' do
-    parent = create_account(@tenant)
-    child = create_account(@tenant)
-
-    # force an error linking a parent account
-    child.parent_account_id = SecureRandom.uuid.to_s
-    put :link_to_parent, {
-        :account => child.to_hash,
-        :account_id => child.account_id
-    }
-    assert_equal "Parent account id not found: #{child.parent_account_id}",flash[:error]
-    assert_redirected_to account_path(child.account_id)
-
-    # link parent account
-    child.parent_account_id = parent.account_id
-    put :link_to_parent, {
-        :account => child.to_hash,
-        :account_id => child.account_id
-    }
-    assert_equal 'Account successfully updated',flash[:notice]
-    assert_redirected_to account_path(child.account_id)
-
-    # un-link parent account
-    delete :link_to_parent, :account_id => child.account_id
-    assert_equal 'Account successfully updated',flash[:notice]
-    assert_redirected_to account_path(child.account_id)
-
-  end
-
-  test 'should set email notifications configuration if plugin is available' do
-
-    parameters = {
-        :configuration => {
-          :account_id => @account.account_id,
-          :event_types => ['INVOICE_NOTIFICATION']
-        }
-    }
-
-    post :set_email_notifications_configuration, parameters
-    assert_equal('Email notification plugin is not installed',flash[:error]) unless flash[:error].blank?
-    assert_equal("Email notifications for account #{@account.account_id} was successfully updated",flash[:notice]) if flash[:error].blank?
-    assert_redirected_to account_path(@account.account_id)
-
-  end
-
-  test 'should close an account' do
-    account_to_be_closed = create_account(@tenant)
-
-    delete :destroy, :account_id => account_to_be_closed.account_id
-    assert_redirected_to account_path(account_to_be_closed.account_id)
-    assert_equal "Account #{account_to_be_closed.account_id} successfully closed", flash[:notice]
-
-  end
-
-  private
-
-    def get_redirected_account_id
-
-      fields = /<a.href="http:\/.*\/.*?\/(?<id>.*?)">/.match(@response.body) if fields.nil?
-
-      return nil if fields.nil?
-
-      fields.nil? ? nil : fields[:id]
-    end
-
-end

data/test/functional/kaui/admin_allowed_users_controller_test.rb

@@ -1,234 +0,0 @@
-require 'test_helper'
-
-module Kaui
-  class AdminAllowedUsersControllerTest < Kaui::FunctionalTestHelper
-
-    test 'should get new' do
-      post :new
-      assert_response :success
-    end
-
-    test 'should get create local only' do
-      parameters = {
-          :allowed_user => {:kb_username => 'Albator', :description => 'My french super hero' },
-          :external => '1' ,
-          :password => 'Albator',
-          :roles => nil,
-      }
-      post :create, parameters
-      assert_equal 'User was successfully configured', flash[:notice]
-      assert_response 302
-
-      # validate redirect path
-      id = get_allowed_id(@response.body)
-      assert response_path.include?(expected_response_path(id)), "#{response_path} is expected to contain #{expected_response_path(id)}"
-    end
-
-    test 'should get create' do
-      parameters = {
-          :allowed_user => {:kb_username => 'Albator', :description => 'My french super hero'},
-          :password => 'Albator',
-          :roles => nil
-      }
-      post :create, parameters
-      assert_equal 'User was successfully configured', flash[:notice]
-      assert_response 302
-
-      # validate redirect path
-      id = get_allowed_id(@response.body)
-      assert response_path.include?(expected_response_path(id)), "#{response_path} is expected to contain #{expected_response_path(id)}"
-
-      # should return an error that the user already exists
-      post :create, parameters
-      assert_equal "User with name #{parameters[:allowed_user][:kb_username]} already exists!", flash[:error]
-      assert_response :success
-    end
-
-    test 'should get index' do
-      get :index
-      assert_response 200
-    end
-
-    test 'should get show' do
-      au = Kaui::AllowedUser.new
-      au.kb_username = 'Mad Max'
-      au.description = 'My super hero'
-      au.save!
-
-      get :show, :id => au.id
-      assert_response :success
-    end
-
-    test 'should get edit' do
-      au = Kaui::AllowedUser.new
-      au.kb_username = 'Mad Max'
-      au.description = 'My super hero'
-      au.save!
-
-      get :edit, :id => au.id
-
-      allowed_username = get_allowed_username
-      assert_equal allowed_username, au.kb_username
-      assert_response :success
-    end
-
-    test 'should update allowed user' do
-      parameters = {
-          :allowed_user => {:kb_username => 'Mad Max', :description => 'My super hero'},
-          :password => 'Batman',
-          :roles => nil
-      }
-      post :create, parameters
-      assert_equal 'User was successfully configured', flash[:notice]
-      assert_response :redirect
-
-      # validate redirect path
-      id = get_allowed_id(@response.body)
-      assert response_path.include?(expected_response_path(id)), "#{response_path} is expected to contain #{expected_response_path(id)}"
-
-      parameters = {
-          :id => id,
-          :allowed_user => { :description => 'An post-apocalyptic super hero' },
-          :roles => 'one,two'
-      }
-
-      put :update, parameters
-      assert_equal 'User was successfully updated', flash[:notice]
-      assert_response :redirect
-      # validate redirect path
-      assert response_path.include?(expected_response_path(id)), "#{response_path} is expected to contain #{expected_response_path(id)}"
-
-      # get the user to verify that the data was actually updated
-      get :edit, :id => id
-      description = get_allowed_description
-      assert_response :success
-      assert_equal parameters[:allowed_user][:description], description
-
-      # delete created user
-      delete :destroy, :id => id
-      assert_equal 'User was successfully deleted', flash[:notice]
-      assert_response :redirect
-      # validate redirect path
-      assert response_path.include?(expected_response_path), "#{response_path} is expected to contain #{expected_response_path}"
-    end
-
-    test 'should delete allowed user' do
-      parameters = {
-          :allowed_user => {:kb_username => 'Batman', :description => 'Everyone wants to be batman'},
-          :password => 'Batman',
-          :roles => nil
-      }
-      post :create, parameters
-      assert_equal 'User was successfully configured', flash[:notice]
-      assert_response :redirect
-      id = get_allowed_id(@response.body)
-      # validate redirect path
-      assert response_path.include?(expected_response_path(id)), "#{response_path} is expected to contain #{expected_response_path(id)}"
-
-      delete :destroy, :id => id
-      assert_equal 'User was successfully deleted', flash[:notice]
-      assert_response :redirect
-      # validate redirect path
-      assert response_path.include?(expected_response_path), "#{response_path} is expected to contain #{expected_response_path}"
-
-      # should respond with an error if tried to delete again
-      delete :destroy, :id => id
-      assert_equal "Error: Couldn't find Kaui::AllowedUser with 'id'=#{id}", flash[:error]
-      assert_response :redirect
-      # validate redirect path
-      assert response_path.include?('/kaui/home'), "#{response_path} is expected to contain '/kaui/home'"
-    end
-
-    test 'should add tenant' do
-      allowed_user = {:kb_username => 'Mad Max', :description => 'My super hero'}
-
-      au = Kaui::AllowedUser.new
-      au.kb_username = allowed_user[:kb_username]
-      au.description = allowed_user[:description]
-      au.save!
-
-      allowed_user[:id] = au.id
-
-      put :add_tenant, :allowed_user => allowed_user, :tenant_1 => nil
-      assert_equal 'Successfully set tenants for user', flash[:notice]
-      assert_response :redirect
-      # validate redirect path
-      assert response_path.include?(expected_response_path(au.id)), "#{response_path} is expected to contain #{expected_response_path(au.id)}"
-    end
-
-    test 'should detect if a user is managed externally' do
-      allowed_user = {:kb_username => 'Local', :description => 'adding only locally'}
-
-      # adding only locally will make the user managed externally
-      au = Kaui::AllowedUser.new
-      au.kb_username = allowed_user[:kb_username]
-      au.description = allowed_user[:description]
-      au.save!
-
-      # edit the added user and validate that the checkbox of managed externally is disabled
-      get :edit, :id => au.id
-      assert_response :success
-      assert_select 'form input#external' do |checkbox|
-        assert_equal checkbox[0]['disabled'], 'disabled'
-      end
-
-      # create a user that is managed externally
-      parameters = {
-          :allowed_user => {:kb_username => 'LDAP', :description => 'LDAP' },
-          :external => '1'
-      }
-      post :create, parameters
-      assert_equal 'User was successfully configured', flash[:notice]
-      assert_response 302
-      added_au_id = response_path.gsub('/kaui/admin_allowed_users/','')
-
-      # edit the added user and validate that the checkbox of managed externally is disabled
-      get :edit, :id => added_au_id
-      assert_response :success
-      assert_select 'form input#external' do |checkbox|
-        assert_equal checkbox[0]['disabled'], 'disabled'
-      end
-
-      # create a user that is not managed externally
-      parameters = {
-          :allowed_user => {:kb_username => 'JDBC', :description => 'Kill Bill JDBC Realm' },
-          :external => '0',
-          :password => 'jdbc',
-          :roles => nil
-      }
-      post :create, parameters
-      assert_equal 'User was successfully configured', flash[:notice]
-      assert_response 302
-      added_au_id = response_path.gsub('/kaui/admin_allowed_users/','')
-
-      # edit the added user and validate that the password is not disabled
-      get :edit, :id => added_au_id
-      assert_response :success
-      assert_select 'form input#password' do |input|
-        assert_nil input[0]['disabled']
-      end
-    end
-
-    private
-      def expected_response_path(id=nil)
-        "/kaui/admin_allowed_users#{id.nil? ? '' : "/#{id}" }"
-      end
-
-      def get_allowed_username
-        get_value_from_input_field('allowed_user_kb_username')
-      end
-
-      def get_allowed_description
-        get_value_from_input_field('allowed_user_description')
-      end
-
-      def get_allowed_id(response_body)
-        fields = /<form.*action="\/.*\/.*\/(?<id>.*?)".accept-charset=.*method="post">/.match(response_body)
-        fields = /<a.href="http:\/.*\/.*\/(?<id>.*?)">/.match(response_body) if fields.nil?
-
-        fields.nil? ? nil : fields[:id]
-      end
-
-
-  end
-end

data/test/functional/kaui/admin_controller_test.rb

@@ -1,45 +0,0 @@
-require 'test_helper'
-
-class Kaui::AdminControllerTest < Kaui::FunctionalTestHelper
-
-  test 'should get index' do
-    get :index
-    clock = get_date
-    assert_not_nil clock
-    date = DateTime.parse(clock.to_s.gsub('"','')).strftime('%F')
-    assert_match(/\d{4}-\d{,2}-\d{,2}/, date)
-    assert_response :success
-  end
-
-  test 'should set clock' do
-
-    # retrieve current clock from killbill
-    get :index
-
-    clock = get_date
-    assert_not_nil clock
-    date = DateTime.parse(clock.to_s.gsub('"','')).strftime('%F')
-    assert_match(/\d{4}-\d{,2}-\d{,2}/, date)
-    assert_response :success
-
-    # update killbill clock
-    put :set_clock, :commit => 'Submit', :new_date => clock
-    assert_response :redirect
-
-    # reset killbill clock
-    put :set_clock, :commit => nil
-    assert_response :redirect
-
-  end
-
-  private
-
-  def get_date
-    return nil if @response.nil? || @response.body.nil?
-
-    pattern = Regexp.new('<span.id="kb_clock">(?<clock>.+?)</span>')
-    data = pattern.match(@response.body)
-    data.nil? ? nil : data[:clock]
-  end
-
-end