kaui 2.0.4 → 2.2.1

data/test/functional/kaui/invoice_items_controller_test.rb

@@ -1,82 +0,0 @@
-require 'test_helper'
-
-class Kaui::InvoiceItemsControllerTest < Kaui::FunctionalTestHelper
-
-  test 'should handle errors in edit screen' do
-    get :edit, :account_id => @account.account_id, :id => @invoice_item.invoice_item_id
-    assert_redirected_to account_path(@account.account_id)
-    assert_equal 'Required parameter missing: invoice_id', flash[:error]
-
-    invoice_id = SecureRandom.uuid.to_s
-    get :edit, :account_id => @account.account_id, :id => @invoice_item.invoice_item_id, :invoice_id => invoice_id
-    assert_redirected_to account_path(@account.account_id)
-    assert_equal "Error while communicating with the Kill Bill server: Error 404: Object id=#{invoice_id} type=INVOICE doesn't exist!", flash[:error]
-
-    invoice_item_id = SecureRandom.uuid.to_s
-    get :edit, :account_id => @account.account_id, :id => invoice_item_id, :invoice_id => @invoice_item.invoice_id
-    assert_redirected_to account_invoice_path(@account.account_id, @invoice_item.invoice_id)
-    assert_equal "Unable to find invoice item #{invoice_item_id}", flash[:error]
-  end
-
-  test 'should get edit' do
-    get :edit, :account_id => @account.account_id, :invoice_id => @invoice_item.invoice_id, :id => @invoice_item.invoice_item_id
-    assert_response 200
-    assert_equal @invoice_item.invoice_item_id, assigns(:invoice_item).invoice_item_id
-  end
-
-  test 'should handle errors during update' do
-    invoice_id = SecureRandom.uuid.to_s
-    put :update,
-        :id => @invoice_item.invoice_item_id,
-        :invoice_item => {
-            :account_id => @account.account_id,
-            :invoice_id => invoice_id,
-            :invoice_item_id => @invoice_item.invoice_item_id,
-            :amount => 5.34,
-            :currency => :USD
-        }
-    assert_template :edit
-    assert_equal "Error while adjusting invoice item: Error 404: Object id=#{invoice_id} type=INVOICE doesn't exist!", flash[:error]
-  end
-
-  test 'should adjust invoice item' do
-    put :update,
-        :id => @invoice_item.invoice_item_id,
-        :invoice_item => {
-            :account_id => @account.account_id,
-            :invoice_id => @invoice_item.invoice_id,
-            :invoice_item_id => @invoice_item.invoice_item_id,
-            :amount => 5.34,
-            :currency => :USD
-        }
-    assert_redirected_to account_invoice_path(@account.account_id, assigns(:invoice_item).invoice_id)
-    assert_equal 'Adjustment item was successfully created', flash[:notice]
-  end
-
-  test 'should handle errors during destroy' do
-    delete :destroy, :id => @cba.invoice_item_id
-    assert_redirected_to home_path
-    assert_equal 'Required parameter missing: invoice_id', flash[:error]
-
-    delete :destroy, :id => @cba.invoice_item_id, :invoice_id => @cba.invoice_id
-    assert_redirected_to home_path
-    assert_equal 'Required parameter missing: account_id', flash[:error]
-
-    invoice_id = SecureRandom.uuid.to_s
-    delete :destroy,
-           :id => @cba.invoice_item_id,
-           :invoice_id => invoice_id,
-           :account_id => @account.account_id
-    assert_redirected_to account_path(@account.account_id)
-    assert_equal "Error while communicating with the Kill Bill server: Error 404: No invoice could be found for id #{invoice_id}.", flash[:error]
-  end
-
-  test 'should delete CBA' do
-    delete :destroy,
-           :id => @cba.invoice_item_id,
-           :invoice_id => @cba.invoice_id,
-           :account_id => @account.account_id
-    assert_redirected_to account_invoice_path(@account.account_id, @cba.invoice_id)
-    assert_equal 'CBA item was successfully deleted', flash[:notice]
-  end
-end

data/test/functional/kaui/invoices_controller_test.rb

