muck-users 3.2.6 → 3.2.7

data/test/spec/controllers/users_controller_spec.rb

@@ -0,0 +1,427 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe Muck::UsersController do
+
+  render_views
+  
+  it { should require_login :welcome, :get }
+  it { should require_login :edit, :get }
+  
+  describe "configuration tests" do
+    teardown do
+      MuckUsers.configuration.automatically_activate = false
+      MuckUsers.configuration.automatically_login_after_account_create = false
+    end
+    
+    describe "automatically activate account and log user in. " do
+      before(:each) do
+        MuckUsers.configuration.automatically_activate = true
+        MuckUsers.configuration.automatically_login_after_account_create = true
+      end
+      describe "on POST to :create" do
+        describe "html" do
+          before(:each) do
+            post_create_user
+          end
+          it { should redirect_to(signup_complete_path(assigns(:user))) }
+          it "should activate user" do
+            assigns(:user).active?.should be_true
+          end
+          it "should be logged in" do
+            user_session = UserSession.find
+            user_session.should_not be_nil
+          end
+        end
+        describe "json" do
+          before(:each) do
+            post_create_user_json
+          end
+          it "should return json" do
+            user = JSON.parse(@response.body)
+            user['success'].should be_true
+            user['user']['login'].should == "testguy"
+          end
+          it "should activate user" do
+            assigns(:user).active?.should be_true
+          end
+          it "should be logged in" do
+            user_session = UserSession.find
+            user_session.should_not be_nil
+          end
+        end
+        describe "xml" do
+          before(:each) do
+            post_create_user_xml
+          end
+          it "should activate user" do
+            assert assigns(:user).active? == true, "user was not activated"
+          end
+          it "should be logged in" do
+            user_session = UserSession.find
+            user_session.should_not be_nil
+          end
+        end        
+      end
+      describe "on POST to :create with bad login (space in login name)" do
+        before(:each) do
+          post_create_user(:login => 'test guy')
+        end
+        it { should respond_with :success }
+        it { should render_template :new }
+        it "should assign an error to the login field" do
+          assigns(:user).errors[:login].should_not be_empty
+        end
+      end
+    end
+  
+    describe "automatically activate account do not log user in" do
+      before(:each) do
+        MuckUsers.configuration.automatically_activate = true
+        MuckUsers.configuration.automatically_login_after_account_create = false
+      end
+      describe "on POST to :create" do  
+        before(:each) do
+          post_create_user 
+        end                             
+        it {should redirect_to(signup_complete_login_required_path(assigns(:user))) }
+      end    
+      describe "on POST to :create with bad login (space in login name)" do
+        before(:each) do
+          post_create_user(:login => 'test guy')
+        end
+        it { should respond_with :success }
+        it { should render_template :new }
+        it "should assign an error to the login field" do
+          assigns(:user).errors[:login].should_not be_empty
+        end
+      end   
+    end
+  
+    describe "do not auto activate. do not login after create" do
+      before(:each) do
+        MuckUsers.configuration.automatically_activate = false
+        MuckUsers.configuration.automatically_login_after_account_create = false
+      end
+      describe "on POST to :create -- Allow signup. " do
+        before(:each) do
+          post_create_user
+        end                                
+        it {should redirect_to(signup_complete_activation_required_path(assigns(:user)))}
+      end
+      describe "on POST to :create -- require login on signup. " do
+        before(:each) do
+          post_create_user :login => ''
+        end
+        it { should respond_with :success }
+        it { should render_template :new }
+        it "should assign an error to the login field" do
+          assigns(:user).errors[:login].should_not be_empty
+        end                                       
+      end
+      describe "on POST to :create with bad login (space in login name)" do
+        before(:each) do
+          post_create_user(:login => 'test guy')
+        end
+        it { should respond_with :success }
+        it { should render_template :new }
+        it "should assign an error to the login field" do
+          assigns(:user).errors[:login].should_not be_empty
+        end
+      end
+      describe "on POST to :create -- require password on signup. " do
+        before(:each) do 
+          post_create_user(:password => nil)
+        end
+        it { should respond_with :success }
+        it { should render_template :new }
+        it "should assign an error to the password field" do
+          assigns(:user).errors[:password].should_not be_empty
+        end                                       
+      end
+      describe "on POST to :create -- require password confirmation on signup. " do
+        before(:each) do
+          post_create_user(:password_confirmation => nil)
+        end
+        it { should respond_with :success }
+        it { should render_template :new }
+          
+        it "should assign an error to the password confirmation field" do
+          assigns(:user).errors[:password_confirmation].should_not be_empty
+        end                                       
+      end
+      describe "on POST to :create -- require email on signup. " do
+        before(:each) do
+          post_create_user(:email => nil)
+        end
+        it { should respond_with :success }
+        it { should render_template :new }
+        it "should assign an error to the email field" do
+          assigns(:user).errors[:email].should_not be_empty 
+        end                                       
+      end
+    end
+  end
+  
+  describe "logged in" do
+    before(:each) do
+      activate_authlogic
+      @user = Factory(:user)
+      login_as @user
+    end
+    
+    describe "on GET to :welcome" do
+      before(:each) do
+        get :welcome, :id => @user.to_param
+      end
+      it { should respond_with :success }
+      it { should render_template :welcome }
+    end
+
+    describe "on GET to new (signup) while logged in" do
+      before(:each) do
+        get :new
+      end
+      it {should redirect_to(user_url(@user))}
+    end
+
+    describe "on GET to show" do
+      before(:each) do
+        get :show
+      end
+      it { should respond_with :success }
+      it { should render_template :show }
+    end
+    
+    describe "on GET to show (json)" do
+      before(:each) do
+        get :show, :format => 'json'
+      end
+      it { should respond_with :success }
+      it "should render user information as json" do
+        data = JSON.parse(response.body)
+        data['user'].should_not be_blank
+      end
+    end
+    
+    describe "on GET to edit" do
+      before(:each) do
+        get :edit, :id => @user.to_param
+      end
+      it { should respond_with :success }
+      it { should render_template :edit }
+    end
+    
+    describe "on GET to edit logged in but wrong user" do
+      before(:each) do
+        @other_user = Factory(:user)
+        get :edit, :id => @other_user.to_param
+      end
+      it { should respond_with :success }
+      it "should set the user to the logged in user" do
+        assert_equal assigns(:user), @user
+      end
+    end
+    
+    describe "on PUT to :update" do
+      before(:each) do
+        put_update_user(@user)
+      end
+      it {should redirect_to(user_path(@user))}
+    end
+    
+  end
+  
+  describe "not logged in" do
+    before(:each) do
+      assure_logout
+    end
+    describe "on GET to :welcome" do
+      before(:each) do
+        @user = Factory(:user)
+        get :welcome, :id => @user.to_param
+      end
+      it {should redirect_to(login_path)}
+    end
+    describe "on GET to :activation_instructions" do
+      before(:each) do
+        @user = Factory(:user)
+        get :activation_instructions, :id => @user.to_param
+      end
+      it { should respond_with :success }
+      it { should render_template :activation_instructions }
+    end
+    describe "GET to new" do
+      describe "standard signup" do
+        before(:each) do
+          get :new
+        end
+        it { should respond_with :success }
+        it { should render_template :new }
+      end
+    end
+    describe "on GET to show" do
+      before(:each) do
+        @user = Factory(:user)
+        get :show
+      end
+      it {should redirect_to(login_path)}
+    end
+    describe "on GET to edit" do
+      before(:each) do
+        @user = Factory(:user)
+        get :edit, :id => @user.to_param
+      end
+      it {should redirect_to(login_path)}
+    end
+    describe "on PUT to :update" do
+      before(:each) do
+        @user = Factory(:user)
+        put_update_user(@user)
+      end
+      it {should redirect_to(login_path)}
+    end
+  end
+  
+  describe "GET to login_search" do
+    before(:each) do
+      @auser = Factory(:user, :login => 'aaaa')
+      @zuser = Factory(:user, :login => 'zzzz')
+    end
+    describe "valid params" do
+      before(:each) do
+        get :login_search, :q => 'a', :format => 'js'
+      end
+      it { should respond_with :success }
+      it "should find a user" do
+        @response.body.should include('aaaa')
+        assigns(:users).should include(@auser)
+      end
+      it "should not find a non-matching user" do
+        @response.body.should_not include('zzzz')
+      end
+    end
+    describe "empty params" do
+      before(:each) do
+        get :login_search, :q => nil, :format => 'js'
+      end
+      it { should respond_with :success }
+      it "should return all users" do
+        assigns(:users).should_not be_blank
+      end
+    end
+  end
+  
+  describe "POST to is_login_available" do
+    describe "no params" do
+      before(:each) do
+        post :is_login_available
+      end
+      it { should respond_with :success }
+      it { @response.body.should include('<span class="unavailable"></span>') }
+    end
+    describe "empty login" do
+      before(:each) do
+        post :is_login_available, :user_login => ''
+      end
+      it { should respond_with :success }
+      it { @response.body.should include('<span class="unavailable">' + I18n.t('muck.users.login_empty') + '</span>') }
+    end
+    describe "valid login" do
+      before(:each) do
+        post :is_login_available, :user_login => 'testdude1945'
+      end
+      it { should respond_with :success }
+      it { @response.body.should include('<span class="available">' + I18n.t('muck.users.username_available') + '</span>') }
+    end
+    describe "invalid login" do
+      before(:each) do
+        post :is_login_available, :user_login => 'testdude1945@example.comm'
+      end
+      it { should respond_with :success }
+      it { response.body.should include(I18n.t('muck.users.invalid_username')) }
+    end
+    describe "login not available" do
+      before(:each) do
+        @user = Factory(:user)
+        post :is_login_available, :user_login => @user.login
+      end
+      it { should respond_with :success }
+      it { response.body.should include(I18n.t('muck.users.username_not_available', :reset_password_help => '')) }
+    end
+  end
+  
+  describe "POST to is_email_available" do
+    describe "no params" do
+      before(:each) do
+        post :is_email_available
+      end
+      it { should respond_with :success }
+      it { response.body.should include('<span class="available"></span>') }
+    end
+    describe "empty email" do
+      before(:each) do
+        post :is_email_available, :user_email => ''
+      end
+      it { should respond_with :success }
+      it { response.body.should include('<span class="available">' + I18n.t('muck.users.email_empty') + '</span>') }
+    end
+    describe "valid email" do
+      before(:each) do
+        post :is_email_available, :user_email => 'testdude1945@example.com'
+      end
+      it { should respond_with :success }
+      it { response.body.should include('<span class="available">' + I18n.t('muck.users.email_available') + '</span>') }
+    end
+    describe "invalid email" do
+      before(:each) do
+        post :is_email_available, :user_email => 'testdude1945@com'
+      end
+      it { should respond_with :success }
+      it { response.body.should include('<span class="unavailable">' + I18n.t('muck.users.email_invalid') + '</span>') }
+    end
+    describe "email not available" do
+      before(:each) do
+        @user = Factory(:user)
+        post :is_email_available, :user_email => @user.email
+      end
+      it { should respond_with :success }
+      it "should indicate the email is not available" do
+        response.body.should include(I18n.t('muck.users.email_not_available', :reset_password_help => ''))
+      end
+    end
+  end
+  
+  def put_update_user(user, options = {})
+    put :update,
+      :id => user.id, 
+      :user => user_params(options)
+  end
+
+  def post_create_user(options = {})
+    post :create, 
+      :user => user_params(options)
+  end
+
+  def post_create_user_json(options = {})
+    post :create, 
+      :user => user_params(options),
+      :format => 'json'
+  end
+  
+  def post_create_user_xml(options = {})
+    post :create, 
+      :user => user_params(options),
+      :format => 'xml'
+  end
+  
+  def user_params(options = {})
+    { :login => 'testguy', 
+      :email => rand(1000).to_s + 'testguy@example.com', 
+      :password => 'testpasswrod', 
+      :password_confirmation => 'testpasswrod', 
+      :first_name => 'Ed',
+      :last_name => 'Decker',
+      :terms_of_service => true }.merge(options)
+  end
+  
+end

