ateam-merb-auth-old 0.0.1

data/plugins/forgotten_password/spec/spec_helper.rb

@@ -0,0 +1,36 @@
+dir = File.dirname(__FILE__)
+
+require 'rubygems'
+require 'spec'
+require 'merb-core'
+require 'merb-slices'
+
+Merb::BootLoader.before_app_loads do
+  Merb::Slices::config[:merb_auth][:forgotten_password] = true
+end
+
+require File.join(File.expand_path(dir), "..", "..", "..", "spec", "spec_helper.rb")
+
+  
+module Merb
+  def self.orm_generator_scope
+    "datamapper"
+  end
+end
+  
+
+DataMapper.setup(:default, 'sqlite3::memory:')
+adapter_path = File.expand_path(File.join(File.dirname(__FILE__), "..", "..", "..", "lib", "merb-auth", "adapters"))
+MA.register_adapter :datamapper, "#{adapter_path}/datamapper"
+MA.register_adapter :activerecord, "#{adapter_path}/activerecord"    
+MA.load_slice
+
+class User
+  include MA::Adapter::DataMapper
+end
+
+User.auto_migrate!
+MA.activate
+Merb::Router.prepare{|r| r.add_slice(:MerbAuth)}
+MA.load_plugins!
+

data/public/stylesheets/master.css

@@ -0,0 +1,2 @@
+html, body { margin: 0; padding: 0; }
+#container { width: 800px; margin: 4em auto; padding: 4em 4em 6em 4em; background: #DDDDDD; }

data/spec/controllers/plugins/test_plugin.rb

@@ -0,0 +1,17 @@
+module MerbAuth
+  module Controller
+    module Tester
+      def self.included(base)
+        base.send(:include, InstanceMethods)
+      end
+      
+      module InstanceMethods
+        def new
+          "NEW TEST"
+        end
+      end
+    end          
+  end
+  
+  Users.send(:include, Controller::Tester) # include the plugin into the Users controller to override the behaviour
+end

data/spec/controllers/sessions_spec.rb

@@ -0,0 +1,118 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe MA::Sessions, "Index action" do
+  
+  before(:all) do
+    Object.class_eval do
+      remove_const("User") if defined?(User)
+    end
+    
+    MA[:use_activation] = true
+    
+    DataMapper.setup(:default, 'sqlite3::memory:')
+    Merb.stub!(:orm_generator_scope).and_return("datamapper")
+    
+    adapter_path = File.join( File.dirname(__FILE__), "..", "..", "lib", "merb-auth", "adapters")
+    MA.register_adapter :datamapper, "#{adapter_path}/datamapper"
+    MA.register_adapter :activerecord, "#{adapter_path}/activerecord"    
+    MA.load_slice
+
+    class User
+      include MA::Adapter::DataMapper
+      include MerbAuth::Adapter::DataMapper::DefaultModelSetup
+    end
+
+  end
+  
+  before(:each) do
+    User.clear_database_table
+    u = User.new
+    u.valid?
+    @quentin = User.create(valid_user_hash.with(:email => "quentin@example.com", :password => "test", :password_confirmation => "test"))
+    @controller = MA::Sessions.new(fake_request)
+    @quentin.activate
+  end
+  
+  it "should have a route to Sessions#new from '/login'" do
+    request_to("/merb-auth/login") do |params|
+      params[:controller].should == "Sessions"
+      params[:action].should == "create"
+    end   
+  end
+  
+  it "should route to Sessions#create from '/login' via post" do
+    request_to("/merb-auth/login", :post) do |params|
+      params[:controller].should  == "Sessions"
+      params[:action].should      == "create"
+    end      
+  end
+  
+  it "should have a named route :login" do
+    @controller.url(:login).should == "/merb-auth/login"
+  end
+  
+  it "should have route to Sessions#destroy from '/logout' via delete" do
+    request_to("/merb-auth/logout", :delete) do |params|
+      params[:controller].should == "Sessions"
+      params[:action].should    == "destroy"
+    end   
+  end
+  
+  it "should route to Sessions#destroy from '/logout' via get" do
+    request_to("/merb-auth/logout") do |params|
+      params[:controller].should == "Sessions" 
+      params[:action].should     == "destroy"
+    end
+  end
+
+  it 'logins and redirects' do
+    controller = post "/merb-auth/login", :email => 'quentin@example.com', :password => 'test'
+    controller.session[:user].should_not be_nil
+    controller.session[:user].should == @quentin.id
+    controller.should redirect_to("/")
+  end
+   
+  it 'fails login and does not redirect' do
+    controller = post "/merb-auth/login", :email => 'quentin@example.com', :password => 'bad password'
+    controller.session[:user].should be_nil
+    controller.should be_successful
+  end
+
+  it 'logs out' do
+    controller = get("/merb-auth/logout"){|controller| controller.stub!(:current_user).and_return(@quentin) }
+    controller.session[:user].should be_nil
+    controller.should redirect
+  end
+
+  it 'remembers me' do
+    controller = post "/merb-auth/login", :email => 'quentin@example.com', :password => 'test', :remember_me => "1"
+    controller.cookies["auth_token"].should_not be_nil
+  end
+ 
+  it 'does not remember me' do
+    controller = post "/merb-auth/login", :email => 'quentin@example.com', :password => 'test', :remember_me => "0"
+    controller.cookies["auth_token"].should be_nil
+  end
+  
+  it 'deletes token on logout' do
+    controller = get("/merb-auth/logout") {|request| request.stub!(:current_user).and_return(@quentin) }
+    controller.cookies["auth_token"].should == nil
+  end
+  
+  
+  it 'logs in with cookie' do
+    @quentin.remember_me
+    controller = get "/merb-auth/login" do |c|
+      c.request.env[Merb::Const::HTTP_COOKIE] = "auth_token=#{@quentin.remember_token}"
+    end
+    controller.should be_logged_in
+  end
+
+  def auth_token(token)
+    CGI::Cookie.new('name' => 'auth_token', 'value' => token)
+  end
+    
+  def cookie_for(user)
+    auth_token user.remember_token
+  end
+end

