Class: ApiMiniTester::TestStep

Inherits:
Object
  • Object
show all
Includes:
HTTParty
Defined in:
lib/api_mini_tester/test_step.rb

Constant Summary collapse

SUPPORTED_METHODS = 
i[ get post put delete ].freeze
SUPPORTED_RANDOM_DISTRIBUTION = 
%w[ static norm uniform ].freeze

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(base_uri, step, context = nil, data = nil, defaults = nil) ⇒ TestStep

Returns a new instance of TestStep.



20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
 
# File 'lib/api_mini_tester/test_step.rb', line 20

def initialize(base_uri, step, context = nil, data = nil, defaults = nil)
  step = step.deep_merge!(defaults) do |key, this_val, other_val|
    if this_val.nil?
      other_val
    elsif this_val.is_a?(Array)
      (this_val + other_val)
    else
      this_val
    end
  end if defaults

  Liquid::Template.register_filter(::TestFakerFilter)
  @context = context
  uri_template = Liquid::Template.parse([base_uri, step['uri']].join("/"), error_mode: :strict)
  @name = step['name']
  @sleeps = step['sleep']

  @uri = uri_template.render(
    {'context' => context, 'data' => data},
    { strict_variables: true })
  @method = step['method'].downcase.to_sym

  input_template = Liquid::Template.parse(step['input'].to_yaml.to_s, error_mode: :strict)
  @input = YAML.load(
    input_template.render({'context' => context, 'data' => data}, { strict_variables: true }))

  output_template = Liquid::Template.parse(step['output'].to_yaml.to_s, error_mode: :strict)
  @output = YAML.load(
    output_template.render({'context' => context, 'data' => data}, { strict_variables: true }))

  @results = { name: step['name'], desc: step['desc'], status: [], headers: [], body: [], url: [], method: [], timing: [] }
end

Instance Attribute Details

#input ⇒ Object

Returns the value of attribute input.



17
18
19
 
# File 'lib/api_mini_tester/test_step.rb', line 17

def input
  @input
end

#method ⇒ Object (readonly)

Returns the value of attribute method.



18
19
20
 
# File 'lib/api_mini_tester/test_step.rb', line 18

def method
  @method
end

#name ⇒ Object

Returns the value of attribute name.



17
18
19
 
# File 'lib/api_mini_tester/test_step.rb', line 17

def name
  @name
end

#output ⇒ Object

Returns the value of attribute output.



17
18
19
 
# File 'lib/api_mini_tester/test_step.rb', line 17

def output
  @output
end

#results ⇒ Object (readonly)

Returns the value of attribute results.



18
19
20
 
# File 'lib/api_mini_tester/test_step.rb', line 18

def results
  @results
end

#sleeps ⇒ Object (readonly)

Returns the value of attribute sleeps.



18
19
20
 
# File 'lib/api_mini_tester/test_step.rb', line 18

def sleeps
  @sleeps
end

#uri ⇒ Object (readonly)

Returns the value of attribute uri.



18
19
20
 
# File 'lib/api_mini_tester/test_step.rb', line 18

def uri
  @uri
end

Instance Method Details

#add_result(section, result) ⇒ Object 



152
153
154
 
# File 'lib/api_mini_tester/test_step.rb', line 152

def add_result(section, result)
  @results[section] << result
end

#array_diff(a, b, path = nil, section = :body) ⇒ Object 



207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
 
# File 'lib/api_mini_tester/test_step.rb', line 207

def array_diff(a, b, path = nil, section = :body)
  a.each do |a_item|
    if b.nil?
      add_result section, { result: false,
        name: "Response boby value: #{[path].join(".")}",
        desc: "Assert #{[path].join(".")} is empty" }
    elsif a_item.instance_of?(Hash)
      found = false
      b.each do |b_item|
        matching = true
        a_item.each_key do |k, v|
          matching = (b_item[k] == a_item[k]) if matching
        end
        found = true if matching
      end
      add_result section, { result: found,
                            name: "Response body value: #{[path].join(".")}",
                            desc: "Assert #{[path].join(".")} #{found ? 'contains' : 'does not contains'} #{a_item}" }
    elsif a_item.instance_of?(Array)
      # TODO: Add support for array of array it isn't so needed to compate so deep structures
    else
      add_result section, { result: b.include?(a_item),
                            name: "Response boby value: #{[path].join(".")}",
                            desc: "Assert #{[path].join(".")} #{b.include?(a_item) ? 'contains' : 'does not contains'} #{a_item}" }
    end
  end
end

#assert_body(response, output) ⇒ Object 



199
200
201
202
203
204
205
 
# File 'lib/api_mini_tester/test_step.rb', line 199

def assert_body(response, output)
  if output.instance_of?(Hash)
    hash_diff(output, response)
  elsif output.instance_of?(Array)
    array_diff(output, response)
  end
end

#assert_headers(response, output) ⇒ Object 



188
189
190
191
192
193
194
195
196
197
 
# File 'lib/api_mini_tester/test_step.rb', line 188

def assert_headers(response, output)
  return if output.nil?

  output.each do |k, v|
    add_result :headers, { result: (v == response[k]),
                           name: "Header value: #{k} == #{v}",
                           desc: "Header #{k} expected: #{v}, got #{response[k]}",
                           exp: v, real: response[k] }
  end
end

#assert_status(response, output) ⇒ Object 



181
182
183
184
185
186
 
# File 'lib/api_mini_tester/test_step.rb', line 181

def assert_status(response, output)
  add_result :status, { result: (response == output),
                        name: "Response code == #{output}",
                        desc: "Expected response #{output}, got response #{response}",
                        exp: output, real: response }
