openbill 0.1.6 → 0.1.7

data/vendor/plugins/restful-authentication/generators/authenticated/templates/model_helper_spec.rb

@@ -1,158 +0,0 @@
-require File.dirname(__FILE__) + '/../spec_helper'
-include ApplicationHelper
-include <%= model_controller_class_name %>Helper
-
-describe "<%= model_controller_class_name %>Helper.link_to_<%= file_name %>" do
-  before do
-    @<%= file_name %> = <%= class_name %>.new({
-        :name  => '<%= class_name %> Name',
-        :login => '<%= file_name %>_name',
-      })
-    @<%= file_name %>.id = 1 # set non-attr_accessible specifically
-  end
-
-  it "should give an error on a nil <%= file_name %>" do
-    lambda { link_to_<%= file_name %>(nil) }.should raise_error('Invalid <%= file_name %>')
-  end
-
-  it "should link to the given <%= file_name %>" do
-    link_to_<%= file_name %>(@<%= file_name %>).should have_tag("a[href='/<%= table_name %>/1']")
-  end
-
-  it "should use given link text if :content_text is specified" do
-    link_to_<%= file_name %>(@<%= file_name %>, :content_text => 'Hello there!').should have_tag("a", 'Hello there!')
-  end
-
-  it "should use the login as link text with no :content_method specified" do
-    link_to_<%= file_name %>(@<%= file_name %>).should have_tag("a", '<%= file_name %>_name')
-  end
-
-  it "should use the name as link text with :content_method => :name" do
-    link_to_<%= file_name %>(@<%= file_name %>, :content_method => :name).should have_tag("a", '<%= class_name %> Name')
-  end
-
-  it "should use the login as title with no :title_method specified" do
-    link_to_<%= file_name %>(@<%= file_name %>).should have_tag("a[title='<%= file_name %>_name']")
-  end
-
-  it "should use the name as link title with :content_method => :name" do
-    link_to_<%= file_name %>(@<%= file_name %>, :title_method => :name).should have_tag("a[title='<%= class_name %> Name']")
-  end
-
-  it "should have nickname as a class by default" do
-    link_to_<%= file_name %>(@<%= file_name %>).should have_tag("a.nickname")
-  end
-
-  it "should take other classes and no longer have the nickname class" do
-    result = link_to_<%= file_name %>(@<%= file_name %>, :class => 'foo bar')
-    result.should have_tag("a.foo")
-    result.should have_tag("a.bar")
-  end
-end
-
-describe "<%= model_controller_class_name %>Helper.link_to_signin_with_IP" do
-  before do
-  end
-
-  it "should link to the signin_path" do
-    link_to_signin_with_IP().should have_tag("a[href='/signin']")
-  end
-
-  it "should use given link text if :content_text is specified" do
-    link_to_signin_with_IP(:content_text => 'Hello there!').should have_tag("a", 'Hello there!')
-  end
-
-  it "should use the login as link text with no :content_method specified" do
-    link_to_signin_with_IP().should have_tag("a", '0.0.0.0')
-  end
-
-  it "should use the ip address as title" do
-    link_to_signin_with_IP().should have_tag("a[title='0.0.0.0']")
-  end
-
-  it "should by default be like school in summer and have no class" do
-    link_to_signin_with_IP().should_not have_tag("a.nickname")
-  end
-  
-  it "should have some class if you tell it to" do
-    result = link_to_signin_with_IP(:class => 'foo bar')
-    result.should have_tag("a.foo")
-    result.should have_tag("a.bar")
-  end
-end
-
-describe "<%= model_controller_class_name %>Helper.link_to_current_<%= file_name %>, When logged in" do
-  fixtures :<%= table_name %>
-  include AuthenticatedTestHelper
-  before do
-    login_as(:quentin)
-  end
-
-  it "should link to the given <%= file_name %>" do
-    link_to_current_<%= file_name %>().should have_tag("a[href='/<%= table_name %>/1']")
-  end
-
-  it "should use given link text if :content_text is specified" do
-    link_to_current_user(:content_text => 'Hello there!').should have_tag("a", 'Hello there!')
-  end
-
-  it "should use the login as link text with no :content_method specified" do
-    link_to_current_user().should have_tag("a", 'quentin')
-  end
-
-  it "should use the name as link text with :content_method => :name" do
-    link_to_current_user(:content_method => :name).should have_tag("a", 'Quentin')
-  end
-
-  it "should use the login as title with no :title_method specified" do
-    link_to_current_user().should have_tag("a[title='quentin']")
-  end
-
-  it "should use the name as link title with :content_method => :name" do
-    link_to_current_user(:title_method => :name).should have_tag("a[title='Quentin']")
-  end
-
-  it "should have nickname as a class" do
-    link_to_current_user().should have_tag("a.nickname")
-  end
-
-  it "should take other classes and no longer have the nickname class" do
-    result = link_to_current_user(:class => 'foo bar')
-    result.should have_tag("a.foo")
-    result.should have_tag("a.bar")
-  end
-end
-
-
-
-describe "<%= model_controller_class_name %>Helper.link_to_current_user, When logged out" do
-  include AuthenticatedTestHelper
-  before do
-  end
-
-  it "should link to the signin_path" do
-    link_to_current_user().should have_tag("a[href='/signin']")
-  end
-
-  it "should use given link text if :content_text is specified" do
-    link_to_current_user(:content_text => 'Hello there!').should have_tag("a", 'Hello there!')
-  end
-
-  it "should use the IP address as link text with no :content_method specified" do
-    link_to_current_user().should have_tag("a", '0.0.0.0')
-  end
-
-  it "should use the ip address as title" do
-    link_to_current_user().should have_tag("a[title='0.0.0.0']")
-  end
-
-  it "should by default be like school in summer and have no class" do
-    link_to_current_user().should_not have_tag("a.nickname")
-  end
-
-  it "should have some class if you tell it to" do
-    result = link_to_current_user(:class => 'foo bar')
-    result.should have_tag("a.foo")
-    result.should have_tag("a.bar")
-  end
-end