@@ -1,88 +0,0 @@
-require 'test_helper'
-
-class Kaui::InvoicesControllerTest < Kaui::FunctionalTestHelper
-
-  test 'should get index' do
-    get :index, :account_id => @invoice_item.account_id
-    assert_response 200
-  end
-
-  test 'should list invoices' do
-    # Test pagination
-    get :pagination, :format => :json
-    verify_pagination_results!
-  end
-
-  test 'should search invoices' do
-    # Test search
-    get :pagination, :search => {:search => 'foo'}, :format => :json
-    verify_pagination_results!
-  end
-
-  test 'should handle Kill Bill errors in show screen' do
-    invoice_id = SecureRandom.uuid.to_s
-    get :show, :account_id => @invoice_item.account_id, :id => invoice_id
-    assert_redirected_to account_path(@invoice_item.account_id)
-    assert_equal "Error while communicating with the Kill Bill server: Error 404: Object id=#{invoice_id} type=INVOICE doesn't exist!", flash[:error]
-  end
-
-  test 'should find unpaid invoice by id' do
-    get :show, :account_id => @invoice_item.account_id, :id => @invoice_item.invoice_id
-    assert_response 200
-
-    assert_not_nil assigns(:account)
-    assert_not_nil assigns(:invoice)
-
-    assert_equal assigns(:account).account_id, @invoice_item.account_id
-    assert_equal assigns(:invoice).invoice_id, @invoice_item.invoice_id
-  end
-
-  # Test bundles and subscriptions retrieval
-  test 'should find invoice by id' do
-    get :show, :account_id => @bundle_invoice.account_id, :id => @bundle_invoice.invoice_id
-    assert_response 200
-
-    assert_not_nil assigns(:account)
-    assert_not_nil assigns(:invoice)
-
-    assert_equal assigns(:account).account_id, @bundle_invoice.account_id
-    assert_equal assigns(:invoice).invoice_id, @bundle_invoice.invoice_id
-  end
-
-  # Test the rendering of the partials
-  test 'should find paid invoice by id' do
-    get :show, :account_id => @paid_invoice_item.account_id, :id => @paid_invoice_item.invoice_id
-    assert_response 200
-
-    assert_not_nil assigns(:account)
-    assert_not_nil assigns(:invoice)
-
-    assert_equal assigns(:account).account_id, @paid_invoice_item.account_id
-    assert_equal assigns(:invoice).invoice_id, @paid_invoice_item.invoice_id
-  end
-
-  test 'should handle Kill Bill errors in show_html screen' do
-    invoice_id = SecureRandom.uuid.to_s
-    get :show_html, :id => invoice_id
-    assert_redirected_to home_path
-    assert_equal "Error while communicating with the Kill Bill server: Error 404: Object id=#{invoice_id} type=INVOICE doesn't exist!", flash[:error]
-  end
-
-  test 'should expose restful endpoint' do
-    get :restful_show, :id => @invoice_item.invoice_id
-    assert_redirected_to account_invoice_path(@invoice_item.account_id, @invoice_item.invoice_id)
-  end
-
-  test 'should render HTML invoice' do
-    get :show_html, :id => @invoice_item.invoice_id
-    assert_response 200
-  end
-
-  test 'should commit invoice' do
-    invoice_id = create_charge(@account, @tenant).invoice_id
-
-    post :commit_invoice, :id => invoice_id
-    assert_redirected_to account_invoice_path(@account.account_id, invoice_id)
-    assert_equal 'Invoice successfully committed', flash[:notice]
-  end
-end

data/test/functional/kaui/login_proxy_controller_test.rb

@@ -1,12 +0,0 @@
-require 'test_helper'
-
-module Kaui
-  class LoginProxyControllerTest < Kaui::FunctionalTestHelper
-
-    test 'should redirect to' do
-      get :check_login, :path => home_path
-      assert_redirected_to home_path
-    end
-
-  end
-end

data/test/functional/kaui/payment_methods_controller_test.rb

