Class: Inferno::Repositories::Requirements

Inherits:
InMemoryRepository show all
Defined in:
lib/inferno/repositories/requirements.rb

Overview

Repository that deals with persistence for the Requirement entity.

Instance Method Summary collapse

Methods inherited from InMemoryRepository

all, #exists?, #find, #insert, #remove

Instance Method Details

#add_referenced_requirement_set_requirements(requirements_to_process, requirement_sets, processed_requirements = []) ⇒ Object

rubocop:disable Metrics/CyclomaticComplexity



96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
 
# File 'lib/inferno/repositories/requirements.rb', line 96

def add_referenced_requirement_set_requirements( # rubocop:disable Metrics/CyclomaticComplexity
  requirements_to_process,
  requirement_sets,
  processed_requirements = []
)
  return processed_requirements if requirements_to_process.blank?

  referenced_requirement_sets = requirement_sets.select(&:referenced?)

  referenced_requirement_ids =
    requirements_to_process
      .flat_map(&:subrequirements)
      .select do |requirement_id|
        referenced_requirement_sets.any? do |set|
          requirement_id.start_with?("#{set.identifier}@") && find(requirement_id)&.actor?(set.actor)
        end
      end

  new_requirements =
    referenced_requirement_ids.map { |id| find(id) } - requirements_to_process - processed_requirements

  add_referenced_requirement_set_requirements(
    new_requirements,
    referenced_requirement_sets,
    (processed_requirements + requirements_to_process).uniq
  )
end

#complete_requirement_set_requirements(requirement_sets) ⇒ Object 



76
77
78
79
80
81
82
83
84
 
# File 'lib/inferno/repositories/requirements.rb', line 76

def complete_requirement_set_requirements(requirement_sets)
  requirement_sets.select(&:complete?)
    .flat_map do |requirement_set|
      all.select do |requirement|
        requirement.requirement_set == requirement_set.identifier &&
          requirement.actor?(requirement_set.actor)
      end
    end
end

#filter_requirements_by_ids(ids) ⇒ Object 



47
48
49
 
# File 'lib/inferno/repositories/requirements.rb', line 47

def filter_requirements_by_ids(ids)
  all.select { |requirement| ids.include?(requirement.id) }
end

#filtered_requirement_set_requirements(requirement_sets) ⇒ Object 



86
87
88
89
90
91
92
93
94
 
# File 'lib/inferno/repositories/requirements.rb', line 86

def filtered_requirement_set_requirements(requirement_sets)
  requirement_sets.select(&:filtered?)
    .flat_map do |requirement_set|
      requirement_set
        .expand_requirement_ids
        .map { |requirement_id| find(requirement_id) }
        .select { |requirement| requirement.actor?(requirement_set.actor) }
    end
end

#insert_from_file(path) ⇒ Object

rubocop:disable Metrics/CyclomaticComplexity



9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
 
# File 'lib/inferno/repositories/requirements.rb', line 9

def insert_from_file(path) # rubocop:disable Metrics/CyclomaticComplexity
  result = []

  CSV.foreach(path, headers: true, header_converters: :symbol) do |row|
    next if row[:conformance].casecmp? 'deprecated'

    req_set = row[:req_set]
    id = row[:id]

    combined_id = "#{req_set}@#{id}"

    result << {
      requirement_set: req_set,
      id: combined_id,
      url: row[:url],
      requirement: row[:requirement],
      conformance: row[:conformance],
      actors: row[:actors]&.split(',')&.map(&:strip) || [],
      subrequirements_string: row[:subrequirements],
      conditionality: row[:conditionality]&.downcase,
      not_tested_reason: row[:not_tested_reason],
      not_tested_details: row[:not_tested_details]
    }
  rescue StandardError => e
    Application[:logger].error("Unable to load requirement: #{combined_id}:\n#{e.full_message.lines.first}")
  end

  result.each do |raw_req|
    requirement = Entities::Requirement.new(raw_req)

    insert(requirement)
  end
end

#requirements_for_actor(requirement_set, actor) ⇒ Object 



43
44
45
 
# File 'lib/inferno/repositories/requirements.rb', line 43

def requirements_for_actor(requirement_set, actor)
  all.select { |requirement| requirement.requirement_set == requirement_set && requirement.actor?(actor) }
end

#requirements_for_suite(test_suite_id, test_session_id = nil) ⇒ Object 



51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
 
# File 'lib/inferno/repositories/requirements.rb', line 51

def requirements_for_suite(test_suite_id, test_session_id = nil)
  test_suite = Inferno::Repositories::TestSuites.new.find(test_suite_id)
  selected_suite_options =
    if test_session_id.present?
      Inferno::Repositories::TestSessions.new.find(test_session_id).suite_options
    else
      []
    end

  requirement_sets =
    test_suite
      .requirement_sets
      .select do |set|
        set.suite_options.all? do |set_option|
          selected_suite_options.blank? || selected_suite_options.include?(set_option)
        end
      end

  requirements =
    complete_requirement_set_requirements(requirement_sets) +
    filtered_requirement_set_requirements(requirement_sets)

  add_referenced_requirement_set_requirements(requirements, requirement_sets).uniq
end