openshift-origin-console 1.3.2

data/test/functional/cartridge_types_controller_isolation_test.rb

@@ -0,0 +1,68 @@
+require File.expand_path('../../test_helper', __FILE__)
+
+class CartridgeTypesIsolationControllerTest < ActionController::TestCase
+  tests CartridgeTypesController
+
+  uses_http_mock :sometimes
+
+  setup :with_unique_user
+
+  def domain
+    {:id => 'test'}
+  end
+  def app
+    {:name => 'test', :framework => 'php-5.3'}
+  end
+
+  def mock_app
+    Rails.cache.clear # cart metadata is mocked
+    allow_http_mock
+    ActiveResource::HttpMock.respond_to({},true) do |mock|
+      mock.get '/broker/rest/domains.json', json_header, [domain].to_json
+      mock.get '/broker/rest/domains/test/applications/test.json', json_header, app.to_json
+      mock.get '/broker/rest/domains/test/applications/test/cartridges.json', json_header, [].to_json
+      mock.get '/broker/rest/cartridges.json', anonymous_json_header, [{:name => 'fake-cart-1', :type => :embedded}].to_json
+    end
+    app
+  end
+
+  test "should list a new server cart with no metadata" do
+    mock_app
+    get :index, :application_id => 'test'
+    assert_response :success
+
+    assert a = assigns(:application)
+    assert_equal app[:name], a.name
+    assert d = assigns(:domain)
+    assert_equal domain[:id], d.id
+
+    assert types = assigns(:installed)
+    assert_equal 0, types.length
+    assert types = assigns(:conflicts)
+    assert_equal 0, types.length
+    assert types = assigns(:requires)
+    assert types.length == 0
+    assert types = assigns(:blacklist)
+    assert types.length == 0
+    assert types = assigns(:carts)
+    assert types.length > 0
+
+    cached = CartridgeType.cached.all
+    assert cached.all? {|t| (t.tags & [:installed, :inactive, 'inactive']).empty? }, cached.pretty_inspect
+  end
+
+  test "should show a new server cart with no metadata" do
+    mock_app
+    get :show, :application_id => 'test', :id => 'fake_cart_1'
+    assert_response :success
+
+    assert a = assigns(:application)
+    assert_equal app[:name], a.name
+    assert d = assigns(:domain)
+    assert_equal domain[:id], d.id
+
+    assert type = assigns(:cartridge_type)
+    assert_equal 'fake_cart_1', type.name
+    assert assigns(:cartridge)
+  end
+end

data/test/functional/cartridge_types_controller_test.rb

@@ -0,0 +1,48 @@
+require File.expand_path('../../test_helper', __FILE__)
+
+class CartridgeTypesControllerTest < ActionController::TestCase
+
+  test "should show index" do
+    get :index, :application_id => with_app.name
+    assert_response :success
+
+    assert app = assigns(:application)
+    assert_equal with_app.name, app.name
+    assert domain = assigns(:domain)
+    assert_equal with_app.domain_id, domain.id
+
+    assert types = assigns(:installed)
+    assert_equal 0, types.length
+    assert types = assigns(:conflicts)
+    assert_equal 0, types.length
+    assert types = assigns(:requires)
+    assert types.length > 0
+    assert types = assigns(:blacklist)
+    assert types.length > 0
+    assert types = assigns(:carts)
+    assert types.length > 0
+
+    cached = CartridgeType.cached.all
+    assert cached.all? {|t| (t.tags & [:installed, :inactive, 'inactive']).empty? }, cached.pretty_inspect
+  end
+
+  test "should show type page" do
+    t = CartridgeType.embedded.first
+    get :show, :application_id => with_app.name, :id => t.name
+    assert_response :success
+    assert type = assigns(:cartridge_type)
+    assert_equal t.name, type.name
+    assert assigns(:cartridge)
+    assert assigns(:application)
+    assert assigns(:domain)
+  end
+
+  test "should not raise on missing type" do
+    # We allow arbitrary cartridges, but we may want to change that
+    #assert_raise(StandardError) do
+      get :show, :application_id => with_app.name, :id => 'missing_cartridge_type'
+      assert_response :success
+    #end
+  end
+end
+