@@ -1,52 +0,0 @@
-require 'test_helper'
-
-class Kaui::PaymentMethodsControllerTest < Kaui::FunctionalTestHelper
-
-  test 'should get new' do
-    get :new, :account_id => @account2.account_id
-    assert_response :success
-    assert_equal get_value_from_input_field('payment_method_plugin_name'), '__EXTERNAL_PAYMENT__'
-    assert_equal get_value_from_input_field('payment_method_account_id'), @account2.account_id
-  end
-
-  test 'should get show' do
-    get :show, :id => @payment_method.payment_method_id
-    assert_response :redirect
-    assert_redirected_to account_path(@payment_method.account_id)
-  end
-
-  test 'should create payment methods' do
-    post :create,
-         :payment_method     => {
-             # Note that @account already has an external payment method
-             :account_id => @account2.account_id,
-             :is_default => true
-         },
-         :card_type          => SecureRandom.uuid.to_s,
-         :card_holder_name   => SecureRandom.uuid.to_s,
-         :expiration_year    => 2020,
-         :expiration_month   => 12,
-         :credit_card_number => 4111111111111111,
-         :address1           => SecureRandom.uuid.to_s,
-         :city               => SecureRandom.uuid.to_s,
-         :postal_code        => SecureRandom.uuid.to_s,
-         :state              => SecureRandom.uuid.to_s,
-         :country            => SecureRandom.uuid.to_s
-    assert_response 302
-  end
-
-  test 'should delete payment methods' do
-    delete :destroy, :id => @payment_method.payment_method_id, :set_auto_pay_off => true
-    assert_response 302
-  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
-
-    get :validate_external_key, :external_key => @payment_method.external_key
-    assert_response :success
-    assert_equal JSON[@response.body]['is_found'], true
-  end
-end

data/test/functional/kaui/payments_controller_test.rb

@@ -1,59 +0,0 @@
-require 'test_helper'
-
-class Kaui::PaymentsControllerTest < Kaui::FunctionalTestHelper
-
-  test 'should get index' do
-    get :index, :account_id => @invoice_item.account_id
-    assert_response 200
-  end
-
-  test 'should list payments' do
-    # Test pagination
-    get :pagination, :format => :json
-    verify_pagination_results!
-  end
-
-  test 'should search payments' do
-    # Test search
-    get :pagination, :search => {:value => 'PENDING'}, :format => :json
-    verify_pagination_results!
-  end
-
-  test 'should create payments' do
-    # Verify we can pre-populate the payment
-    get :new, :account_id => @invoice_item.account_id, :invoice_id => @invoice_item.invoice_id
-    assert_response 200
-    assert_not_nil assigns(:payment)
-
-    # Create the payment
-    post :create, :account_id => @invoice_item.account_id, :invoice_payment => {:account_id => @invoice_item.account_id, :target_invoice_id => @invoice_item.invoice_id, :purchased_amount => 10}, :external => 1
-    assert_response 302
-
-    # Test pagination
-    get :pagination, :format => :json
-    verify_pagination_results!(1)
-  end
-
-  test 'should expose restful endpoint' do
-    get :restful_show, :id => @payment.payment_id
-    assert_redirected_to account_payment_path(@payment.account_id, @payment.payment_id)
-
-    # Search by external_key
-    get :restful_show, :id => @payment.payment_external_key
-    assert_redirected_to account_payment_path(@payment.account_id, @payment.payment_id)
-  end
-
-  test 'should cancel scheduled payment' do
-    delete :cancel_scheduled_payment, :id => @payment.payment_id, :account_id => @payment.account_id
-    assert_match(/Error deleting payment attempt retry:/, flash[:error])
-    expected_response_path = "/accounts/#{@payment.account_id}"
-    assert response_path.include?(expected_response_path), "#{response_path} is expected to contain #{expected_response_path}"
-
-    delete :cancel_scheduled_payment, :id => @payment.payment_id, :account_id => @payment.account_id,
-           :transaction_external_key => @payment.transactions[0].transaction_external_key
-    assert_equal 'Payment attempt retry successfully deleted', flash[:notice]
-    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
-end

data/test/functional/kaui/queues_controller_test.rb

@@ -1,17 +0,0 @@
-require 'test_helper'
-
-class Kaui::QueuesControllerTest < Kaui::FunctionalTestHelper
-
-  test 'should get queues' do
-    get :index, :account_id => @account.account_id, :with_history => true
-    now = assigns(:now)
-    queues_entries = assigns(:queues_entries)
-
-    assert_not_nil now
-    assert_not_nil queues_entries
-    assert queues_entries['busEvents'].size > 0
-
-    assert_response :success
-  end
-
-end

data/test/functional/kaui/refunds_controller_test.rb

