class QTestScenario::QTestScenarioPlugin

Attributes

api_key[RW]
destination_dir[RW]
jql[RW]
keys[RW]
server[RW]
support_folder[RW]

Public Class Methods

new(args) click to toggle source
# File lib/qTestScenarioRuby.rb, line 36
def initialize(args)
  args.each do |k, v|
    instance_variable_set("@#{k}", v) unless v.nil?
  end
  if @server.nil? or @api_key.nil? or @destination_dir.nil?
    puts '--------------------------------------------------------------'
    puts 'Must set at least Jira host URI (server), api key (api_key) and destination folder (destination_dir) for feature files'
    puts '--------------------------------------------------------------'
    exit 1
  end
  if @jql.nil? and @keys.nil?
    puts '--------------------------------------------------------------'
    puts 'Must set at least jql or issue key to select feature files'
    puts '--------------------------------------------------------------'
    exit 1
  end

  @setup_is_done = false
  HookUtils.generate_hook(@support_folder, HOOK_VERSION)
end

Public Instance Methods

after_scenario(scenario) click to toggle source
# File lib/qTestScenarioRuby.rb, line 170
def after_scenario (scenario)
  feature_meta = @feature_mappings_map[scenario.feature.name]
  feature_log = @feature_logs_map[feature_meta.id]
  scenario_log = get_scenario_log(feature_log.scenarioLogs, feature_meta, scenario)

  if !scenario_log.nil?
    scenario_log.endDate = Time.now.to_ms
    result = ''
    if scenario.failed?
      scenario_log.executionLog = scenario.exception
      result = QspecResult::FAILED
    else
      if 'passed'.eql? scenario.status.to_s
        result = QspecResult::PASSED
      else
        result = QspecResult::UNCOMPLETED
      end
    end

    if !scenario.outline?
      # not scenario outline: update result to scenarioLog
      scenario_log.result = result
      feature_log.addScenarioResult(scenario_log.result)
    else
      # scenario outline: doesn't calculate scenario, defer it until all outline has been executed
      scenario_log.outLineResult.push(result)
      @current_outline_count += 1

      if @current_outline_count.eql? @scenario_id_to_outline_number[scenario_log.scenarioId]
        # put the outline result to scenario log
        scenario_log.result = calculate_result(scenario_log.outLineResult)
        feature_log.addScenarioResult(scenario_log.result)
        @current_outline_count = 0
      end
    end
  end

  if feature_log.done?
    # all scenarios have been executed, updates the qspecFeature log and sends it to scenario server
    feature_log.result = calculate_result(feature_log.resultSet)
    feature_log.endDate = Time.now.to_ms

    QTestScenarioUtils.submit_feature_test_log(feature_log, @server, @api_key)
  end
end
at_exit() click to toggle source
# File lib/qTestScenarioRuby.rb, line 216
def at_exit
  @execution.endDate = Time.now.to_ms
  QTestScenarioUtils.update_execution(@execution, @server, @api_key)
end
before_scenario(scenario) click to toggle source
# File lib/qTestScenarioRuby.rb, line 103
def before_scenario (scenario)

  if (!@setup_is_done)
    @setup_is_done = true
    @feature_mappings_map = QTestScenarioUtils.load_feature_mapping_file(@destination_dir)
    @execution = QTestScenarioUtils.create_execution(@server, @api_key)
    @feature_logs_map = Hash.new
    @scenario_id_to_outline_number = Hash.new
    @current_outline_count = 0
  end

  feature_meta = @feature_mappings_map[scenario.feature.name]
  feature_log = @feature_logs_map[feature_meta.id]
  if feature_log.nil?
    # new feature if not exists
    feature_log = FeatureLog.new
    feature_log.totalScenariosNumber = feature_meta.scenarios.length
    feature_log.featureId = feature_meta.id
    feature_log.versionId = feature_meta.versionId
    feature_log.executionId = @execution.executionId
    feature_log.startDate = Time.now.to_ms
    feature_log.totalScenariosNumber = feature_meta.scenarios.length
    @feature_logs_map[feature_meta.id] = feature_log

    # build outline count for scenarios
    scenario.feature.feature_elements.each { |child|
      if ('Scenario Outline'.eql? child.keyword) || ('scenario outline'.eql? child.keyword)
        outline_example_count = 0
        scenarioId = feature_meta.scenarios[child.name]
        child.examples_tables.each { |table|
          outline_example_count += table.example_rows.length
          table.example_rows.each { |row|
            outLineName = OUTLINE_PATTERN % [child.name, table.name, row.number]
            feature_meta.scenarios[outLineName] = scenarioId
          }
        }
        @scenario_id_to_outline_number[scenarioId] = outline_example_count
      end
    }
  end
  # get the scenario log, in case Scenario Outline, we will get the same scenarioLog
  scenario_log = get_scenario_log(feature_log.scenarioLogs, feature_meta, scenario)
  scenario_id = feature_meta.scenarios[scenario.name]

  if scenario_log.nil?
    scenario_log = ScenarioLog.new
    scenario_log.featureId = feature_meta.id
    scenario_log.featureName = feature_meta.name
    scenario_log.startDate = Time.now.to_ms
    scenario_log.host = Socket.gethostname
    scenario_log.scenarioName = scenario.name
    scenario_log.scenarioId = scenario_id
    feature_log.addScenarioLog(scenario_log)
  end
end
calculate_result(results) click to toggle source
# File lib/qTestScenarioRuby.rb, line 159
def calculate_result (results)
  if results.include? QspecResult::FAILED
    result = QspecResult::FAILED
  elsif results.include? QspecResult::UNCOMPLETED
    result = QspecResult::UNCOMPLETED
  else
    result = QspecResult::PASSED
  end
  result
end
get_scenario_log(scenariosLog, featureMeta, scenario) click to toggle source
# File lib/qTestScenarioRuby.rb, line 93
def get_scenario_log (scenariosLog, featureMeta, scenario)
  scenariosLog.each { |scenarioLog|
    scenarioId = featureMeta.scenarios[scenario.name]
    if scenarioLog.scenarioId.eql? scenarioId
      return scenarioLog
    end
  }
  return nil
end
prepare_test() click to toggle source
# File lib/qTestScenarioRuby.rb, line 57
def prepare_test
  FileUtils.rm_rf(@destination_dir)
  begin
    FileUtils.mkdir(@destination_dir)
  rescue
    # retry if we encounter PermissionDenied exception
    FileUtils.mkdir(@destination_dir)
  end

  response = QTestScenarioUtils.get_feature_files(@keys, @jql, @server, @api_key)
  if response.code === 200
    features = JSON.parse(response.body)
    feature_mapper = Hash.new

    features.each { |feature|
      qspec_feature = QspecFeature.from_json feature

      # Write qspec_feature to file
      write_to_file(@destination_dir, qspec_feature.fileName, qspec_feature.content)

      feature_meta = FeatureMeta.new(qspec_feature.id, qspec_feature.name, qspec_feature.scenarios, qspec_feature.versionId)
      feature_mapper[qspec_feature.name] = feature_meta.to_json
    }

    # Write qspecFeature mapping to file
    write_to_file(@destination_dir, Constants.getMappingFileName, feature_mapper.to_json)
  end
end
write_to_file(destination_dir, file_name, content) click to toggle source
# File lib/qTestScenarioRuby.rb, line 86
def write_to_file (destination_dir, file_name, content)
  path = destination_dir + file_name
  File.open(path, 'wb') do |f|
    f.puts content
  end
end