openbill 0.1.6 → 0.1.7

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

@@ -1,198 +0,0 @@
-require File.dirname(__FILE__) + '<%= ('/..'*model_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 <%= model_controller_class_name %>Controller do
-  fixtures :<%= table_name %>
-
-  it 'allows signup' do
-    lambda do
-      create_<%= file_name %>
-      response.should be_redirect
-    end.should change(<%= class_name %>, :count).by(1)
-  end
-
-  <% if options[:stateful] %>
-  it 'signs up user in pending state' do
-    create_<%= file_name %>
-    assigns(:<%= file_name %>).reload
-    assigns(:<%= file_name %>).should be_pending
-  end<% end %>
-
-<% if options[:include_activation] -%>
-  it 'signs up user with activation code' do
-    create_<%= file_name %>
-    assigns(:<%= file_name %>).reload
-    assigns(:<%= file_name %>).activation_code.should_not be_nil
-  end<% end -%>
-
-  it 'requires login on signup' do
-    lambda do
-      create_<%= file_name %>(:login => nil)
-      assigns[:<%= file_name %>].errors.on(:login).should_not be_nil
-      response.should be_success
-    end.should_not change(<%= class_name %>, :count)
-  end
-  
-  it 'requires password on signup' do
-    lambda do
-      create_<%= file_name %>(:password => nil)
-      assigns[:<%= file_name %>].errors.on(:password).should_not be_nil
-      response.should be_success
-    end.should_not change(<%= class_name %>, :count)
-  end
-  
-  it 'requires password confirmation on signup' do
-    lambda do
-      create_<%= file_name %>(:password_confirmation => nil)
-      assigns[:<%= file_name %>].errors.on(:password_confirmation).should_not be_nil
-      response.should be_success
-    end.should_not change(<%= class_name %>, :count)
-  end
-
-  it 'requires email on signup' do
-    lambda do
-      create_<%= file_name %>(:email => nil)
-      assigns[:<%= file_name %>].errors.on(:email).should_not be_nil
-      response.should be_success
-    end.should_not change(<%= class_name %>, :count)
-  end
-  
-  <% if options[:include_activation] %>
-  it 'activates user' do
-    <%= class_name %>.authenticate('aaron', 'monkey').should be_nil
-    get :activate, :activation_code => <%= table_name %>(:aaron).activation_code
-    response.should redirect_to('/login')
-    flash[:notice].should_not be_nil
-    flash[:error ].should     be_nil
-    <%= class_name %>.authenticate('aaron', 'monkey').should == <%= table_name %>(:aaron)
-  end
-  
-  it 'does not activate user without key' do
-    get :activate
-    flash[:notice].should     be_nil
-    flash[:error ].should_not be_nil
-  end
-  
-  it 'does not activate user with blank key' do
-    get :activate, :activation_code => ''
-    flash[:notice].should     be_nil
-    flash[:error ].should_not be_nil
-  end
-  
-  it 'does not activate user with bogus key' do
-    get :activate, :activation_code => 'i_haxxor_joo'
-    flash[:notice].should     be_nil
-    flash[:error ].should_not be_nil
-  end<% end %>
-  
-  def create_<%= file_name %>(options = {})
-    post :create, :<%= file_name %> => { :login => 'quire', :email => 'quire@example.com',
-      :password => 'quire69', :password_confirmation => 'quire69' }.merge(options)
-  end
-end
-
-describe <%= model_controller_class_name %>Controller do
-  describe "route generation" do
-    it "should route <%= model_controller_controller_name %>'s 'index' action correctly" do
-      route_for(:controller => '<%= model_controller_controller_name %>', :action => 'index').should == "/<%= model_controller_routing_path %>"
-    end
-    
-    it "should route <%= model_controller_controller_name %>'s 'new' action correctly" do
-      route_for(:controller => '<%= model_controller_controller_name %>', :action => 'new').should == "/signup"
-    end
-    
-    it "should route {:controller => '<%= model_controller_controller_name %>', :action => 'create'} correctly" do
-      route_for(:controller => '<%= model_controller_controller_name %>', :action => 'create').should == "/register"
-    end
-    
-    it "should route <%= model_controller_controller_name %>'s 'show' action correctly" do
-      route_for(:controller => '<%= model_controller_controller_name %>', :action => 'show', :id => '1').should == "/<%= model_controller_routing_path %>/1"
-    end
-    
-    it "should route <%= model_controller_controller_name %>'s 'edit' action correctly" do
-      route_for(:controller => '<%= model_controller_controller_name %>', :action => 'edit', :id => '1').should == "/<%= model_controller_routing_path %>/1/edit"
-    end
-    
-    it "should route <%= model_controller_controller_name %>'s 'update' action correctly" do
-      route_for(:controller => '<%= model_controller_controller_name %>', :action => 'update', :id => '1').should == "/<%= model_controller_routing_path %>/1"
-    end
-    
-    it "should route <%= model_controller_controller_name %>'s 'destroy' action correctly" do
-      route_for(:controller => '<%= model_controller_controller_name %>', :action => 'destroy', :id => '1').should == "/<%= model_controller_routing_path %>/1"
-    end
-  end
-  
-  describe "route recognition" do
-    it "should generate params for <%= model_controller_controller_name %>'s index action from GET /<%= model_controller_routing_path %>" do
-      params_from(:get, '/<%= model_controller_routing_path %>').should == {:controller => '<%= model_controller_controller_name %>', :action => 'index'}
-      params_from(:get, '/<%= model_controller_routing_path %>.xml').should == {:controller => '<%= model_controller_controller_name %>', :action => 'index', :format => 'xml'}
-      params_from(:get, '/<%= model_controller_routing_path %>.json').should == {:controller => '<%= model_controller_controller_name %>', :action => 'index', :format => 'json'}
-    end
-    
-    it "should generate params for <%= model_controller_controller_name %>'s new action from GET /<%= model_controller_routing_path %>" do
-      params_from(:get, '/<%= model_controller_routing_path %>/new').should == {:controller => '<%= model_controller_controller_name %>', :action => 'new'}
-      params_from(:get, '/<%= model_controller_routing_path %>/new.xml').should == {:controller => '<%= model_controller_controller_name %>', :action => 'new', :format => 'xml'}
-      params_from(:get, '/<%= model_controller_routing_path %>/new.json').should == {:controller => '<%= model_controller_controller_name %>', :action => 'new', :format => 'json'}
-    end
-    
-    it "should generate params for <%= model_controller_controller_name %>'s create action from POST /<%= model_controller_routing_path %>" do
-      params_from(:post, '/<%= model_controller_routing_path %>').should == {:controller => '<%= model_controller_controller_name %>', :action => 'create'}
-      params_from(:post, '/<%= model_controller_routing_path %>.xml').should == {:controller => '<%= model_controller_controller_name %>', :action => 'create', :format => 'xml'}
-      params_from(:post, '/<%= model_controller_routing_path %>.json').should == {:controller => '<%= model_controller_controller_name %>', :action => 'create', :format => 'json'}
-    end
-    
-    it "should generate params for <%= model_controller_controller_name %>'s show action from GET /<%= model_controller_routing_path %>/1" do
-      params_from(:get , '/<%= model_controller_routing_path %>/1').should == {:controller => '<%= model_controller_controller_name %>', :action => 'show', :id => '1'}
-      params_from(:get , '/<%= model_controller_routing_path %>/1.xml').should == {:controller => '<%= model_controller_controller_name %>', :action => 'show', :id => '1', :format => 'xml'}
-      params_from(:get , '/<%= model_controller_routing_path %>/1.json').should == {:controller => '<%= model_controller_controller_name %>', :action => 'show', :id => '1', :format => 'json'}
-    end
-    
-    it "should generate params for <%= model_controller_controller_name %>'s edit action from GET /<%= model_controller_routing_path %>/1/edit" do
-      params_from(:get , '/<%= model_controller_routing_path %>/1/edit').should == {:controller => '<%= model_controller_controller_name %>', :action => 'edit', :id => '1'}
-    end
-    
-    it "should generate params {:controller => '<%= model_controller_controller_name %>', :action => update', :id => '1'} from PUT /<%= model_controller_routing_path %>/1" do
-      params_from(:put , '/<%= model_controller_routing_path %>/1').should == {:controller => '<%= model_controller_controller_name %>', :action => 'update', :id => '1'}
-      params_from(:put , '/<%= model_controller_routing_path %>/1.xml').should == {:controller => '<%= model_controller_controller_name %>', :action => 'update', :id => '1', :format => 'xml'}
-      params_from(:put , '/<%= model_controller_routing_path %>/1.json').should == {:controller => '<%= model_controller_controller_name %>', :action => 'update', :id => '1', :format => 'json'}
-    end
-    
-    it "should generate params for <%= model_controller_controller_name %>'s destroy action from DELETE /<%= model_controller_routing_path %>/1" do
-      params_from(:delete, '/<%= model_controller_routing_path %>/1').should == {:controller => '<%= model_controller_controller_name %>', :action => 'destroy', :id => '1'}
-      params_from(:delete, '/<%= model_controller_routing_path %>/1.xml').should == {:controller => '<%= model_controller_controller_name %>', :action => 'destroy', :id => '1', :format => 'xml'}
-      params_from(:delete, '/<%= model_controller_routing_path %>/1.json').should == {:controller => '<%= model_controller_controller_name %>', :action => 'destroy', :id => '1', :format => 'json'}
-    end
-  end
-  
-  describe "named routing" do
-    before(:each) do
-      get :new
-    end
-    
-    it "should route <%= model_controller_routing_name %>_path() to /<%= model_controller_routing_path %>" do
-      <%= model_controller_routing_name %>_path().should == "/<%= model_controller_routing_path %>"
-      formatted_<%= model_controller_routing_name %>_path(:format => 'xml').should == "/<%= model_controller_routing_path %>.xml"
-      formatted_<%= model_controller_routing_name %>_path(:format => 'json').should == "/<%= model_controller_routing_path %>.json"
-    end
-    
-    it "should route new_<%= model_controller_routing_name.singularize %>_path() to /<%= model_controller_routing_path %>/new" do
-      new_<%= model_controller_routing_name.singularize %>_path().should == "/<%= model_controller_routing_path %>/new"
-      formatted_new_<%= model_controller_routing_name.singularize %>_path(:format => 'xml').should == "/<%= model_controller_routing_path %>/new.xml"
-      formatted_new_<%= model_controller_routing_name.singularize %>_path(:format => 'json').should == "/<%= model_controller_routing_path %>/new.json"
-    end
-    
-    it "should route <%= model_controller_routing_name.singularize %>_(:id => '1') to /<%= model_controller_routing_path %>/1" do
-      <%= model_controller_routing_name.singularize %>_path(:id => '1').should == "/<%= model_controller_routing_path %>/1"
-      formatted_<%= model_controller_routing_name.singularize %>_path(:id => '1', :format => 'xml').should == "/<%= model_controller_routing_path %>/1.xml"
-      formatted_<%= model_controller_routing_name.singularize %>_path(:id => '1', :format => 'json').should == "/<%= model_controller_routing_path %>/1.json"
-    end
-    
-    it "should route edit_<%= model_controller_routing_name.singularize %>_path(:id => '1') to /<%= model_controller_routing_path %>/1/edit" do
-      edit_<%= model_controller_routing_name.singularize %>_path(:id => '1').should == "/<%= model_controller_routing_path %>/1/edit"
-    end
-  end
-  
-end