@@ -1,63 +0,0 @@
-require 'test_helper'
-
-class Kaui::RefundsControllerTest < 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, :payment_id => @payment.payment_id
-    assert_redirected_to account_path(@account.account_id)
-    assert_equal "Error while communicating with the Kill Bill server: Error 404: Object id=#{invoice_id} type=INVOICE doesn't exist!", flash[:error]
-
-    payment_id = SecureRandom.uuid.to_s
-    get :new, :account_id => @account.account_id, :invoice_id => @paid_invoice_item.invoice_id, :payment_id => payment_id
-    assert_redirected_to account_path(@account.account_id)
-    assert_equal "Error while communicating with the Kill Bill server: Error 404: Object id=#{payment_id} type=PAYMENT doesn't exist!", flash[:error]
-  end
-
-  test 'should get new' do
-    get :new, :account_id => @account.account_id, :invoice_id => @paid_invoice_item.invoice_id, :payment_id => @payment.payment_id
-    assert_response 200
-    assert_not_nil assigns(:invoice)
-    assert_not_nil assigns(:payment)
-    assert_not_nil assigns(:refund)
-  end
-
-  test 'should create refund without adjustment' do
-    refund_amount = @payment.purchased_amount.to_f / 3.0
-
-    post :create,
-         :account_id => @account.account_id,
-         :invoice_id => @paid_invoice_item.invoice_id,
-         :payment_id => @payment.payment_id,
-         :amount => refund_amount,
-         :adjustment_type => 'noInvoiceAdjustment'
-    assert_redirected_to account_invoice_path(@account.account_id, @paid_invoice_item.invoice_id)
-  end
-
-  test 'should create refund with invoice adjustment' do
-    refund_amount = @payment.purchased_amount.to_f / 3.0
-
-    post :create,
-         :account_id => @account.account_id,
-         :invoice_id => @paid_invoice_item.invoice_id,
-         :payment_id => @payment.payment_id,
-         :amount => refund_amount,
-         :adjustment_type => 'invoiceAdjustment'
-    assert_redirected_to account_invoice_path(@account.account_id, @paid_invoice_item.invoice_id)
-  end
-
-  test 'should create refund with invoice item adjustment' do
-    refund_amount = @payment.purchased_amount.to_f / 3.0
-
-    post :create,
-         :account_id => @account.account_id,
-         :invoice_id => @paid_invoice_item.invoice_id,
-         :payment_id => @payment.payment_id,
-         :amount => refund_amount,
-         :adjustment_type => 'invoiceItemAdjustment',
-         :adjustments => {
-             @paid_invoice_item.invoice_item_id => refund_amount
-         }
-    assert_redirected_to account_invoice_path(@account.account_id, @paid_invoice_item.invoice_id)
-  end
-end

data/test/functional/kaui/registrations_controller_test.rb

@@ -1,49 +0,0 @@
-require 'test_helper'
-
-module Kaui
-  class RegistrationsControllerTest < Kaui::FunctionalTestHelper
-
-    test 'should get new' do
-      logout
-
-      get :new
-      assert_response :success
-      assert has_input_field('user_kb_username'), 'Expected input with id user_kb_username not found'
-      assert has_input_field('user_password'), 'Expected input with id user_password not found'
-    end
-
-    test 'should get create' do
-      logout
-
-      # enable the option of registration
-      Kaui.disable_sign_up_link = false
-
-      parameters = {
-        :user => {
-          :kb_username => 'Voltron',
-          :password => 'Voltron'
-        }
-      }
-      post :create, parameters
-      assert_equal "User #{parameters[:user][:kb_username]} successfully created, please login", flash[:notice]
-      assert_response :redirect
-      # validate redirect path
-      assert response_path.include?('/users/sign_in'), "#{response_path} is expected to contain /users/sign_in"
-
-      # should return an error that the user already exists
-      post :create, parameters
-      assert_equal "User with name #{parameters[:user][:kb_username]} already exists!", flash[:error]
-      assert_response :success
-
-      # disable the option of registration
-      Kaui.disable_sign_up_link = true
-
-      post :create, parameters
-      assert_equal 'You need to sign in before adding a user!', flash[:error]
-      assert_response :redirect
-      # validate redirect path
-      assert response_path.include?('/users/sign_in'), "#{response_path} is expected to contain /users/sign_in"
-    end
-
-  end
-end

data/test/functional/kaui/role_definitions_controller_test.rb

