openshift-origin-console 1.3.2

data/test/support/base.rb

@@ -0,0 +1,142 @@
+require 'mocha'
+
+require 'webmock/test_unit'
+WebMock.allow_net_connect!
+
+def inline_test(file)
+  require "#{Console::Engine.root}/#{Pathname.new(file).relative_path_from(Rails.application.root)}"
+end
+
+Test::Unit::TestCase.test_order = :random
+
+class ActiveSupport::TestCase
+
+  #
+  # Rails 3.2 + Test::Unit 2.x - handle_exception is not called in
+  # active_support/testing/setup_and_teardown.rb
+  #
+  def add_error(e)
+    if /active_support/ =~ caller[0]
+      super unless handle_exception(e)
+    else
+      super
+    end
+  end
+
+  def self.isolate(&block)
+    self.module_eval do
+      include ActiveSupport::Testing::Isolation
+      setup do
+        yield block
+      end
+    end
+  end
+
+  def self.uses_http_mock(sym=:always)
+    require 'active_resource/persistent_http_mock'
+    self.module_eval do
+      setup{ ActiveResource::HttpMock.enabled = true } unless sym == :sometimes
+      teardown do
+        ActiveResource::HttpMock.reset!
+        ActiveResource::HttpMock.enabled = false
+      end
+    end
+  end
+  def allow_http_mock
+    ActiveResource::HttpMock.enabled = true
+  end
+
+  setup { $VERBOSE = nil }
+  teardown { $VERBOSE = false }
+  setup { Rails.cache.clear }
+
+  #
+  # In any test case where css_select is valid, take a form object or selector
+  # and extract the data from that form.  Yields a block and returns either
+  # the return value of the block or an array of [method, action, form_values]
+  #
+  def extract_form(form, &block)
+    if form.is_a?(String)
+      selector = form
+      assert (form = css_select(selector).first), "Could not find '#{selector}' in the response"
+    end
+    values = {}
+    (css_select(form, 'input') + css_select(form, 'textarea')).each do |input|
+      (values[input['name']] ||= []) << input['value'] if input['value']
+    end
+    css_select(form, 'select').each do |input|
+      (values[input['name']] ||= []) << input['value'] if input['value']
+    end
+    values.each_pair{ |k,v| values[k] = v.first if v.length == 1 }
+    r = [form['method'], form['action'], values]
+    block_given? ? yield(r) : r
+  end
+
+  #
+  # Extract a form from the most recent response and perform an HTTP
+  # post.  Yields and returns the response object.
+  #
+  def submit_form(selector, params={}, &block)
+    extract_form(selector) do |method, action, values|
+      uri = URI(action)
+      req = Net::HTTP::Post.new(uri.path)
+      req.set_form_data(values.merge!(params))
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.set_debug_output $stderr if ENV['HTTP_DEBUG']
+      if http.use_ssl = (uri.scheme == 'https')
+        http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+      end
+      http.start{ |http| http.request(req) }
+    end.tap do |res|
+      yield res if block_given?
+    end
+  end
+
+  def with_config(name, value, &block)
+    old = Rails.configuration.send(:"#{name}")
+    Rails.configuration.send(:"#{name}=", value)
+    yield
+  ensure
+    Rails.configuration.send(:"#{name}=", old)
+  end
+
+  def with_rescue_from(&block)
+    old = Rails.configuration.action_dispatch.show_exceptions
+    Rails.configuration.action_dispatch.show_exceptions = true
+    #@request.env['action_dispatch.show_exceptions'] = true
+    yield
+  ensure
+    Rails.configuration.action_dispatch.show_exceptions = old
+  end
+
+  def expects_integrated
+    flunk 'Test requires integrated Streamline authentication' unless Rails.configuration.integrated
+  end
+
+  def gen_small_uuid()
+    %x[/usr/bin/uuidgen].gsub('-', '').strip
+  end
+
+  @@name = 0
+  def unique_name_format
+    'name%i'
+  end
+  def unique_name(format=nil)
+    (format || unique_name_format) % self.class.next
+  end
+  def self.next
+    @@name += 1
+  end
+
+  @@once = []
+  def once(symbol, &block)
+    unless @@once.include? symbol
+      @@once << symbol
+      exit_block = yield block
+      at_exit do
+        exit_block.call if exit_block
+      end
+    end
+  end
+end
+

data/test/support/errors.rb