data/vendor/plugins/restful-authentication/generators/authenticated/templates/observer.rb

@@ -1,11 +0,0 @@
-class <%= class_name %>Observer < ActiveRecord::Observer
-  def after_create(<%= file_name %>)
-    <%= class_name %>Mailer.deliver_signup_notification(<%= file_name %>)
-  end
-
-  def after_save(<%= file_name %>)
-  <% if options[:include_activation] %>
-    <%= class_name %>Mailer.deliver_activation(<%= file_name %>) if <%= file_name %>.recently_activated?
-  <% end %>
-  end
-end

data/vendor/plugins/restful-authentication/generators/authenticated/templates/signup.html.erb

@@ -1,19 +0,0 @@
-<h1>Sign up as a new user</h1>
-<%% @<%= file_name %>.password = @<%= file_name %>.password_confirmation = nil %>
-
-<%%= error_messages_for :<%= file_name %> %>
-<%% form_for :<%= file_name %>, :url => <%= model_controller_routing_name %>_path do |f| -%>
-<p><%%= label_tag 'login' %><br/>
-<%%= f.text_field :login %></p>
-
-<p><%%= label_tag 'email' %><br/>
-<%%= f.text_field :email %></p>
-
-<p><%%= label_tag 'password' %><br/>
-<%%= f.password_field :password %></p>
-
-<p><%%= label_tag 'password_confirmation', 'Confirm Password' %><br/>
-<%%= f.password_field :password_confirmation %></p>
-
-<p><%%= submit_tag 'Sign up' %></p>
-<%% end -%>

data/vendor/plugins/restful-authentication/generators/authenticated/templates/signup_notification.erb

@@ -1,8 +0,0 @@
-Your account has been created.
-
-  Username: <%%=h @<%= file_name %>.login %>
-  Password: <%%=h @<%= file_name %>.password %>
-
-Visit this url to activate your account:
-
-  <%%=h @url %>

data/vendor/plugins/restful-authentication/generators/authenticated/templates/site_keys.rb