@@ -1,47 +0,0 @@
-require 'test_helper'
-
-class Kaui::RoleDefinitionsControllerTest < Kaui::FunctionalTestHelper
-
-  test 'should instantiate RoleDefinition class' do
-    get :new
-    role_definition = assigns(:role_definition)
-
-    assert_not_nil role_definition
-    assert_instance_of Kaui::RoleDefinition, role_definition
-    assert_response :success
-  end
-
-  test 'should return an error if no parameter role definition is passed' do
-    post :create
-
-    role_definition = assigns(:role_definition)
-
-    assert_nil role_definition
-    assert_equal 'Required parameter missing: role_definition', flash[:error]
-    assert_response :redirect
-  end
-
-  test 'should create a new role definition' do
-    role_definition = Hash.new
-
-    role_definition['role'] = 'test' + SecureRandom.base64(9).gsub(/[\/+=]/,'')
-    role_definition['permissions'] = 'account:delete_emails,account:add_emails'
-
-    post :create, :role_definition => role_definition
-
-    assert_equal 'Role was successfully created', flash[:notice]
-    assert_response :redirect
-  end
-
-  test 'should return an error if there is a error while creating role' do
-    role_definition = Hash.new
-
-    role_definition['role'] = 'test' + SecureRandom.base64(9).gsub(/[\/+=]/,'')
-    role_definition['permissions'] = 'account:delete_emails,account:add_emails'
-
-    post :create, :role_definition => role_definition, :reason => SecureRandom.base64(4000), :comment => SecureRandom.base64(4000)
-    assert_match 'Error while creating role', flash[:error]
-    assert_response :success
-  end
-
-end

data/test/functional/kaui/subscriptions_controller_test.rb

