cafe-grader-web Commit - r158:13c9210ae5ca

cafe-grader-web

Commit `r158:13c9210ae5ca` public

parent | child

Description:

Merged online-registration branch changes r297:303 into the trunk git-svn-id: http://theory.cpe.ku.ac.th/grader/web/trunk@303 6386c4cd-e34a-4fa8-8920-d93eb39b512e

Commit status:

[Not Reviewed]

References:

default

Diff options:

| | | |

Comments:

0 Commit comments 0 Inline Comments

Unresolved TODOs:

There are no unresolved TODOs

Add another comment

r158:13c9210ae5ca - Wed, 10 Dec 2008 02:48:32 - 16 files changed: 318 inserted, 29 deleted

app/views/users/confirm.html.haml created 644 ¶ +15

@@ -0,0 +1,15
	1	+ - if @result == :successful
	2	+ %h1 User activated
	3	+ Your account has been activated.
	4	+ %br/
	5	+ Please go ahead to
	6	+ = link_to 'login.', :controller => 'main', :action => 'login'
	7	+ - else
	8	+ %h1 Activation failed
	9	+ - if @result == :email_used
	10	+ A user with this E-mail exists.
	11	+ - else
	12	+ Your activation code is invalid. Please check again.
	13	+ %br/
	14	+ Get back to
	15	+ = link_to 'home.', :controller => 'main', :action => 'login'

app/views/users/email_error.html.haml created 644 ¶ +9

@@ -0,0 +1,9
	1	+ %h1 Errors in sending registration confirmation
	2	+
	3	+ .errorExplanation
	4	+ %h2
	5	+ Your user account has been created, but the system cannot send you the
	6	+ confirmation e-mail.
	7	+
	8	+ Maybe there's a problem in the configuration. Please report the
	9	+ admin. Thank you!

db/migrate/20081205172258_add_emailing_info_on_config_option.rb created 644 ¶ +18

@@ -0,0 +1,18
	1	+ class AddEmailingInfoOnConfigOption < ActiveRecord::Migration
	2	+ def self.up
	3	+ # If Configuration['system.online_registration'] is true, the
	4	+ # system allows online registration, and will use these
	5	+ # information for sending confirmation emails.
	6	+ Configuration.create(:key => 'system.online_registration.smtp',
	7	+ :value_type => 'string',
	8	+ :value => 'smtp.somehost.com')
	9	+ Configuration.create(:key => 'system.online_registration.from',
	10	+ :value_type => 'string',
	11	+ :value => 'your.email@address')
	12	+ end
	13	+
	14	+ def self.down
	15	+ Configuration.find_by_key("system.online_registration.smtp").destroy
	16	+ Configuration.find_by_key("system.online_registration.from").destroy
	17	+ end
	18	+ end

db/migrate/20081210021333_add_timestamps_to_users.rb created 644 ¶ +9

@@ -0,0 +1,9
	1	+ class AddTimestampsToUsers < ActiveRecord::Migration
	2	+ def self.up
	3	+ add_timestamps :users
	4	+ end
	5	+
	6	+ def self.down
	7	+ remove_timestamps :users
	8	+ end
	9	+ end

spec/controllers/users_controller_spec.rb created 644 ¶ +95