@@ -0,0 +1,28 @@
+module ErrorPageAssertions
+  def default_not_found_message
+    /not found/i
+  end
+  def default_error_message
+    /An error has occurred/i
+  end
+
+  def assert_not_found_page(title=default_not_found_message)
+    assert_response :success
+    assert_select 'h1', title
+  end
+  def assert_error_page(title=default_error_message)
+    assert_response :success
+    assert_select 'h1', title
+
+    assert assigns(:reference_id)
+    assert_select 'p', /#{assigns(:reference_id)}/
+  end
+end
+
+class ActionController::TestCase
+  include ErrorPageAssertions
+end
+
+class ActionDispatch::IntegrationTest
+  include ErrorPageAssertions
+end

data/test/support/rest_api.rb

@@ -0,0 +1,189 @@
+class ActiveSupport::TestCase
+
+  def uuid
+    @ts ||= new_uuid
+  end
+  def new_uuid
+    "#{Time.now.to_i}#{gen_small_uuid[0,6]}"
+  end
+
+  def set_domain(domain)
+    @domain = domain
+  end
+
+  def setup_domain
+    domain = Domain.new :name => "#{uuid}", :as => @user
+    begin
+      domain.save!
+    rescue Domain::AlreadyExists, Domain::UserAlreadyHasDomain
+      domain.errors.clear
+    rescue => e
+      puts "Domain create failed: #{e.response.errors.inspect}" rescue nil
+      raise
+    end
+    set_domain(domain)
+  end
+  def find_or_create_domain
+    set_domain(Domain.find(:one, :as => @user))
+  rescue
+    setup_domain
+  end
+
+  def cleanup_user?
+    not @with_unique_user
+  end
+
+  def new_named_user(name)
+    new_user(:login => name, :password => 'foo')
+  end
+
+  def with_user_with_multiple_gear_sizes
+    set_user(new_named_user('user_with_multiple_gear_sizes@test.com'))
+    @controller.stubs(:current_user).returns(set_user(new_named_user('user_with_multiple_gear_sizes@test.com')))
+  end
+
+  # some unit tests or test environments may want to preserve domains
+  # created for unique users
+  alias_method :cleanup_domain?, :cleanup_user?
+
+  def cleanup_domain
+    if cleanup_domain? 
+      @domain.destroy_recursive if @domain
+    end
+  end
+
+  def with_unique_domain
+    with_unique_user # FIXME: test for non-unique
+    setup_domain
+  end
+
+  def delete_keys
+    Key.find(:all, :as => @user).map(&:destroy)
+  end
+
+  def allow_duplicate_domains
+    Domain.any_instance.expects(:check_duplicate_domain).at_least(0).returns(false)
+  end
+
+  def assert_attr_equal(o1, o2)
+    unless o1 == o2
+      assert o1, "#{o1} is not equal to #{o2}"
+      assert o2, "#{o1} is not equal to #{o2}"
+      if o1.is_a? Array and o2.is_a? Array
+        assert o1.length == o2.length, "Array 1 length #{o1.length} is not array 2 length #{o2.length}"
+        o1.each_with_index { |o,i| assert_attr_equal(o, o2[i]) }
+      else
+        assert_equal o1.attributes, o2.attributes, "Attributes do not match"
+      end
+    end
+  end
+
+  def setup_from_app(app)
+    set_domain Domain.new({:id => app.domain_id, :as => app.as}, true)
+    set_user app.as
+    app
+  end
+
+  def self.api_cache
+    @@cache ||= {}
+  end
+
+  def api_fetch(name, &block)
+    varname = "@#{name}_cached"
+    instance_variable_get(varname) || begin
+      created = if cached = self.class.api_cache[name]
+          block.call(cached) || cached
+        else
+          self.class.api_cache[name] = block.call(nil)
+        end
+      instance_variable_set(varname, created)
+    end
+  end
+
+  def use_domain(symbol=nil, &block)
+    api_fetch(symbol) do |cached|
+      if cached
+        set_domain cached
+        set_user cached.as
+        cached
+      else
+        if block_given?
+          set_domain(yield block)
+        else
+          with_unique_domain
+        end
+      end
+    end
+  end
+
+  #
+  # Create or retrieve a domain and user.  Does not guarantee that the domain is
+  # empty.  If other tests are running in parallel altering the domain may result
+  # in errors.
+  #
+  def with_domain
+    use_domain(:any)
+  end
+
+  def gears_free?(count)
+    User.find(:one, :as => @user).gears_free >= count
+  end
+
+  def use_app(symbol, &block)
+    api_fetch(symbol) do |cached|
+      if cached
+        setup_from_app(cached)
+      else
+        app = yield block if block_given?
+        app ||= Application.new :name => uuid
+        if app.as
+          set_user(app.as)
+        else
+          with_unique_user
+          app.as = @user
+        end
+        find_or_create_domain
+        @domain.expects(:destroy).never
+        begin
+          app = @domain.find_application(app.name)
+        rescue
+          app.domain = @domain
+          app.save!
+        end
+        app
+      end
+    end
+  end
+
+  def with_app
+    use_app(:readable_app) { Application.new({:name => "normal", :cartridge => 'ruby-1.8', :as => new_named_user('user_with_normal_app')}) }
+  end
+
+  def with_scalable_app
+    use_app(:scalable_app) { Application.new({:name => "scaled", :cartridge => 'ruby-1.8', :scale => true, :as => new_named_user('user_with_scaled_app')}) }
+  end
+
+  def mock_body_for(&block)
+    req = ActiveResource::HttpMock.requests.find &block
+    assert req, "No mock request was found for this block"
+    body = req.body
+    body = ActiveSupport::JSON.decode(req.body) if req.headers['Content-Type'].include?('application/json')
+    body
+  end
+
+  def auth_headers
+   h = {}
+   h['Cookie'] = "rh_sso=#{@user.ticket}" if @user.ticket
+   h['Authorization'] = ActionController::HttpAuthentication::Basic.encode_credentials(@user.login, @user.password) if @user.login
+   h
+  end
+
+  def json_header(is_post=false)
+    anonymous_json_header(is_post).merge!(auth_headers)
+  end
+
+  def anonymous_json_header(is_post=false)
+    {(is_post ? 'Content-Type' : 'Accept') => 'application/json', 'User-Agent' => Console.config.api[:user_agent]}
+  end
+
+end