data/test/spec/helpers/muck_users_helper_spec.rb

@@ -0,0 +1,70 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe MuckUsersHelper do
+  
+  before do
+    @user = Factory(:user)
+  end
+  
+  describe "signup_form" do
+    it "should render the sign up form" do
+      title = 'This is a great title for a test sign up form.'
+      helper.signup_form(@user, nil, {:title => title}).should include(title)
+    end
+    
+    describe "signup with access codes enabled" do
+      before do
+        MuckUsers.configuration.stub!(:require_access_code).and_return(true)
+      end
+      describe "with valid access code" do
+        before(:each) do
+          @access_code = Factory(:access_code, :sent_to => 'testguy@example.com')
+        end
+        it "should include an access code from the params" do
+          params = {}
+          params[:access_code] = @access_code.code
+          helper.stub!(:params).and_return(params)
+          helper.signup_form(@user).should include('testguy@example.com')
+        end
+        it "should include an access code from the session" do
+          controller.session[:access_code] = @access_code.code
+          helper.signup_form(@user).should include('testguy@example.com')
+        end
+        it "should leave @access_code_help blank" do
+          params = {}
+          params[:access_code] = @access_code.code
+          helper.stub!(:params).and_return(params)
+          helper.signup_form(@user).should_not include('id="access_code_help"')
+        end
+      end
+      describe "without valid access code" do
+        before(:each) do
+          controller.params = {:access_code => 'bogus'}
+        end
+        it "should not find the access code" do
+          helper.signup_form(@user).should include('access-code-not-found-msg')
+        end
+      end
+    end
+  end
+  
+  describe "signin_form" do
+    it "should render the sign in form" do
+      title = 'This is a great title for a test sign in form.'
+      helper.signin_form({:title => title}).should include(title)
+    end
+  end
+  
+  describe "random_access_code" do
+    before do
+      @user = Factory(:user)
+    end
+    it "should generate a random access code" do
+      helper.random_access_code(@user).code.should_not be_blank
+    end
+    it "should assign the provided_by user" do
+      helper.random_access_code(@user).provided_by.should == @user
+    end
+  end
+  
+end