@@ -1,194 +0,0 @@
-require 'test_helper'
-
-class Kaui::SubscriptionsControllerTest < Kaui::FunctionalTestHelper
-
-  test 'should handle Kill Bill errors in new screen' do
-    bundle_id = SecureRandom.uuid.to_s
-    get :new, :bundle_id => bundle_id, :account_id => @account.account_id, :product_category => 'ADD_ON'
-    assert_redirected_to account_path(@account.account_id)
-    assert_equal "Error while communicating with the Kill Bill server: Error 404: Object id=#{bundle_id} type=BUNDLE doesn't exist!", flash[:error]
-  end
-
-  test 'should get new page for base plan' do
-    get :new,
-        :account_id => @account.account_id,
-        :product_category => 'BASE'
-    assert assigns(:plans).size > 0
-  end
-
-  test 'should get new page for base addon' do
-    get :new,
-        :base_product_name => 'Sports',
-        :bundle_id => @bundle.bundle_id,
-        :account_id => @account.account_id,
-        :product_category => 'ADD_ON'
-    assert assigns(:plans).size > 0, 'Plans were not created'
-  end
-
-  test 'should handle errors during creation' do
-    post :create,
-         :subscription => {
-             :bundle_id => @bundle.bundle_id,
-             :account_id => @account.account_id,
-             :product_category => 'ADD_ON'
-         },
-         :base_product_name => 'Sports'
-    assert_redirected_to account_path(@account.account_id)
-    assert_equal 'Required parameter missing: plan_name', flash[:error]
-
-    post :create,
-         :subscription => {
-             :bundle_id => @bundle.bundle_id,
-             :account_id => @account.account_id,
-             :product_category => 'ADD_ON'
-         },
-         :base_product_name => 'Sports',
-         :plan_name => 'not-exists'
-    assert_template :new
-    assert_equal 'Error while creating the subscription: Unable to find plan not-exists', flash[:error]
-  end
-
-  test 'should create a new base subscription' do
-    post :create,
-         :subscription => {
-             :account_id => @account.account_id,
-             :external_key => SecureRandom.uuid,
-         },
-         :plan_name => 'standard-monthly'
-    assert_response 302
-  end
-
-  test 'should create a new addon subscription' do
-    post :create,
-         :subscription => {
-             :bundle_id => @bundle.bundle_id,
-             :account_id => @account.account_id,
-             :product_category => 'ADD_ON'
-         },
-         :base_product_name => 'Sports',
-         :plan_name => 'oilslick-monthly'
-    assert_includes((200..399), response.code.to_i)
-  end
-
-  test 'should handle Kill Bill errors in edit screen' do
-    subscription_id = SecureRandom.uuid.to_s
-    get :edit, :id => subscription_id
-    assert_redirected_to home_path
-    assert_equal "Error while communicating with the Kill Bill server: Error 404: Object id=#{subscription_id} type=SUBSCRIPTION doesn't exist!", flash[:error]
-  end
-
-  test 'should get edit page' do
-    get :edit, :id => @bundle.subscriptions.first.subscription_id
-    assert_response 200
-    assert_not_nil assigns(:subscription)
-    assert_not_nil assigns(:plans)
-  end
-
-  test 'should handle errors during update' do
-    post :update, :id => @bundle.subscriptions.first.subscription_id
-    assert_redirected_to edit_subscription_path(@bundle.subscriptions.first.subscription_id)
-    assert_equal 'Error while changing subscription: param is missing or the value is empty: plan_name', flash[:error]
-
-    subscription_id = SecureRandom.uuid.to_s
-    post :update, :id => subscription_id, :plan_name => 'super-monthly'
-    assert_redirected_to edit_subscription_path(subscription_id)
-    assert_equal "Error while changing subscription: Error 404: Object id=#{subscription_id} type=SUBSCRIPTION doesn't exist!", flash[:error]
-
-    post :update, :id => @bundle.subscriptions.first.subscription_id, :plan_name => 'not-exists'
-    assert_redirected_to edit_subscription_path(@bundle.subscriptions.first.subscription_id)
-    assert_equal "Error while changing subscription: Error 400: Could not find any plans named 'not-exists'", flash[:error]
-  end
-
-  test 'should update' do
-    post :update,
-         :id => @bundle.subscriptions.first.subscription_id,
-         :plan_name => 'super-monthly'
-    assert_response 302
-  end
-
-  test 'should handle errors during destroy' do
-    subscription_id = SecureRandom.uuid.to_s
-    delete :destroy, :id => subscription_id, :plan_name => 'super-monthly'
-    assert_redirected_to home_path
-    assert_equal "Error while communicating with the Kill Bill server: Error 404: Object id=#{subscription_id} type=SUBSCRIPTION doesn't exist!", flash[:error]
-  end
-
-  test 'should handle errors during reinstate' do
-    subscription_id = SecureRandom.uuid.to_s
-    put :reinstate, :id => subscription_id
-    assert_redirected_to home_path
-    assert_equal "Error while communicating with the Kill Bill server: Error 404: Object id=#{subscription_id} type=SUBSCRIPTION doesn't exist!", flash[:error]
-  end
-
-  test 'should cancel and reinstate subscription' do
-    delete :destroy,
-           :id => @bundle.subscriptions.first.subscription_id,
-           :requested_date => (Date.today >> 1).to_time.utc.iso8601,
-           :use_requested_date_for_billing => '1'
-    assert_response 302
-
-    put :reinstate, :id => @bundle.subscriptions.first.subscription_id
-    assert_response 302
-  end
-
-  test 'should get show' do
-    get :show, :id => @bundle.subscriptions.first.subscription_id
-    assert_redirected_to account_bundles_path(@bundle.subscriptions.first.account_id)
-  end
-
-  test 'should get edit bcd' do
-    get :edit_bcd, :id => @bundle.subscriptions.first.subscription_id
-    assert_response :success
-    assert_equal get_value_from_input_field('subscription_account_id'), @bundle.subscriptions.first.account_id
-    assert_equal get_value_from_input_field('subscription_bill_cycle_day_local'), @bundle.subscriptions.first.bill_cycle_day_local.to_s
-    assert_equal get_value_from_input_field('effective_from_date'), Date.parse(Time.now.to_s).to_s
-  end
-
-  test 'should update bcd' do
-    bundle = create_bundle(@account, @tenant)
-    parameters = {
-        :id => bundle.subscriptions.first.subscription_id,
-        :subscription => { :account_id => bundle.subscriptions.first.account_id,
-                           :bill_cycle_day_local =>	bundle.subscriptions.first.bill_cycle_day_local
-        },
-        :effective_from_date => (Date.today >> 1).to_s
-    }
-
-    put :update_bcd, parameters
-    assert_redirected_to account_bundles_path(bundle.subscriptions.first.account_id)
-    assert_equal 'Subscription BCD was successfully changed', flash[:notice]
-  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
-
-    get :validate_external_key, :external_key => @bundle.subscriptions.first.external_key
-    assert_response :success
-    assert_equal JSON[@response.body]['is_found'], true
-  end
-
-  test 'should update with price override' do
-    post :update,
-         :id => @bundle.subscriptions.first.subscription_id,
-         :plan_name => 'super-monthly',
-         :price_override => 500
-    assert_redirected_to account_bundles_path(@bundle.subscriptions.first.account_id)
-    assert_equal 'Subscription plan successfully changed', flash[:notice]
-  end
-
-  test 'should create with price override' do
-    post :create,
-         :subscription => {
-             :account_id => @account.account_id,
-             :external_key => SecureRandom.uuid,
-         },
-         :price_override => 500,
-         :plan_name => 'standard-monthly'
-
-    assert_redirected_to account_bundles_path(@account.account_id)
-    assert_equal 'Subscription was successfully created', flash[:notice]
-  end
-
-end