Plugins » Katello » Runcible

if RUBY_VERSION > "2.2"

  # Coverage - Keep these two lines at the top of this file

  require 'simplecov'

  require 'coveralls'

  SimpleCov.formatters = [SimpleCov::Formatter::HTMLFormatter,

                          Coveralls::SimpleCov::Formatter]

  SimpleCov.start do

    minimum_coverage 90

    refuse_coverage_drop

    track_files "lib/**/*.rb"

    add_filter '/test/'

  end

end

require 'rubygems'

require 'logger'

require 'minitest/unit'

require 'minitest/autorun'

require 'mocha/setup'

require './test/vcr_setup'

require './lib/runcible'

begin

  require 'debugger'

rescue LoadError

  puts 'Debugging not enabled.'

end

class TestRuncible

  def self.server=(instance)

    @@instance = instance

  end

  def self.server

    @@instance

  end

end

module MiniTest

  class Unit

    class TestCase

      def cassette_name

        test_name = self.__name__.gsub('test_', '')

        parent = (self.class.name.split('::')[-2] || '').underscore

        self_class = self.class.name.split('::')[-1].underscore.gsub('test_', '')

        "#{parent}/#{self_class}/#{test_name}"

      end

      def run_with_vcr(args)

        options = self.class.respond_to?(:cassette_options) ? self.class.cassette_options : {}

        VCR.insert_cassette(cassette_name, options)

        to_ret = run_without_vcr(args)

        VCR.eject_cassette

        to_ret

      end

      alias_method_chain :run, :vcr

      class << self

        attr_accessor :support

        def suite_cassette_name

          parent = (self.name.split('::')[-2] || '').underscore

          self_class = self.name.split('::')[-1].underscore.gsub('test_', '')

          "#{parent}/#{self_class}/suite"

        end

      end

      def assert_async_response(response)

        support = @support || self.class.support

        fail '@support or @@support not defined' unless support

        if response.key? "group_id"

          assert_async_task_groups(response, support)

        else

          assert_async_tasks(response, support)

        end

      end

      def assert_async_tasks(response, support)

        assert_equal 202, response.code

        tasks = support.wait_on_response(response)

        tasks.each do |task|

          assert task['state'], 'finished'

        end

      end

      def assert_async_task_groups(response, support)

        assert_equal 202, response.code

        summary = support.wait_on_task_group(response)

        assert_equal summary["total"], summary["finished"]

        summary

      end

    end

  end

end

class CustomMiniTestRunner

  class Unit < MiniTest::Unit

    def before_suites

      # code to run before the first test

    end

    def after_suites

      # code to run after the last test

    end

    def _run_suites(suites, type)

      if ENV['suite']

        suites = suites.select do |suite|

          suite.name == ENV['suite']

        end

      end

      before_suites

      super(suites, type)

    ensure

      after_suites

    end

    def _run_suite(suite, type)

      options = suite.respond_to?(:cassette_options) ? suite.cassette_options : {}

      if logging?

        puts "Running Suite #{suite.inspect} - #{type.inspect} "

      end

      if suite.respond_to?(:before_suite)

        VCR.use_cassette(suite.suite_cassette_name, options) do

          suite.before_suite

        end

      end

      super(suite, type)

    ensure

      if suite.respond_to?(:after_suite)

        VCR.use_cassette(suite.suite_cassette_name, options) do

          suite.after_suite

        end

      end

      if logging?

        puts "Completed Running Suite #{suite.inspect} - #{type.inspect} "

      end

    end

    def logging?

      ENV['logging']

    end

  end

end

class PulpMiniTestRunner

  def run_tests(suite, options = {})

    mode      = options[:mode] || 'none'

    test_name = options[:test_name] || nil

    auth_type = options[:auth_type] || 'http'

    logging   = options[:logging] || false

    MiniTest::Unit.runner = CustomMiniTestRunner::Unit.new

    if mode == 'all'

      runcible_config(:auth_type => auth_type, :logging => logging)

    else

      runcible_config(:logging => logging)

    end

    vcr_config(mode)

    if test_name && File.exist?(test_name)

      require test_name

    elsif test_name

      require "./test/#{test_name}_test.rb"

    else

      Dir["./test/#{suite}/*_test.rb"].each { |file| require file }

    end

  end

  def runcible_config(options)

    config = { :api_path   => '/pulp/api/v2/',

               :http_auth  => {}}

    if options[:logging] == 'true'

      log = ::Logger.new(STDOUT)

      log.level = Logger::DEBUG

      config[:logging] = { :logger => log,

                           :debug  => true,

                           :stdout => true}

    end

    if options[:auth_type] == 'http'

      File.open('/etc/pulp/server.conf') do |f|

        f.each_line do |line|

          if line.start_with?('default_password')

            config[:http_auth][:password] = line.split(':')[1].strip

          elsif line.start_with?('default_login')

            config[:user] = line.split(':')[1].strip

          elsif line.start_with?('server_name')

            config[:url] = "https://#{line.split(':')[1].chomp.strip}"

          end

        end

      end

    elsif options[:auth_type] == 'oauth'

      File.open('/etc/pulp/server.conf') do |f|

        f.each_line do |line|

          if line.start_with?('oauth_secret')

            config[:oauth][:oauth_secret] = line.split(':')[1].strip

          elsif line.start_with?('oauth_key')

            config[:oauth][:oauth_key] = line.split(':')[1].strip

          elsif line.start_with?('default_login')

            config[:user] = line.split(':')[1].strip

          elsif line.start_with?('server_name')

            config[:url] = "https://#{line.split(':')[1].chomp.strip}"

          end

        end

      end

    else

      config[:http_auth][:password] = 'admin'

      config[:user]  = 'admin'

      config[:url]   = 'https://localhost'

    end

    config[:verify_ssl] = false

    TestRuncible.server = Runcible::Instance.new(config)

  end

  def vcr_config(mode)

    if mode == 'all'

      configure_vcr(:all)

    elsif mode == 'new_episodes'

      configure_vcr(:new_episodes)

    elsif mode == 'once'

      configure_vcr(:once)

    else

      configure_vcr(:none)

    end

  end

end