Merge pull request #436 from ahx/test-track-after-handle

Test: Track request after calling the app

Author: ahx

CHANGELOG.md

@@ -2,6 +2,21 @@
 
 ## Unreleased
 
+### Changed
+- Changed OpenapiFirst::Test to track the request _after_ the app has handled the request. See [PR #434](https://github.com/ahx/openapi_first/pull/434). You can restore the old behavior with 
+```ruby
+  include OpenapiFirst::Test::Methods[MyApp, validate_request_before_handling: true]
+```
+
+### Added
+
+- Added support for a static `path_prefix` value to be set on the creation of a Definition. See [PR #432](https://github.com/ahx/openapi_first/pull/432):
+  ```ruby
+  OpenapiFirst.configure do |config|
+    config.register('openapi/openapi.yaml' path_prefix: '/weather')
+  end
+  ```
+
 ## 3.1.1
 
 - Changed: Return uniqe errors in default error responses

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_before_handling: false)
       spec ||= self[api]
-      App.new(app, api: spec)
+      App.new(app, api: spec, validate_request_before_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_before_handling:)
         super(app)
         @app = app
         @definition = Test[api]
+        @validate_request_before_handling = validate_request_before_handling
       end
 
       def call(env)
         request = Rack::Request.new(env)
-        env[Test::REQUEST] = @definition.validate_request(request, raise_error: false)
+        if @validate_request_before_handling
+          env[Test::REQUEST] = @definition.validate_request(request, raise_error: false)
+        end
+
         response = @app.call(env)
+        unless @validate_request_before_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_before_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_before_handling?) { validate_request_before_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_before_handling: openapi_first_validate_request_before_handling?
+            )
+          end
         end
 
         mod

spec/test/methods_spec.rb

@@ -24,6 +24,25 @@ def last_response = Rack::Response.new
     end.to raise_error(OpenapiFirst::Error)
   end
 
+  it 'runs request validation after handling the request' 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]
+    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
+
   context 'with RSpec' do
     context 'with metadata', api: :v1 do
       include OpenapiFirst::Test::Methods
@@ -88,24 +107,31 @@ def last_response = Rack::Response.new
   end
 
   context 'with [arguments]' do
-    it 'adds an app method that wraps the default API' do
+    it 'can run validation before handling the request' 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]
+        include OpenapiFirst::Test::Methods[myapp, validate_request_before_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_nil
+        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 before 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_a(OpenapiFirst::ValidatedRequest)
+        Rack::Response.new('hello').finish
+      end
+
+      minitest_class = Class.new(Minitest::Test) do
+        include OpenapiFirst::Test::Methods[myapp, api: :v1, validate_request_before_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