muck-users 3.2.12 → 3.2.13

data/test/spec/helpers/muck_users_helper_spec.rb

@@ -1,70 +0,0 @@
-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

@@ -1,108 +0,0 @@
-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

data/test/spec/models/access_code_request_spec.rb

@@ -1,105 +0,0 @@
-require File.dirname(__FILE__) + '/../spec_helper'
-
-describe AccessCodeRequest do
-
-  before(:each) do
-    @access_code_request = Factory(:access_code_request)
-  end
-  
-  
-  
-  it { should validate_presence_of :email }
-  #it { should validate_uniqueness_of :email }
-
-  describe "named scopes" do
-    it {should scope_by_newest}
-    it {should scope_by_oldest}
-    
-    describe "unfullfilled" do
-      #scope :unfilled, where('access_code_requests.code_sent_at IS NULL')
-      before(:each) do
-        AccessCodeRequest.delete_all
-        @fullfilled = Factory(:access_code_request, :code_sent_at => DateTime.now)
-        @unfullfilled = Factory(:access_code_request)
-      end
-      it "should find unfullfilled requests" do
-        assert !AccessCodeRequest.unfullfilled.include?(@fullfilled)
-        assert AccessCodeRequest.unfullfilled.include?(@unfullfilled)
-      end
-    end
-    
-    describe "fullfilled" do
-      before(:each) do
-        AccessCodeRequest.delete_all
-        @fullfilled = Factory(:access_code_request, :code_sent_at => DateTime.now)
-        @unfullfilled = Factory(:access_code_request)
-      end
-      it "should find fullfilled requests" do
-        assert !AccessCodeRequest.unfullfilled.include?(@fullfilled)
-        assert AccessCodeRequest.unfullfilled.include?(@unfullfilled)
-      end
-    end
-  end
-  
-  describe "get emails" do
-    before(:each) do
-      # setup a few access codes
-      Factory(:access_code_request)
-      Factory(:access_code_request)
-      Factory(:access_code_request)
-    end
-    it "should get 1 access code request" do
-      access_code_requests = AccessCodeRequest.get_requests(1)
-      assert_equal 1, access_code_requests.length
-    end
-    it "should get all access code requests" do
-      access_code_requests = AccessCodeRequest.get_requests('')
-      assert access_code_requests.length > 0
-    end
-  end
-  
-  describe "mark_fullfilled" do
-    it "should mark the request fullfilled" do
-      AccessCodeRequest.mark_fullfilled(AccessCodeRequest.get_requests)
-      @access_code_request.reload
-      @access_code_request.code_sent_at.should_not be_blank
-    end
-  end
-  
-  describe "send_access_code_request_confirm" do
-    before do
-      MuckUsers.configuration.send_access_code_request_confirm = true
-    end
-    it "should send the user an email confirming their access code request" do
-      mailer = mock(:user_mailer)
-      mailer.should_receive(:deliver)
-      UserMailer.should_receive(:access_code_request_confirm).and_return(mailer)
-      Factory(:access_code_request)
-    end
-  end
-  
-  describe "send_access_code" do
-    before do
-      @access_code_request = Factory(:access_code_request)
-      @subject = "test subject"
-      @message = "test message"
-      @expires_at = 1.year.from_now
-    end
-    it "should create an access code" do
-      lambda {
-        @access_code_request.send_access_code(@subject, @message, @expires_at)
-      }.should change(AccessCode, :count)
-    end
-    it "should send the user an email with the access code" do
-      mailer = mock(:user_mailer)
-      mailer.should_receive(:deliver)
-      UserMailer.should_receive(:access_code).and_return(mailer)
-      @access_code_request.send_access_code(@subject, @message, @expires_at)
-    end
-    it "should mark the request fullfilled" do
-      AccessCodeRequest.should_receive(:mark_fullfilled)
-      @access_code_request.send_access_code(@subject, @message, @expires_at)
-    end
-  end
-
-end

data/test/spec/models/access_code_spec.rb

