rest-assured 2.1.0 → 2.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7f22fb40a5da375669712d668d450c79397ddd9a
-  data.tar.gz: ee5916c4ee0dac3b82230c24bb606c90205091ab
+  metadata.gz: 370e594e8946de24f24b8469929fbc069fe5235f
+  data.tar.gz: 9e1e1621fa5b64411827d967dfd6705cf1872e5b
 SHA512:
-  metadata.gz: 5333399d35149cd78f6fbb8a2c404a2535fcb75845a77b8352de6955bbbfe332ce429bc4ada5044c0ef8146e986e13385642c4cbbf09ec8c61f72c61ba926721
-  data.tar.gz: 5e90dbf790b43165c31efc5ae29094ae2af86e9ef5acfd3be0ba5a4a1d98fa215f62ddbeb570044375e84d68a196c3bd9945ef5f710034d309ef4ec4e0c26d19
+  metadata.gz: 4652bf11923b101cdbd09e61c6e3f45a01c9756d81a3816bbe7330fbee9a60d1dee4e0d4338dcbafe18ec51e314c947d6c548a6762ba7b5e7de40bea1ec1039e
+  data.tar.gz: 886b1e670a667bfb494d30535a5e275f8c3dedcd892be3d5c6edb7fad5c04b7fa7321052a6f10ca433c644dd73cb01b3bee3ab486cea238cf23847fdfcd23eb7

data/README.markdown

@@ -89,7 +89,16 @@ Create double:
 RestAssured::Double.create(fullpath: '/products', content: 'this is content')
 ```
 
-Now GET `http://localhost:4578/products` will be returning `this is content`.
+Alternatively using a regular expression for the path
+
+```ruby
+RestAssured::Double.create(pathpattern: /products\/[a-z]{10}\/?param=.*/, content: 'this is more content')
+```
+
+Now GET `http://localhost:4578/products` will be returning `this is content` and a GET to
+`http://localhost:4578/products/coolprod22?param=foo` will be returning `this is more content`.
+
+The pathpattern parameter must be a ruby Regexp object or a string containing a valid regular expression.
 
 You can also verify what requests happen on a double (spy on it). Say this is a Given part of a test:
 
@@ -146,14 +155,24 @@ For using REST-assured from non-ruby environments.
   Example:
 
 ```
-    $ curl -d 'fullpath=/api/something&content=awesome&response_headers%5BContent-Type%5D=text%2Fhtml' http://localhost:4578/doubles
+    $ curl -d 'fullpath=%2Fapi%2Fsomething%5C%3Fparam%3D.*&content=awesome&response_headers%5BContent-Type%5D=text%2Fhtml' http://localhost:4578/doubles
     {"double":{"active":true,"content":"awesome","description":null,"fullpath":"/api/something","id":1,"response_headers":{"Content-Type":"text/html"},"status":200,"verb":"GET"}}
 
     $ curl http://localhost:4578/api/something
     awesome
 ```
+  Example using a regular expression for the path:
+  ```
+      $ curl -d 'pathpattern=/api/something\?param=.*&content=awesome&response_headers%5BContent-Type%5D=text%2Fhtml' http://localhost:4578/doubles
+      {"double":{"active":true,"content":"awesome","description":null,"pathpattern":"/api/something\?param=.*","id":1,"response_headers":{"Content-Type":"text/html"},"status":200,"verb":"GET"}}
+
+      $ curl http://localhost:4578/api/something?param=foo
+      awesome
+  ```
 
-  If there is more than one double for the same fullpath and verb, the last created one gets served. In UI you can manually control which double is 'active' (gets served).
+  If there is more than one double for the same fullpath and verb, the last created one gets served.
+  Doubles with `fullpath`'s are served in preference to `pathpattern`'s.
+  In UI you can manually control which double is 'active' (gets served).
 
 #### Get double state
 