@@ -1,38 +0,0 @@
-
-# A Site key gives additional protection against a dictionary attack if your
-# DB is ever compromised.  With no site key, we store
-#   DB_password = hash(user_password, DB_user_salt)
-# If your database were to be compromised you'd be vulnerable to a dictionary
-# attack on all your stupid users' passwords.  With a site key, we store
-#   DB_password = hash(user_password, DB_user_salt, Code_site_key)
-# That means an attacker needs access to both your site's code *and* its
-# database to mount an "offline dictionary attack.":http://www.dwheeler.com/secure-programs/Secure-Programs-HOWTO/web-authentication.html
-# 
-# It's probably of minor importance, but recommended by best practices: 'defense
-# in depth'.  Needless to say, if you upload this to github or the youtubes or
-# otherwise place it in public view you'll kinda defeat the point.  Your users'
-# passwords are still secure, and the world won't end, but defense_in_depth -= 1.
-# 
-# Please note: if you change this, all the passwords will be invalidated, so DO
-# keep it someplace secure.  Use the random value given or type in the lyrics to
-# your favorite Jay-Z song or something; any moderately long, unpredictable text.
-REST_AUTH_SITE_KEY         = '<%= $rest_auth_site_key_from_generator %>'
-  
-# Repeated applications of the hash make brute force (even with a compromised
-# database and site key) harder, and scale with Moore's law.
-#
-#   bq. "To squeeze the most security out of a limited-entropy password or
-#   passphrase, we can use two techniques [salting and stretching]... that are
-#   so simple and obvious that they should be used in every password system.
-#   There is really no excuse not to use them." http://tinyurl.com/37lb73
-#   Practical Security (Ferguson & Scheier) p350
-# 
-# A modest 10 foldings (the default here) adds 3ms.  This makes brute forcing 10
-# times harder, while reducing an app that otherwise serves 100 reqs/s to 78 signin
-# reqs/s, an app that does 10reqs/s to 9.7 reqs/s
-# 
-# More:
-# * http://www.owasp.org/index.php/Hashing_Java
-# * "An Illustrated Guide to Cryptographic Hashes":http://www.unixwiz.net/techtips/iguide-crypto-hashes.html
-
-REST_AUTH_DIGEST_STRETCHES = <%= $rest_auth_digest_stretches_from_generator %>

data/vendor/plugins/restful-authentication/generators/authenticated/templates/spec/controllers/access_control_spec.rb

@@ -1,90 +0,0 @@
-require File.dirname(__FILE__) + '<%= ('/..'*controller_class_nesting_depth) + '/../spec_helper' %>'
-  # Be sure to include AuthenticatedTestHelper in spec/spec_helper.rb instead
-# Then, you can remove it from this and the units test.
-include AuthenticatedTestHelper
-
-#
-# A test controller with and without access controls
-#
-class AccessControlTestController < ApplicationController
-  before_filter :login_required, :only => :login_is_required
-  def login_is_required
-    respond_to do |format|
-      @foo = { 'success' => params[:format]||'no fmt given'}
-      format.html do render :text => "success"             end
-      format.xml  do render :xml  => @foo, :status => :ok  end
-      format.json do render :json => @foo, :status => :ok  end
-    end
-  end
-  def login_not_required
-    respond_to do |format|
-      @foo = { 'success' => params[:format]||'no fmt given'}
-      format.html do render :text => "success"             end
-      format.xml  do render :xml  => @foo, :status => :ok  end
-      format.json do render :json => @foo, :status => :ok  end
-    end
-  end
-end
-
-#
-# Access Control
-#
-
-ACCESS_CONTROL_FORMATS = [
-  ['',     "success"],
-  ['xml',  "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<hash>\n  <success>xml</success>\n</hash>\n"],
-  ['json', "{\"success\": \"json\"}"],]
-ACCESS_CONTROL_AM_I_LOGGED_IN = [
-  [:i_am_logged_in,     :quentin],
-  [:i_am_not_logged_in, nil],]
-ACCESS_CONTROL_IS_LOGIN_REQD = [
-  :login_not_required,
-  :login_is_required,]
-
-describe AccessControlTestController do
-  fixtures        :<%= table_name %>
-  before do
-    # is there a better way to do this?
-    ActionController::Routing::Routes.add_route '/login_is_required',           :controller => 'access_control_test',   :action => 'login_is_required'
-    ActionController::Routing::Routes.add_route '/login_not_required',          :controller => 'access_control_test',   :action => 'login_not_required'
-  end
-
-  ACCESS_CONTROL_FORMATS.each do |format, success_text|
-    ACCESS_CONTROL_AM_I_LOGGED_IN.each do |logged_in_status, <%= file_name %>_login|
-      ACCESS_CONTROL_IS_LOGIN_REQD.each do |login_reqd_status|
-        describe "requesting #{format.blank? ? 'html' : format}; #{logged_in_status.to_s.humanize} and #{login_reqd_status.to_s.humanize}" do
-          before do
-            logout_keeping_session!
-            @<%= file_name %> = format.blank? ? login_as(<%= file_name %>_login) : authorize_as(<%= file_name %>_login)
-            get login_reqd_status.to_s, :format => format
-          end
-
-          if ((login_reqd_status == :login_not_required) ||
-              (login_reqd_status == :login_is_required && logged_in_status == :i_am_logged_in))
-            it "succeeds" do
-              response.should have_text(success_text)
-              response.code.to_s.should == '200'
-            end
-
-          elsif (login_reqd_status == :login_is_required && logged_in_status == :i_am_not_logged_in)
-            if ['html', ''].include? format
-              it "redirects me to the log in page" do
-                response.should redirect_to('/<%= controller_routing_path %>/new')
-              end
-            else
-              it "returns 'Access denied' and a 406 (Access Denied) status code" do
-                response.should have_text("HTTP Basic: Access denied.\n")
-                response.code.to_s.should == '401'
-              end
-            end
-
-          else
-            warn "Oops no case for #{format} and #{logged_in_status.to_s.humanize} and #{login_reqd_status.to_s.humanize}"
-          end
-        end # describe
-
-      end
-    end
-  end # cases
-
-end