@@ -0,0 +1,95
	1	+
	2	+ require File.dirname(__FILE__) + '/../spec_helper'
	3	+
	4	+ describe UsersController, "when a new user registers" do
	5	+
	6	+ before(:each) do
	7	+ # create john
	8	+
	9	+ @john_info = {:login => 'john',
	10	+ :full_name => 'John John',
	11	+ :email => 'john@space.com'}
	12	+ @john = User.new(@john_info)
	13	+
	14	+ @john_activation_key = "123456"
	15	+
	16	+ @john.should_receive(:activation_key).
	17	+ any_number_of_times.
	18	+ and_return(@john_activation_key)
	19	+
	20	+ get :new
	21	+ response.should render_template('users/new')
	22	+ end
	23	+
	24	+ it "should show the new form again when user information is invalid" do
	25	+ User.should_receive(:new).with(any_args()).and_return(@john)
	26	+ @john.should_receive(:activated=).with(false)
	27	+ @john.should_receive(:valid?).and_return(false)
	28	+ @john.should_not_receive(:save)
	29	+
	30	+ post :register, :login => @john_info[:login],
	31	+ :full_name => @john_info[:full_name],
	32	+ :email => @john_info[:email]
	33	+
	34	+ response.should render_template('users/new')
	35	+ end
	36	+
	37	+ it "should create unactivated user and send e-mail with activation key" do
	38	+ User.should_receive(:new).with(any_args()).and_return(@john)
	39	+ @john.should_receive(:activated=).with(false)
	40	+ @john.should_receive(:valid?).and_return(true)
	41	+ @john.should_receive(:save).and_return(true)
	42	+
	43	+ smtp_mock = mock("smtp")
	44	+ smtp_mock.should_receive(:send_message) do \|msg,fr,to\|
	45	+ to.should == [@john_info[:email]]
	46	+ msg.index(@john_activation_key).should_not be_nil
	47	+ end
	48	+
	49	+ Net::SMTP.should_receive(:start).
	50	+ with(any_args()).
	51	+ and_yield(smtp_mock)
	52	+
	53	+ post :register, :login => @john_info[:login],
	54	+ :full_name => @john_info[:full_name],
	55	+ :email => @john_info[:email]
	56	+
	57	+ response.should render_template('users/new_splash')
	58	+ end
	59	+
	60	+ it "should create unactivated user and return error page when e-mail sending error" do
	61	+ User.should_receive(:new).with(any_args()).and_return(@john)
	62	+ @john.should_receive(:activated=).with(false)
	63	+ @john.should_receive(:valid?).and_return(true)
	64	+ @john.should_receive(:save).and_return(true)
	65	+
	66	+ smtp_mock = mock("smtp")
	67	+ smtp_mock.should_receive(:send_message).
	68	+ and_throw(:error)
	69	+
	70	+ Net::SMTP.should_receive(:start).
	71	+ with(any_args()).
	72	+ and_yield(smtp_mock)
	73	+
	74	+ post :register, :login => @john_info[:login],
	75	+ :full_name => @john_info[:full_name],
	76	+ :email => @john_info[:email]
	77	+
	78	+ response.should render_template('users/email_error')
	79	+ end
	80	+
	81	+ it "should activate user with valid activation key" do
	82	+ login = @john_info[:login]
	83	+ User.should_receive(:find_by_login).
	84	+ with(login).
	85	+ and_return(@john)
	86	+ @john.should_receive(:valid?).and_return(true)
	87	+ @john.should_receive(:activated=).with(true)
	88	+ @john.should_receive(:save).and_return(true)
	89	+
	90	+ get :confirm, :login => login, :activation => @john_activation_key
	91	+
	92	+ response.should render_template('users/confirm')
	93	+ end
	94	+
	95	+ end

app/controllers/users_controller.rb ¶ +64 -4

-            - require 'pony'
+            + require 'tmail'
+            + require 'net/smtp'
               class UsersController < ApplicationController
-            -   before_filter :authenticate, :except => [:new, :register]
+            +   before_filter :authenticate, :except => [:new, :register, :confirm]
                 verify :method => :post, :only => [:chg_passwd],
                        :redirect_to => { :action => :index }
                 in_place_edit_for :user, :alias_for_editing
                 in_place_edit_for :user, :email_for_editing
                 def index
                   if !Configuration['system.user_setting_enabled']
                     redirect_to :controller => 'main', :action => 'list'
                   else
                     @user = User.find(session[:user_id])
                   end
                 end
                 def chg_passwd
                   user = User.find(session[:user_id])
                   user.password = params[:passwd]
                   user.password_confirmation = params[:passwd_verify]
                   if user.save
                     flash[:notice] = 'password changed'
                   else
                     flash[:notice] = 'Error: password changing failed'
                   end
                   redirect_to :action => 'index'
                 end
                 def new
                   @user = User.new
                   render :action => 'new', :layout => 'empty'
                 end
                 def register
                   @user = User.new(params[:user])
                   @user.password_confirmation = @user.password = User.random_password
                   @user.activated = false
                   if (@user.valid?) and (@user.save)
-            -       send_confirmation_email(@user)
+            +       if send_confirmation_email(@user)
-            -       render :action => 'new_splash', :layout => 'empty'
+            +         render :action => 'new_splash', :layout => 'empty'
+            +       else
+            +         render :action => 'email_error', :layout => 'empty'
+            +       end
                   else
                     @user.errors.add_to_base("Email cannot be blank") if @user.email==''
                     render :action => 'new', :layout => 'empty'
                   end
                 end
