remarkable_rails 3.1.9 → 3.1.10

data/spec/action_controller/redirect_to_matcher_spec.rb

@@ -1,102 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
-
-describe 'redirect_to' do
-  include FunctionalBuilder
-
-  describe 'messages' do
-    before(:each) do
-      build_response { redirect_to projects_url }
-      @matcher = redirect_to(project_tasks_url(1)).with(302)
-    end
-
-    it 'should contain a description message' do
-      @matcher = redirect_to(project_tasks_url(1))
-      @matcher.description.should == 'redirect to "http://test.host/projects/1/tasks"'
-
-      @matcher.with(301)
-      @matcher.description.should == 'redirect to "http://test.host/projects/1/tasks" with status 301'
-    end
-
-    it 'should set redirected? message' do
-      build_response
-      @matcher.matches?(@controller)
-      @matcher.failure_message.should == 'Expected redirect to "http://test.host/projects/1/tasks", got no redirect'
-    end
-
-    it 'should set status_matches? message' do
-      @matcher.with(200).matches?(@controller)
-      @matcher.failure_message.should == 'Expected redirect to "http://test.host/projects/1/tasks" with status 200, got status 302'
-    end
-
-    it 'should set url_matches? message' do
-      @matcher.matches?(@controller)
-      @matcher.failure_message.should == 'Expected redirect to "http://test.host/projects/1/tasks", got redirect to "http://test.host/projects"'
-    end
-  end
-
-  describe 'matcher' do
-
-    {
-      :hash => { :controller => 'tasks', :action => 'index', :project_id => 1 },
-      :url =>  'http://test.host/projects/1/tasks',
-      :path => '/projects/1/tasks'
-    }.each do |type, route|
-      describe "redirecting to an #{type}" do 
-        before(:each){ build_response { redirect_to route } }
-
-        it { should redirect_to(project_tasks_url(1)) }
-        it { should redirect_to(project_tasks_path(1)) }
-        it { should redirect_to(:controller => 'tasks', :action => 'index', :project_id => 1) }
-        it { should redirect_to(:controller => 'tasks', :action => 'index', :project_id => 1).with(302) }
-
-        it { should_not redirect_to(project_tasks_url(2)) }
-        it { should_not redirect_to(project_tasks_path(2)) }
-        it { should_not redirect_to(:controller => 'tasks', :action => 'index', :project_id => 2) }
-        it { should_not redirect_to(:controller => 'tasks', :action => 'index', :project_id => 1).with(301) }
-
-        it { response.should redirect_to(project_tasks_url(1)) }
-        it { response.should redirect_to(project_tasks_path(1)) }
-        it { response.should redirect_to(:controller => 'tasks', :action => 'index', :project_id => 1) }
-        it { response.should redirect_to(:controller => 'tasks', :action => 'index', :project_id => 1).with(302) }
-
-        it { response.should_not redirect_to(project_tasks_url(2)) }
-        it { response.should_not redirect_to(project_tasks_path(2)) }
-        it { response.should_not redirect_to(:controller => 'tasks', :action => 'index', :project_id => 2) }
-        it { response.should_not redirect_to(:controller => 'tasks', :action => 'index', :project_id => 1).with(301) }
-      end
-    end
-
-  end
-
-  describe 'macro' do
-
-    {
-      :hash => { :controller => 'tasks', :action => 'index', :project_id => 1 },
-      :url =>  'http://test.host/projects/1/tasks',
-      :path => '/projects/1/tasks'
-    }.each do |type, route|
-      describe "redirecting to an #{type}" do 
-        before(:each){ build_response { redirect_to route } }
-
-        should_redirect_to{ project_tasks_url(1) }
-        should_redirect_to{ project_tasks_path(1) }
-        should_redirect_to proc{ project_tasks_url(1) }
-        should_redirect_to proc{ project_tasks_path(1) }
-        should_redirect_to proc{ project_tasks_url(1) }, :with => 302
-        should_redirect_to proc{ project_tasks_path(1) }, :with => 302
-        should_redirect_to :controller => 'tasks', :action => 'index', :project_id => 1
-
-        should_not_redirect_to{ project_tasks_url(2) }
-        should_not_redirect_to{ project_tasks_path(2) }
-        should_not_redirect_to proc{ project_tasks_url(2) }
-        should_not_redirect_to proc{ project_tasks_path(2) }
-        should_not_redirect_to proc{ project_tasks_url(1) }, :with => 301
-        should_not_redirect_to proc{ project_tasks_path(1) }, :with => 301
-        should_not_redirect_to :controller => 'tasks', :action => 'index', :project_id => 2
-      end
-    end
-
-  end
-
-  generate_macro_stubs_specs_for(:redirect_to, 'http://google.com/')
-end