data/spec/controllers/users_spec.rb

@@ -0,0 +1,119 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe MA::Users do
+  
+  before(:all) do
+    
+    
+    MA[:use_activation] = true
+    
+    DataMapper.setup(:default, 'sqlite3::memory:')
+    Merb.stub!(:orm_generator_scope).and_return("datamapper")
+    
+    adapter_path = File.join( File.dirname(__FILE__), "..", "..", "lib", "merb-auth", "adapters")
+    MA.register_adapter :datamapper, "#{adapter_path}/datamapper"
+    MA.register_adapter :activerecord, "#{adapter_path}/activerecord"    
+    MA.load_slice
+    MA.activate
+
+    class User
+      include MA::Adapter::DataMapper
+      include MerbAuth::Adapter::DataMapper::DefaultModelSetup
+    end
+  end
+  
+  before(:each) do
+    User.clear_database_table
+  end
+  
+  it "should have MixinSessionContainer mixed into the User Controller" do
+    Merb::Controller.should include(::Merb::SessionMixin)    
+  end
+  
+  it "should provide a current_ma_user method" do
+    MA::Users.new({}).should respond_to(:current_ma_user)
+    MA::Users.new({}).should respond_to(:current_user)
+  end
+  
+  it "should provide a current_user method" do
+    MA::Users.new({}).should respond_to(:current_ma_user=)
+    MA::Users.new({}).should respond_to(:current_user=)
+  end
+  
+  it 'allows signup' do
+     # lambda do
+     users = User.count
+       controller = create_user
+       controller.should redirect      
+     User.count.should == (users + 1)
+     # end.should change(User, :count).by(1)
+   end
+    
+   it 'requires password on signup' do
+     lambda do
+       controller = create_user(:password => nil)
+       controller.assigns(:user).errors.on(:password).should_not be_nil
+       controller.should respond_successfully
+     end.should_not change(User, :count)
+   end
+     
+   it 'requires password confirmation on signup' do
+     lambda do
+       controller = create_user(:password_confirmation => nil)
+       controller.assigns(:user).errors.should_not be_empty
+       controller.should respond_successfully
+     end.should_not change(User, :count)
+   end
+   
+   it 'requires email on signup' do
+     lambda do
+       controller = create_user(:email => nil)
+       controller.assigns(:user).errors.on(:email).should_not be_nil
+       controller.should respond_successfully
+     end.should_not change(User, :count)
+   end
+   
+   it "should have a route for user activation" do
+     request_to("/merb-auth/users/activate/1234") do |params|
+       params[:controller].should == "Users"
+       params[:action].should == "activate" 
+       params[:activation_code].should == "1234"    
+     end
+   end
+
+   it 'activates user' do
+     controller = create_user(:email => "aaron@example.com", :password => "test", :password_confirmation => "test")
+     @user = controller.assigns(:user)
+     User.authenticate('aaron@example.com', 'test').should be_nil
+     controller = get "/merb-auth/users/activate/#{@user.activation_code}" 
+     controller.should redirect_to("/")
+     User.authenticate('aaron@example.com', 'test').should_not be_nil
+   end
+
+  it "should log the user in automatically on creation if :use_activation is false" do
+    MA[:use_activation] = false
+    dispatch_to(MA::Users, :create, :user => {:email => "aaron@example.com", :password => "test", :password_confirmation => "test"}) do |c|
+      u = mock("user")
+      User.should_receive(:new).and_return(u)
+      u.should_receive(:save).and_return(true)
+      c.should_receive(:current_ma_user=).with(u)
+    end
+  end
+
+  it "should not log the user in automatically on creation if :use_activation is true" do
+    MA[:use_activation] = true
+    dispatch_to(MA::Users, :create, :user => {:email => "aaron@example.com", :password => "test", :password_confirmation => "test"}) do |c|
+      u = mock("user")
+      User.should_receive(:new).and_return(u)
+      u.should_receive(:save).and_return(true)
+      c.should_not_receive(:current_ma_user=)
+    end
+  end
+
+   
+   
+     
+   def create_user(options = {})
+     post "/merb-auth/users/", :user => valid_user_hash.merge(options)
+   end
+end

