File: spec_events.rb

package info (click to toggle)
ruby-rack 2.1.4-3
  • links: PTS, VCS
  • area: main
  • in suites: bullseye, sid
  • size: 1,492 kB
  • sloc: ruby: 14,778; sh: 12; makefile: 6; javascript: 1
file content (135 lines) | stat: -rw-r--r-- 3,643 bytes parent folder | download | duplicates (2)
1
2
3
4
5
6
7
8
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
42
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
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
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
123
124
125
126
127
128
129
130
131
132
133
134
135
# frozen_string_literal: true

require 'helper'
require 'rack/events'

module Rack
  class TestEvents < Rack::TestCase
    class EventMiddleware
      attr_reader :events

      def initialize events
        @events = events
      end

      def on_start req, res
        events << [self, __method__]
      end

      def on_commit req, res
        events << [self, __method__]
      end

      def on_send req, res
        events << [self, __method__]
      end

      def on_finish req, res
        events << [self, __method__]
      end

      def on_error req, res, e
        events << [self, __method__]
      end
    end

    def test_events_fire
      events = []
      ret = [200, {}, []]
      app = lambda { |env| events << [app, :call]; ret }
      se = EventMiddleware.new events
      e = Events.new app, [se]
      triple = e.call({})
      response_body = []
      triple[2].each { |x| response_body << x }
      triple[2].close
      triple[2] = response_body
      assert_equal ret, triple
      assert_equal [[se, :on_start],
                    [app, :call],
                    [se, :on_commit],
                    [se, :on_send],
                    [se, :on_finish],
      ], events
    end

    def test_send_and_finish_are_not_run_until_body_is_sent
      events = []
      ret = [200, {}, []]
      app = lambda { |env| events << [app, :call]; ret }
      se = EventMiddleware.new events
      e = Events.new app, [se]
      triple = e.call({})
      assert_equal [[se, :on_start],
                    [app, :call],
                    [se, :on_commit],
      ], events
    end

    def test_send_is_called_on_each
      events = []
      ret = [200, {}, []]
      app = lambda { |env| events << [app, :call]; ret }
      se = EventMiddleware.new events
      e = Events.new app, [se]
      triple = e.call({})
      triple[2].each { |x| }
      assert_equal [[se, :on_start],
                    [app, :call],
                    [se, :on_commit],
                    [se, :on_send],
      ], events
    end

    def test_finish_is_called_on_close
      events = []
      ret = [200, {}, []]
      app = lambda { |env| events << [app, :call]; ret }
      se = EventMiddleware.new events
      e = Events.new app, [se]
      triple = e.call({})
      triple[2].each { |x| }
      triple[2].close
      assert_equal [[se, :on_start],
                    [app, :call],
                    [se, :on_commit],
                    [se, :on_send],
                    [se, :on_finish],
      ], events
    end

    def test_finish_is_called_in_reverse_order
      events = []
      ret = [200, {}, []]
      app = lambda { |env| events << [app, :call]; ret }
      se1 = EventMiddleware.new events
      se2 = EventMiddleware.new events
      se3 = EventMiddleware.new events

      e = Events.new app, [se1, se2, se3]
      triple = e.call({})
      triple[2].each { |x| }
      triple[2].close

      groups = events.group_by { |x| x.last }
      assert_equal groups[:on_start].map(&:first), groups[:on_finish].map(&:first).reverse
      assert_equal groups[:on_commit].map(&:first), groups[:on_finish].map(&:first)
      assert_equal groups[:on_send].map(&:first), groups[:on_finish].map(&:first)
    end

    def test_finish_is_called_if_there_is_an_exception
      events = []
      ret = [200, {}, []]
      app = lambda { |env| raise }
      se = EventMiddleware.new events
      e = Events.new app, [se]
      assert_raises(RuntimeError) do
        e.call({})
      end
      assert_equal [[se, :on_start],
                    [se, :on_error],
                    [se, :on_finish],
      ], events
    end
  end
end