data/vendor/plugins/restful-authentication/generators/authenticated/templates/spec/controllers/authenticated_system_spec.rb

@@ -1,102 +0,0 @@
-require File.dirname(__FILE__) + '<%= ('/..'*controller_class_nesting_depth) + '/../spec_helper' %>'
-
-# Be sure to include AuthenticatedTestHelper in spec/spec_helper.rb instead
-# Then, you can remove it from this and the units test.
-include AuthenticatedTestHelper
-include AuthenticatedSystem
-def action_name() end
-
-describe <%= controller_class_name %>Controller do
-  fixtures :<%= table_name %>
-  
-  before do
-    # FIXME -- <%= controller_file_name %> controller not testing xml logins 
-    stub!(:authenticate_with_http_basic).and_return nil
-  end    
-  describe "logout_killing_session!" do
-    before do
-      login_as :quentin
-      stub!(:reset_session)
-    end
-    it 'resets the session'         do should_receive(:reset_session);         logout_killing_session! end
-    it 'kills my auth_token cookie' do should_receive(:kill_remember_cookie!); logout_killing_session! end
-    it 'nils the current <%= file_name %>'      do logout_killing_session!; current_<%= file_name %>.should be_nil end
-    it 'kills :<%= file_name %>_id session' do
-      session.stub!(:[]=)
-      session.should_receive(:[]=).with(:<%= file_name %>_id, nil).at_least(:once)
-      logout_killing_session!
-    end
-    it 'forgets me' do    
-      current_<%= file_name %>.remember_me
-      current_<%= file_name %>.remember_token.should_not be_nil; current_<%= file_name %>.remember_token_expires_at.should_not be_nil
-      <%= class_name %>.find(1).remember_token.should_not be_nil; <%= class_name %>.find(1).remember_token_expires_at.should_not be_nil
-      logout_killing_session!
-      <%= class_name %>.find(1).remember_token.should     be_nil; <%= class_name %>.find(1).remember_token_expires_at.should     be_nil
-    end
-  end
-
-  describe "logout_keeping_session!" do
-    before do
-      login_as :quentin
-      stub!(:reset_session)
-    end
-    it 'does not reset the session' do should_not_receive(:reset_session);   logout_keeping_session! end
-    it 'kills my auth_token cookie' do should_receive(:kill_remember_cookie!); logout_keeping_session! end
-    it 'nils the current <%= file_name %>'      do logout_keeping_session!; current_<%= file_name %>.should be_nil end
-    it 'kills :<%= file_name %>_id session' do
-      session.stub!(:[]=)
-      session.should_receive(:[]=).with(:<%= file_name %>_id, nil).at_least(:once)
-      logout_keeping_session!
-    end
-    it 'forgets me' do    
-      current_<%= file_name %>.remember_me
-      current_<%= file_name %>.remember_token.should_not be_nil; current_<%= file_name %>.remember_token_expires_at.should_not be_nil
-      <%= class_name %>.find(1).remember_token.should_not be_nil; <%= class_name %>.find(1).remember_token_expires_at.should_not be_nil
-      logout_keeping_session!
-      <%= class_name %>.find(1).remember_token.should     be_nil; <%= class_name %>.find(1).remember_token_expires_at.should     be_nil
-    end
-  end
-  
-  describe 'When logged out' do 
-    it "should not be authorized?" do
-      authorized?().should be_false
-    end    
-  end
-
-  #
-  # Cookie Login
-  #
-  describe "Logging in by cookie" do
-    def set_remember_token token, time
-      @<%= file_name %>[:remember_token]            = token; 
-      @<%= file_name %>[:remember_token_expires_at] = time
-      @<%= file_name %>.save!
-    end    
-    before do 
-      @<%= file_name %> = <%= class_name %>.find(:first); 
-      set_remember_token 'hello!', 5.minutes.from_now
-    end    
-    it 'logs in with cookie' do
-      stub!(:cookies).and_return({ :auth_token => 'hello!' })
-      logged_in?.should be_true
-    end
-    
-    it 'fails cookie login with bad cookie' do
-      should_receive(:cookies).at_least(:once).and_return({ :auth_token => 'i_haxxor_joo' })
-      logged_in?.should_not be_true
-    end
-    
-    it 'fails cookie login with no cookie' do
-      set_remember_token nil, nil
-      should_receive(:cookies).at_least(:once).and_return({ })
-      logged_in?.should_not be_true
-    end
-    
-    it 'fails expired cookie login' do
-      set_remember_token 'hello!', 5.minutes.ago
-      stub!(:cookies).and_return({ :auth_token => 'hello!' })
-      logged_in?.should_not be_true
-    end
-  end
-  
-end