data/spec/mailers/user_mailer_spec.rb

@@ -0,0 +1,75 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe MA::UserMailer do
+  
+  before(:all) do
+    MA[:use_activation] = true
+    
+    DataMapper.setup(:default, 'sqlite3::memory:')
+    Merb.stub!(:orm_generator_scope).and_return("datamapper")
+    
+    adapter_path = File.join( File.dirname(__FILE__), "..", "..", "lib", "merb-auth", "adapters")
+    MA.register_adapter :datamapper, "#{adapter_path}/datamapper"
+    MA.register_adapter :activerecord, "#{adapter_path}/activerecord"    
+    MA.loaded
+
+    class User
+      include MA::Adapter::DataMapper
+      include MerbAuth::Adapter::DataMapper::DefaultModelSetup
+    end
+  end
+  
+  def deliver(action, mail_opts= {},opts = {})
+    MA::UserMailer.dispatch_and_deliver action, mail_opts, opts
+    @delivery = Merb::Mailer.deliveries.last
+  end
+  
+  before(:each) do
+    @u = MA[:user].new(:email => "homer@simpsons.com", :login => "homer", :activation_code => "12345")
+    @mailer_params = { :from      => "info@mysite.com",
+                       :to        => @u.email,
+                       :subject   => "Welcome to MySite.com" }
+  end
+  
+  after(:each) do
+    Merb::Mailer.deliveries.clear
+  end
+  
+  it "should send mail to homer@simpsons.com for the signup email" do
+    deliver(:signup, @mailer_params, :user => @u)
+    @delivery.assigns(:headers).should include("to: homer@simpsons.com")
+  end
+  
+  it "should send the mail from 'info@mysite.com' for the signup email" do
+    deliver(:signup, @mailer_params, :user => @u)
+    @delivery.assigns(:headers).should include("from: info@mysite.com")
+  end
+  
+  it "should mention the users login in the text signup mail" do
+    deliver(:signup, @mailer_params, :user => @u)
+    @delivery.text.should include(@u.email)
+  end
+  
+  it "should mention the activation link in the signup emails" do
+    deliver(:signup, @mailer_params, :user => @u)
+    the_url = MA::UserMailer.new.url(:user_activation, :activation_code => @u.activation_code)
+    the_url.should_not be_nil
+    @delivery.text.should include( the_url )   
+  end
+  
+  it "should send mail to homer@simpson.com for the activation email" do
+    deliver(:activation, @mailer_params, :user => @u)
+    @delivery.assigns(:headers).should include("to: homer@simpsons.com")
+  end
+  
+  it "should send the mail from 'info@mysite.com' for the activation email" do
+    deliver(:activation, @mailer_params, :user => @u)
+    @delivery.assigns(:headers).should include("from: info@mysite.com")    
+  end
+  
+  it "should mention ther users login in the text activation mail" do
+    deliver(:activation, @mailer_params, :user => @u)
+    @delivery.text.should include(@u.email)
+  end
+
+end