@@ -166,6 +185,7 @@ For using REST-assured from non-ruby environments.
         "double": {
             "verb": "GET",
             "fullpath": "/api/something",
+            "pathpattern" : null,
             "response_headers": {
                 "Content-Type": "text/html"
             },

data/db/migrate/20170818001158_add_pathpattern_to_doubles.rb

@@ -0,0 +1,9 @@
+class AddPathpatternToDoubles < ActiveRecord::Migration
+  def self.up
+    add_column :doubles, :pathpattern, :text
+  end
+
+  def self.down
+    remove_column :doubles, :text
+  end
+end

data/features/rest_api/doubles.feature

@@ -18,6 +18,15 @@ Feature: use doubles via api
       | /api/file          |              | HEAD   | HEAD        |        | 200           | 5     | 5            |
       | /api/file          |              | PATCH  | PATCH       |        | 200           | 6     | 6            |
 
+  Scenario Outline: create a double with a url pattern
+    When I create a double with "<pathpattern>" as pathpattern, "<content>" as response content, "<verb>" as request verb, status as "<status>" and delay as "<delay>"
+    Then there should be 1 double with "<pathpattern>" as pathpattern, "<content>" as response content, "<result_verb>" as request verb, status as "<result_status>" and delay as "<result_delay>"
+    Examples:
+      | pathpattern         | content | verb   | result_verb | status | result_status | delay | result_delay |
+      | ^\/api\/.*$         | created | POST   | POST        | 200    | 200           |       | 0            |
+      | ^.*\/\?nocache=\d+$ | changed | PUT    | PUT         | 201    | 201           | 0     | 0            |
+      | ^[a-zA-Z]\/123$     | removed | DELETE | DELETE      | 300    | 300           | 1     | 1            |
+
   Scenario: view created double details
     When I create a double
     Then I should be able to get json representation of that double from response
@@ -36,6 +45,17 @@ Feature: use doubles via api
       | /other/api         |              | GET    | 303    |
       | /patch/api         |              | PATCH  | 200    |
 
+  Scenario Outline: request a path that matches double a path pattern
+    Given there is double with "<pathpattern>" as pathpattern, "<content>" as response content, "<verb>" as request verb and "<status>" as status
+    When I "<verb>" "<fullpath>"
+    Then I should get "<status>" as response status and "<content>" in response content
+
+    Examples:
+      | pathpattern                   | fullpath            | content      | verb | status |
+      | ^.*$                          | /api/something      | created      | POST | 200    |
+      | ^/api/.*$                     | /api/sss            | changed      | PUT  | 201    |
+      | ^\/api\/some\?a=\d&b=[a-z]{2}$ | /api/some?a=3&b=dd | more content | GET  | 203    |
+
   # current rule: last added double gets picked
   Scenario Outline: request fullpath that matches multiple doubles
     Given there is double with "<fullpath>" as fullpath and "<content>" as response content
@@ -48,6 +68,30 @@ Feature: use doubles via api
       | /api/something     | test content | another content |
       | /api/some?a=3&b=dd | more content | some text       |
 
+  # current rule: full path matches over pattern
+  Scenario Outline: request fullpath that matches the full path of a double and a url pattern of another double
+    Given there is double with "<fullpath>" as fullpath and "<content>" as response content
+    Given there is double with "<pathpattern>" as pathpattern and "<content2>" as response content
+    When I "GET" "<fullpath>"
+    Then I should get "<content>" in response content
+
+    Examples:
+      | fullpath           | content      | pathpattern                  | content2     |
+      | /api/something     | test content | ^/api/.*$                    | more content |
+      | /api/some?a=3&b=dd | test content | ^\/api\/some?a=\d+&b=d[a-z]$ | more content |
+
+  # current rule: last added double gets picked
+  Scenario Outline: request full path that matches more than one path pattern
+    Given there is double with "<pathpattern>" as pathpattern and "<content>" as response content
+    Given there is double with "<pathpattern2>" as pathpattern and "<content2>" as response content
+    When I "GET" "<fullpath>"
+    Then I should get "<content2>" in response content
+
+    Examples:
+      | fullpath             | pathpattern                   | content      | pathpattern2                  | content2     |
+      | /api/sam             | ^.*$                          | test content | ^\/api\/.*$                   | more content |
+      | /api/some?a=123&b=dd | ^\/api\/some\?a=\d+&b=d[a-z]$ | test content | ^\/api\/some\?a=\d+&b=d[a-z]$ | more content |
+
   Scenario: request fullpath that does not match any double
     Given there are no doubles
     When I "GET" "/api/something"

data/features/ruby_api/create_double.feature

@@ -20,6 +20,22 @@ Feature: create double
     last_response.should be_ok
     """
 
+  Scenario: use a path pattern
+    When I create a double:
+    """
+    @double = RestAssured::Double.create(:pathpattern => /^\/some\/api\?nocache=\d+$/)
+    """
+    Then the following should be true:
+    """
+    @double.verb.should             == 'GET'
+    @double.response_headers.should == {}
+    @double.status.should           == 200
+    @double.content.should          == nil
+
+    get '/some/api?nocache=1234'
+    last_response.should be_ok
+    """
+
   Scenario: specify response headers
     When I create a double:
     """

data/features/step_definitions/doubles_steps.rb

@@ -9,6 +9,11 @@ When /^I create a double with "([^""]*)" as fullpath, "([^""]*)" as response con
   last_response.should be_ok
 end
 
+When /^I create a double with "([^""]*)" as pathpattern, "([^""]*)" as response content, "([^""]*)" as request verb, status as "([^""]*)" and delay as "([^""]*)"$/ do |pathpattern, content, verb, status, delay|
+  post '/doubles.json', { :pathpattern => pathpattern, :content => content, :verb => verb, :status => status, :delay => delay}
+  last_response.should be_ok
+end
+
 When /^I create a double$/ do
   post '/doubles.json', { :fullpath => '/api/something' }
   @create_a_double_response = last_response.body
@@ -27,14 +32,26 @@ Then /^there should be (#{CAPTURE_A_NUMBER}) double with "([^""]*)" as fullpath,
   RestAssured::Models::Double.where(:fullpath => fullpath, :content => content, :verb => verb, :status => status, :delay => delay).count.should == n
 end
 
+Then /^there should be (#{CAPTURE_A_NUMBER}) double with "([^""]*)" as pathpattern, "([^""]*)" as response content, "([^""]*)" as request verb, status as "(#{CAPTURE_A_NUMBER})" and delay as "(#{CAPTURE_A_NUMBER})"$/ do |n, pathpattern, content, verb, status, delay|
+  RestAssured::Models::Double.where(:pathpattern => pathpattern, :content => content, :verb => verb, :status => status, :delay => delay).count.should == n
+end
+
 Given /^there is double with "([^"]*)" as fullpath and "([^"]*)" as response content$/ do |fullpath, content|
   RestAssured::Models::Double.create(:fullpath => fullpath, :content => content)
 end
 
+Given /^there is double with "([^"]*)" as pathpattern and "([^"]*)" as response content$/ do |pathpattern, content|
+  RestAssured::Models::Double.create(:pathpattern => pathpattern, :content => content)
+end
+
 Given /^there is double with "([^"]*)" as fullpath, "([^"]*)" as response content, "([^"]*)" as request verb and "([^"]*)" as status$/ do |fullpath, content, verb, status|
   RestAssured::Models::Double.create(:fullpath => fullpath, :content => content, :verb => verb, :status => status)
 end
 
+Given /there is double with "([^"]*)" as pathpattern, "([^"]*)" as response content, "([^"]*)" as request verb and "([^"]*)" as status$/ do |pathpattern, content, verb, status|
+  RestAssured::Models::Double.create(:pathpattern => pathpattern, :content => content, :verb => verb, :status => status)
+end
+
 When /^I request "([^"]*)"$/ do |fullpath|
   get fullpath
 end
@@ -73,6 +90,7 @@ Given /^the following doubles exist:$/ do |doubles|
   doubles.hashes.each do |row|
     RestAssured::Models::Double.create(
       :fullpath    => row['fullpath'],
+      :pathpattern    => row['pathpattern'],
       :description => row['description'],
       :content     => row['content'],
       :verb        => row['verb'],
@@ -83,7 +101,8 @@ end
 
 Then /^I should see existing doubles:$/ do |doubles|
   doubles.hashes.each do |row|
-    page.should have_content(row[:fullpath])
+    page.should have_content(row[:fullpath]) unless row[:fullpath].blank?
+    page.should have_content(row[:pathpattern]) unless row[:pathpattern].blank?
     page.should have_content(row[:description])
     page.should have_content(row[:verb])
     page.should have_content(row[:status])
@@ -100,8 +119,8 @@ end
 
 When /^I enter double details:$/ do |details|
   double = details.hashes.first
-
   fill_in 'Request fullpath', :with => double['fullpath']
+  fill_in 'Request path pattern', :with => double['pathpattern']
   fill_in 'Content', :with => double['content']
   select  double['verb'], :from => 'Verb'
   fill_in 'Description', :with => double['description']

data/features/web_ui/doubles.feature

@@ -6,29 +6,43 @@ Feature: manage doubles via ui
 
   Scenario: view existing doubles
     Given the following doubles exist:
-      | fullpath  | description  | content      | verb | delay |
-      | /url1/aaa | twitter      | test content | GET  | 0     |
-      | /url2/bbb | geo location | more content | POST | 1     |
-      | /u/b?c=1  | wikipedia    | article      | PUT  | 2     |
+      | fullpath  | pathpattern             | description  | content         | verb | delay |
+      | /url1/aaa |                         | twitter      | test content    | GET  | 0     |
+      | /url2/bbb |                         | geo location | more content    | POST | 1     |
+      | /u/b?c=1  |                         | wikipedia    | article         | PUT  | 2     |
+      |           | ^/api/foo\?nocache=123$ | pattern      | pattern content | GET  | 0     |
     When I visit "doubles" page
     Then I should see existing doubles:
-      | fullpath  | description  | verb | delay |
-      | /url1/aaa | twitter      | GET  | 0     |
-      | /url2/bbb | geo location | POST | 1     |
-      | /u/b?c=1  | wikipedia    | PUT  | 2     |
+      | fullpath  | pathpattern             | description  | verb | delay |
+      | /url1/aaa |                         | twitter      | GET  | 0     |
+      | /url2/bbb |                         | geo location | POST | 1     |
+      | /u/b?c=1  |                         | wikipedia    | PUT  | 2     |
+      |           | ^/api/foo\?nocache=123$ | pattern      | GET  | 0     |
 
   Scenario: add new double
     Given I am on "doubles" page
     When I choose to create a double
     And I enter double details:
-      | fullpath      | description | content      | verb | status | delay |
-      | /url2/bb?a=b5 | google api  | test content | POST | 200    | 1     |
+      | fullpath      | pathpattern | description | content      | verb | status | delay |
+      | /url2/bb?a=b5 |             | google api  | test content | POST | 200    | 1     |
     And I save it
     Then I should see "Double created"
     And I should see existing doubles:
       | fullpath      | description | verb | status | delay |
       | /url2/bb?a=b5 | google api  | POST | 200    | 1     |
 
+  Scenario: add a new double with a path pattern
+    Given I am on "doubles" page
+    When I choose to create a double
+    And I enter double details:
+      | fullpath | pathpattern | description | content        | verb | status | delay |
+      |          | ^\/api\/.*$ | pattern api | test content 1 | GET  | 200    | 0     |
+    And I save it
+    Then I should see "Double created"
+    And I should see existing doubles:
+      | pathpattern | description | verb | status | delay |
+      | ^\/api\/.*$ | pattern api | GET  | 200    | 1     |
+
   @javascript
   Scenario: choose active double
     Given there are two doubles for the same fullpath

data/lib/rest-assured/models/double.rb

@@ -10,7 +10,8 @@ module RestAssured
       STATUSES = Net::HTTPResponse::CODE_TO_OBJ.keys.map(&:to_i)
       MAX_DELAY = 30
 
-      validates_presence_of :fullpath
+      validate :fullpath_or_pattern
+      validate :pattern_is_regex
       validates_inclusion_of :verb, :in => VERBS
       validates_inclusion_of :status, :in => STATUSES
 
@@ -18,6 +19,7 @@ module RestAssured
       after_initialize :set_verb
       after_initialize :set_response_headers
       after_initialize :set_delay
+      after_initialize :stringify_regexp
 
       before_save :toggle_active
       after_destroy :set_active
@@ -59,7 +61,29 @@ module RestAssured
             puts "delay #{self.delay} exceeds maxmium.  Defaulting to #{MAX_DELAY}"
             self.delay = MAX_DELAY
           end
+      end
+
+      def fullpath_or_pattern
+        unless self.fullpath.blank? ^ self.pathpattern.blank?
+          errors.add(:path, "Exactly one of fullpath or pathpattern must be present")
+        end
+      end
+
+      def pattern_is_regex
+        unless self.pathpattern.blank?
+          begin
+            Regexp.new(self.pathpattern)
+          rescue RegexpError
+            errors.add(:pathpattern, "not a valid regular expression")
+          end
+        end
+      end
+
+      def stringify_regexp
+        unless self.pathpattern.blank?
+          self.pathpattern = self.pathpattern.to_s
         end
+      end
     end
   end
 end

data/lib/rest-assured/routes/double.rb

@@ -51,7 +51,7 @@ module RestAssured
           end
         rescue
           d = params['double'] ||
-            params.slice(*%w[fullpath content description verb status response_headers delay])
+            params.slice(*%w[fullpath pathpattern content description verb status response_headers delay])
         end
 
         @double = Models::Double.create(d)

data/lib/rest-assured/routes/response.rb

@@ -3,10 +3,10 @@ module RestAssured
 
     def self.perform(app)
       request = app.request
-      if d = Models::Double.where(:fullpath => request.fullpath, :active => true, :verb => request.request_method).first
+      if d = find_matching_double(request.request_method, request.fullpath)
         return_double app, d
       elsif redirect_url = Models::Redirect.find_redirect_url_for(request.fullpath)
-        if d = Models::Double.where(:fullpath => redirect_url, :active => true, :verb => request.request_method).first
+        if d = find_matching_double(request.request_method, redirect_url)
           return_double app, d
         else
           app.redirect redirect_url
@@ -16,6 +16,13 @@ module RestAssured
       end
     end
 
+    def self.find_matching_double(method, fullpath)
+      active_doubles_for_verb = Models::Double.where(:active => true, :verb => method)
+
+      active_doubles_for_verb.select {|d| !d.fullpath.blank? && d.fullpath == fullpath}.sort_by { |d| d[:id] }.last ||
+          active_doubles_for_verb.select {|d| !d.pathpattern.blank? && Regexp.new(d.pathpattern).match(fullpath)}.sort_by { |d| d[:id] }.last
+    end
+
     def self.return_double(app, d)
       request = app.request
       request.body.rewind

data/lib/rest-assured/version.rb

@@ -1,3 +1,3 @@
 module RestAssured
-  VERSION = '2.1.0'
+  VERSION = '2.2.0'
 end

data/spec/functional/double_routes_spec.rb

@@ -75,7 +75,7 @@ module RestAssured
         post '/doubles', invalid_params
 
         expect(last_response).to be_ok
-        expect(last_response.body).to match(/Crumps!.*Fullpath can't be blank/)
+        expect(last_response.body).to match(/Crumps!.*Exactly one of fullpath or pathpattern must be present/)
       end
 
       it "renders double edit form" do
@@ -137,7 +137,7 @@ module RestAssured
         post '/doubles.json', test_double.except(:fullpath)
 
         expect(last_response).not_to be_ok
-        expect(last_response.body).to match(/\{"fullpath":\["can't be blank"\]\}/)
+        expect(last_response.body).to match(/[\"Exactly one of fullpath or pathpattern must be present\"]/)
       end
 
       it "deletes double" do
@@ -187,7 +187,7 @@ module RestAssured
         post '/doubles.json', test_double.except(:fullpath).to_json, 'CONTENT_TYPE' => 'Application/json'
 
         expect(last_response).not_to be_ok
-        expect(last_response.body).to match(/\{"fullpath":\["can't be blank"\]\}/)
+        expect(last_response.body).to match("{\"path\":[\"Exactly one of fullpath or pathpattern must be present\"]}")
       end
 
       it 'loads double as AR resource' do

data/spec/functional/response_spec.rb

@@ -11,30 +11,21 @@ module RestAssured
       end
     end
 
-    let(:env) { double(:to_json => 'env').as_null_object }
+    let(:env) {double(:to_json => 'env').as_null_object}
+
     let(:request) {
       double('Request',
-        :request_method => 'GET',
-        :fullpath       => '/api',
-        :env            => env,
-        :body           => double(:read    => 'body').as_null_object,
-        :params         => double(:to_json => 'params')
+             :request_method => 'GET',
+             :fullpath => '/api',
+             :env => env,
+             :body => double(:read => 'body').as_null_object,
+             :params => double(:to_json => 'params')
       )
     }
-    let(:rest_assured_app) { double('App', :request => request).as_null_object }
-
-    context 'when double matches request' do
-      before do
-        @double = Models::Double.create \
-          :fullpath         => '/some/path',
-          :content          => 'content',
-          :response_headers => { 'ACCEPT' => 'text/html' },
-          :status           => 201,
-          :delay          => 0
 
-        allow(request).to receive(:fullpath).and_return(@double.fullpath)
-      end
+    let(:rest_assured_app) {double('App', :request => request).as_null_object}
 
+    shared_examples "double_matches" do |path|
       it "returns double content" do
         expect(rest_assured_app).to receive(:body).with(@double.content)
 
@@ -55,17 +46,19 @@ module RestAssured
 
       it 'records request' do
         requests = double
-        allow(Models::Double).to receive_message_chain('where.first').and_return(double(:requests => requests, :delay => 0).as_null_object)
+        allow(Models::Double).to receive(:where).and_return(double(:requests => requests, :delay => 0).as_null_object)
 
         expect(requests).to receive(:create!).with(:rack_env => 'env', :body => 'body', :params => 'params')
 
         Response.perform(rest_assured_app)
       end
-    
+
       it "returns double when redirect matches double" do
         fullpath = '/some/other/path'
         allow(request).to receive(:fullpath).and_return(fullpath)
-        allow(Models::Redirect).to receive(:find_redirect_url_for).with(fullpath).and_return('/some/path')
+        allow(Models::Redirect).to receive(:find_redirect_url_for).with(fullpath).and_return(path)
+        puts "PATH"
+        puts path
 
         expect(rest_assured_app).to receive(:body).with(@double.content)
         expect(rest_assured_app).to receive(:status).with(@double.status)
@@ -73,7 +66,39 @@ module RestAssured
 
         Response.perform(rest_assured_app)
       end
+    end
+
+    context 'when double matches request' do
+      path = '/some/path'
+      before do
+        @double = Models::Double.create \
+          :fullpath => path,
+          :content => 'content',
+          :response_headers => {'ACCEPT' => 'text/html'},
+          :status => 201,
+          :delay => 0
+
+        allow(request).to receive(:fullpath).and_return(@double.fullpath)
+      end
+
+      include_examples "double_matches", path
+    end
+
+    context 'when double matches request pattern' do
+      path = '/api?someparam=something'
+
+      before do
+        @double = Models::Double.create \
+          :pathpattern => '\/api\?someparam=.*',
+          :content => 'content',
+          :response_headers => {'ACCEPT' => 'text/html'},
+          :status => 201,
+          :delay => 0
+
+        allow(request).to receive(:fullpath).and_return(path)
+      end
 
+      include_examples "double_matches", path
     end
 
     it "redirects if double not hit but there is redirect that matches request" do
@@ -97,7 +122,7 @@ module RestAssured
     # TODO change to instead exclude anything that does not respond_to?(:to_s)
     it 'excludes "rack.input" and "rack.errors" as they break with "IOError - not opened for reading:" on consequent #to_json (as they are IO and StringIO)' do
       requests = double.as_null_object
-      allow(Models::Double).to receive_message_chain('where.first').and_return(double(:requests => requests, :delay => 0).as_null_object)
+      allow(Models::Double).to  receive(:where).and_return(double(:requests => requests, :delay => 0).as_null_object)
 
       expect(env).to receive(:except).with('rack.input', 'rack.errors', 'rack.logger')
 
@@ -106,7 +131,7 @@ module RestAssured
 
     it 'it sleeps for delay seconds' do
       requests = double.as_null_object
-      allow(Models::Double).to receive_message_chain('where.first').and_return(double(:requests => requests, :delay => 10).as_null_object)
+      allow(Models::Double).to  receive(:where).and_return(double(:requests => requests, :delay => 10).as_null_object)
 
       Response.stub(:sleep)
       expect(Response).to receive(:sleep).with(10)

data/spec/models/double_spec.rb

@@ -13,17 +13,41 @@ module RestAssured::Models
       }
     end
 
-    it { is_expected.to validate_presence_of(:fullpath) }
+    let :valid_params_with_pattern do
+      valid_params.except(:fullpath).merge(:pathpattern => /^\/api\/.*\/[a-zA-Z]\?nocache=true/)
+    end
+
     it { is_expected.to validate_inclusion_of(:verb).in_array Double::VERBS }
     it { is_expected.to validate_inclusion_of(:status).in_array Double::STATUSES }
 
     it { is_expected.to have_many(:requests) }
 
+    it 'rejects double with neither fullpath or pathpattern' do
+      d = Double.new valid_params.except(:fullpath)
+      expect(d).to_not be_valid
+    end
+
+    it 'rejects double with both fullpath or pathpattern' do
+      d = Double.new valid_params.merge(valid_params_with_pattern)
+      expect(d).to_not be_valid
+    end
+
     it 'creates double with valid params' do
       d = Double.new valid_params
       expect(d).to be_valid
     end
 
+    it 'creates double with pathpattern' do
+      d = Double.new valid_params_with_pattern
+      expect(d).to be_valid
+    end
+
+    it 'rejects double with invalid pathpattern regex string' do
+      # Probably a common mistake - not escaping forward slashes
+      d = Double.new valid_params_with_pattern.merge(:pathpattern => '**')
+      expect(d).to_not be_valid
+    end
+
     it "defaults verb to GET" do
       f = Double.create valid_params.except(:verb)
       expect(f.verb).to eq('GET')

data/views/doubles/_form.haml

@@ -1,7 +1,11 @@
 %p
-  %label{:for => 'double_fullpath'} Request fullpath*
+  Specify either a fullpath or a path pattern
+  %label{:for => 'double_fullpath'} Request fullpath
   %input.wide#double_fullpath{:type => 'text', :name => 'double[fullpath]', :value => @double.fullpath}
 
+  %label{:for => 'double_pathpattern'} Request path pattern
+  %input.wide#double_pathpattern{:type => 'text', :name => 'double[pathpattern]', :value => @double.pathpattern}
+
 %p
   %label{:for => 'double_content'} Content
   %textarea.wide#double_content{:name => 'double[content]', :rows => 10}= @double.content

data/views/doubles/index.haml

@@ -4,6 +4,7 @@
   %thead
     %tr
       %th Request fullpath
+      %th Request path pattern
       %th Description
       %th Verb
       %th Status
@@ -11,7 +12,7 @@
       %th Active?
       %th  
   %tbody
-    - @doubles.group_by {|f| f.fullpath + f.verb }.each do |group, fs|
+    - @doubles.group_by {|f| (f.fullpath || f.pathpattern) + f.verb }.each do |group, fs|
       - fs.each_with_index do |f, i|
         %tr{:id => "double_row_#{f.id}"}
           - if i == 0
@@ -20,6 +21,7 @@
                 %a{:href => f.fullpath, :target => '_blank'}= f.fullpath
               - else
                 = f.fullpath
+          %td= f.pathpattern
           %td= f.description
           %td= f.verb
           %td= f.status

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rest-assured
 version: !ruby/object:Gem::Version
-  version: 2.1.0
+  version: 2.2.0
 platform: ruby
 authors:
 - Artem Avetisyan
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-08-17 00:00:00.000000000 Z
+date: 2017-08-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sinatra
@@ -134,6 +134,7 @@ files:
 - db/migrate/20111208155906_add_response_headers_to_doubles.rb
 - db/migrate/20120320200820_change_fullpath_to_text.rb
 - db/migrate/20170713000515_add_delay_to_doubles.rb
+- db/migrate/20170818001158_add_pathpattern_to_doubles.rb
 - db/test.db
 - features/command_line_options.feature
 - features/rest_api/doubles.feature