+            +   def confirm
+            +     login = params[:login]
+            +     key = params[:activation]
+            +     user = User.find_by_login(login)
+            +     if (user) and (user.verify_activation_key(key))
+            +       if user.valid?  # check uniquenss of email
+            +         user.activated = true
+            +         user.save
+            +         @result = :successful
+            +       else
+            +         @result = :email_used
+            +       end
+            +     else
+            +       @result = :failed
+            +     end
+            +     render :action => 'confirm', :layout => 'empty'
+            +   end
+            +
                 protected
                 def send_confirmation_email(user)
+            +     contest_name = Configuration['contest.name']
+            +     activation_url = url_for(:action => 'confirm',
+            +                              :login => user.login,
+            +                              :activation => user.activation_key)
+            +     home_url = url_for(:controller => 'main', :action => 'index')
+            +     mail = TMail::Mail.new
+            +     mail.to = user.email
+            +     mail.from = Configuration['system.online_registration.from']
+            +     mail.subject = "[#{contest_name}] Confirmation"
+            +     mail.body = <<-EOF
+            + Hello #{user.full_name},
+            +
+            + You have registered for #{contest_name} (#{home_url}).
+            +
+            + Your login is: #{user.login}
+            + Your password is: #{user.password}
+            +
+            + Please follow the link:
+            + #{activation_url}
+            + to activate your user account.
+            +
+            + If you did not register, please ignore this e-mail.
+            +
+            + Thanks!
+            + EOF
+            +
+            +     smtp_server = Configuration['system.online_registration.smtp']
+            +
+            +     begin
+            +       Net::SMTP.start(smtp_server) do |smtp|
+            +         smtp.send_message(mail.to_s, mail.from, mail.to)
+            +       end
+            +       result = true
+            +     rescue
+            +       result = false
+            +     end
+            +
+            +     return result
                 end
               end

app/models/configuration.rb ¶ +4

                 def self.get(key)
                   if @@cache
                     if @@configurations == nil
                       self.read_config
                     end
                     return @@configurations[key]
                   else
                     return Configuration.read_one_key(key)
                   end
                 end
                 def self.[](key)
                   self.get(key)
                 end
                 def self.reload
                   self.read_config
                 end
                 def self.clear
                   @@configurations = nil
                 end
+            +   def self.enable_caching
+            +     @@cache = true
+            +   end
+            +
                 #
                 # View decision
                 #
                 def self.show_submitbox_to?(user)
                   mode = get(SYSTEM_MODE_CONF_KEY)
                   return false if mode=='analysis'
                   if (mode=='contest')
                     return false if (user.site!=nil) and
                       ((user.site.started!=true) or (user.site.finished?))
                   end
                   return true
                 end
                 def self.show_tasks_to?(user)
                   mode = get(SYSTEM_MODE_CONF_KEY)
                   if (mode=='contest')
                     return false if (user.site!=nil) and (user.site.started!=true)
                   end
                   return true
                 end
                 def self.show_grading_result
                   return (get(SYSTEM_MODE_CONF_KEY)=='analysis')
                 end

app/models/user.rb ¶ +16 -2

               require 'digest/sha1'
               class User < ActiveRecord::Base
                 has_and_belongs_to_many :roles
                 has_many :test_requests, :order => "submitted_at DESC"
                 has_many :messages,
                          :class_name => "Message",
                          :foreign_key => "sender_id",
                          :order => 'created_at DESC'
                 has_many :replied_messages,
                          :class_name => "Message",
                          :foreign_key => "receiver_id",
                          :order => 'created_at DESC'
                 belongs_to :site
                 belongs_to :country
-            -   named_scope :activated, :conditions => {:activated => true}
+            +   named_scope :activated_users, :conditions => {:activated => true}
                 validates_presence_of :login
                 validates_uniqueness_of :login
                 validates_format_of :login, :with => /^[\_a-z0-9]+$/
                 validates_length_of :login, :within => 3..10
                 validates_presence_of :full_name
                 validates_length_of :full_name, :minimum => 1
                 validates_presence_of :password, :if => :password_required?
                 validates_length_of :password, :within => 4..20, :if => :password_required?
                 validates_confirmation_of :password, :if => :password_required?
                 validates_format_of :email, :with => /\A([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})\Z/i, :allow_blank => true
                 validate :uniqueness_of_email_from_activated_users
