rest-assured 0.2.0.rc8 → 0.2.0

data/spec/functional/redirect_routes_spec.rb

@@ -1,108 +1,119 @@
 require File.expand_path('../../spec_helper', __FILE__)
 
-describe 'Redirects routes' do
-  let :redirect do
-    { :pattern => '/sdf.*', :to => 'http://google.com/api' }
-  end
+module RestAssured
+  describe 'Redirects routes' do
+    let :redirect do
+      { :pattern => '/sdf.*', :to => 'http://google.com/api' }
+    end
 
-  let :valid_params do
-    { 'redirect[pattern]' => redirect[:pattern], 'redirect[to]' => redirect[:to] }
-  end
+    let :valid_params do
+      { 'redirect[pattern]' => redirect[:pattern], 'redirect[to]' => redirect[:to] }
+    end
 
-  let :invalid_params do
-    { 'redirect[to]' => redirect[:to] }
-  end
+    let :invalid_params do
+      { 'redirect[to]' => redirect[:to] }
+    end
 
-  context 'via ui', :ui => true do
-    it 'shows list of redirects' do
-      r = Redirect.create redirect
+    context 'via ui', :ui => true do
+      it 'shows list of redirects' do
+        r = Models::Redirect.create redirect
 
-      visit '/redirects'
+        visit '/redirects'
 
-      page.should have_content(r.pattern)
-      page.should have_content(r.to)
-    end
+        page.should have_content(r.pattern)
+        page.should have_content(r.to)
+      end
 
-    it "shows form for creating new redirect" do
-      visit '/redirects/new'
+      it "shows form for creating new redirect" do
+        visit '/redirects/new'
 
-      page.should have_css('#redirect_pattern')
-      page.should have_css('#redirect_to')
-    end
+        page.should have_css('#redirect_pattern')
+        page.should have_css('#redirect_to')
+      end
 
-    it "creates redirect" do
-      post '/redirects', valid_params
-      follow_redirect!
+      it "creates redirect" do
+        post '/redirects', valid_params
+        follow_redirect!
 
-      last_request.fullpath.should == '/redirects'
-      last_response.body.should =~ /Redirect created/
-      Redirect.exists?(redirect).should be true
-    end
+        last_request.fullpath.should == '/redirects'
+        last_response.body.should =~ /Redirect created/
+        Models::Redirect.exists?(redirect).should be true
+      end
 
-    it "reports failure when creating with invalid parameters" do
-      post '/redirects', invalid_params
+      it "reports failure when creating with invalid parameters" do
+        post '/redirects', invalid_params
 
-      last_response.should be_ok
-      last_response.body.should =~ /Crumps!.*Pattern can't be blank/
-    end
+        last_response.should be_ok
+        last_response.body.should =~ /Crumps!.*Pattern can't be blank/
+      end
 
-    it "brings up redirect edit form" do
-      r = Redirect.create redirect
-      visit "/redirects/#{r.id}/edit"
+      it "brings up redirect edit form" do
+        r = Models::Redirect.create redirect
+        visit "/redirects/#{r.id}/edit"
 
-      find('#redirect_pattern').value.should == r.pattern
-      find('#redirect_to').value.should == r.to
-    end
+        find('#redirect_pattern').value.should == r.pattern
+        find('#redirect_to').value.should == r.to
+      end
 
-    it "updates redirect" do
-      r = Redirect.create redirect
+      it "updates redirect" do
+        r = Models::Redirect.create redirect
 
-      put "/redirects/#{r.id}", 'redirect[to]' => '/some/other/api'
-      follow_redirect!
+        put "/redirects/#{r.id}", 'redirect[to]' => '/some/other/api'
+        follow_redirect!
 
-      last_request.fullpath.should == '/redirects'
-      last_response.body.should =~ /Redirect updated/
-      r.reload.to.should == '/some/other/api'
-    end
+        last_request.fullpath.should == '/redirects'
+        last_response.body.should =~ /Redirect updated/
+        r.reload.to.should == '/some/other/api'
+      end
 