end

#assert_timing(runtime, limit = nil) ⇒ Object 



173
174
175
176
177
178
179
 
# File 'lib/api_mini_tester/test_step.rb', line 173

def assert_timing(runtime, limit = nil)
  limit ||= Float::INFINITY
  add_result :timing, { result: (runtime < limit),
                        name: "Request time < #{limit}",
                        desc: "Expected request time #{limit}, real time #{runtime}",
                        exp: limit, real: runtime }
end

#body ⇒ Object 



73
74
75
76
77
78
79
80
81
82
 
# File 'lib/api_mini_tester/test_step.rb', line 73

def body
  case content_type
  when 'application/x-www-form-urlencoded'
    body_to_form_data
  when 'multipart/form-data'
    body_to_form_data
  else
    @input["body"].to_json
  end
end

#body_to_form_data ⇒ Object 



84
85
86
87
88
89
90
91
 
# File 'lib/api_mini_tester/test_step.rb', line 84

def body_to_form_data
  body = {}
  @input["body"].each do |item|
    body[item['name']] = item['value'] if item['type'] == 'input'
    body[item['name']] = File.open(item['value'], 'r') if item['type'] == 'file'
  end
  body
end

#content_type ⇒ Object 



63
64
65
 
# File 'lib/api_mini_tester/test_step.rb', line 63

def content_type
  @input['content_type'] || 'application/json'
end

#hash_diff(a, b, path = nil, section = :body) ⇒ Object 



235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
 
# File 'lib/api_mini_tester/test_step.rb', line 235

def hash_diff(a, b, path = nil, section = :body)
  return nil if a.nil? || b.nil?

  a.each_key do |k, v|
    current_path = [path, k].join('.')
    if b[k].nil?
      add_result section, { result: false,
                            name: "Reponse value: #{[path, k].join(".")}",
                            desc: "Missing #{current_path}" }
    elsif v.instance_of?(Hash)
      hash_diff(a[k], b[k], current_path, section)
    elsif v.instance_of?(Array)
      array_diff(a[k], b[k], current_path, section)
    else
      add_result section, { result: (a[k] == b[k]),
                            name: "Reponse body value: #{[path, k].join(".")}",
                            desc: "Assert #{[path, k].join(".")}: #{a[k]} #{a[k] == b[k] ? '==' : '!='} #{b[k]}" }
    end
  end
end

#headers ⇒ Object 



67
68
69
70
71
 
# File 'lib/api_mini_tester/test_step.rb', line 67

def headers
  @input['header'] = {} unless @input['header']
  @input['header']['Content-type'] = content_type if content_type == 'application/json'
  @input['header']
end

#print_results ⇒ Object 



146
147
148
149
150
 
# File 'lib/api_mini_tester/test_step.rb', line 146

def print_results
  @results.each do |line|
    puts line
  end
end

#run_step ⇒ Object 



109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
 
# File 'lib/api_mini_tester/test_step.rb', line 109

def run_step
  if sleeps
    step_sleep(sleeps['before']) if sleeps['before']
  end

  @timing = Time.now
  case method
  when :get
    response = HTTParty.get(uri, headers: headers)
  when :post
    response = HTTParty.post(uri, headers: headers, body: body)
  when :put
    response = HTTParty.put(uri, headers: headers, body: body)
  when :delete
    response = HTTParty.delete(uri, headers: headers)
  when :patch
    response = HTTParty.patch(uri, headers: headers, body: body)
  else
    raise "Unknown HTTP method: #{method}"
  end
  @timing = Time.now - @timing

  if sleeps
    step_sleep(sleeps['after']) if sleeps['after']
  end

  add_result :url, { result: true, desc: "Url: #{uri}" }
  add_result :method, { result: true, desc: "Method: #{method}" }

  assert_status(response.code, test_status)
  assert_headers(response.headers, test_headers)
  assert_body(response.parsed_response, test_body)
  assert_timing(@timing, test_timing)

  [ results, response ]
end

#step_sleep(params) ⇒ Object 



156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
 
# File 'lib/api_mini_tester/test_step.rb', line 156

def step_sleep(params)
  params['distribution'] = 'static' unless SUPPORTED_RANDOM_DISTRIBUTION.include?(params['distribution'])

  t = begin
    case params['distribution']
    when 'static'
      params['value']
    when 'norm'
      Distribution::Normal.rng(params['mean'], params['sigma'], srand).call
    when 'uniform'
      Random.new.rand(params['max'] - params['min']) + params['min']
    end
  end
  puts "Sleeping for #{t} seconds"
  sleep(t.to_f.abs) if t
end

#test_body ⇒ Object 



97
98
99
 
# File 'lib/api_mini_tester/test_step.rb', line 97

def test_body
  @output['body']
end

#test_headers ⇒ Object 



93
94
95
 
# File 'lib/api_mini_tester/test_step.rb', line 93

def test_headers
  @output['header']
end

#test_status ⇒ Object 



101
102
103
 
# File 'lib/api_mini_tester/test_step.rb', line 101

def test_status
  @output['status']
end

#test_timing ⇒ Object 



105
106
107
 
# File 'lib/api_mini_tester/test_step.rb', line 105

def test_timing
  @output['timing']
end

#valid? ⇒ Boolean

Returns:

  • (Boolean) 


53
54
55
56
57
58
59
60
61
 
# File 'lib/api_mini_tester/test_step.rb', line 53

def valid?
  return false if uri.nil? || uri.empty?

  return false unless URI.parse(uri) rescue false
  return false unless SUPPORTED_METHODS.include? method
  return false if @name.nil? || @name.empty?

  true
end