data/test/functional/cartridges_controller_test.rb

@@ -0,0 +1,83 @@
+require File.expand_path('../../test_helper', __FILE__)
+
+class CartridgesControllerTest < ActionController::TestCase
+
+  def with_testable_app(remove_carts=false)
+    use_app(:cart_testable_app) { Application.new({:name => "carttestable", :cartridge => 'ruby-1.9', :as => new_named_user('user_with_cartridge_testable_app')}) }.tap do |app|
+      if remove_carts
+        Cartridge.all(app.send(:child_options)).each do |cart|
+          next if cart.name == app.framework
+          #puts "Destroying cart #{cart.name}"
+          begin
+            cart.destroy
+          rescue => e
+            puts "Unable to delete cart #{cart.name}: #{e.message}, #{e.backtrace.join("\n")}"
+          end
+        end
+      end
+    end
+  end
+
+  test "should create one cartridge" do
+    with_testable_app(true)
+
+    post(:create, get_post_form)
+    assert cart = assigns(:cartridge)
+    assert cart.errors.empty?, cart.errors.to_hash.inspect
+    assert_response :success
+    assert_template :next_steps
+  end
+
+  test "should create two cartridges" do
+    with_testable_app(true)
+
+    post(:create, get_post_form)
+    assert cart = assigns(:cartridge)
+    assert cart.errors.empty?, cart.errors.to_hash.inspect
+    assert_response :success
+    assert_template :next_steps
+
+    post_form = get_post_form
+    post_form[:cartridge][:name] = 'cron-1.4'
+    post(:create, post_form)
+    assert cart = assigns(:cartridge)
+    assert cart.errors.empty?, cart.errors.to_hash.inspect
+
+    assert_response :success
+    assert_template :next_steps
+  end
+
+  test "should error out if cartridge is installed" do
+    with_testable_app(true)
+
+    post(:create, get_post_form)
+    assert cart = assigns(:cartridge)
+    assert cart.errors.empty?, cart.errors.to_hash.inspect
+    assert_response :success
+    assert_template :next_steps
+
+    post(:create, get_post_form)
+    assert_response :success
+    assert cart = assigns(:cartridge)
+    assert !cart.errors.empty?, cart.errors.to_hash.inspect
+    assert cart.errors[:base].present?
+    assert_equal 1, cart.errors[:base].length
+
+    assert_response :success
+    assert_template 'cartridge_types/show'
+  end
+
+  #test "should be able to view next steps cartridge page" do
+  #  with_testable_app(true)
+
+  #  get :next_steps, get_post_form
+  #  assert_response :success
+  #  assert_template :next_steps
+  #end
+
+  def get_post_form
+    {:cartridge => {:name => 'mysql-5.1', :type => 'embedded'},
+     :application_id => with_testable_app.id,
+     :domain_id => @domain.id}
+  end
+end

data/test/functional/console_auth_basic_controller_test.rb

