Class: Rack::PactBroker::Cascade

Inherits:
Object
  • Object
show all
Defined in:
lib/rack/pact_broker/cascade.rb

Constant Summary collapse

NotFound =

deprecated, no longer used

[404, { CONTENT_TYPE => "text/plain" }, []]

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(apps, cascade_for = [404, 405]) ⇒ Cascade

Set the apps to send requests to, and what statuses result in cascading. Arguments:

apps: An enumerable of rack applications. cascade_for: The statuses to use cascading for. If a response is received

from an app, the next app is tried.



32
33
34
35
36
37
38
 
# File 'lib/rack/pact_broker/cascade.rb', line 32

def initialize(apps, cascade_for = [404, 405])
  @apps = []
  apps.each { |app| add app }

  @cascade_for = {}
  [*cascade_for].each { |status| @cascade_for[status] = true }
end

Instance Attribute Details

#apps ⇒ Object (readonly)

An array of applications to try in order.



24
25
26
 
# File 'lib/rack/pact_broker/cascade.rb', line 24

def apps
  @apps
end

Instance Method Details

#add(app) ⇒ Object Also known as: <<

Append an app to the list of apps to cascade. This app will be tried last.



75
76
77
 
# File 'lib/rack/pact_broker/cascade.rb', line 75

def add(app)
  @apps << app
end

#call(env) ⇒ Object

Call each app in order. If the responses uses a status that requires cascading, try the next app. If all responses require cascading, return the response from the last app.



43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
 
# File 'lib/rack/pact_broker/cascade.rb', line 43

def call(env)
  return [404, { CONTENT_TYPE => "text/plain" }, []] if @apps.empty?
  result = nil
  last_body = nil

  @apps.each_with_index do |app, i|
    # The SPEC says that the body must be closed after it has been iterated
    # by the server, or if it is replaced by a middleware action. Cascade
    # replaces the body each time a cascade happens. It is assumed that nil
    # does not respond to close, otherwise the previous application body
    # will be closed. The final application body will not be closed, as it
    # will be passed to the server as a result.
    last_body.close if last_body.respond_to? :close
    result = app.call(env)

    puts result.last

    # If it is a 404/403 AND the response body is empty, then try the next app
    if @cascade_for.include?(result[0].to_i) && result[2].respond_to?(:empty?) && result[2].empty?
      last_body = result[2]
    else
      puts "returned from #{i} of #{@apps.size}"
      # otherwise, return the result
      return result
    end
  end

  result
end

#include?(app) ⇒ Boolean

Whether the given app is one of the apps to cascade to.

Returns:

  • (Boolean) 


80
81
82
 
# File 'lib/rack/pact_broker/cascade.rb', line 80

def include?(app)
  @apps.include?(app)
end