-    it "reorders redirects" do
-      r1 = Redirect.create! redirect
-      r2 = Redirect.create! redirect
+      it "reorders redirects" do
+        r1 = Models::Redirect.create! redirect
+        r2 = Models::Redirect.create! redirect
 
-      put "/redirects/reorder", :redirect => [r2.id, r1.id]
+        put "/redirects/reorder", :redirect => [r2.id, r1.id]
 
-      last_response.should be_ok
-      last_response.body.should == 'Changed'
-      r1.reload.position.should == 1
-      r2.reload.position.should == 0
-    end
+        last_response.should be_ok
+        last_response.body.should == 'Changed'
+        r1.reload.position.should == 1
+        r2.reload.position.should == 0
+      end
 
-    it "deletes redirect" do
-      f = Redirect.create redirect
+      it "deletes redirect" do
+        f = Models::Redirect.create redirect
 
-      delete "/redirects/#{f.id}"
-      follow_redirect!
+        delete "/redirects/#{f.id}"
+        follow_redirect!
 
-      last_response.should be_ok
-      last_response.body.should =~ /Redirect deleted/
+        last_response.should be_ok
+        last_response.body.should =~ /Redirect deleted/
 
-      Redirect.exists?(redirect).should be_false
+        Models::Redirect.exists?(redirect).should be_false
+      end
     end
-  end
 
-  context 'via api', :ui => false do
-    it "creates redirect" do
-      post '/redirects', redirect
+    context 'via api', :ui => false do
+      it "creates redirect" do
+        post '/redirects', redirect
 
-      last_response.should be_ok
-      Redirect.count.should == 1
-    end
+        last_response.should be_ok
+        Models::Redirect.count.should == 1
+      end
+
+      it "reports failure when creating with invalid parameters" do
+        post '/redirects', redirect.except(:pattern)
+
+        last_response.should_not be_ok
+        last_response.body.should =~ /Pattern can't be blank/
+      end
+
+      it "deletes all redirects" do
+        Models::Redirect.create redirect
 
-    it "reports failure when creating with invalid parameters" do
-      post '/redirects', redirect.except(:pattern)
+        delete '/redirects/all'
 
-      last_response.should_not be_ok
-      last_response.body.should =~ /Pattern can't be blank/
+        last_response.should be_ok
+        Models::Redirect.count.should == 0
+      end
     end
   end
 end

data/spec/functional/response_spec.rb

@@ -1,78 +1,80 @@
 require File.expand_path('../../spec_helper', __FILE__)
 require 'rest-assured/routes/response'
 
-describe Response do
-  [:get, :post, :put, :delete].each do |verb|
-    it "processes an unknown request" do
-
-      Response.should_receive(:perform).with(an_instance_of(RestAssured::Application))
-      send verb, '/some/path'
+module RestAssured
+  describe Response do
+    [:get, :post, :put, :delete].each do |verb|
+      it "processes an unknown request" do
+
+        Response.should_receive(:perform).with(an_instance_of(RestAssured::Application))
+        send verb, '/some/path'
+      end
     end
-  end
 
-  let(:env) { stub(:to_json => 'env').as_null_object }
-  let(:request) {
-    double('Request',
-           :request_method => 'GET',
-           :fullpath => '/api',
-           :env => env,
-           :body => stub(:read => 'body').as_null_object,
-           :params => stub(:to_json => 'params')
-          )
-  }
-  let(:rest_assured_app) { double('App', :request => request).as_null_object }
-
-  context 'when double matches request' do
-    before do
-      @double = Double.create :fullpath => '/some/path', :content => 'content', :status => 201
-      request.stub(:fullpath).and_return(@double.fullpath)
-    end
+    let(:env) { stub(:to_json => 'env').as_null_object }
+    let(:request) {
+      double('Request',
+             :request_method => 'GET',
+             :fullpath => '/api',
+             :env => env,
+             :body => stub(:read => 'body').as_null_object,
+             :params => stub(:to_json => 'params')
+            )
+    }
+    let(:rest_assured_app) { double('App', :request => request).as_null_object }
 