@@ -1,117 +0,0 @@
-# == Schema Information
-#
-# Table name: access_codes
-#
-#  id         :integer(4)      not null, primary key
-#  code       :string(255)
-#  uses       :integer(4)      default(0), not null
-#  unlimited  :boolean(1)      not null
-#  expires_at :datetime
-#  use_limit  :integer(4)      default(1), not null
-#  created_at :datetime
-#  updated_at :datetime
-#
-
-require File.dirname(__FILE__) + '/../spec_helper'
-
-describe AccessCode do
-
-  before(:each) do
-    @access_code = Factory(:access_code)
-  end
-      
-  it { should validate_presence_of :uses }
-  it { should validate_uniqueness_of :code }
-  
-  it { should have_many :users }
-  it { should belong_to :provided_by }
-
-  describe "scopes" do
-    
-    it { should scope_by_newest }
-    
-    describe "by_alpha" do
-      before(:each) do
-        AccessCode.delete_all
-        @first = Factory(:access_code, :code => 'a')
-        @second = Factory(:access_code, :code => 'b')
-      end
-      it "should sort by code" do
-        @first.should == AccessCode.by_alpha[0]
-        @second.should == AccessCode.by_alpha[1]
-      end
-    end
-        
-    describe "active" do
-      before(:each) do
-        AccessCode.delete_all
-        codes = [
-          Factory(:access_code, :code => 'expired', :expires_at => DateTime.now - 1.day),
-          Factory(:access_code, :code => 'overused', :uses => 10, :use_limit => 9, :expires_at => DateTime.now + 2.days),
-          Factory(:access_code, :code => 'valid_code', :expires_at => DateTime.now + 5.days), 
-        ]
-      end
-      it "should get active codes" do
-        AccessCode.active.each do |access_code|
-          access_code.code.should == 'valid_code'
-        end
-      end
-    end
-    
-  end
-  
-  it "should use code" do
-    access_code = Factory(:access_code)
-    access_code.use_code
-    access_code.reload
-    access_code.uses.should == 1
-  end
-  it "should not be overused" do
-    access_code = Factory(:access_code, :use_limit => 100)
-    access_code.should_not be_overused
-  end
-  it "should be over used" do
-    access_code = Factory(:access_code, :use_limit => 1)
-    access_code.use_code
-    access_code.use_code
-    access_code.should be_overused
-  end
-  it "should unlimited" do
-    access_code = Factory(:access_code, :use_limit => 1, :unlimited => true)
-    access_code.use_code
-    access_code.use_code
-    access_code.should_not be_overused
-  end
-  it "should be valid" do
-    code = 'accesscodetest'
-    access_code = Factory(:access_code, :code => code)
-    AccessCode.valid_code?(code).should be_true
-  end
-  it "should be expired" do
-    access_code = Factory(:access_code, :unlimited => false, :expires_at => Time.now.to_date - 1.day)
-    access_code.should be_expired
-  end
-  
-  it "should generate a unique code" do
-    AccessCode.random_code.length.should > 0
-  end
-  
-  describe "send_requests" do
-    before do
-      @access_code = Factory(:access_code)
-    end
-    it "should return false if set to '0'" do
-      @access_code.send_requests = '0'
-      @access_code.send_requests.should be_false
-    end
-    it "should return false if set to 'false'" do
-      @access_code.send_requests = 'false'
-      @access_code.send_requests.should be_false
-    end
-    it "should return true if set to true" do
-      @access_code.send_requests = true
-      @access_code.send_requests.should be_true      
-    end
-  end
-  
-end

data/test/spec/models/permission_spec.rb

@@ -1,19 +0,0 @@
-require File.dirname(__FILE__) + '/../spec_helper'
-
-describe Permission do
-
-  it {should belong_to :user}
-  it {should belong_to :role}
-  
-  describe "Create new permission" do
-    it "should should create a new permission" do
-      lambda {
-        user = Factory(:user)
-        role = Factory(:role)
-        permission = Permission.create(:user => user, :role => role)
-        permission.save
-      }.should change(Permission, :count)        
-    end
-  end
-  
-end

data/test/spec/models/role_spec.rb

@@ -1,18 +0,0 @@
-require File.dirname(__FILE__) + '/../spec_helper'
-
-describe Role do
-
-  it { should validate_presence_of :rolename }
-  it { should have_many :permissions }
-  it { should have_many :users }
-
-  describe "Create new role" do
-    it "should should create a new role" do
-      lambda {
-        new_role = Role.create(:rolename => "new role")
-        new_role.save
-      }.should change(Role, :count)
-    end
-  end
-  
-end

data/test/spec/models/secure_methods_spec.rb

@@ -1,56 +0,0 @@
-require File.dirname(__FILE__) + '/../spec_helper'
-
-describe "SecureMethods" do
-
-  describe "check creator method" do
-    before(:each) do
-      @user = Factory(:user)
-      @another_user = Factory(:user)
-    end
-    it "should return true if creators are equal" do
-      @user.send(:check_creator, @user).should be_true
-    end
-    it "should return false if creators are different" do
-      @another_user.send(:check_creator, @user).should be_false
-    end
-  end
-  describe "check user method" do
-    before(:each) do
-      @user = Factory(:user)
-      @another_user = Factory(:user)
-    end
-    it "should return true if users are equal" do
-      @user.send(:check_user, @user).should be_true
-    end
-    it "should return false if users are different" do
-      @another_user.send(:check_user, @user).should be_false
-    end
-  end
-  describe "check sharer method" do
-    before(:each) do
-      @user = Factory(:user)
-      @another_user = Factory(:user)
-    end
-    it "should return true if sharers are equal" do
-      @user.send(:check_sharer, @user).should be_true
-    end
-    it "should return false if sharers are different" do
-      @another_user.send(:check_sharer, @user).should be_false
-    end
-  end
-  describe "check method" do
-    before(:each) do
-      @user = Factory(:user)
-      @admin = Factory(:user)
-    end
-    it "should  return false when user is nil" do
-      @user.send(:check, nil, :user_id).should be_false
-    end
-    it "should return true when user is different but an admin" do
-      @admin.add_to_role('administrator')
-      @admin.reload
-      @user.send(:check, @admin, :user_id).should be_true
-    end
-  end
-  
-end