rest-assured 2.0.0 → 2.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a4be619d9752d4b3fc3ef2f4755c2f1de691d83b
-  data.tar.gz: c289e34540a93ae862f2bd2087f495d4ae993968
+  metadata.gz: 320425382c9e1d8d34f2a6d6daa53bf7e6af42f6
+  data.tar.gz: 5e9c14601074ee5b5ee589617b9d2e0be387fe9a
 SHA512:
-  metadata.gz: 0df823b94ad412f0c966155ef635fc19121a64d5b673f4b79c48459fd4c178a986b5ad274f2c932576df2b952ec4731168bf904b321282a1135416550c4d5434
-  data.tar.gz: 9c4289f4b76be49c696b84ccc263a00375e118177f02368b69c86f8b9a702644ea30bb107cda78bb5a7d936963cd8eb441787e0a2c3d58c968696f4cc78f3be4
+  metadata.gz: 805ce441b6dc113fe988e691533ecce3609798163e60875eeeb1c1640ecc0bc60ead758129a7dcec17012a3b3caab7623bf01d6af8a1893a88ca664fa74c5eaf
+  data.tar.gz: 1640ad76091994a6ff2794f5df9394a88158aaad556551da207ae2085b04bbd9d11ab8d44ea820707ae6c977f957d526b5f59df456138c5e2a960d1ff127de81

data/CHANGELOG

@@ -1,3 +1,7 @@
+2.0.1 (9 May 2015)
+
+- update dependencies
+
 2.0.0 (1 Feb 2014)
 
 - discontinue ruby 1.8.7 support

data/README.markdown