data/vendor/plugins/restful-authentication/generators/authenticated/templates/spec/fixtures/users.yml

@@ -1,60 +0,0 @@
-<%
-  ## this code must match that in templates/model.rb
-  require 'digest/sha1'
-  def make_fake_token
-    @fake_token_counter ||= 0
-    @fake_token_counter +=  1
-    Digest::SHA1.hexdigest(@fake_token_counter.to_s)
-  end
-  salts   = (1..2).map{ make_fake_token }
-  passwds = salts.map{ |salt| password_digest('monkey', salt) }
--%>
-
-quentin:
-  id:                        1
-  login:                     quentin
-  email:                     quentin@example.com
-  salt:                      <%= salts[0]   %> # SHA1('0')
-  crypted_password:          <%= passwds[0] %> # 'monkey'
-  created_at:                <%%= 5.days.ago.to_s :db  %>
-  remember_token_expires_at: <%%= 1.days.from_now.to_s %>
-  remember_token:            <%= make_fake_token %>
-<% if options[:include_activation] -%>
-  activation_code:           
-  activated_at:              <%%= 5.days.ago.to_s :db %>
-<% end -%>
-<% if options[:stateful] -%>
-  state:                     active
-<% end -%>
-      
-aaron:
-  id:                        2
-  login:                     aaron
-  email:                     aaron@example.com
-  salt:                      <%= salts[1]   %> # SHA1('1')
-  crypted_password:          <%= passwds[1] %> # 'monkey'
-  created_at:                <%%= 1.days.ago.to_s :db %>
-  remember_token_expires_at: 
-  remember_token:            
-<% if options[:include_activation] -%>
-  activation_code:           <%= make_fake_token %>
-  activated_at:              
-<% end -%>
-<% if options[:stateful] %>
-  state:                     pending
-<% end -%>
-
-
-old_password_holder:
-  id:                        3
-  login:                     old_password_holder
-  email:                     salty_dog@example.com
-  salt:                      7e3041ebc2fc05a40c60028e2c4901a81035d3cd
-  crypted_password:          00742970dc9e6319f8019fd54864d3ea740f04b1 # test
-  created_at:                <%%= 1.days.ago.to_s :db %>
-<% if options[:include_activation] %>
-  activation_code:           
-  activated_at:              <%%= 5.days.ago.to_s :db %>
-<% end %>
-<% if options[:stateful] %>
-  state:                     active<% end %>