@@ -0,0 +1,82 @@
+require File.expand_path('../../test_helper', __FILE__)
+
+class ConsoleAuthBasicControllerTest < ActionController::TestCase
+  uses_http_mock :sometimes
+
+  class ConsoleAuthBasicController < ActionController::Base
+    include Console::Rescue
+    include Console::Auth::Basic
+
+    before_filter :authenticate_user!, :except => :unprotected
+
+    def protected
+      render :status => 200, :nothing => true
+    end
+    def unprotected
+      render :status => 200, :nothing => true
+    end
+    def restapi
+      @user = User.find :one, :as => current_user
+      render :status => 200, :nothing => true
+    end
+  end
+
+  setup{ Rails.application.routes.draw{ match ':action' => ConsoleAuthBasicController } }
+  teardown{ Rails.application.reload_routes! }
+
+  tests ConsoleAuthBasicController
+
+  test 'should challenge when protected' do
+    get :protected
+    assert_response :unauthorized
+  end
+
+  test 'should challenge when username empty' do
+    @request.env['HTTP_AUTHORIZATION'] = ActionController::HttpAuthentication::Basic.encode_credentials(nil, 'password')
+
+    get :protected
+    assert_response :unauthorized
+  end
+
+  test 'should render when protected' do
+    @request.env['HTTP_AUTHORIZATION'] = ActionController::HttpAuthentication::Basic.encode_credentials('bob', 'password')
+
+    get :protected
+
+    assert_response :success
+    assert assigns(:authenticated_user)
+    assert_equal 'bob', @controller.current_user.login
+    assert_equal 'bob', assigns(:authenticated_user).login
+
+    assert !@controller.current_user.persisted?
+    assert @controller.current_user.email_address.nil?
+    assert @controller.user_signed_in?
+    assert !@controller.previously_signed_in?
+  end
+
+  test 'should pass headers to REST API' do
+    @request.env['HTTP_AUTHORIZATION'] = ActionController::HttpAuthentication::Basic.encode_credentials('bob', 'password')
+
+    allow_http_mock
+    ActiveResource::HttpMock.respond_to do |mock|
+      mock.get '/broker/rest/user.json', anonymous_json_header.merge('Authorization' => @request.env['HTTP_AUTHORIZATION']), {:login => 'foo'}.to_json
+    end
+
+    get :restapi
+    assert_response :success
+    assert user = assigns(:user)
+    assert_equal 'foo', user.login
+  end
+
+  test 'should challenge when broker rejects password' do
+    @request.env['HTTP_AUTHORIZATION'] = ActionController::HttpAuthentication::Basic.encode_credentials('bob', 'password')
+
+    allow_http_mock
+    ActiveResource::HttpMock.respond_to do |mock|
+      mock.get '/broker/rest/user.json', anonymous_json_header.merge('Authorization' => @request.env['HTTP_AUTHORIZATION']), nil, 401
+    end
+
+    get :restapi
+    assert_response :unauthorized
+  end
+end

data/test/functional/console_auth_remote_user_controller_test.rb

@@ -0,0 +1,90 @@
+require File.expand_path('../../test_helper', __FILE__)
+
+class ConsoleAuthRemoteUserControllerTest < ActionController::TestCase
+  uses_http_mock :sometimes
+
+  class ConsoleAuthRemoteUserController < ActionController::Base
+    include Console::Rescue
+    include Console::Auth::RemoteUser
+
+    before_filter :authenticate_user!, :except => :unprotected
+
+    def protected
+      render :status => 200, :nothing => true
+    end
+    def unprotected
+      render :status => 200, :nothing => true
+    end
+    def restapi
+      @user = User.find :one, :as => current_user
+      render :status => 200, :nothing => true
+    end
+  end
+
+  setup{ Rails.application.routes.draw{ match ':action' => ConsoleAuthRemoteUserController } }
+  teardown{ Rails.application.reload_routes! }
+
+  setup{ Console.config.expects(:remote_user_header).at_least_once.returns('HTTP_X_REMOTE_USER') }
+  setup{ Console.config.stubs(:remote_user_copy_headers).returns(['X-Remote-User','X-Other-Header']) }
+
+  tests ConsoleAuthRemoteUserController
+
+  test 'should redirect when protected' do
+    get :protected
+    assert_redirected_to @controller.unauthorized_path
+  end
+
+  test 'should render when protected' do
+    @request.env['HTTP_X_REMOTE_USER'] = 'bob'
+
+    get :protected
+
+    assert_response :success
+    assert assigns(:authenticated_user)
+    assert_equal 'bob', @controller.current_user.login
+    assert_equal 'bob', assigns(:authenticated_user).login
+
+    assert !@controller.current_user.persisted?
+    assert @controller.user_signed_in?
+    assert !@controller.previously_signed_in?
+  end
+
+  test 'should override name configured' do
+    Console.config.expects(:remote_user_name_header).at_least_once.returns('HTTP_X_REMOTE_USER_NAME')
+    @request.env['HTTP_X_REMOTE_USER'] = 'bob'
+    @request.env['HTTP_X_REMOTE_USER_NAME'] = 'alice'
+
+    get :protected
+
+    assert_response :success
+    assert assigns(:authenticated_user)
+    assert_equal 'alice', @controller.current_user.login
+    assert_equal 'alice', assigns(:authenticated_user).login
+  end
+
+  test 'should pass headers to REST API' do
+    @request.env['HTTP_X_REMOTE_USER'] = 'bob'
+
+    allow_http_mock
+    ActiveResource::HttpMock.respond_to do |mock|
+      mock.get '/broker/rest/user.json', anonymous_json_header.merge('X-Remote-User' => 'bob'), {:login => 'foo'}.to_json
+    end
+
+    get :restapi
+    assert_response :success
+    assert user = assigns(:user)
+    assert_equal 'foo', user.login
+  end
+
+  test 'should redirect when misconfigured' do
+    @request.env['HTTP_X_REMOTE_USER'] = 'bob'
+
+    allow_http_mock
+    ActiveResource::HttpMock.respond_to do |mock|
+      mock.get '/broker/rest/user.json', anonymous_json_header.merge('X-Remote-User' => 'bob'), nil, 401
+    end
+
+    get :restapi
+    assert_redirected_to  @controller.unauthorized_path
+  end
+end