data/test/spec/mailers/user_mailer_spec.rb

@@ -0,0 +1,108 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe UserMailer do
+  
+  before(:each) do
+    ActionMailer::Base.delivery_method = :test
+    ActionMailer::Base.perform_deliveries = true
+    ActionMailer::Base.deliveries = []
+  end
+
+  it "should send activation confirmation email" do
+    user = Factory(:user)
+    email = UserMailer.activation_confirmation(user).deliver
+    ActionMailer::Base.deliveries.should_not be_empty
+    email.to.should == [user.email]
+    email.from.should == [MuckEngine.configuration.from_email]
+    email.subject.should == I18n.t('muck.users.activation_complete')
+    #email.body.should include(user.login)
+  end
+
+  it "should send activation instructions email" do
+    user = Factory(:user)
+    email = UserMailer.activation_instructions(user).deliver
+    ActionMailer::Base.deliveries.should_not be_empty
+    email.to.should == [user.email]
+    email.from.should == [MuckEngine.configuration.from_email]
+    email.subject.should == I18n.t('muck.users.activation_instructions')
+    #email.body.should include(user.login)
+  end
+
+  it "should send password reset account not active instructions email" do
+    user = Factory(:user)
+    email = UserMailer.password_not_active_instructions(user).deliver
+    ActionMailer::Base.deliveries.should_not be_empty
+    email.to.should == [user.email]
+    email.from.should == [MuckEngine.configuration.from_email]
+    email.subject.should == I18n.t('muck.users.account_not_activated', :application_name => MuckEngine.configuration.application_name)
+  end
+  
+  it "should send password reset instructions email" do
+    user = Factory(:user)
+    email = UserMailer.password_reset_instructions(user).deliver
+    ActionMailer::Base.deliveries.should_not be_empty
+    email.to.should == [user.email]
+    email.from.should == [MuckEngine.configuration.from_email]
+    email.subject.should == I18n.t('muck.users.password_reset_email_subject', :application_name => MuckEngine.configuration.application_name)
+  end
+  
+  it "should send username request email" do
+    user = Factory(:user)
+    email = UserMailer.username_request(user).deliver
+    ActionMailer::Base.deliveries.should_not be_empty
+    email.to.should == [user.email]
+    email.from.should == [MuckEngine.configuration.from_email]
+    email.subject.should == I18n.t('muck.users.request_username_subject', :application_name => MuckEngine.configuration.application_name)
+  end
+  
+  it "should send welcome email" do
+    user = Factory(:user)
+    email = UserMailer.welcome_notification(user).deliver
+    ActionMailer::Base.deliveries.should_not be_empty
+    email.to.should == [user.email]
+    email.from.should == [MuckEngine.configuration.from_email]
+    email.subject.should == I18n.t('muck.users.welcome_email_subject', :application_name => MuckEngine.configuration.application_name)
+  end
+  
+  describe "access code email" do
+    before do
+      @email_address = 'testguy@example.com'
+      @subject = 'test subject'
+      @message = 'test message'
+      @code = 'testcode'
+    end
+    it "should send access code email" do
+      email = UserMailer.access_code(@email_address, @subject, @message, @code).deliver
+      ActionMailer::Base.deliveries.should_not be_empty
+      email.to.should == [@email_address]
+      email.from.should == [MuckEngine.configuration.from_email]
+      email.subject.should == @subject
+      email.body.parts[0].body.should include(@message)
+      email.body.parts[0].body.should include(@code)
+    end
+    it "should set code_included to true" do
+      @message = "message that includes {code}"
+      email = UserMailer.access_code(@email_address, @subject, @message, @code).deliver
+      email.body.parts[0].body.should include(@message.gsub('{code}', @code))
+      email.body.parts[0].body.should_not include("<p>Access Code: #{@code}</p>")
+    end
+    it "should set signup_link_included to true" do
+      # HACK the signup link shouldn't be hard coded. It needs to be stubbed somehow - just not sure how.
+      signup = '<a href="http://localhost:3000/signup?access_code=testcode">Click here to sign up now.</a>'
+      @message = "message that includes {signup_link}"      
+      email = UserMailer.access_code(@email_address, @subject, @message, @code).deliver
+      email.body.parts[0].body.should include(@message.gsub('{signup_link}', signup))
+      email.body.parts[0].body.should_not include("<p>#{signup}</p>")
+    end
+  end
+  
+  it "should send access code request confirmation email" do
+    email_address = 'testguy@example.com'
+    email = UserMailer.access_code_request_confirm(email_address).deliver
+    ActionMailer::Base.deliveries.should_not be_empty
+    email.to.should == [email_address]
+    email.from.should == [MuckEngine.configuration.from_email]
+    email.subject.should == I18n.t('muck.users.access_code_request_confirm_subject', :application_name => MuckEngine.configuration.application_name)
+  end
+  
+end