+            +   validate :enough_time_interval_between_same_email_registrations
                 attr_accessor :password
                 before_save :encrypt_new_password
                 def self.authenticate(login, password)
                   user = find_by_login(login)
                   return user if user && user.authenticated?(password)
                 end
                 def authenticated?(password)
                   if self.activated
                     hashed_password == User.encrypt(password,self.salt)
                   else
                     false
                   end
                 end
                 def admin?
                   self.roles.detect {|r| r.name == 'admin' }
                 end
                 def email_for_editing
                   if self.email==nil
                   else
                     self.email
                   end
                 end
                 def email_for_editing=(e)
                   self.email=e
                 end
                 def alias_for_editing
                   if self.alias==nil
                     "(unknown)"
                   elsif self.alias==''
                     "(blank)"
                   else
                     self.alias
                   end
                 end
                 def alias_for_editing=(e)
                   self.alias=e
                 end
                 def activation_key
+            +     if self.hashed_password==nil
+            +       encrypt_new_password
+            +     end
                   Digest::SHA1.hexdigest(self.hashed_password)[0..7]
                 end
                 def verify_activation_key(key)
                   key == activation_key
                 end
                 def self.random_password(length=5)
                   chars = 'abcdefghjkmnopqrstuvwxyz'
                   password = ''
                   length.times { password << chars[rand(chars.length - 1)] }
                   password
                 end
                 protected
                   def encrypt_new_password
                     return if password.blank?
                     self.salt = (10+rand(90)).to_s
                     self.hashed_password = User.encrypt(self.password,self.salt)
                   end
                   def password_required?
                     self.hashed_password.blank? || !self.password.blank?
                   end
                   def self.encrypt(string,salt)
                     Digest::SHA1.hexdigest(salt + string)
                   end
                   def uniqueness_of_email_from_activated_users
-            -       if User.activated.find_by_email(self.email)!=nil
+            +       user = User.activated_users.find_by_email(self.email)
+            +       if user and (user.login != self.login)
                       self.errors.add_to_base("Email has already been taken")
                     end
                   end
+            +
+            +     def enough_time_interval_between_same_email_registrations
+            +       open_user = User.find_by_email(self.email,
+            +                                      :order => 'created_at DESC')
+            +       if open_user and open_user.created_at and
+            +           (open_user.created_at > Time.now.gmtime - 5.minutes)
+            +         self.errors.add_to_base("There are already unactivated registrations with this e-mail address (please wait for 5 minutes)")
+            +       end
+            +     end
               end

config/environment.rb.SAMPLE ¶ +4 -1

                 # Use the database for sessions instead of the file system
                 # (create the session table with 'rake db:sessions:create')
                 config.action_controller.session_store = :active_record_store
                 # Use SQL instead of Active Record's schema dumper when creating the test database.
                 # This is necessary if your schema can't be completely dumped by the schema dumper,
                 # like if you have constraints or database-specific column types
                 # config.active_record.schema_format = :sql
                 # Activate observers that should always be running
                 # config.active_record.observers = :cacher, :garbage_collector
                 # Make Active Record use UTC-base instead of local time
                 config.active_record.default_timezone = :utc
                 # See Rails::Configuration for more options
                 # -------------
                 # Required gems
                 # -------------
                 # This is for rspec
                 config.gem "rspec-rails", :lib => "spec"
                 config.gem "haml"
-            -   config.gem "pony"
+            +   config.gem "tmail"
                 #config.gem "BlueCloth", :lig => "bluecloth"
               end
               # Add new inflection rules using the following format
               # (all these examples are active by default):
               # Inflector.inflections do |inflect|
               #   inflect.plural /^(ox)$/i, '\1en'
               #   inflect.singular /^(ox)en/i, '\1'
               #   inflect.irregular 'person', 'people'
               #   inflect.uncountable %w( fish sheep )
               # end
               # Add new mime types for use in respond_to blocks:
               # Mime::Type.register "text/richtext", :rtf
               # Mime::Type.register "application/x-mobile", :mobile
               # Include your application configuration below
               # These are where inputs and outputs of test requests are stored
               TEST_REQUEST_INPUT_FILE_DIR = RAILS_ROOT + '/data/test_request/input'
               TEST_REQUEST_OUTPUT_FILE_DIR = RAILS_ROOT + '/data/test_request/output'
+            +
+            + # Uncomment so that configuration is read only once when the server is loaded
+            + # Configuration.enable_caching