data/test/test_helper.rb

@@ -0,0 +1,14 @@
+unless defined? Rails.application
+  require File.expand_path('../coverage_helper.rb', __FILE__)
+
+  ENV["RAILS_ENV"] = "test"
+
+  require File.expand_path("../rails_app/config/environment.rb",  __FILE__)
+  require "rails/test_help"
+end
+
+Rails.backtrace_cleaner.remove_silencers!
+
+# Load support files
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each { |f| require f }
+

data/test/unit/active_model_compliance_test.rb

@@ -0,0 +1,23 @@
+require File.expand_path('../../test_helper', __FILE__)
+
+module ActiveModelComplianceTest
+  [
+    RestApi::Base,
+    RestApi::Info,
+    Key,
+    Domain,
+    Application,
+    Alias,
+    Cartridge,
+    CartridgeType,
+    Embedded,
+    Gear,
+    GearGroup,
+    User,
+  ].each do |klass|
+    const_set("#{klass.to_s.gsub(':','')}Test", Class.new(ActiveModel::TestCase) do
+      include ActiveModel::Lint::Tests
+      setup{ @model = klass.new }
+    end)
+  end
+end

data/test/unit/async_aware_test.rb

@@ -0,0 +1,55 @@
+require File.expand_path('../../test_helper', __FILE__)
+
+class AsyncAwareTest < ActiveSupport::TestCase
+
+  def obj
+    @test_obj ||= Class.new(Object) do
+      include AsyncAware
+      def logger
+        Logger.new
+      end
+    end.new
+  end
+
+  class A < StandardError; end
+  class B < StandardError; end
+  class C < StandardError; end
+
+  test "runs in order" do
+    obj.async{ 'a' }
+    obj.async{ 'b' }
+    assert_equal ['a','b'], obj.join
+    assert_equal 1, Thread.list.size
+
+    assert_raise(NoMethodError){ obj.join }
+  end
+  test "returns in consistent order" do
+    obj.async{ sleep(0.01); 'a' }
+    obj.async{ 'b' }
+    assert_equal ['a','b'], obj.join
+  end
+  test "join returns results" do
+    obj.async{ sleep(0.01); raise A }
+    obj.async{ sleep(0.02); raise B }
+    obj.async{ 'c' }
+    arr = obj.join
+    assert arr[0].is_a? A
+    assert arr[1].is_a? B
+    assert_equal 'c', arr[2]
+  end
+  test "join! raises the first exception" do
+    obj.async{ sleep(0.01); raise A }
+    obj.async{ raise B }
+    assert_raise(A){ result obj.join! }
+    assert_equal 1, Thread.list.size
+  end
+  test "join on thread expiration returns timeout" do
+    obj.async{ sleep(1) }
+    assert_raise(AsyncAware::ThreadTimedOut){ obj.join!(0.01) }
+  end
+  test "Thread timeout has message" do
+    ex = AsyncAware::ThreadTimedOut.new(Thread.current, 13045)
+    assert /13045/ =~ ex.to_s
+    assert ex.to_s.include? Thread.current.inspect
+  end
+end