-    it "returns double content" do
-      rest_assured_app.should_receive(:body).with(@double.content)
+    context 'when double matches request' do
+      before do
+        @double = Models::Double.create :fullpath => '/some/path', :content => 'content', :status => 201
+        request.stub(:fullpath).and_return(@double.fullpath)
+      end
 
-      Response.perform(rest_assured_app)
-    end
+      it "returns double content" do
+        rest_assured_app.should_receive(:body).with(@double.content)
 
-    it 'sets response status to the one from double' do
-      rest_assured_app.should_receive(:status).with(@double.status)
+        Response.perform(rest_assured_app)
+      end
 
-      Response.perform(rest_assured_app)
+      it 'sets response status to the one from double' do
+        rest_assured_app.should_receive(:status).with(@double.status)
+
+        Response.perform(rest_assured_app)
+      end
+
+      it 'records request' do
+        requests = double
+        Models::Double.stub_chain('where.first').and_return(double(:requests => requests).as_null_object)
+
+        requests.should_receive(:create!).with(:rack_env => 'env', :body => 'body', :params => 'params')
+
+        Response.perform(rest_assured_app)
+      end
     end
 
-    it 'records request' do
-      requests = double
-      Double.stub_chain('where.first').and_return(double(:requests => requests).as_null_object)
+    it "redirects if double not hit but there is redirect that matches request" do
+      r = Models::Redirect.create :to => 'http://exmple.com/api', :pattern => '.*'
+      fullpath = '/some/other/path'
+      request.stub(:fullpath).and_return(fullpath)
 
-      requests.should_receive(:create!).with(:rack_env => 'env', :body => 'body', :params => 'params')
+      rest_assured_app.should_receive(:redirect).with(r.to + fullpath)
 
       Response.perform(rest_assured_app)
     end
-  end
 
-  it "redirects if double not hit but there is redirect that matches request" do
-    r = Redirect.create :to => 'http://exmple.com/api', :pattern => '.*'
-    fullpath = '/some/other/path'
-    request.stub(:fullpath).and_return(fullpath)
+    it "returns 404 if neither double nor redirect matches the request" do
+      rest_assured_app.should_receive(:status).with(404)
 
-    rest_assured_app.should_receive(:redirect).with(r.to + fullpath)
+      Response.perform(rest_assured_app)
+    end
 
-    Response.perform(rest_assured_app)
-  end
+    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
+      Models::Double.stub_chain('where.first').and_return(double(:requests => requests).as_null_object)
 
-  it "returns 404 if neither double nor redirect matches the request" do
-    rest_assured_app.should_receive(:status).with(404)
-    
-    Response.perform(rest_assured_app)
-  end
+      env.should_receive(:except).with('rack.input', 'rack.errors', 'rack.logger')
 
-  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
-    Double.stub_chain('where.first').and_return(double(:requests => requests).as_null_object)
-
-    env.should_receive(:except).with('rack.input', 'rack.errors', 'rack.logger')
+      Response.perform(rest_assured_app)
+    end
 
-    Response.perform(rest_assured_app)
   end
-
 end

data/spec/models/double_spec.rb

@@ -1,90 +1,92 @@
 require File.expand_path('../../spec_helper', __FILE__)
 
-describe Double do
-  let :valid_params do
-    { :fullpath => '/some/api', :content => 'some content', :verb => 'GET', :status => '303' }
-  end
-
-  it { should validate_presence_of(:fullpath) }
-  it { should validate_inclusion_of(:verb, Double::VERBS) }
-  it { should validate_inclusion_of(:status, Double::STATUSES) }
-  it { should allow_mass_assignment_of(:fullpath) }
-  it { should allow_mass_assignment_of(:content) }
-  it { should allow_mass_assignment_of(:verb) }
-  it { should allow_mass_assignment_of(:status) }
-
-  it { should have_many(:requests) }
-
-  it 'creates double with valid params' do
-    d = Double.new valid_params
-    d.should be_valid
-  end
+module RestAssured::Models
+  describe Double do
+    let :valid_params do
+      { :fullpath => '/some/api', :content => 'some content', :verb => 'GET', :status => '303' }
+    end
 