data/test/functional/console_index_controller_test.rb

@@ -0,0 +1,22 @@
+require File.expand_path('../../test_helper', __FILE__)
+
+class ConsoleIndexControllerTest < ActionController::TestCase
+  test 'redirect to applications path' do
+    with_configured_user
+    get :index
+    assert_redirected_to applications_path
+  end
+
+  test 'render unauthorized' do
+    get :unauthorized
+    assert_response :success
+    assert_template 'console/unauthorized'
+  end
+
+  test 'render help' do
+    with_configured_user
+    get :help
+    assert_response :success
+    assert_template 'console/help'
+  end
+end

data/test/functional/domains_controller_test.rb

@@ -0,0 +1,194 @@
+require File.expand_path('../../test_helper', __FILE__)
+
+class DomainsControllerTest < ActionController::TestCase
+
+  @@user = nil
+
+  def setup
+    with_unique_user
+  end
+
+  def with_particular_user
+    if @@user
+      set_user(@@user)
+    else
+      @@user = @user
+    end
+    with_domain
+  end
+
+  def with_domain
+    @domain = Domain.first :as => @user
+    unless @domain
+      @domain = Domain.new(get_post_form.merge(:as => @user))
+      flunk @domain.errors.inspect unless @domain.save
+    end
+  end
+
+  def unique_name_format
+    "d#{uuid[0..10]}%i"
+  end
+
+  test "should display domain creation form" do
+    get :new
+
+    assert domain = assigns(:domain)
+    assert_response :success
+    assert_template :new
+  end
+
+  test "should create domain" do
+    post :create, {:domain => get_post_form}
+
+    assert domain = assigns(:domain)
+    assert domain.errors.empty?, domain.errors.inspect
+    assert_redirected_to account_path
+  end
+
+  test "should clear domain session cache" do
+    session[:domain] = 'foo'
+    post :create, {:domain => get_post_form}
+
+    assert domain = assigns(:domain)
+    assert domain.errors.empty?, domain.errors.inspect
+    assert_redirected_to account_path
+    assert_nil session[:domain]
+  end
+
+  test "should assign errors on empty name" do
+    post :create, {:domain => get_post_form.merge(:name => '')}
+
+    assert domain = assigns(:domain)
+    assert !domain.errors.empty?
+    assert domain.errors[:name].present?, domain.errors.inspect
+    assert_equal 1, domain.errors[:name].length
+    assert_template :new
+  end
+
+  test "should assign errors on long name" do
+    post :create, {:domain => get_post_form.merge(:name => 'aoeu'*2000)}
+
+    assert domain = assigns(:domain)
+    assert !domain.errors.empty?
+    assert domain.errors[:name].present?, domain.errors.inspect
+    assert_equal 1, domain.errors[:name].length, domain.errors.inspect
+    assert_template :new
+  end
+
+  test "should assign errors on invalid name" do
+    post :create, {:domain => get_post_form.merge(:name => '@@@@')}
+
+    assert domain = assigns(:domain)
+    assert !domain.errors.empty?
+    assert domain.errors[:name].present?, domain.errors.inspect
+    assert_equal 1, domain.errors[:name].length, domain.errors.inspect
+    assert_template :new
+  end
+
+  test "should assign errors on duplicate name" do
+    assert (domain = Domain.new(get_post_form.merge(:as => unique_user))).save, domain.errors.inspect
+
+    post :create, {:domain => get_post_form.merge(:name => domain.name)}
+
+    assert domain = assigns(:domain)
+    assert !domain.errors.empty?
+    assert domain.errors[:name].present?, domain.errors.inspect
+    assert_equal 1, domain.errors[:name].length, domain.errors.inspect
+    assert_template :new
+  end
+
+  #test "should allow only one domain" do
+  #  with_domain
+
+  #  post :create, {:domain => {:name => unique_name}}
+
+  #  assert domain = assigns(:domain)
+  #  assert !domain.errors.empty?
+  #  assert domain.errors[:name].present?, domain.errors.inspect
+  #  assert_equal 1, domain.errors[:name].length, domain.errors.inspect
+  #  assert_template :new
+  #end
+
+  test "should show edit domain page" do
+    with_domain
+
+    get :edit
+    assert_template :edit
+    assert_response :success
+  end
+
+  test "should update domain" do
+    with_particular_user
+
+    put :update, {:domain => {:name => unique_name}}
+
+    assert domain = assigns(:domain)
+    assert domain.errors.empty?, domain.errors.inspect
+    assert_redirected_to account_path
+  end
+
+  test "should update domain and clear session cache" do
+    with_particular_user
+    session[:domain] = 'foo'
+
+    put :update, {:domain => {:name => unique_name}}
+
+    assert domain = assigns(:domain)
+    assert domain.errors.empty?, domain.errors.inspect
+    assert_redirected_to account_path
+    assert_nil session[:domain]
+  end
+
+  test "update should assign errors on empty name" do
+    with_particular_user
+
+    put :update, {:domain => {:name => ''}}
+
+    assert domain = assigns(:domain)
+    assert !domain.errors.empty?
+    assert domain.errors[:name].present?, domain.errors.inspect
+    assert_equal 1, domain.errors[:name].length
+    assert_template :edit
+  end
+
+  test "update should assign errors on long name" do
+    with_particular_user
+
+    put :update, {:domain => {:name => 'aoeu'*2000}}
+
+    assert domain = assigns(:domain)
+    assert !domain.errors.empty?
+    assert domain.errors[:name].present?, domain.errors.inspect
+    assert_equal 1, domain.errors[:name].length
+    assert_template :edit
+  end
+
+  test "update should assign errors on invalid name" do
+    with_particular_user
+
+    put :update, {:domain => {:name => '@@@@'}}
+
+    assert domain = assigns(:domain)
+    assert !domain.errors.empty?, domain.inspect
+    assert domain.errors[:name].present?, domain.inspect
+    assert_equal 1, domain.errors[:name].length
+    assert_template :edit
+  end
+
+  test "update should assign errors on duplicate name" do
+    with_particular_user
+    assert (domain = Domain.new(get_post_form.merge(:name => "d#{new_uuid[0..12]}", :as => unique_user))).save, domain.errors.inspect
+
+    put :update, {:domain => {:name => domain.name}}
+
+    assert domain = assigns(:domain)
+    assert !domain.errors.empty?
+    assert domain.errors[:name].present?, domain.errors.inspect
+    assert_equal 1, domain.errors[:name].length
+    assert_template :edit
+  end
+
+  def get_post_form
+    {:name => "d#{uuid[0..12]}"}
+  end
+end