db/schema.rb ¶ +12 -10

               # This file is auto-generated from the current state of the database. Instead of editing this file,
               # please use the migrations feature of Active Record to incrementally modify your database, and
               # then regenerate this schema definition.
               #
               # Note that this schema.rb definition is the authoritative source for your database schema. If you need
               # to create the application database on another system, you should be using db:schema:load, not running
               # all the migrations from scratch. The latter is a flawed and unsustainable approach (the more migrations
               # you'll amass, the slower it'll run and the greater likelihood for issues).
               #
               # It's strongly recommended to check this file into your version control system.
-            - ActiveRecord::Schema.define(:version => 20081204122651) do
+            + ActiveRecord::Schema.define(:version => 20081210021333) do
                 create_table "announcements", :force => true do |t|
                   t.string   "author"
                   t.text     "body"
                   t.boolean  "published"
                   t.datetime "created_at"
                   t.datetime "updated_at"
                   t.boolean  "frontpage",  :default => false
                 end
                 create_table "configurations", :force => true do |t|
                   t.string   "key"
                   t.string   "value_type"
                   t.string   "value"
                   t.datetime "created_at"
                   t.datetime "updated_at"
                 end
                 create_table "countries", :force => true do |t|
                   t.string   "name"
                   t.datetime "created_at"
                   t.datetime "updated_at"
                 end
                 create_table "test_requests", :force => true do |t|
                   t.integer  "user_id"
                   t.integer  "problem_id"
                   t.integer  "submission_id"
                   t.string   "input_file_name"
                   t.string   "output_file_name"
                   t.string   "running_stat"
                   t.integer  "status"
                   t.datetime "updated_at"
                   t.datetime "submitted_at"
                   t.datetime "compiled_at"
                   t.text     "compiler_message"
                   t.datetime "graded_at"
                   t.string   "grader_comment"
                   t.datetime "created_at"
                   t.float    "running_time"
                   t.string   "exit_status"
                   t.integer  "memory_usage"
                 end
                 add_index "test_requests", ["user_id", "problem_id"], :name => "index_test_requests_on_user_id_and_problem_id"
                 create_table "users", :force => true do |t|
-            -     t.string  "login",           :limit => 10
+            +     t.string   "login",           :limit => 10
-            -     t.string  "full_name"
+            +     t.string   "full_name"
-            -     t.string  "hashed_password"
+            +     t.string   "hashed_password"
-            -     t.string  "salt",            :limit => 5
+            +     t.string   "salt",            :limit => 5
-            -     t.string  "alias"
+            +     t.string   "alias"
-            -     t.string  "email"
+            +     t.string   "email"
-            -     t.integer "site_id"
+            +     t.integer  "site_id"
-            -     t.integer "country_id"
+            +     t.integer  "country_id"
-            -     t.boolean "activated",                     :default => false
+            +     t.boolean  "activated",                     :default => false
+            +     t.datetime "created_at"
+            +     t.datetime "updated_at"
                 end
                 add_index "users", ["login"], :name => "index_users_on_login", :unique => true
               end

public/stylesheets/application.css ¶ +8

                   background: #777777;
                   color: white;
               }
               tr.info-odd {
                   background: #dddddd;
               }
               tr.info-even {
                   background: #f0f0f0;
               }
               /*******************************
                [Main]
               ********************************/
               div.submitbox {
                   border: thin solid black;
                   padding: 5px;
                   color: white;
                   background-color: #777777;
                   font-weight: bold;
                   font-size: 13px;
               }