-  it "defaults verb to GET" do
-    f = Double.create valid_params.except(:verb)
-    f.verb.should == 'GET'
-  end
+    it { should validate_presence_of(:fullpath) }
+    it { should validate_inclusion_of(:verb, Double::VERBS) }
+    it { should validate_inclusion_of(:status, Double::STATUSES) }
+    it { should allow_mass_assignment_of(:fullpath) }
+    it { should allow_mass_assignment_of(:content) }
+    it { should allow_mass_assignment_of(:verb) }
+    it { should allow_mass_assignment_of(:status) }
 
-  it "defaults status to 200" do
-    f = Double.create valid_params.except(:status)
-    f.status.should == 200
-  end
+    it { should have_many(:requests) }
 
-  it "makes double active by default" do
-    f = Double.create valid_params.except(:active)
-    f.active.should be true
-  end
+    it 'creates double with valid params' do
+      d = Double.new valid_params
+      d.should be_valid
+    end
 
-  describe 'when created' do
-    it "toggles active double for the same fullpath" do
-      f1 = Double.create valid_params
-      f2 = Double.create valid_params
-      f3 = Double.create valid_params.merge(:fullpath => '/some/other/api')
+    it "defaults verb to GET" do
+      f = Double.create valid_params.except(:verb)
+      f.verb.should == 'GET'
+    end
 
-      f1.reload.active.should be false
-      f2.reload.active.should be true
-      f3.reload.active.should be true
+    it "defaults status to 200" do
+      f = Double.create valid_params.except(:status)
+      f.status.should == 200
     end
-  end
 
-  describe 'when saved' do
-    it "toggles active double for the same fullpath" do
-      f1 = Double.create valid_params
-      f2 = Double.create valid_params
-      f3 = Double.create valid_params.merge(:fullpath => '/some/other/api')
+    it "makes double active by default" do
+      f = Double.create valid_params.except(:active)
+      f.active.should be true
+    end
 
-      f1.active = true
-      f1.save
+    describe 'when created' do
+      it "toggles active double for the same fullpath" do
+        f1 = Double.create valid_params
+        f2 = Double.create valid_params
+        f3 = Double.create valid_params.merge(:fullpath => '/some/other/api')
 
-      f2.reload.active.should be false
-      f3.reload.active.should be true
+        f1.reload.active.should be false
+        f2.reload.active.should be true
+        f3.reload.active.should be true
+      end
     end
 
-    it "makes other doubles inactive only when active bit set to true" do
-      f1 = Double.create valid_params
-      f2 = Double.create valid_params
-      f3 = Double.create valid_params.merge(:fullpath => '/some/other/api')
+    describe 'when saved' do
+      it "toggles active double for the same fullpath" do
+        f1 = Double.create valid_params
+        f2 = Double.create valid_params
+        f3 = Double.create valid_params.merge(:fullpath => '/some/other/api')
 
-      f1.reload.save
-      f2.reload.save
+        f1.active = true
+        f1.save
 
-      f1.reload.active.should be false
-      f2.reload.active.should be true
-      f3.reload.active.should be true
-    end
-  end
+        f2.reload.active.should be false
+        f3.reload.active.should be true
+      end
 
-  describe 'when destroying' do
-    context 'active double' do
-      it "makes another double for the same fullpath active" do
+      it "makes other doubles inactive only when active bit set to true" do
         f1 = Double.create valid_params
         f2 = Double.create valid_params
         f3 = Double.create valid_params.merge(:fullpath => '/some/other/api')
 
-        f2.destroy
-        f1.reload.active.should be true
+        f1.reload.save
+        f2.reload.save
+
+        f1.reload.active.should be false
+        f2.reload.active.should be true
         f3.reload.active.should be true
       end
     end
+
+    describe 'when destroying' do
+      context 'active double' do
+        it "makes another double for the same fullpath active" do
+          f1 = Double.create valid_params
+          f2 = Double.create valid_params
+          f3 = Double.create valid_params.merge(:fullpath => '/some/other/api')
+
+          f2.destroy
+          f1.reload.active.should be true
+          f3.reload.active.should be true
+        end
+      end
+    end
   end
 end