data/spec/action_controller/render_template_matcher_spec.rb

@@ -1,251 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
-
-describe 'render_template' do
-  include FunctionalBuilder
-
-  describe 'messages' do
-    before(:each) do
-      build_response { render :action => 'new' }
-      @matcher = render_template('edit')
-    end
-
-    it 'should contain a description message' do
-      @matcher.description.should == 'render template "edit"'
-
-      @matcher.layout('application')
-      @matcher.description.should == 'render template "edit" and with layout "application"'
-
-      @matcher.layout(nil)
-      @matcher.description.should == 'render template "edit" and with no layout'
-
-      @matcher.content_type(Mime::XML).matches?(@controller)
-      @matcher.description.should == 'render template "edit", with no layout, and with content type "application/xml"'
-    end
-
-    it 'should set rendered? message' do
-      build_response
-      @matcher.matches?(@controller)
-      @matcher.failure_message.should == 'Expected template "edit" to be rendered, got no render'
-      @matcher.negative_failure_message.should == 'Did not expect template "edit" to be rendered, got no render'
-    end
-
-    # Is not possible to check extensions on Rails 2.1
-    unless RAILS_VERSION =~ /^2.1/
-      it 'should set template_matches? message' do
-        @matcher.matches?(@controller)
-        @matcher.failure_message.should == 'Expected template "edit" to be rendered, got "examples/new.html.erb"'
-      end
-    end
-
-    it 'should set layout_matches? message' do
-      @matcher = render_template('new')
-      @matcher.layout('users').matches?(@controller)
-      @matcher.failure_message.should == 'Expected to render with layout "users", got nil'
-    end
-  end
-
-  describe 'matcher' do
-
-    [ :controller, :response ].each do |subject_name|
-      describe "with #{subject_name} subject" do
-
-        describe 'rendering a template' do
-          before(:each) do
-            build_response { render :action => :new }
-            @subject = instance_variable_get("@#{subject_name}")
-          end
-
-          it { @subject.should render_template('new') }
-          it { @subject.should render_template('new.html') }
-          it { @subject.should render_template('new.html.erb') }
-          it { @subject.should render_template('examples/new') }
-          it { @subject.should render_template('examples/new.html') }
-          it { @subject.should render_template('examples/new.html.erb') }
-
-          it { @subject.should_not render_template('edit') }
-          it { @subject.should_not render_template('projects/new') }
-          it { @subject.should_not render_template('examples/edit') }
-        end
-
-        describe 'rendering a template with path' do
-          before(:each) do
-            build_response { render :template => 'projects/new' }
-            @subject = instance_variable_get("@#{subject_name}")
-          end
-
-          it { @subject.should render_template('projects/new') }
-          it { @subject.should render_template('projects/new.html') }
-          it { @subject.should render_template('projects/new.html.erb') }
-
-          it { @subject.should_not render_template('new') }
-          it { @subject.should_not render_template('examples/new') }
-          it { @subject.should_not render_template('projects/edit') }
-        end
-
-        describe 'rendering a template with extention xml.builder' do
-          before(:each) do
-            build_response { respond_to{ |format| format.xml } }
-            @subject = instance_variable_get("@#{subject_name}")
-          end
-
-          it { @subject.should render_template('example') }
-          it { @subject.should render_template('example.xml') }
-          it { @subject.should render_template('example.xml.builder') }
-          it { @subject.should render_template('examples/example') }
-          it { @subject.should render_template('examples/example.xml') }
-          it { @subject.should render_template('examples/example.xml.builder') }
-
-          # Is not possible to check extensions on Rails 2.1
-          unless RAILS_VERSION =~ /^2.1/
-            it { @subject.should_not render_template('example.html') }
-            it { @subject.should_not render_template('example.html.erb') }
-            it { @subject.should_not render_template('example.html.builder') }
-            it { @subject.should_not render_template('examples/example.html') }
-            it { @subject.should_not render_template('examples/example.html') }
-            it { @subject.should_not render_template('examples/example.html.erb') }
-          end
-        end
-
-        describe 'rendering a partial' do
-          before(:each) do
-            build_response { render :partial => 'example' }
-            @subject = instance_variable_get("@#{subject_name}")
-          end
-
-          it { @subject.should render_template('_example') }
-          it { @subject.should render_template('_example.html') }
-          it { @subject.should render_template('_example.html.erb') }
-          it { @subject.should render_template('examples/_example') }
-          it { @subject.should render_template('examples/_example.html') }
-          it { @subject.should render_template('examples/_example.html.erb') }
-
-          it { @subject.should_not render_template('example') }
-          it { @subject.should_not render_template('example.html') }
-          it { @subject.should_not render_template('example.html.erb') }
-          it { @subject.should_not render_template('examples/example') }
-          it { @subject.should_not render_template('examples/example.html') }
-          it { @subject.should_not render_template('examples/example.html.erb') }
-        end
-
-      end
-    end
-
-    describe 'render_with_layout' do
-      before(:each){ build_response { render :layout => 'examples' } }
-
-      it { should render_with_layout('examples') }
-      it { should_not render_with_layout('users') }
-      it { should_not render_with_layout(nil) }
-      it { should_not render_without_layout }
-
-      it { should render_template.layout('examples') }
-      it { should_not render_template.layout('users') }
-      it { should_not render_template.layout(nil) }
-    end
-
-    describe 'render_without_layout' do
-      before(:each){ build_response }
-
-      it { should render_without_layout }
-      it { should_not render_with_layout('examples') }
-
-      it { should render_without_layout }
-      it { should_not render_with_layout('examples') }
-    end
-  end
-
-  describe 'macro' do
-
-    describe 'rendering a template' do
-      before(:each) { build_response { render :action => :new } }
-
-      should_render_template 'new'
-      should_render_template 'new.html'
-      should_render_template 'new.html.erb'
-      should_render_template 'examples/new'
-      should_render_template 'examples/new.html'
-      should_render_template 'examples/new.html.erb'
-
-      should_not_render_template 'edit'
-      should_not_render_template 'projects/new'
-      should_not_render_template 'examples/edit'
-    end
-
-    describe 'rendering a template with path' do
-      before(:each) { build_response { render :template => 'projects/new' } }
-
-      should_render_template 'projects/new'
-      should_render_template 'projects/new.html'
-      should_render_template 'projects/new.html.erb'
-
-      should_not_render_template 'new'
-      should_not_render_template 'examples/new'
-      should_not_render_template 'projects/edit'
-    end
-
-    describe 'rendering a template with extention xml.builder' do
-      before(:each) { build_response { respond_to{ |format| format.xml } } }
-
-      should_render_template 'example'
-      should_render_template 'example.xml'
-      should_render_template 'example.xml.builder'
-      should_render_template 'examples/example'
-      should_render_template 'examples/example.xml'
-      should_render_template 'examples/example.xml.builder'
-
-      # Is not possible to check extensions on Rails 2.1
-      unless RAILS_VERSION =~ /^2.1/
-        should_not_render_template 'example.html'
-        should_not_render_template 'example.html.erb'
-        should_not_render_template 'example.html.builder'
-        should_not_render_template 'examples/example.html'
-        should_not_render_template 'examples/example.html'
-        should_not_render_template 'examples/example.html.erb'
-      end
-    end
-
-    describe 'rendering a partial' do
-      before(:each) { build_response { render :partial => 'example' } }
-
-      should_render_template '_example'
-      should_render_template '_example.html'
-      should_render_template '_example.html.erb'
-      should_render_template 'examples/_example'
-      should_render_template 'examples/_example.html'
-      should_render_template 'examples/_example.html.erb'
-
-      should_not_render_template 'example'
-      should_not_render_template 'example.html'
-      should_not_render_template 'example.html.erb'
-      should_not_render_template 'examples/example'
-      should_not_render_template 'examples/example.html'
-      should_not_render_template 'examples/example.html.erb'
-    end
-
-    describe 'render_with_layout' do
-      before(:each){ build_response { render :layout => 'examples' } }
-
-      should_render_with_layout 'examples'
-      should_not_render_with_layout 'users'
-      should_not_render_with_layout nil
-
-      should_render_template :layout => 'examples'
-      should_not_render_template :layout => 'users'
-      should_not_render_template :layout => nil
-    end
-
-    describe 'render_without_layout' do
-      before(:each){ build_response }
-
-      should_render_without_layout
-      should_not_render_with_layout 'examples'
-
-      should_render_without_layout
-      should_not_render_with_layout 'examples'
-    end
-  end
-
-  generate_macro_stubs_specs_for(:render_template, 'new')
-  generate_macro_stubs_specs_for(:render_with_layout, 'examples')
-  generate_macro_stubs_specs_for(:render_without_layout)
-end

