support test request validation after request handling

Author: orionstudt

lib/openapi_first/test.rb

@@ -95,9 +95,9 @@ def self.report_coverage(formatter: Coverage::TerminalFormatter, **)
     # Returns the Rack app wrapped with silent request, response validation
     # You can use this if you want to track coverage via Test::Coverage, but don't want to use
     # the middlewares or manual request, response validation.
-    def self.app(app, spec: nil, api: :default)
+    def self.app(app, spec: nil, api: :default, validate_request_after_handling: false)
       spec ||= self[api]
-      App.new(app, api: spec)
+      App.new(app, api: spec, validate_request_after_handling:)
     end
 
     def self.install

lib/openapi_first/test/app.rb

@@ -10,16 +10,24 @@ module Test
     # A wrapper of the original app
     # with silent request/response validation to track requests/responses.
     class App < SimpleDelegator
-      def initialize(app, api:)
+      def initialize(app, api:, validate_request_after_handling:)
         super(app)
         @app = app
         @definition = Test[api]
+        @validate_request_after_handling = validate_request_after_handling
       end
 
       def call(env)
         request = Rack::Request.new(env)
-        env[Test::REQUEST] = @definition.validate_request(request, raise_error: false)
+        unless @validate_request_after_handling
+          env[Test::REQUEST] = @definition.validate_request(request, raise_error: false)
+        end
+
         response = @app.call(env)
+        if @validate_request_after_handling
+          env[Test::REQUEST] = @definition.validate_request(request, raise_error: false)
+        end
+
         status, headers, body = response
         env[Test::RESPONSE] =
           @definition.validate_response(request, Rack::Response[status, headers, body], raise_error: false)

lib/openapi_first/test/methods.rb

@@ -12,12 +12,13 @@ def self.included(base)
         base.include(AssertionMethod)
       end
 
-      def self.[](application_under_test = nil, api: nil)
+      def self.[](application_under_test = nil, api: nil, validate_request_after_handling: false)
         mod = Module.new do
           def self.included(base)
             base.include OpenapiFirst::Test::Methods::AssertionMethod
           end
         end
+        mod.define_method(:openapi_first_validate_request_after_handling?) { validate_request_after_handling }
 
         if api
           mod.define_method(:openapi_first_default_api) { api }
@@ -26,7 +27,12 @@ def self.included(base)
         end
 
         if application_under_test
-          mod.define_method(:app) { OpenapiFirst::Test.app(application_under_test, api: openapi_first_default_api) }
+          mod.define_method(:app) do
+            OpenapiFirst::Test.app(
+              application_under_test, api: openapi_first_default_api,
+                                      validate_request_after_handling: openapi_first_validate_request_after_handling?
+            )
+          end
         end
 
         mod

spec/test/methods_spec.rb

@@ -90,7 +90,10 @@ def last_response = Rack::Response.new
   context 'with [arguments]' do
     it 'adds an app method that wraps the default API' do
       OpenapiFirst::Test.register('./examples/openapi.yaml')
-      myapp = ->(_env) { Rack::Response.new('hello').finish }
+      myapp = lambda do |env|
+        expect(env[OpenapiFirst::Test::REQUEST]).to be_a(OpenapiFirst::ValidatedRequest)
+        Rack::Response.new('hello').finish
+      end
 
       minitest_class = Class.new(Minitest::Test) do
         include OpenapiFirst::Test::Methods[myapp]
@@ -101,11 +104,34 @@ def last_response = Rack::Response.new
       env = Rack::MockRequest.env_for('/')
       expect(test_app.call(env)).to eq(Rack::Response.new('hello').finish)
       expect(env[OpenapiFirst::Test::REQUEST]).to be_valid
+      expect(env[OpenapiFirst::Test::RESPONSE]).to be_a(OpenapiFirst::ValidatedResponse)
+    end
+
+    it 'can run validation after handling the request, for the default API' do
+      OpenapiFirst::Test.register('./examples/openapi.yaml')
+      myapp = lambda do |env|
+        expect(env[OpenapiFirst::Test::REQUEST]).to be_nil
+        Rack::Response.new('hello').finish
+      end
+
+      minitest_class = Class.new(Minitest::Test) do
+        include OpenapiFirst::Test::Methods[myapp, validate_request_after_handling: true]
+      end
+
+      expect(minitest_class.included_modules).to include(OpenapiFirst::Test::MinitestHelpers)
+      test_app = minitest_class.new(1).app
+      env = Rack::MockRequest.env_for('/')
+      expect(test_app.call(env)).to eq(Rack::Response.new('hello').finish)
+      expect(env[OpenapiFirst::Test::REQUEST]).to be_valid
+      expect(env[OpenapiFirst::Test::RESPONSE]).to be_a(OpenapiFirst::ValidatedResponse)
     end
 
     it 'adds an app method that wraps the app for a specific API' do
       OpenapiFirst::Test.register('./examples/openapi.yaml', as: :v1)
-      myapp = ->(_env) { Rack::Response.new('hello').finish }
+      myapp = lambda do |env|
+        expect(env[OpenapiFirst::Test::REQUEST]).to be_a(OpenapiFirst::ValidatedRequest)
+        Rack::Response.new('hello').finish
+      end
 
       minitest_class = Class.new(Minitest::Test) do
         include OpenapiFirst::Test::Methods[myapp, api: :v1]
@@ -116,6 +142,26 @@ def last_response = Rack::Response.new
       env = Rack::MockRequest.env_for('/')
       expect(test_app.call(env)).to eq(Rack::Response.new('hello').finish)
       expect(env[OpenapiFirst::Test::REQUEST]).to be_valid
+      expect(env[OpenapiFirst::Test::RESPONSE]).to be_a(OpenapiFirst::ValidatedResponse)
+    end
+
+    it 'can run validation after handling the request, for a specific API' do
+      OpenapiFirst::Test.register('./examples/openapi.yaml', as: :v1)
+      myapp = lambda do |env|
+        expect(env[OpenapiFirst::Test::REQUEST]).to be_nil
+        Rack::Response.new('hello').finish
+      end
+
+      minitest_class = Class.new(Minitest::Test) do
+        include OpenapiFirst::Test::Methods[myapp, api: :v1, validate_request_after_handling: true]
+      end
+
+      expect(minitest_class.included_modules).to include(OpenapiFirst::Test::MinitestHelpers)
+      test_app = minitest_class.new(1).app
+      env = Rack::MockRequest.env_for('/')
+      expect(test_app.call(env)).to eq(Rack::Response.new('hello').finish)
+      expect(env[OpenapiFirst::Test::REQUEST]).to be_valid
+      expect(env[OpenapiFirst::Test::RESPONSE]).to be_a(OpenapiFirst::ValidatedResponse)
     end
 
     it 'adds an assert_api_conform method that targets the specified API' do