data/vendor/plugins/restful-authentication/generators/authenticated/templates/spec/helpers/users_helper_spec.rb

@@ -1,141 +0,0 @@
-require File.dirname(__FILE__) + '<%= ('/..'*model_controller_class_nesting_depth) + '/../spec_helper' %>'
-include ApplicationHelper
-include <%= model_controller_class_name %>Helper
-include AuthenticatedTestHelper
-
-describe <%= model_controller_class_name %>Helper do
-  before do
-    @<%= file_name %> = mock_<%= file_name %>
-  end
-  
-  describe "if_authorized" do 
-    it "yields if authorized" do
-      should_receive(:authorized?).with('a','r').and_return(true)
-      if_authorized?('a','r'){|action,resource| [action,resource,'hi'] }.should == ['a','r','hi']
-    end
-    it "does nothing if not authorized" do
-      should_receive(:authorized?).with('a','r').and_return(false)
-      if_authorized?('a','r'){ 'hi' }.should be_nil
-    end
-  end
-  
-  describe "link_to_<%= file_name %>" do
-    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
-      should_receive(:<%= model_controller_routing_name.singularize %>_path).at_least(:once).and_return('/<%= model_controller_file_path %>/1')
-      link_to_<%= file_name %>(@<%= file_name %>).should have_tag("a[href='/<%= model_controller_file_path %>/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", 'user_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", 'U. Surname')
-    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='user_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='U. Surname']")
-    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 "link_to_login_with_IP" do
-    it "should link to the login_path" do
-      link_to_login_with_IP().should have_tag("a[href='/login']")
-    end
-    it "should use given link text if :content_text is specified" do
-      link_to_login_with_IP('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_login_with_IP().should have_tag("a", '0.0.0.0')
-    end
-    it "should use the ip address as title" do
-      link_to_login_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_login_with_IP().should_not have_tag("a.nickname")
-    end
-    it "should have some class if you tell it to" do
-      result = link_to_login_with_IP(nil, :class => 'foo bar')
-      result.should have_tag("a.foo")
-      result.should have_tag("a.bar")
-    end
-    it "should have some class if you tell it to" do
-      result = link_to_login_with_IP(nil, :tag => 'abbr')
-      result.should have_tag("abbr[title='0.0.0.0']")
-    end
-  end
-
-  describe "link_to_current_<%= file_name %>, When logged in" do
-    before do
-      stub!(:current_<%= file_name %>).and_return(@<%= file_name %>)
-    end
-    it "should link to the given <%= file_name %>" do
-      should_receive(:<%= model_controller_routing_name.singularize %>_path).at_least(:once).and_return('/<%= model_controller_file_path %>/1')
-      link_to_current_<%= file_name %>().should have_tag("a[href='/<%= model_controller_file_path %>/1']")
-    end
-    it "should use given link text if :content_text is specified" do
-      link_to_current_<%= 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_current_<%= file_name %>().should have_tag("a", 'user_name')
-    end
-    it "should use the name as link text with :content_method => :name" do
-      link_to_current_<%= file_name %>(:content_method => :name).should have_tag("a", 'U. Surname')
-    end
-    it "should use the login as title with no :title_method specified" do
-      link_to_current_<%= file_name %>().should have_tag("a[title='user_name']")
-    end
-    it "should use the name as link title with :content_method => :name" do
-      link_to_current_<%= file_name %>(:title_method => :name).should have_tag("a[title='U. Surname']")
-    end
-    it "should have nickname as a class" do
-      link_to_current_<%= file_name %>().should have_tag("a.nickname")
-    end
-    it "should take other classes and no longer have the nickname class" do
-      result = link_to_current_<%= file_name %>(:class => 'foo bar')
-      result.should have_tag("a.foo")
-      result.should have_tag("a.bar")
-    end
-  end
-
-  describe "link_to_current_<%= file_name %>, When logged out" do
-    before do
-      stub!(:current_<%= file_name %>).and_return(nil)
-    end
-    it "should link to the login_path" do
-      link_to_current_<%= file_name %>().should have_tag("a[href='/login']")
-    end
-    it "should use given link text if :content_text is specified" do
-      link_to_current_<%= file_name %>(:content_text => 'Hello there!').should have_tag("a", 'Hello there!')
-    end
-    it "should use 'not signed in' as link text with no :content_method specified" do
-      link_to_current_<%= file_name %>().should have_tag("a", 'not signed in')
-    end
-    it "should use the ip address as title" do
-      link_to_current_<%= file_name %>().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_<%= file_name %>().should_not have_tag("a.nickname")
-    end
-    it "should have some class if you tell it to" do
-      result = link_to_current_<%= file_name %>(:class => 'foo bar')
-      result.should have_tag("a.foo")
-      result.should have_tag("a.bar")
-    end
-  end
-
-end

data/vendor/plugins/restful-authentication/generators/authenticated/templates/spec/models/user_spec.rb

@@ -1,290 +0,0 @@
-# -*- coding: utf-8 -*-
-require File.dirname(__FILE__) + '<%= ('/..'*model_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 functional test.
-include AuthenticatedTestHelper
-
-describe <%= class_name %> do
-  fixtures :<%= table_name %>
-
-  describe 'being created' do
-    before do
-      @<%= file_name %> = nil
-      @creating_<%= file_name %> = lambda do
-        @<%= file_name %> = create_<%= file_name %>
-        violated "#{@<%= file_name %>.errors.full_messages.to_sentence}" if @<%= file_name %>.new_record?
-      end
-    end
-
-    it 'increments <%= class_name %>#count' do
-      @creating_<%= file_name %>.should change(<%= class_name %>, :count).by(1)
-    end
-<% if options[:include_activation] %>
-    it 'initializes #activation_code' do
-      @creating_<%= file_name %>.call
-      @<%= file_name %>.reload
-      @<%= file_name %>.activation_code.should_not be_nil
-    end
-<% end %><% if options[:stateful] %>
-    it 'starts in pending state' do
-      @creating_<%= file_name %>.call
-      @<%= file_name %>.reload
-      @<%= file_name %>.should be_pending
-    end
-<% end %>  end
-
-  #
-  # Validations
-  #
-
-  it 'requires login' do
-    lambda do
-      u = create_<%= file_name %>(:login => nil)
-      u.errors.on(:login).should_not be_nil
-    end.should_not change(<%= class_name %>, :count)
-  end
-
-  describe 'allows legitimate logins:' do
-    ['123', '1234567890_234567890_234567890_234567890',
-     'hello.-_there@funnychar.com'].each do |login_str|
-      it "'#{login_str}'" do
-        lambda do
-          u = create_<%= file_name %>(:login => login_str)
-          u.errors.on(:login).should     be_nil
-        end.should change(<%= class_name %>, :count).by(1)
-      end
-    end
-  end
-  describe 'disallows illegitimate logins:' do
-    ['12', '1234567890_234567890_234567890_234567890_', "tab\t", "newline\n",
-     "Iñtërnâtiônàlizætiøn hasn't happened to ruby 1.8 yet",
-     'semicolon;', 'quote"', 'tick\'', 'backtick`', 'percent%', 'plus+', 'space '].each do |login_str|
-      it "'#{login_str}'" do
-        lambda do
-          u = create_<%= file_name %>(:login => login_str)
-          u.errors.on(:login).should_not be_nil
-        end.should_not change(<%= class_name %>, :count)
-      end
-    end
-  end
-
-  it 'requires password' do
-    lambda do
-      u = create_<%= file_name %>(:password => nil)
-      u.errors.on(:password).should_not be_nil
-    end.should_not change(<%= class_name %>, :count)
-  end
-
-  it 'requires password confirmation' do
-    lambda do
-      u = create_<%= file_name %>(:password_confirmation => nil)
-      u.errors.on(:password_confirmation).should_not be_nil
-    end.should_not change(<%= class_name %>, :count)
-  end
-
-  it 'requires email' do
-    lambda do
-      u = create_<%= file_name %>(:email => nil)
-      u.errors.on(:email).should_not be_nil
-    end.should_not change(<%= class_name %>, :count)
-  end
-
-  describe 'allows legitimate emails:' do
-    ['foo@bar.com', 'foo@newskool-tld.museum', 'foo@twoletter-tld.de', 'foo@nonexistant-tld.qq',
-     'r@a.wk', '1234567890-234567890-234567890-234567890-234567890-234567890-234567890-234567890-234567890@gmail.com',
-     'hello.-_there@funnychar.com', 'uucp%addr@gmail.com', 'hello+routing-str@gmail.com',
-     'domain@can.haz.many.sub.doma.in', 'student.name@university.edu'
-    ].each do |email_str|
-      it "'#{email_str}'" do
-        lambda do
-          u = create_<%= file_name %>(:email => email_str)
-          u.errors.on(:email).should     be_nil
-        end.should change(<%= class_name %>, :count).by(1)
-      end
-    end
-  end
-  describe 'disallows illegitimate emails' do
-    ['!!@nobadchars.com', 'foo@no-rep-dots..com', 'foo@badtld.xxx', 'foo@toolongtld.abcdefg',
-     'Iñtërnâtiônàlizætiøn@hasnt.happened.to.email', 'need.domain.and.tld@de', "tab\t", "newline\n",
-     'r@.wk', '1234567890-234567890-234567890-234567890-234567890-234567890-234567890-234567890-234567890@gmail2.com',
-     # these are technically allowed but not seen in practice:
-     'uucp!addr@gmail.com', 'semicolon;@gmail.com', 'quote"@gmail.com', 'tick\'@gmail.com', 'backtick`@gmail.com', 'space @gmail.com', 'bracket<@gmail.com', 'bracket>@gmail.com'
-    ].each do |email_str|
-      it "'#{email_str}'" do
-        lambda do
-          u = create_<%= file_name %>(:email => email_str)
-          u.errors.on(:email).should_not be_nil
-        end.should_not change(<%= class_name %>, :count)
-      end
-    end
-  end
-
-  describe 'allows legitimate names:' do
-    ['Andre The Giant (7\'4", 520 lb.) -- has a posse',
-     '', '1234567890_234567890_234567890_234567890_234567890_234567890_234567890_234567890_234567890_234567890',
-    ].each do |name_str|
-      it "'#{name_str}'" do
-        lambda do
-          u = create_<%= file_name %>(:name => name_str)
-          u.errors.on(:name).should     be_nil
-        end.should change(<%= class_name %>, :count).by(1)
-      end
-    end
-  end
-  describe "disallows illegitimate names" do
-    ["tab\t", "newline\n",
-     '1234567890_234567890_234567890_234567890_234567890_234567890_234567890_234567890_234567890_234567890_',
-     ].each do |name_str|
-      it "'#{name_str}'" do
-        lambda do
-          u = create_<%= file_name %>(:name => name_str)
-          u.errors.on(:name).should_not be_nil
-        end.should_not change(<%= class_name %>, :count)
-      end
-    end
-  end
-
-  it 'resets password' do
-    <%= table_name %>(:quentin).update_attributes(:password => 'new password', :password_confirmation => 'new password')
-    <%= class_name %>.authenticate('quentin', 'new password').should == <%= table_name %>(:quentin)
-  end
-
-  it 'does not rehash password' do
-    <%= table_name %>(:quentin).update_attributes(:login => 'quentin2')
-    <%= class_name %>.authenticate('quentin2', 'monkey').should == <%= table_name %>(:quentin)
-  end
-
-  #
-  # Authentication
-  #
-
-  it 'authenticates <%= file_name %>' do
-    <%= class_name %>.authenticate('quentin', 'monkey').should == <%= table_name %>(:quentin)
-  end
-
-  it "doesn't authenticate <%= file_name %> with bad password" do
-    <%= class_name %>.authenticate('quentin', 'invalid_password').should be_nil
-  end
-
- if REST_AUTH_SITE_KEY.blank?
-   # old-school passwords
-   it "authenticates a user against a hard-coded old-style password" do
-     <%= class_name %>.authenticate('old_password_holder', 'test').should == <%= table_name %>(:old_password_holder)
-   end
- else
-   it "doesn't authenticate a user against a hard-coded old-style password" do
-     <%= class_name %>.authenticate('old_password_holder', 'test').should be_nil
-   end
-
-   # New installs should bump this up and set REST_AUTH_DIGEST_STRETCHES to give a 10ms encrypt time or so
-   desired_encryption_expensiveness_ms = 0.1
-   it "takes longer than #{desired_encryption_expensiveness_ms}ms to encrypt a password" do
-     test_reps = 100
-     start_time = Time.now; test_reps.times{ <%= class_name %>.authenticate('quentin', 'monkey'+rand.to_s) }; end_time   = Time.now
-     auth_time_ms = 1000 * (end_time - start_time)/test_reps
-     auth_time_ms.should > desired_encryption_expensiveness_ms
-   end
- end
-
-  #
-  # Authentication
-  #
-
-  it 'sets remember token' do
-    <%= table_name %>(:quentin).remember_me
-    <%= table_name %>(:quentin).remember_token.should_not be_nil
-    <%= table_name %>(:quentin).remember_token_expires_at.should_not be_nil
-  end
-
-  it 'unsets remember token' do
-    <%= table_name %>(:quentin).remember_me
-    <%= table_name %>(:quentin).remember_token.should_not be_nil
-    <%= table_name %>(:quentin).forget_me
-    <%= table_name %>(:quentin).remember_token.should be_nil
-  end
-
-  it 'remembers me for one week' do
-    before = 1.week.from_now.utc
-    <%= table_name %>(:quentin).remember_me_for 1.week
-    after = 1.week.from_now.utc
-    <%= table_name %>(:quentin).remember_token.should_not be_nil
-    <%= table_name %>(:quentin).remember_token_expires_at.should_not be_nil
-    <%= table_name %>(:quentin).remember_token_expires_at.between?(before, after).should be_true
-  end
-
-  it 'remembers me until one week' do
-    time = 1.week.from_now.utc
-    <%= table_name %>(:quentin).remember_me_until time
-    <%= table_name %>(:quentin).remember_token.should_not be_nil
-    <%= table_name %>(:quentin).remember_token_expires_at.should_not be_nil
-    <%= table_name %>(:quentin).remember_token_expires_at.should == time
-  end
-
-  it 'remembers me default two weeks' do
-    before = 2.weeks.from_now.utc
-    <%= table_name %>(:quentin).remember_me
-    after = 2.weeks.from_now.utc
-    <%= table_name %>(:quentin).remember_token.should_not be_nil
-    <%= table_name %>(:quentin).remember_token_expires_at.should_not be_nil
-    <%= table_name %>(:quentin).remember_token_expires_at.between?(before, after).should be_true
-  end
-<% if options[:stateful] %>
-  it 'registers passive <%= file_name %>' do
-    <%= file_name %> = create_<%= file_name %>(:password => nil, :password_confirmation => nil)
-    <%= file_name %>.should be_passive
-    <%= file_name %>.update_attributes(:password => 'new password', :password_confirmation => 'new password')
-    <%= file_name %>.register!
-    <%= file_name %>.should be_pending
-  end
-
-  it 'suspends <%= file_name %>' do
-    <%= table_name %>(:quentin).suspend!
-    <%= table_name %>(:quentin).should be_suspended
-  end
-
-  it 'does not authenticate suspended <%= file_name %>' do
-    <%= table_name %>(:quentin).suspend!
-    <%= class_name %>.authenticate('quentin', 'monkey').should_not == <%= table_name %>(:quentin)
-  end
-
-  it 'deletes <%= file_name %>' do
-    <%= table_name %>(:quentin).deleted_at.should be_nil
-    <%= table_name %>(:quentin).delete!
-    <%= table_name %>(:quentin).deleted_at.should_not be_nil
-    <%= table_name %>(:quentin).should be_deleted
-  end
-
-  describe "being unsuspended" do
-    fixtures :<%= table_name %>
-
-    before do
-      @<%= file_name %> = <%= table_name %>(:quentin)
-      @<%= file_name %>.suspend!
-    end
-
-    it 'reverts to active state' do
-      @<%= file_name %>.unsuspend!
-      @<%= file_name %>.should be_active
-    end
-
-    it 'reverts to passive state if activation_code and activated_at are nil' do
-      <%= class_name %>.update_all :activation_code => nil, :activated_at => nil
-      @<%= file_name %>.reload.unsuspend!
-      @<%= file_name %>.should be_passive
-    end
-
-    it 'reverts to pending state if activation_code is set and activated_at is nil' do
-      <%= class_name %>.update_all :activation_code => 'foo-bar', :activated_at => nil
-      @<%= file_name %>.reload.unsuspend!
-      @<%= file_name %>.should be_pending
-    end
-  end
-<% end %>
-protected
-  def create_<%= file_name %>(options = {})
-    record = <%= class_name %>.new({ :login => 'quire', :email => 'quire@example.com', :password => 'quire69', :password_confirmation => 'quire69' }.merge(options))
-    record.<% if options[:stateful] %>register! if record.valid?<% else %>save<% end %>
-    record
-  end
-end