data/spec/action_controller/respond_with_matcher_spec.rb

@@ -1,230 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
-
-describe 'respond_with' do
-  include FunctionalBuilder
-
-  describe 'messages' do
-    before(:each) do
-      build_response
-      @matcher = respond_with(:error)
-    end
-
-    it 'should contain a description message' do
-      respond_with(404).description.should == 'respond with 404'
-      respond_with(:error).description.should == 'respond with error'
-      respond_with(500..599).description.should == 'respond with 500..599'
-
-      @matcher.body(/anything/)
-      @matcher.description.should == 'respond with error and with body /anything/'
-
-      @matcher.content_type(Mime::XML).matches?(@controller)
-      @matcher.description.should == 'respond with error, with body /anything/, and with content type "application/xml"'
-    end
-
-    it 'should set status_matches? message' do
-      @matcher.matches?(@controller)
-      @matcher.failure_message.should == 'Expected to respond with status :error, got 200'
-    end
-
-    it 'should set content_type_matches? message' do
-      @matcher = respond_with(:success)
-      @matcher.body(/anything/).matches?(@controller)
-      @matcher.failure_message.should == 'Expected to respond with body /anything/, got " "'
-    end
-
-    it 'should set content_type_matches? message' do
-      @matcher = respond_with(:success)
-      @matcher.content_type(Mime::XML).matches?(@controller)
-      @matcher.failure_message.should == 'Expected to respond with content type "application/xml", got "text/html"'
-    end
-  end
-
-  describe 'matcher' do
-
-    describe 'on success' do
-      before(:each){ build_response }
-
-      it { should respond_with(200) }
-      it { should respond_with(:ok) }
-      it { should respond_with(:success) }
-      it { should respond_with(200..299) }
-
-      it { should respond_with(200, :content_type => Mime::HTML) }
-      it { should respond_with(:ok, :content_type => Mime::HTML) }
-      it { should respond_with(:success, :content_type => Mime::HTML) }
-      it { should respond_with(200..299, :content_type => Mime::HTML) }
-
-      it { should_not respond_with(404) }
-      it { should_not respond_with(:not_found) }
-      it { should_not respond_with(300..400) }
-    end
-
-    describe 'on missing' do
-      before(:each){ build_response { render :text => "404 Not Found", :status => 404 } }
-
-      it { should respond_with(404) }
-      it { should respond_with(:not_found) }
-      it { should respond_with(:missing) }
-      it { should respond_with(400..405) }
-
-      it { should_not respond_with(302) }
-      it { should_not respond_with(:found) }
-      it { should_not respond_with(:redirect) }
-      it { should_not respond_with(300..305) }
-    end
-
-    describe 'respond_with_body' do
-      before(:each) { build_response { respond_to{ |format| format.xml { render :xml => [].to_xml } } } }
-
-      it { should respond_with_body(%{<?xml version="1.0" encoding="UTF-8"?>\n<nil-classes type="array"/>\n}) }
-      it { should respond_with_body(/xml/)       }
-      it { should respond_with_body{/xml/}       }
-      it { should respond_with_body proc{/xml/}  }
-      it { should_not respond_with_body('html')  }
-      it { should_not respond_with_body(/html/)  }
-    end
-
-    describe 'on redirect' do
-      before(:each){ build_response { redirect_to project_tasks_url(1) } }
-
-      it { should respond_with(302) }
-      it { should respond_with(:found) }
-      it { should respond_with(:redirect) }
-      it { should respond_with(300..305) }
-
-      it { should_not respond_with(200) }
-      it { should_not respond_with(:ok) }
-      it { should_not respond_with(:success) }
-      it { should_not respond_with(200..299) }
-    end
-
-    describe 'respond_with_content_type' do
-      describe 'and Mime::HTML' do
-        before(:each){ build_response { render :action => :new } }
-
-        it { should respond_with_content_type(:html) }
-        it { should respond_with_content_type(/html/) }
-        it { should respond_with_content_type(Mime::HTML) }
-        it { should respond_with_content_type('text/html') }
-
-        it { should_not respond_with_content_type(:xml) }
-        it { should_not respond_with_content_type(/xml/) }
-        it { should_not respond_with_content_type(Mime::XML) }
-        it { should_not respond_with_content_type('application/xml') }
-      end
-
-      describe 'and Mime::XML' do
-        before(:each) { build_response { respond_to{ |format| format.xml } } }
-
-        it { should respond_with_content_type(:xml) }
-        it { should respond_with_content_type(/xml/) }
-        it { should respond_with_content_type(Mime::XML) }
-        it { should respond_with_content_type('application/xml') }
-
-        it { should_not respond_with_content_type(:html) }
-        it { should_not respond_with_content_type(/html/) }
-        it { should_not respond_with_content_type(Mime::HTML) }
-        it { should_not respond_with_content_type('text/html') }
-      end
-    end
-
-  end
-
-  describe 'macro' do
-
-    describe 'on success' do
-      before(:each){ build_response }
-
-      should_respond_with 200
-      should_respond_with :ok
-      should_respond_with :success
-      should_respond_with 200..299
-
-      should_respond_with 200, :content_type => Mime::HTML
-      should_respond_with :ok, :content_type => Mime::HTML
-      should_respond_with :success, :content_type => Mime::HTML
-      should_respond_with 200..299, :content_type => Mime::HTML
-
-      should_respond_with 200 do |m|
-        m.body /\s*/
-        m.content_type Mime::HTML
-      end
-
-      should_not_respond_with 404
-      should_not_respond_with :not_found
-      should_not_respond_with 300..400
-    end
-
-    describe 'on missing' do
-      before(:each){ build_response { render :text => "404 Not Found", :status => 404 } }
-
-      should_respond_with 404
-      should_respond_with :not_found
-      should_respond_with :missing
-      should_respond_with 400..405
-
-      should_not_respond_with 302
-      should_not_respond_with :found
-      should_not_respond_with :redirect
-      should_not_respond_with 300..305
-    end
-
-    describe 'on redirect' do
-      before(:each){ build_response { redirect_to project_tasks_url(1) } }
-
-      should_respond_with 302
-      should_respond_with :found
-      should_respond_with :redirect
-      should_respond_with 300..305
-
-      should_not_respond_with 200
-      should_not_respond_with :ok
-      should_not_respond_with :success
-      should_not_respond_with 200..299
-    end
-
-    describe 'respond_with_body' do
-      before(:each) { build_response { respond_to{ |format| format.xml { render :xml => [].to_xml } } } }
-
-      should_respond_with_body %{<?xml version="1.0" encoding="UTF-8"?>\n<nil-classes type="array"/>\n}
-      should_respond_with_body /xml/
-      should_not_respond_with_body 'html'
-      should_not_respond_with_body /html/
-    end
-
-    describe 'respond_with_content_type' do
-      describe 'and Mime::HTML' do
-        before(:each){ build_response { render :action => :new } }
-
-        should_respond_with_content_type :html
-        should_respond_with_content_type /html/
-        should_respond_with_content_type Mime::HTML
-        should_respond_with_content_type 'text/html'
-
-        should_not_respond_with_content_type :xml
-        should_not_respond_with_content_type /xml/
-        should_not_respond_with_content_type Mime::XML
-        should_not_respond_with_content_type 'application/xml'
-      end
-
-      describe 'and Mime::XML' do
-        before(:each) { build_response { respond_to{ |format| format.xml } } }
-
-        should_respond_with_content_type :xml
-        should_respond_with_content_type /xml/
-        should_respond_with_content_type Mime::XML
-        should_respond_with_content_type 'application/xml'
-
-        should_not_respond_with_content_type :html
-        should_not_respond_with_content_type /html/
-        should_not_respond_with_content_type Mime::HTML
-        should_not_respond_with_content_type 'text/html'
-      end
-    end
-
-  end
-
-  generate_macro_stubs_specs_for(:respond_with, 200)
-  generate_macro_stubs_specs_for(:respond_with_body, /xml/)
-  generate_macro_stubs_specs_for(:respond_with_content_type, Mime::HTML)
-end