+            + div.errorExplanation {
+            +     border: 1px dashed black;
+            +     color: black;
+            +     padding: 5px;
+            +     margin-bottom: 5px;
+            +     background-color: white;
+            + }
+            +
               /*******************************
                [Settings]
               ********************************/
               table.uinfo {
                   border-collapse: collapse;
                   border: 1px solid black;
                   font-size: 13px;
               }
               td.uinfo {
                   vertical-align: top;
                   border: 1px solid black;
                   padding: 5px;
               }
               th.uinfo {
                   background: lightgreen;
                   vertical-align: top;
                   text-align: right;
                   border: 1px solid black;
                   padding: 5px;
               }
               /*******************************

script/spec ¶ +1

               #!/usr/bin/env ruby
               $LOAD_PATH.unshift(File.expand_path(File.dirname(__FILE__) + "/../vendor/plugins/rspec/lib"))
+            + require 'rubygems'
               require 'spec'
               exit ::Spec::Runner::CommandLine.run(::Spec::Runner::OptionParser.parse(ARGV, STDERR, STDOUT))

spec/controllers/main_controller_spec.rb ¶ +6 -1

               require File.dirname(__FILE__) + '/../spec_helper'
               describe MainController do
                 before(:each) do
-            -     @problem = mock(Problem, :name => 'test')
+            +     @problem = mock(Problem, :name => 'test', :output_only => false)
                   @language = mock(Language, :name => 'cpp', :ext => 'cpp')
                   @submission = mock(Submission,
                                      :id => 1,
                                      :user_id => 1,
                                      :problem => @problem,
                                      :language => @language,
                                      :source => 'sample source',
                                      :compiler_message => 'none')
                   @user = mock(User, :id => 1, :login => 'john')
+            +     @another_user = mock(User, :id => 2, :login => 'mary')
                 end
                 it "should redirect user to login page when unlogged-in user try to access main/list" do
                   get 'list'
                   response.should redirect_to(:action => 'login')
                 end
                 it "should let user sees her own source" do
                   Submission.should_receive(:find).with(@submission.id.to_s).and_return(@submission)
+            +     User.should_receive(:find).with(1).and_return(@user)
                   get 'source', {:id => @submission.id}, {:user_id => 1}
                   response.should be_success
                 end
                 it "should let user sees her own compiler message" do
                   Submission.should_receive(:find).with(@submission.id.to_s).and_return(@submission)
+            +     User.should_receive(:find).with(1).and_return(@user)
                   get 'compiler_msg', {:id => @submission.id}, {:user_id => 1}
                   response.should be_success
                 end
                 it "should not let user sees other user's source" do
                   Submission.should_receive(:find).with(@submission.id.to_s).and_return(@submission)
+            +     User.should_receive(:find).with(2).and_return(@another_user)
                   get 'source', {:id => @submission.id}, {:user_id => 2}
                   flash[:notice].should =~ /[Ee]rror/
                   response.should redirect_to(:action => 'list')
                 end
                 it "should not let user sees other user's compiler message" do
                   Submission.should_receive(:find).with(@submission.id.to_s).and_return(@submission)
+            +     User.should_receive(:find).with(2).and_return(@another_user)
                   get 'compiler_msg', {:id => @submission.id}, {:user_id => 2}
                   flash[:notice].should =~ /[Ee]rror/
                   response.should redirect_to(:action => 'list')
                 end
               end

spec/controllers/test_controller_spec.rb ¶ +1 -1

               require File.dirname(__FILE__) + '/../spec_helper'
               describe TestController do
                 before(:each) do
                   @john = mock(User, :id => "1", :login => 'john')
                   @john_result = mock(TestRequest, :id => "1", :user_id => @john.id)
                   @mary_result = mock(TestRequest, :id => "2", :user_id => @john.id + '1')
-            -     User.should_receive(:find).with(@john.id).and_return(@john)
+            +     User.should_receive(:find).at_least(:once).with(@john.id).and_return(@john)
                 end
                 it "should let user see her testing result" do
                   TestRequest.should_receive(:find).with(@john_result.id).
                     and_return(@john_result)
                   get 'result', {:id => @john_result.id}, {:user_id => @john.id}
                   response.should be_success
                 end
                 it "should not let user see other's testing result" do
                   TestRequest.should_receive(:find).with(@mary_result.id).
                     and_return(@mary_result)
                   get 'result', {:id => @mary_result.id}, {:user_id => @john.id}
                   response.should redirect_to(:action => 'index')
                 end
               end

spec/models/site_spec.rb ¶ +14 -9

               require File.dirname(__FILE__) + '/../spec_helper'
               describe Site do
                 before(:each) do
-            -     start_time = Time.local(2008,5,10,9,00)
+            +     start_time = Time.local(2008,5,10,9,00).gmtime
                   @site = Site.new({:name => 'Test site',
                                      :started => true,
                                      :start_time => start_time })
+            +     @site.stub!(:start_time).
+            +       any_number_of_times.
+            +       and_return(start_time)
+            +     @site.stub!(:started).any_number_of_times.and_return(true)
                 end
                 it "should report that the contest is not finished when the contest time limit is not set" do
                   Configuration.should_receive(:[]).with('contest.time_limit').
                     and_return('unlimit')
-            -     Time.should_not_receive(:now)
                   @site.finished?.should == false
                 end
                 it "should report that the contest is finished when the contest is over" do
                   Configuration.should_receive(:[]).with('contest.time_limit').
-            -       and_return('5:00')
+            +     and_return('5:00')
-            -     Time.should_receive(:now).and_return(Time.local(2008,5,10,14,01))
+            +     Time.stub!(:now).
-            -     @site.finished?.should == true
+            +       and_return(Time.local(2008,5,10,14,01).gmtime)
-            -   end
+            +     @site.finished?.should == true end
                 it "should report if the contest is finished correctly, when the contest is over, and the contest time contains some minutes" do
                   Configuration.should_receive(:[]).twice.with('contest.time_limit').
                     and_return('5:15')
-            -     Time.should_receive(:now).
+            +     Time.stub!(:now).
-            -       and_return(Time.local(2008,5,10,14,14),Time.local(2008,5,10,14,16))
+            +       and_return(Time.local(2008,5,10,14,14))
                   @site.finished?.should == false
+            +     Time.stub!(:now).
+            +       and_return(Time.local(2008,5,10,14,16))
                   @site.finished?.should == true
                 end
                 it "should report that the contest is not finished, when the time is exactly at the finish time" do
                   Configuration.should_receive(:[]).with('contest.time_limit').
                     and_return('5:00')
-            -     Time.should_receive(:now).and_return(Time.local(2008,5,10,14,00))
+            +     Time.stub!(:now).and_return(Time.local(2008,5,10,14,00))
                   @site.finished?.should == false
                 end
               end

spec/models/user_spec.rb ¶ +42 -1

                 end
               end
               describe User, "during registration" do
                 class User
                   public :encrypt_new_password
                 end
                 before(:each) do
                   @john = User.new(:login => 'john', :password => 'hello')
                   @john.encrypt_new_password
                 end
                 it "should produce and accept activation key" do
                   activation_key = @john.activation_key
                   @john.verify_activation_key(activation_key).should == true
                 end
                 it "should not accept invalid activation key" do
                   @john.verify_activation_key("12345").should == false
                 end
+            + end
+            +
+            + describe User, "when re-register with the same e-mail" do
+            +
+            +   before(:each) do
+            +     @mary_email = 'mary@in.th'
+            +
+            +     @time_first_register = Time.local(2008,5,10,9,00).gmtime
+            +
+            +     @mary_first = mock_model(User,
+            +                              :login => 'mary1',
+            +                              :password => 'hello',
+            +                              :email => @mary_email,
+            +                              :created_at => @time_first_register)
+            +     @mary_second = User.new(:login => 'mary2',
+            +                             :password => 'hello',
+            +                             :email => @mary_email)
+            +     User.stub!(:find_by_email).
+            +       with(@mary_email, {:order => "created_at DESC"}).
+            +       and_return(@mary_first)
+            +   end
+            +
+            +   class User
+            +     public :enough_time_interval_between_same_email_registrations
+            +   end
+            +
+            +   it "should not be allowed if the time interval is less than 5 mins" do
+            +     time_now = @time_first_register + 4.minutes
+            +     Time.stub!(:now).and_return(time_now)
+            +
+            +     @mary_second.enough_time_interval_between_same_email_registrations
+            +     @mary_second.errors.length.should_not be_zero
+            +   end
+            +
+            +   it "should be allowed if the time interval is more than 5 mins" do
+            +     time_now = @time_first_register + 6.minutes
+            +     Time.stub!(:now).and_return(time_now)
+            +
+            +     @mary_second.enough_time_interval_between_same_email_registrations
+            +     @mary_second.errors.length.should be_zero
+            +   end
+            +
               end
               describe User, "as a class" do
                 it "should be able to generate random password" do
                   password1 = User.random_password
                   password2 = User.random_password
                   password1.should_not == password2
                 end
               end

Write
Preview

You need to be logged in to leave comments. Login now

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository permissions settings

Sign in to your account

Author

r158:13c9210ae5ca - Wed, 10 Dec 2008 02:48:32 - 16 files changed: 318 inserted, 29 deleted

Sign in to your account

Commit r158:13c9210ae5ca public

Author

r158:13c9210ae5ca - Wed, 10 Dec 2008 02:48:32 - 16 files changed: 318 inserted, 29 deleted

Commit `r158:13c9210ae5ca` public