@@ -2,29 +2,31 @@
 
 [![Build status](https://secure.travis-ci.org/artemave/REST-assured.png)](https://travis-ci.org/artemave/REST-assured)
 [![Gem Version](https://badge.fury.io/rb/rest-assured.png)](http://badge.fury.io/rb/rest-assured)
-[![Bitdeli Badge](https://d2weczhvl823v0.cloudfront.net/artemave/rest-assured/trend.png)](https://bitdeli.com/free "Bitdeli Badge")
 
 ## Overview
 
 Stub/spy http(s) based external dependencies in your integration/acceptance tests.
 
+## Description
+
 In a nutshell, you can:
 
 * replace external data sources with predefined data (stubbing)
 * verify requests to external services (spying)
 * simulate different behavior of external services using web UI; useful in development
 
-Here is how it works. REST-assured starts a web server whose routes can be configured at runtime (via ruby client library or REST api) to respond to any request with arbitrary content, status, headers, etc. Configure api endpoints of the application under test to point to REST-assured instead of real services. Now in tests use the REST-assured api to create routes (doubles) that match requests your application is firing. Either to stub content or to verify various aspects of how your application requests dependencies (headers, payload, etc).
+REST-assured runs in a standalone process. It can be configured at runtime (via ruby client library or REST api) to respond to any request with arbitrary content, status, headers, etc.
+
+The idea is that in "test" environment your app is making calls to REST-assured rather than to real external services.
 
-<br>
-[Playground](http://rest-assured.herokuapp.com) (might take few seconds to load while heroku is taking off)
+[Playground](http://fakesh.it/)
 
 [Example project](https://github.com/artemave/REST-assured-example)
 
 
 ## Set up
 
-You are going to need ruby >= 1.8.7 on Linux/MacOS. Also, one of sqlite3, postgres or mysql.
+You are going to need ruby >= 1.9.2 on Linux/MacOS. Also, one of sqlite3, postgres or mysql.
 
 ### In ruby project
 
@@ -65,24 +67,15 @@ This starts up an instance of rest-assured on port 4578. It is accessible via RE
 
 Various options (such as ssl, port, db credentials, etc.) are available through command line options. Check out `rest-assured -h` to see what they are.
 
-You can also deploy it to heroku:
-
-    $ git clone git://github.com/artemave/REST-assured.git
-    $ cd REST-assured
-
-    $ gem install heroku
-    $ heroku login # assuming you already have an account
-    $ heroku create --stack cedar
-    
-    $ git push heroku master
+You can also [![Deploy](https://www.herokucdn.com/deploy/button.png)](https://heroku.com/deploy)
 
 ## Usage
 
-REST-assured is all about doubles. Double is a stub/spy of HTTP request. Create one that has the same request fullpath and method as the one your app is sending to a service it depends on (e.g. twitter) and then convience your app that REST-assured is that dependency (e.g. by swapping endpoints - twitter.com to localhost:4578 - in test environment).
+REST-assured can do two things: respond to a particular path and method (e.g. GET /stuff/v2?thing=1) and redirect requests based on a pattern (e.g. all /foo\* will redirect to http://example.com/bar). Both of these are available to create/read/delete in runtime via api.
 
-### Ruby Client
+### Ruby API
 
-REST-assured provides client library to work with doubles. Check out 'Ruby API' section in [live documentation](https://www.relishapp.com/artemave/rest-assured) for full reference.
+REST-assured provides ruby client library to work with doubles (but not redirects). Check out 'Ruby API' section in [live documentation](https://www.relishapp.com/artemave/rest-assured) for full reference.
 
 Create double:
 
@@ -121,7 +114,7 @@ RestClient.delete "#{RestAssured::Server.address}/doubles/all"
 
 ### REST API
 
-For those using REST-assured from non-ruby environments.
+For using REST-assured from non-ruby environments.
 
 #### Create double
 

data/features/ruby_api/test_server.feature

@@ -12,7 +12,7 @@ Feature: test server
     """
     Then rest-assured server should be running:
     """
-    RestAssured::Server.should be_up
+    expect(RestAssured::Server.up?).to eq true
     """
 
   Scenario: start asyncronously (so that other heavy setup - e.g. firefox startup - can be done in parallel)
@@ -23,12 +23,12 @@ Feature: test server
     """
     Then rest-assured server should not be running:
     """
-    RestAssured::Server.should_not be_up
+    expect(RestAssured::Server.up?).to eq false
     """
     When it finally comes up
     Then rest-assured server should be running:
     """
-    RestAssured::Server.should be_up
+    expect(RestAssured::Server.up?).to eq true
     """
 
   Scenario: stop rest-assured server
@@ -39,5 +39,5 @@ Feature: test server
     """
     Then it should be stopped:
     """
-    RestAssured::Server.should_not be_up
+    expect(RestAssured::Server.up?).to eq false
     """

data/features/step_definitions/command_line_options_steps.rb

@@ -21,7 +21,7 @@ Then /^database options should be:$/ do |table|
   empty_to_nil = lambda do |string|
     string.try(:empty?) ? nil : string
   end
-  
+
   @app_config[:db_config][:adapter].should  == res['adapter']
   @app_config[:db_config][:database].should == res['dbname']
   @app_config[:db_config][:username].should == res['dbuser']

data/features/step_definitions/doubles_steps.rb

@@ -16,7 +16,7 @@ end
 
 Then /^I should be able to get json representation of that double from response$/ do
   d = RestAssured::Models::Double.last
-  MultiJson.load( @create_a_double_response ).should == MultiJson.load( d.to_json )
+  JSON.load( @create_a_double_response ).should == MultiJson.load( d.to_json )
 end
 
 Then /^I should get (#{CAPTURE_A_NUMBER}) in response status$/ do |status|

data/features/support/env.rb

@@ -33,19 +33,19 @@ end
 World(Capybara, Rack::Test::Methods, RackHeaderHack, WorldHelpers, Anticipate)
 
 require 'rest-assured/config'
-db_opts = { :adapter => 'mysql' }
+db_opts = { :adapter => 'postgresql' }
 RestAssured::Config.build(db_opts)
 
 require 'rest-assured'
 require 'shoulda-matchers'
 
-RestAssured::Server.start(db_opts.merge(:port => 9876))
+RestAssured::Server.start(db_opts.merge(:port => 19876))
 
 Before "@api_server" do
   RestAssured::Server.stop
 end
 After "@api_server" do
-  RestAssured::Server.start(db_opts.merge(:port => 9876))
+  RestAssured::Server.start(db_opts.merge(:port => 19876))
 end
 
 require 'rest-assured/application'

data/features/support/world_helpers.rb

@@ -6,9 +6,8 @@ module WorldHelpers
     rest_assured_exec = File.expand_path '../../../bin/rest-assured', __FILE__
     code = File.read rest_assured_exec
 
-    code.sub!(/(.*)/, "\\1\nENV['RACK_ENV'] = 'production'")
     code.sub!(/require 'rest-assured\/application'/, '')
-    code.sub!(/RestAssured::Application.run!.*/m, 'puts AppConfig.to_yaml')
+    code.sub!(/RestAssured::Application.run!.*/m, 'require "yaml"; puts AppConfig.to_yaml')
 
     new_exec = "#{rest_assured_exec}_temp"
     File.open(new_exec, 'w') do |file|
@@ -17,12 +16,7 @@ module WorldHelpers
 
     `chmod +x #{new_exec}`
 
-    # this is 1.9.X version. So much more useful than 1.8 (uncommented). Sigh...
-    #config_yaml, stderr_str, status = Open3.capture3({'RACK_ENV' => 'production'}, new_exec, *options.split(' '))
-    config_yaml = nil
-    Open3.popen3(new_exec, *options.split(' ')) do |stdin, stdout, stderr|
-      config_yaml = stdout.read
-    end
+    config_yaml, _, _ = Open3.capture3({'RACK_ENV' => 'production'}, new_exec, *options.split(' '))
 
     `rm #{new_exec}`
 

data/lib/rest-assured/api/app_session.rb

@@ -3,11 +3,16 @@ require 'childprocess'
 module RestAssured
   class AppSession
     def initialize
-      @child = ChildProcess.build('rest-assured', *Config.to_cmdargs)
+      @child = ChildProcess.build('bin/rest-assured', *Config.to_cmdargs)
+      @child.cwd = File.expand_path '../../../..', __FILE__
       @child.io.inherit!
       @child.start
     end
 
+    def stop
+      @child.stop while @child.alive?
+    end
+
     def method_missing(*args)
       @child.send(*args)
     end

data/lib/rest-assured/api/server.rb

@@ -11,8 +11,6 @@ module RestAssured
     include Singleton
 
     at_exit do
-      # I don't know why, but without this puts() at_exit is triggered on Ctrl-C when running in spork
-      puts ''
       instance.stop if instance
     end
 
@@ -39,21 +37,11 @@ module RestAssured
     end
 
     def stop
-      @session.try(:stop)
-
-      10.times do
-        if up?
-          sleep 0.5
-          next
-        else
-          return
-        end
-      end
-      raise "Failed to stop RestAssured server"
+      @session.try :stop
     end
 
     def up?
-      !!@session && @session.alive? && !Utils::PortExplorer.port_free?(AppConfig.port) 
+      !!@session && @session.alive? && !Utils::PortExplorer.port_free?(AppConfig.port)
     end
 
     def self.method_missing(*args)

data/lib/rest-assured/config.rb

@@ -103,9 +103,15 @@ module RestAssured
 
       def self.migrate_db
         migrate = lambda { ActiveRecord::Migrator.migrate(File.expand_path('../../../db/migrate', __FILE__)) }
+        silence_stdout = lambda do |&thing|
+          original_stdout = $stdout
+          $stdout = File.open(File::NULL, "w")
+          thing.call
+          $stdout = original_stdout
+        end
 
-        if AppConfig[:environment] == 'production' && Kernel.respond_to?(:silence)
-          silence(:stdout, &migrate)
+        if AppConfig[:environment] == 'production'
+          silence_stdout.call(&migrate)
         else
           migrate.call
         end
@@ -135,7 +141,8 @@ module RestAssured
                                 opts = {
                                   :adapter  => 'postgresql',
                                   :username => AppConfig.user || 'root',
-                                  :database => AppConfig.database || default_database
+                                  :database => AppConfig.database || default_database,
+                                  :pool     => 20
                                 }
                                 if adapter =~ /mysql/
                                   adapter = RUBY_PLATFORM == "java" ? 'jdbcmysql' : 'mysql2'

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

@@ -3,8 +3,6 @@ require 'net/http'
 module RestAssured
   module Models
     class Double < ActiveRecord::Base
-      attr_accessible :fullpath, :content, :description, :verb, :status, :response_headers
-
       serialize :response_headers, Hash
 
       VERBS = %w{GET POST PUT DELETE HEAD PATCH}

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

@@ -1,11 +1,9 @@
 module RestAssured
   module Models
     class Redirect < ActiveRecord::Base
-      attr_accessible :pattern, :to, :position
-
       validates_presence_of :pattern, :to
 
-      scope :ordered, order('position')
+      scope :ordered, -> { order('position') }
 
       before_create :assign_position
 

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

@@ -43,7 +43,7 @@ module RestAssured
       router.post /^\/doubles(\.json)?$/ do |needs_json|
         begin
           data = request.body.read
-          d = MultiJson.load(data)['double']
+          d = JSON.load(data)
 
           # fix acitve resource dumbness
           if d['response_headers'] and d['response_headers']['response_headers']
@@ -54,7 +54,7 @@ module RestAssured
             params.slice(*%w[fullpath content description verb status response_headers])
         end
 
-        @double = Models::Double.create(d) 
+        @double = Models::Double.create(d)
 
         if needs_json
           if @double.errors.present?

data/lib/rest-assured/version.rb

@@ -1,3 +1,3 @@
 module RestAssured
-  VERSION = '2.0.0'
+  VERSION = '2.0.1'
 end

data/spec/api/app_session_spec.rb

@@ -4,17 +4,23 @@ require File.expand_path('../../../lib/rest-assured/api/app_session', __FILE__)
 
 module RestAssured
   describe AppSession do
+    let(:child) do
+      double(io: double, :cwd= => double)
+    end
+
     it 'starts application in childprocess' do
       cmdargs = %w{-d :memory: -p 6666}
-      Config.stub(:to_cmdargs => cmdargs)
+      allow(Config).to receive_messages(:to_cmdargs => cmdargs)
+
+      expect(ChildProcess).to receive(:build).with('bin/rest-assured', *cmdargs).and_return(child)
 
-      ChildProcess.should_receive(:build).with('rest-assured', *cmdargs).and_return(child = double(:io => double))
+      expect(child).to receive(:cwd=)
 
       state = ''
-      child.io.should_receive(:inherit!) do
-        state.should_not == 'started'
+      expect(child.io).to receive(:inherit!) do
+        expect(state).not_to eq('started')
       end
-      child.should_receive(:start) do
+      expect(child).to receive(:start) do
         state << 'started'
       end
 

data/spec/api/resource_double_spec.rb

@@ -6,24 +6,25 @@ module RestAssured
     before(:all) do
       Server.start(DB_OPTS.merge(:port => 9877))
     end
+
     after(:all) do
       Server.stop
     end
 
-    it { should be_kind_of ActiveResource::Base }
+    it { is_expected.to be_kind_of ActiveResource::Base }
 
     it 'creates new double' do
-      d = Double.create :fullpath => '/some/api', :content => 'content'
-      Models::Double.where(:fullpath => d.fullpath, :content => d.content).should exist
+      d = Models::Double.create! :fullpath => '/some/api', :content => 'content'
+      expect(Models::Double.where(:fullpath => d.fullpath, :content => d.content)).to exist
     end
 
     it 'finds exising double' do
-      d = Models::Double.create :fullpath => '/some/api', :content => 'content'
+      d = Models::Double.create! :fullpath => '/some/api', :content => 'content'
 
       dd = Double.find(d.id)
 
-      dd.fullpath.should == d.fullpath
-      dd.content.should == d.content
+      expect(dd.fullpath).to eq(d.fullpath)
+      expect(dd.content).to eq(d.content)
     end
 
     it 'shows request history' do
@@ -32,10 +33,10 @@ module RestAssured
       d.requests << Models::Request.create(:rack_env => 'different rack_env', :body => 'other body', :params => 'more params')
 
       dd = Double.find(d.id)
-      dd.requests.size.should == 2
-      dd.requests.first.rack_env.should == 'rack_env json'
-      dd.requests.first.params.should == 'params'
-      dd.requests.last.body.should == 'other body'
+      expect(dd.requests.size).to eq(2)
+      expect(dd.requests.first.rack_env).to eq('rack_env json')
+      expect(dd.requests.first.params).to eq('params')
+      expect(dd.requests.last.body).to eq('other body')
     end
 
     context 'when waits requests' do
@@ -56,13 +57,13 @@ module RestAssured
 
         dd.wait_for_requests(2)
 
-        dd.requests.count.should >= 2
+        expect(dd.requests.count).to be >= 2
       end
 
       it 'raises exception if requests have not happened within timeout' do
         d = Models::Double.create :fullpath => '/some/api', :content => 'content'
         dd = Double.find(d.id)
-        dd.stub(:sleep)
+        allow(dd).to receive(:sleep)
 
         @t = Thread.new do
           2.times do
@@ -71,7 +72,7 @@ module RestAssured
         end
 
         sleep 0.5
-        lambda { dd.wait_for_requests(3) }.should raise_error(MoreRequestsExpected, 'Expected 3 requests. Got 2.')
+        expect { dd.wait_for_requests(3) }.to raise_error(MoreRequestsExpected, 'Expected 3 requests. Got 2.')
       end
     end
   end

data/spec/api/server_spec.rb

@@ -3,95 +3,91 @@ require File.expand_path('../../../lib/rest-assured/api/server', __FILE__)
 
 module RestAssured
   describe Server do
-    around do |example|
-      Server.reset_instance
-      example.run
-      Server.reset_instance
+    before do
+      allow(AppSession).to receive(:new).and_return(session)
     end
 
+    after do
+      Singleton.__init__(Server)
+    end
+
+    let (:session) { double.as_null_object }
+
     it 'khows when it is up' do
-      AppSession.stub(:new).and_return(session = double(:alive? => true).as_null_object)
-      Utils::PortExplorer.stub(:port_free? => false)
+      allow(session).to receive(:alive?).and_return(true)
+      allow(Utils::PortExplorer).to receive(:port_free?).and_return(false)
 
       Server.start
-      Server.up?.should == true
+      expect(Server.up?).to eq true
     end
 
     context 'knows that it is NOT up' do
       it 'if it has not been started' do
-        Server.up?.should == false
+        expect(Server.up?).to eq false
       end
 
       it 'if it is starting at the moment' do
-        AppSession.stub(:new).and_return(session = double(:alive? => true).as_null_object)
-        Utils::PortExplorer.stub(:port_free? => true)
+        allow(session).to receive(:alive?).and_return(true)
+        allow(Utils::PortExplorer).to receive(:port_free?).and_return(true)
         Server.start!
 
-        Server.up?.should == false
+        expect(Server.up?).to eq false
       end
     end
 
     context 'when starts' do
       it 'makes sure no previous session is running' do
-        session = double.as_null_object
-        session.stub(:alive?).and_return(true, false)
-        Utils::PortExplorer.stub(:port_free? => false)
-        AppSession.stub(:new).and_return(session)
+        allow(session).to receive(:alive?).and_return(true, false)
+        allow(Utils::PortExplorer).to receive(:port_free?).and_return(false)
 
-        session.should_receive(:stop).once
+        expect(session).to receive(:stop).once
         Server.start!
         Server.start!
       end
 
       it 'builds application config' do
-        AppSession.stub(:new).as_null_object
-
         opts = { :port => 34545, :database => ':memory:' }
 
-        Config.should_receive(:build).with(opts)
+        expect(Config).to receive(:build).with(opts)
         Server.start!(opts)
       end
 
       context 'sets up server address' do
-        before do
-          AppSession.stub(:new).as_null_object
-        end
-
         it 'uses 127.0.0.1 as hostname' do
-          RestAssured::Double.should_receive(:site=).with(/127\.0\.0\.1/)
+          expect(RestAssured::Double).to receive(:site=).with(/127\.0\.0\.1/)
           Server.start!
-          Server.address.should =~ /127\.0\.0\.1/
+          expect(Server.address).to match(/127\.0\.0\.1/)
         end
 
         it 'uses port from config' do
-          RestAssured::Double.should_receive(:site=).with(/#{AppConfig.port}/)
+          expect(RestAssured::Double).to receive(:site=).with(/#{AppConfig.port}/)
             Server.start!
-          Server.address.should =~ /#{AppConfig.port}/
+          expect(Server.address).to match(/#{AppConfig.port}/)
         end
 
         it 'uses http by default' do
-          RestAssured::Double.should_receive(:site=).with(/http[^s]/)
+          expect(RestAssured::Double).to receive(:site=).with(/http[^s]/)
           Server.start!
-          Server.address.should =~ /http[^s]/
+          expect(Server.address).to match(/http[^s]/)
         end
 
         it 'uses https if ssl is set in config' do
           AppConfig.ssl = true
-          RestAssured::Double.should_receive(:site=).with(/https/)
+          expect(RestAssured::Double).to receive(:site=).with(/https/)
           Server.start!
-          Server.address.should =~ /https/
+          expect(Server.address).to match(/https/)
         end
       end
 
       describe 'async/sync start' do
         before do
-          AppSession.stub(:new).and_return(session = double(:alive? => false).as_null_object)
-          Utils::PortExplorer.stub(:port_free? => true)
+          allow(session).to receive(:alive?).and_return(false)
+          allow(Utils::PortExplorer).to receive(:port_free?).and_return(true)
 
           @t = Thread.new do
             sleep 0.5
-            session.stub(:alive?).and_return(true)
-            Utils::PortExplorer.stub(:port_free? => false)
+            allow(session).to receive(:alive?).and_return(true)
+            allow(Utils::PortExplorer).to receive(:port_free?).and_return(false)
           end
         end
 
@@ -101,31 +97,30 @@ module RestAssured
 
         it 'does not wait for Application to come up' do
           Server.start!
-          Server.up?.should == false
+          expect(Server.up?).to eq false
         end
 
         it 'can wait until Application is up before passing control' do
           Server.start
-          Server.up?.should == true
+          expect(Server.up?).to eq true
         end
       end
     end
 
     context 'when stopped' do
       it 'stops application subprocess' do
-        AppSession.stub(:new).and_return(session = double(:alive? => false))
+        allow(session).to receive(:alive?).and_return(false)
         Server.start!
 
-        session.should_receive(:stop)
+        expect(session).to receive(:stop)
         Server.stop
       end
     end
 
     it 'stops application subprocess when current process exits' do
       res_file = Tempfile.new('res')
-      AppSession.stub(:new).and_return(session = double.as_null_object)
-      session.stub(:alive?).and_return(false)
-      session.stub(:stop) do
+      allow(session).to receive(:alive?).and_return(false)
+      allow(session).to receive(:stop) do
         res_file.write "stopped"
         res_file.rewind
       end
@@ -133,7 +128,7 @@ module RestAssured
         Server.start!
       end
       Process.wait
-      res_file.read.should == 'stopped'
+      expect(res_file.read).to eq 'stopped'
     end
   end
 end