data/vendor/plugins/restful-authentication/generators/authenticated/templates/spec/controllers/sessions_controller_spec.rb

@@ -1,139 +0,0 @@
-require File.dirname(__FILE__) + '<%= ('/..'*controller_class_nesting_depth) + '/../spec_helper' %>'
-
-# Be sure to include AuthenticatedTestHelper in spec/spec_helper.rb instead
-# Then, you can remove it from this and the units test.
-include AuthenticatedTestHelper
-
-describe <%= controller_class_name %>Controller do
-  fixtures        :<%= table_name %>
-  before do 
-    @<%= file_name %>  = mock_<%= file_name %>
-    @login_params = { :login => 'quentin', :password => 'test' }
-    <%= class_name %>.stub!(:authenticate).with(@login_params[:login], @login_params[:password]).and_return(@<%= file_name %>)
-  end
-  def do_create
-    post :create, @login_params
-  end
-  describe "on successful login," do
-    [ [:nil,       nil,            nil],
-      [:expired,   'valid_token',  15.minutes.ago],
-      [:different, 'i_haxxor_joo', 15.minutes.from_now], 
-      [:valid,     'valid_token',  15.minutes.from_now]
-        ].each do |has_request_token, token_value, token_expiry|
-      [ true, false ].each do |want_remember_me|
-        describe "my request cookie token is #{has_request_token.to_s}," do
-          describe "and ask #{want_remember_me ? 'to' : 'not to'} be remembered" do 
-            before do
-              @ccookies = mock('cookies')
-              controller.stub!(:cookies).and_return(@ccookies)
-              @ccookies.stub!(:[]).with(:auth_token).and_return(token_value)
-              @ccookies.stub!(:delete).with(:auth_token)
-              @ccookies.stub!(:[]=)
-              @<%= file_name %>.stub!(:remember_me) 
-              @<%= file_name %>.stub!(:refresh_token) 
-              @<%= file_name %>.stub!(:forget_me)
-              @<%= file_name %>.stub!(:remember_token).and_return(token_value) 
-              @<%= file_name %>.stub!(:remember_token_expires_at).and_return(token_expiry)
-              @<%= file_name %>.stub!(:remember_token?).and_return(has_request_token == :valid)
-              if want_remember_me
-                @login_params[:remember_me] = '1'
-              else 
-                @login_params[:remember_me] = '0'
-              end
-            end
-            it "kills existing login"        do controller.should_receive(:logout_keeping_session!); do_create; end    
-            it "authorizes me"               do do_create; controller.send(:authorized?).should be_true;   end    
-            it "logs me in"                  do do_create; controller.send(:logged_in?).should  be_true  end    
-            it "greets me nicely"            do do_create; response.flash[:notice].should =~ /success/i   end
-            it "sets/resets/expires cookie"  do controller.should_receive(:handle_remember_cookie!).with(want_remember_me); do_create end
-            it "sends a cookie"              do controller.should_receive(:send_remember_cookie!);  do_create end
-            it 'redirects to the home page'  do do_create; response.should redirect_to('/')   end
-            it "does not reset my session"   do controller.should_not_receive(:reset_session).and_return nil; do_create end # change if you uncomment the reset_session path
-            if (has_request_token == :valid)
-              it 'does not make new token'   do @<%= file_name %>.should_not_receive(:remember_me);   do_create end
-              it 'does refresh token'        do @<%= file_name %>.should_receive(:refresh_token);     do_create end 
-              it "sets an auth cookie"       do do_create;  end
-            else
-              if want_remember_me
-                it 'makes a new token'       do @<%= file_name %>.should_receive(:remember_me);       do_create end 
-                it "does not refresh token"  do @<%= file_name %>.should_not_receive(:refresh_token); do_create end
-                it "sets an auth cookie"       do do_create;  end
-              else 
-                it 'does not make new token' do @<%= file_name %>.should_not_receive(:remember_me);   do_create end
-                it 'does not refresh token'  do @<%= file_name %>.should_not_receive(:refresh_token); do_create end 
-                it 'kills user token'        do @<%= file_name %>.should_receive(:forget_me);         do_create end 
-              end
-            end
-          end # inner describe
-        end
-      end
-    end
-  end
-  
-  describe "on failed login" do
-    before do
-      <%= class_name %>.should_receive(:authenticate).with(anything(), anything()).and_return(nil)
-      login_as :quentin
-    end
-    it 'logs out keeping session'   do controller.should_receive(:logout_keeping_session!); do_create end
-    it 'flashes an error'           do do_create; flash[:error].should =~ /Couldn't log you in as 'quentin'/ end
-    it 'renders the log in page'    do do_create; response.should render_template('new')  end
-    it "doesn't log me in"          do do_create; controller.send(:logged_in?).should == false end
-    it "doesn't send password back" do 
-      @login_params[:password] = 'FROBNOZZ'
-      do_create
-      response.should_not have_text(/FROBNOZZ/i)
-    end
-  end
-
-  describe "on signout" do
-    def do_destroy
-      get :destroy
-    end
-    before do 
-      login_as :quentin
-    end
-    it 'logs me out'                   do controller.should_receive(:logout_killing_session!); do_destroy end
-    it 'redirects me to the home page' do do_destroy; response.should be_redirect     end
-  end
-  
-end
-
-describe <%= controller_class_name %>Controller do
-  describe "route generation" do
-    it "should route the new <%= controller_controller_name %> action correctly" do
-      route_for(:controller => '<%= controller_controller_name %>', :action => 'new').should == "/login"
-    end
-    it "should route the create <%= controller_controller_name %> correctly" do
-      route_for(:controller => '<%= controller_controller_name %>', :action => 'create').should == "/<%= controller_routing_path %>"
-    end
-    it "should route the destroy <%= controller_controller_name %> action correctly" do
-      route_for(:controller => '<%= controller_controller_name %>', :action => 'destroy').should == "/logout"
-    end
-  end
-  
-  describe "route recognition" do
-    it "should generate params from GET /login correctly" do
-      params_from(:get, '/login').should == {:controller => '<%= controller_controller_name %>', :action => 'new'}
-    end
-    it "should generate params from POST /<%= controller_routing_path %> correctly" do
-      params_from(:post, '/<%= controller_routing_path %>').should == {:controller => '<%= controller_controller_name %>', :action => 'create'}
-    end
-    it "should generate params from DELETE /<%= controller_routing_path %> correctly" do
-      params_from(:delete, '/logout').should == {:controller => '<%= controller_controller_name %>', :action => 'destroy'}
-    end
-  end
-  
-  describe "named routing" do
-    before(:each) do
-      get :new
-    end
-    it "should route <%= controller_routing_name %>_path() correctly" do
-      <%= controller_routing_name %>_path().should == "/<%= controller_routing_path %>"
-    end
-    it "should route new_<%= controller_routing_name %>_path() correctly" do
-      new_<%= controller_routing_name %>_path().should == "/<%= controller_routing_path %>/new"
-    end
-  end
-  
-end