data/spec/merb_auth_spec.rb

@@ -0,0 +1,231 @@
+require File.dirname(__FILE__) + '/spec_helper'
+require 'activerecord'
+require 'dm-core'
+
+# For note purposes
+# Merb::Slices.register_and_load(../../lib/merb-auth.rb)
+
+describe MerbAuth do
+  
+  before(:all) do
+    @adapter_path = File.dirname(__FILE__) / ".." / "lib" / "merb-auth" / "adapters"
+    @ar_path = @adapter_path / "activerecord"
+    @config = Merb::Slices::config[:merb_auth]
+    DataMapper.setup(:default, 'sqlite3::memory:')
+  end
+  
+  before(:each) do
+    register_activerecord!
+    register_datamapper!
+    register_sequel!
+  end
+  
+  after(:each) do
+    MA.clear_adapter_list!
+    MA[:user] = nil
+    ::DataMapper::Resource.descendants.delete(User) if defined?(User)
+    Object.class_eval do
+      remove_const("User") if defined?(User)
+    end
+    MA::Adapter.module_eval do
+      remove_const("DataMapper") if defined?(MA::Adapter::DataMapper)
+    end if defined?(MA::Adapter)
+  end
+  
+  def stub_orm_scope(scope = "datamapper")
+    Merb.stub!(:orm_generator_scope).and_return(scope)
+  end
+  
+  def register_activerecord!
+    MA.register_adapter :activerecord, "#{@adapter_path}/activerecord"
+  end
+  
+  def register_datamapper!
+    MA.register_adapter :datamapper, "#{@adapter_path}/datamapper"
+  end
+
+  def register_sequel!
+    MA.register_adapter :sequel, "#{@adapter_path}/sequel"
+  end
+  
+  describe "Adapter Loading" do
+  
+    it "should allow adapters to register themselves" do
+      MA.adapters[:activerecord][:path].should == @ar_path
+    end
+  
+    it "should clear the registered adapters (for specs only)" do
+      MA.adapters.should_not be_empty
+      MA.clear_adapter_list!
+      MA.adapters.should be_empty
+    end
+  
+    it "should return a hash of registered adapters" do
+      MA.adapters.should be_a_kind_of(Hash)
+      MA.adapters.keys.should include(:activerecord)
+      MA.adapters.keys.should include(:datamapper)
+      MA.adapters.keys.should include(:sequel)
+    end
+  
+    it "should load the adapter" do
+      defined?(MA::Adapter::DataMapper).should be_nil
+      MA.load_adapter!(:datamapper)
+      defined?(MA::Adapter::DataMapper).should_not be_nil
+    end
+    
+    it "should raise an error if an adapter is loaded that has not been registered" do
+      lambda do
+        MA.load_adapter!(:no_adapter)
+      end.should raise_error(RuntimeError, "MerbAuth: Adapter Not Registered - no_adapter")
+    end
+    
+    it "should load the adapter scope as the type if there is no specified adapter type" do
+      Merb.should_receive(:orm_generator_scope).and_return("datamapper")
+      MA.load_adapter!
+    end
+
+    it "should load the correct adapter in the loaded hook" do
+      stub_orm_scope
+      defined?(MA::Adapter::DataMapper).should be_nil
+      MA.loaded
+      defined?(MA::Adapter::DataMapper).should_not be_nil    
+    end
+  
+    it "should expose the adapter model class via the configuration" do
+      stub_orm_scope
+      MA.load_adapter!
+      class User
+        include MA::Adapter::DataMapper
+      end
+      MA[:user].should == User
+    end
+    
+    it "should allow DM to create it's table correctly" do
+      stub_orm_scope 
+      MA[:user] = nil
+      MA.load_adapter!
+      class User
+        include MA::Adapter::DataMapper
+        include MA::Adapter::DataMapper::DefaultModelSetup
+      end
+      
+      results = DataMapper.auto_migrate!
+      results.should include(User)
+    end
+    
+  end
+
+  describe "controller Plugin loading" do
+        
+    def add_test_plugin!
+      MA.plugins["Tester"] = File.join(File.dirname(__FILE__), "controllers", "plugins", "test_plugin.rb")
+    end
+    
+    before(:each) do
+      reload_ma!
+    end
+        
+    after(:all) do
+      reload_ma!
+    end
+    
+    it "should allow for registration" do
+      defined?(MA::Controller::Tester).should be_nil
+      reload_ma!("User"){  add_test_plugin! }
+      defined?(MA::Controller::Tester).should_not be_nil
+      MA::Users.should include(MA::Controller::Tester)
+    end
+    
+    it "should overwrite the new method" do
+      Object.class_eval <<-EOS
+        class User
+          include MerbAuth::Adapter::DataMapper
+          include MerbAuth::Adapter::DataMapper::DefaultModelSetup
+        end
+        EOS
+      controller = dispatch_to(MA::Users, :new)
+      controller.body.should_not == "NEW TEST"
+      reload_ma!("User"){ add_test_plugin!}
+      controller = dispatch_to(MA::Users, :new)
+      controller.body.should == "NEW TEST"      
+    end
+  end
+
+end
+
+describe "MerbAuth (module)" do
+  
+  # Feel free to remove the specs below
+  
+  it "should be registered in Merb::Slices.slices" do
+    Merb::Slices.slices.should include(MerbAuth)
+  end
+  
+  it "should have an :identifier property" do
+    MerbAuth.identifier.should == "merb-auth"
+  end
+  
+  it "should have an :identifier_sym property" do
+    MerbAuth.identifier_sym.should == :merb_auth
+  end
+  
+  it "should have a :root property" do
+    MerbAuth.root.should == current_slice_root
+    MerbAuth.root_path('app').should == current_slice_root / 'app'
+  end
+  
+  it "should have metadata properties" do
+    MerbAuth.description.should == "MerbAuth is a Merb slice that provides authentication"
+    MerbAuth.version.should == "0.1.0"
+    MerbAuth.author.should == "Merb Core"
+  end
+  
+  it "should have a config property (Hash)" do
+    MerbAuth.config.should be_kind_of(Hash)
+  end
+  
+  it "should have a :layout config option set" do
+    MerbAuth.config[:layout].should == :merb_auth
+  end
+  
+  it "should have a dir_for method" do
+    app_path = MerbAuth.dir_for(:application)
+    app_path.should == current_slice_root / 'app'
+    [:view, :model, :controller, :helper, :mailer, :part].each do |type|
+      MerbAuth.dir_for(type).should == app_path / "#{type}s"
+    end
+    public_path = MerbAuth.dir_for(:public)
+    public_path.should == current_slice_root / 'public'
+    [:stylesheet, :javascript, :image].each do |type|
+      MerbAuth.dir_for(type).should == public_path / "#{type}s"
+    end
+  end
+  
+  it "should have a app_dir_for method" do
+    root_path = MerbAuth.app_dir_for(:root)
+    root_path.should == Merb.root / 'slices' / 'merb-auth'
+    app_path = MerbAuth.app_dir_for(:application)
+    app_path.should == root_path / 'app'
+    [:view, :model, :controller, :helper, :mailer, :part].each do |type|
+      MerbAuth.app_dir_for(type).should == app_path / "#{type}s"
+    end
+    public_path = MerbAuth.app_dir_for(:public)
+    public_path.should == Merb.dir_for(:public) / 'slices' / 'merb-auth'
+    [:stylesheet, :javascript, :image].each do |type|
+      MerbAuth.app_dir_for(type).should == public_path / "#{type}s"
+    end
+  end
+  
+  it "should have a public_dir_for method" do
+    public_path = MerbAuth.public_dir_for(:public)
+    public_path.should == '/slices' / 'merb-auth'
+    [:stylesheet, :javascript, :image].each do |type|
+      MerbAuth.public_dir_for(type).should == public_path / "#{type}s"
+    end
+  end
+  
+  it "should keep a list of path component types to use when copying files" do
+    (MerbAuth.mirrored_components & MerbAuth.slice_paths.keys).length.should == MerbAuth.mirrored_components.length
+  end
+  
+end