cafe-grader-web Commit - r294:069c049fbc3a

cafe-grader-web

Commit `r294:069c049fbc3a` public

parent | child

Description:

logs out users after contests changed

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

r294:069c049fbc3a - Sun, 28 Mar 2010 11:18:26 - 22 files changed: 191 inserted, 192 deleted

spec/integration/contest_managements_spec.rb created 644 ¶ +87

@@ -0,0 +1,87
	1	+ require 'spec_helper'
	2	+ require 'config_spec_helper'
	3	+ require 'delorean'
	4	+
	5	+ describe "ContestManagements" do
	6	+ include ConfigSpecHelperMethods
	7	+
	8	+ fixtures :users
	9	+ fixtures :problems
	10	+ fixtures :contests
	11	+ fixtures :roles
	12	+
	13	+ before(:each) do
	14	+ @admin_user = users(:mary)
	15	+ @contest_b = contests(:contest_b)
	16	+ @james = users(:james)
	17	+ @jack = users(:jack)
	18	+
	19	+ set_contest_time_limit('3:00')
	20	+ set_indv_contest_mode
	21	+ end
	22	+
	23	+ it "should reset users' timer when their contests change" do
	24	+ james_session = open_session
	25	+ james_session.extend(MainSessionMethods)
	26	+
	27	+ james_login_and_get_main_list(james_session)
	28	+ james_session.response.should_not have_text(/OVER/)
	29	+
	30	+ Delorean.time_travel_to(190.minutes.since) do
	31	+ james_session.get_main_list
	32	+ james_session.response.should have_text(/OVER/)
	33	+
	34	+ james_session.get '/' # logout
	35	+ james_session.get '/main/list' # clearly log out
	36	+ james_session.response.should_not render_template 'main/list'
	37	+
	38	+ admin_change_users_contest_to("james", @contest_b, true)
	39	+
	40	+ james_login_and_get_main_list(james_session)
	41	+ james_session.response.should_not have_text(/OVER/)
	42	+ end
	43	+ end
	44	+
	45	+ private
	46	+
	47	+ module MainSessionMethods
	48	+ def login(login_name, password)
	49	+ post '/login/login', :login => login_name, :password => password
	50	+ assert_redirected_to '/main/list'
	51	+ end
	52	+
	53	+ def get_main_list
	54	+ get '/main/list'
	55	+ assert_template 'main/list'
	56	+ end
	57	+ end
	58	+
	59	+ module ContestManagementSessionMethods
	60	+ def change_users_contest_to(user_login_list, contest, reset_timer=false)
	61	+ post_data = {
	62	+ :contest => {:id => contest.id},
	63	+ :operation => 'assign',
	64	+ :login_list => user_login_list
	65	+ }
	66	+ post_data[:reset_timer] = true if reset_timer
	67	+ post '/user_admin/manage_contest', post_data
	68	+ end
	69	+ end
	70	+
	71	+ def admin_change_users_contest_to(user_list, contest, reset_timer)
	72	+ admin_session = open_session
	73	+ admin_session.extend(MainSessionMethods)
	74	+ admin_session.extend(ContestManagementSessionMethods)
	75	+
	76	+ admin_session.login('mary','goodbye')
	77	+ admin_session.get '/main/list'
	78	+ admin_session.change_users_contest_to(user_list, contest, reset_timer)
	79	+ end
	80	+
	81	+ def james_login_and_get_main_list(session)
	82	+ session.login('james', 'morning')
	83	+ session.get_main_list
	84	+ end
	85	+
	86	+ end
	87	+

app/controllers/user_admin_controller.rb ¶ +20 -4

                     render :action => 'edit'
                   end
                 end
                 def destroy
                   User.find(params[:id]).destroy
                   redirect_to :action => 'list'
                 end
                 def user_stat
                   @problems = Problem.find_available_problems
                   @users = User.find(:all)
                   @scorearray = Array.new
                   @users.each do |u|
                     ustat = Array.new
                     ustat[0] = u
                     @problems.each do |p|
               	sub = Submission.find_last_by_user_and_problem(u.id,p.id)
               	if (sub!=nil) and (sub.points!=nil)
               	  ustat << [(sub.points.to_f*100/p.full_score).round, (sub.points>=p.full_score)]
               	else
               	  ustat << [0,false]
               	end
                     end
                     @scorearray << ustat
                   end
                 end
                 def import
                   if params[:file]==''
                     flash[:notice] = 'Error importing no file'
                     redirect_to :action => 'list' and return
                   end
                   import_from_file(params[:file])
                 end
                 def random_all_passwords
                   users = User.find(:all)
                   @prefix = params[:prefix] || ''
                   @non_admin_users = User.find_non_admin_with_prefix(@prefix)
                   @changed = false
                   if request.request_method == :post
                     @non_admin_users.each do |user|
                       password = random_password
                       user.password = password
                       user.password_confirmation = password
                       user.save
                     end
                     @changed = true
                   end
                 end
                 # contest management
                 def add_to_contest
                   user = User.find(params[:id])
                   contest = Contest.find(params[:contest_id])
                   if user and contest
                     user.contests << contest
                   end
                   redirect_to :action => 'list'
                 end
                 def remove_from_contest
                   user = User.find(params[:id])
                   contest = Contest.find(params[:contest_id])
                   if user and contest
                     user.contests.delete(contest)
                   end
                   redirect_to :action => 'list'
                 end
                 def contest_management
                 end
                 def manage_contest
                   contest = Contest.find(params[:contest][:id])
                   if !contest
                     flash[:notice] = 'You did not choose the contest.'
                     redirect_to :action => 'contest_management' and return
                   end
                   operation = params[:operation]
                   if not ['add','remove','assign'].include? operation
                     flash[:notice] = 'You did not choose the operation to perform.'
                     redirect_to :action => 'contest_management' and return
                   end
                   lines = params[:login_list]
                   if !lines or lines.blank?
                     flash[:notice] = 'You entered an empty list.'
                     redirect_to :action => 'contest_management' and return
                   end
                   note = []
+            +     user_ids = {}
                   lines.split("\n").each do |line|
-            -       puts line
                     user = User.find_by_login(line.chomp)
-            -       puts user
                     if user
                       if operation=='add'
-            -           user.contests << contest
+            +           if ! user.contests.include? contest
+            +             user.contests << contest
+            +           end
                       elsif operation=='remove'
                         user.contests.delete(contest)
                       else
                         user.contests = [contest]
                       end
+            +
                       user.contest_stat.destroy if params[:reset_timer]
                       note << user.login
+            +         user_ids[user.id] = true
                     end
                   end
+            +
+            +     if params[:reset_timer]
+            +       logout_users(user_ids)
+            +     end
+            +
                   flash[:notice] = 'User(s) ' + note.join(', ') +
                     ' were successfully modified.  '
                   redirect_to :action => 'contest_management'
                 end
                 # admin management
                 def admin
                   @admins = User.find(:all).find_all {|user| user.admin? }
                 end
                 def grant_admin
                   login = params[:login]
                   user = User.find_by_login(login)
                   if user!=nil
                     admin_role = Role.find_by_name('admin')
                     user.roles << admin_role
                   else
                     flash[:notice] = 'Unknown user'
                   end
                   flash[:notice] = 'User added as admins'
                   redirect_to :action => 'admin'
                 end
                 def revoke_admin
                   user = User.find(params[:id])
                   if user==nil
                     flash[:notice] = 'Unknown user'
                     redirect_to :action => 'admin' and return
                   elsif user.login == 'root'
                     flash[:notice] = 'You cannot revoke admisnistrator permission from root.'
                     redirect_to :action => 'admin' and return
                   end
                   admin_role = Role.find_by_name('admin')
                   user.roles.delete(admin_role)
                   flash[:notice] = 'User permission revoked'
                   redirect_to :action => 'admin'
                 end
                 protected
                 def random_password(length=5)
                   chars = 'abcdefghijkmnopqrstuvwxyz23456789'
                   newpass = ""
                   length.times { newpass << chars[rand(chars.size-1)] }
                   return newpass
                 end
                 def import_from_file(f)
                   data_hash = YAML.load(f)
                   @import_log = ""
                   country_data = data_hash[:countries]
                   site_data = data_hash[:sites]
                   user_data = data_hash[:users]
                   # import country
                   countries = {}
                   country_data.each_pair do |id,country|
                     c = Country.find_by_name(country[:name])
                     if c!=nil
                       countries[id] = c
                       @import_log << "Found #{country[:name]}\n"
                     else
                       countries[id] = Country.new(:name => country[:name])
                       countries[id].save
                       @import_log << "Created #{country[:name]}\n"
                     end
                   end
                   # import sites
                   sites = {}
                   site_data.each_pair do |id,site|
                     s = Site.find_by_name(site[:name])
                     if s!=nil
                       @import_log << "Found #{site[:name]}\n"
                     else
                       s = Site.new(:name => site[:name])
                       @import_log << "Created #{site[:name]}\n"
                     end
                     s.password = site[:password]
                     s.country = countries[site[:country_id]]
                     s.save
                     sites[id] = s
                   end
                   # import users
                   user_data.each_pair do |id,user|
                     u = User.find_by_login(user[:login])
                     if u!=nil
                       @import_log << "Found #{user[:login]}\n"
                     else
                       u = User.new(:login => user[:login])
                       @import_log << "Created #{user[:login]}\n"
                     end
                     u.full_name = user[:name]
                     u.password = user[:password]
                     u.country = countries[user[:country_id]]
                     u.site = sites[user[:site_id]]
                     u.activated = true
                     u.email = "empty-#{u.login}@none.com"
                     if not u.save
                       @import_log << "Errors\n"
                       u.errors.each { |attr,msg|  @import_log << "#{attr} - #{msg}\n" }
                     end
                   end
                 end
+            +   def logout_users(user_ids)
+            +     sessions = ActiveRecord::SessionStore::Session.find(:all, :conditions => ["updated_at >= ?", 60.minutes.ago])
+            +     sessions.each do |session|
+            +       if user_ids.has_key? session.data[:user_id]
+            +         session.destroy
+            +       end
+            +     end
+            +   end
+            +
               end

app/models/configuration.rb ¶ +4 -3

               require 'yaml'
               #
               # This class also contains various login of the system.
               #
               class Configuration < ActiveRecord::Base
                 SYSTEM_MODE_CONF_KEY = 'system.mode'
                 TEST_REQUEST_EARLY_TIMEOUT_KEY = 'contest.test_request.early_timeout'
+            +   MULTICONTESTS_KEY = 'system.multicontests'
+            +   CONTEST_TIME_LIMIT_KEY = 'contest.time_limit'
                 cattr_accessor :cache
                 cattr_accessor :config_cache
                 cattr_accessor :task_grading_info_cache
                 cattr_accessor :contest_time_str
                 cattr_accessor :contest_time
                 # set @@cache = true to only reload once.
                 Configuration.cache = false
                 Configuration.config_cache = nil
                 Configuration.task_grading_info_cache = nil
                 def self.get(key)
                   if Configuration.cache
                     if Configuration.config_cache == nil
                       self.read_config
                     end
                     return Configuration.config_cache[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
                   Configuration.config_cache = nil
                 end
                 def self.cache?
                   Configuration.cache
                 end
                 def self.enable_caching
                   Configuration.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)
                   if time_limit_mode?
                     return false if not user.contest_started?
                   end
                   return true
                 end
                 def self.show_grading_result
                   return (get(SYSTEM_MODE_CONF_KEY)=='analysis')
                 end
                 def self.allow_test_request(user)
                   mode = get(SYSTEM_MODE_CONF_KEY)
                   early_timeout = get(TEST_REQUEST_EARLY_TIMEOUT_KEY)
                   if (mode=='contest')
                     return false if ((user.site!=nil) and
                       ((user.site.started!=true) or
                        (early_timeout and (user.site.time_left < 30.minutes))))
                   end
                   return false if mode=='analysis'
                   return true
                 end
                 def self.task_grading_info
                   if Configuration.task_grading_info_cache==nil
                     read_grading_info
                   end
                   return Configuration.task_grading_info_cache
                 end
                 def self.standard_mode?
                   return get(SYSTEM_MODE_CONF_KEY) == 'standard'
                 end
                 def self.contest_mode?
                   return get(SYSTEM_MODE_CONF_KEY) == 'contest'
                 end
                 def self.indv_contest_mode?
                   return get(SYSTEM_MODE_CONF_KEY) == 'indv-contest'
                 end
                 def self.multicontests?
-            -     g = get('system.multicontests')
+            +     return get(MULTICONTESTS_KEY) == true
-            -     return get('system.multicontests') == true
                 end
                 def self.time_limit_mode?
                   mode = get(SYSTEM_MODE_CONF_KEY)
                   return ((mode == 'contest') or (mode == 'indv-contest'))
                 end
                 def self.analysis_mode?
                   return get(SYSTEM_MODE_CONF_KEY) == 'analysis'
                 end
                 def self.contest_time_limit
-            -     contest_time_str = Configuration['contest.time_limit']
+            +     contest_time_str = Configuration[CONTEST_TIME_LIMIT_KEY]
                   if not defined? Configuration.contest_time_str
                     Configuration.contest_time_str = nil
                   end
                   if Configuration.contest_time_str != contest_time_str
                     Configuration.contest_time_str = contest_time_str
                     if tmatch = /(\d+):(\d+)/.match(contest_time_str)
                       h = tmatch[1].to_i
                       m = tmatch[2].to_i
                       Configuration.contest_time = h.hour + m.minute
                     else
                       Configuration.contest_time = nil
                     end
                   end
                   return Configuration.contest_time
                 end
                 protected
                 def self.convert_type(val,type)
                   case type
                   when 'string'
                     return val
                   when 'integer'
                     return val.to_i
                   when 'boolean'
                     return (val=='true')
                   end
                 end
                 def self.read_config
                   Configuration.config_cache = {}
                   Configuration.find(:all).each do |conf|
                     key = conf.key
                     val = conf.value
                     Configuration.config_cache[key] = Configuration.convert_type(val,conf.value_type)
                   end
                 end
                 def self.read_one_key(key)
                   conf = Configuration.find_by_key(key)
                   if conf
                     return Configuration.convert_type(conf.value,conf.value_type)
                   else
                     return nil
                   end
                 end
                 def self.read_grading_info
                   f = File.open(TASK_GRADING_INFO_FILENAME)
                   Configuration.task_grading_info_cache = YAML.load(f)
                   f.close
                 end
               end

app/models/user.rb ¶ +1 -4

                 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
                     "(unknown)"
                   elsif self.email==''
                     "(blank)"
                   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
                 def self.find_non_admin_with_prefix(prefix='')
                   users = User.find(:all)
                   return users.find_all { |u| !(u.admin?) and u.login.index(prefix)==0 }
                 end
                 # Contest information
                 def contest_time_left
                   if Configuration.contest_mode?
                     return nil if site==nil
                     return site.time_left
                   elsif Configuration.indv_contest_mode?
                     time_limit = Configuration.contest_time_limit
                     if time_limit == nil
                       return nil
                     end
                     if contest_stat==nil
                       return (Time.now.gmtime + time_limit) - Time.now.gmtime
                     else
                       finish_time = contest_stat.started_at + time_limit
                       current_time = Time.now.gmtime
                       if current_time > finish_time
                         return 0
                       else
                         return finish_time - current_time
                       end
                     end
                   else
                     return nil
                   end
                 end
                 def contest_finished?
                   if Configuration.contest_mode?
                     return false if site==nil
                     return site.finished?
                   elsif Configuration.indv_contest_mode?
-            -       time_limit = Configuration.contest_time_limit
+            +       return false if self.contest_stat(true)==nil
-            -       return false if contest_stat==nil
                     return contest_time_left == 0
                   else
                     return false
                   end
                 end
                 def contest_started?
                   if Configuration.contest_mode?
                     return true if site==nil
                     return site.started
                   else
                     return true
                   end
                 end
                 def update_start_time
                   stat = self.contest_stat
                   if stat == nil
                     stat = UserContestStat.new(:user => self,
                                                :started_at => Time.now.gmtime)
                     stat.save
                   end
                 end
                 def problem_in_user_contests?(problem)
                   problem_contests = problem.contests.all
                   if problem_contests.length == 0   # this is public contest
                     return true
                   end
                   contests.each do |contest|
                     if problem_contests.find {|c| c.id == contest.id }
                       return true
                     end
                   end
                   return false
                 end
                 def available_problems_group_by_contests
                   contest_problems = []
                   pin = {}
                   contests.enabled.each do |contest|
                     available_problems = contest.problems.available
                     contest_problems << {
                       :contest => contest,
                       :problems => available_problems
                     }
                     available_problems.each {|p| pin[p.id] = true}
                   end
                   other_avaiable_problems = Problem.available.find_all {|p| pin[p.id]==nil and p.contests.length==0}
                   contest_problems << {
                     :contest => nil,
                     :problems => other_avaiable_problems
                   }
                   return contest_problems
                 end
                 def available_problems
                   if not Configuration.multicontests?
                     return Problem.find_available_problems
                   else
                     contest_problems = []
                     pin = {}
                     contests.enabled.each do |contest|
                       contest.problems.available.each do |problem|
                         if not pin.has_key? problem.id
                           contest_problems << problem
                         end
                         pin[problem.id] = true
                       end
                     end
                     other_avaiable_problems = Problem.available.find_all {|p| pin[p.id]==nil and p.contests.length==0}
                     return contest_problems + other_avaiable_problems
                   end
                 end
                 def can_view_problem?(problem)
                   if not Configuration.multicontests?
                     return problem.available
                   else
                     return problem_in_user_contests? problem
                   end
                 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 assign_default_site
                     # have to catch error when migrating (because self.site is not available).
                     begin
                       if self.site==nil

db/seeds.rb ¶ +1 -1

               CONFIGURATIONS =
                 [
                  {
                    :key => 'system.single_user_mode',
                    :value_type => 'boolean',
                    :default_value => 'false',
                    :description => 'Only admins can log in to the system when running under single user mode.'
                  },
                  {
                    :key => 'ui.front.title',
                    :value_type => 'string',
                    :default_value => 'Grader'
                  },
                  {
                    :key => 'ui.front.welcome_message',
                    :value_type => 'string',
                    :default_value => 'Welcome!'
                  },
                  {
                    :key => 'ui.show_score',
                    :value_type => 'boolean',
                    :default_value => 'true'
                  },
                  {
                    :key => 'contest.time_limit',
                    :value_type => 'string',
                    :default_value => 'unlimited',
-            -      :description => 'Time limit in format hh:mm, or "unlimited" for contests with no time limits.'
+            +      :description => 'Time limit in format hh:mm, or "unlimited" for contests with no time limits.  This config is CACHED.  Restart the server before the change can take effect.'
                  },
                  {
                    :key => 'system.mode',
                    :value_type => 'string',
                    :default_value => 'standard',
                    :description => 'Current modes are "standard", "contest", "indv-contest", and "analysis".'
                  },
                  {
                    :key => 'contest.name',
                    :value_type => 'string',
                    :default_value => 'Grader',
                    :description => 'This name will be shown on the user header bar.'
                  },
                  {
                    :key => 'contest.multisites',
                    :value_type => 'boolean',
                    :default_value => 'false',
                    :description => 'If the server is in contest mode and this option is true, on the log in of the admin a menu for site selections is shown.'
                  },
                  {
                    :key => 'system.online_registration',
                    :value_type => 'boolean',
                    :default_value => 'false',
                    :description => 'This option enables online registration.'
                  },
                  # If Configuration['system.online_registration'] is true, the
                  # system allows online registration, and will use these
                  # information for sending confirmation emails.
                  {
                    :key => 'system.online_registration.smtp',
                    :value_type => 'string',
                    :default_value => 'smtp.somehost.com'
                  },
                  {
                    :key => 'system.online_registration.from',
                    :value_type => 'string',
                    :default_value => 'your.email@address'
                  },
                  {
                    :key => 'system.admin_email',
                    :value_type => 'string',
                    :default_value => 'admin@admin.email'
                  },
                  {
                    :key => 'system.user_setting_enabled',
                    :value_type => 'boolean',
                    :default_value => 'true',
                    :description => 'If this option is true, users can change their settings'
                  },
                  # If Configuration['contest.test_request.early_timeout'] is true
                  # the user will not be able to use test request at 30 minutes
                  # before the contest ends.
                  {
                    :key => 'contest.test_request.early_timeout',
                    :value_type => 'boolean',
                    :default_value => 'false'
                  },
                  {
                    :key => 'system.multicontests',
                    :value_type => 'boolean',
                    :default_value => 'false'
                  }
                 ]
               def create_configuration_key(key,
                                            value_type,
                                            default_value,
                                            description='')
                 conf = (Configuration.find_by_key(key) ||
                         Configuration.new(:key => key,
                                           :value_type => value_type,
                                           :value => default_value))
                 conf.description = description
                 conf.save
               end
               def seed_config
                 CONFIGURATIONS.each do |conf|
                   if conf.has_key? :description
                     desc = conf[:description]
                   else
                     desc = ''
                   end
                   create_configuration_key(conf[:key],
                                            conf[:value_type],

spec/config_spec_helper.rb ¶ +20 -2

               module ConfigSpecHelperMethods
                 def find_or_create_and_set_config(key, type, value)
                   c = Configuration.find_by_key(key)
                   c ||= Configuration.new(:key => key,
                                           :value_type => type)
                   c.value = value
                   c.save!
                 end
                 def enable_multicontest
-            -     find_or_create_and_set_config('system.multicontests','boolean','true')
+            +     find_or_create_and_set_config(Configuration::MULTICONTESTS_KEY,
+            +                                   'boolean','true')
                 end
                 def disable_multicontest
-            -     find_or_create_and_set_config('system.multicontests','boolean','false')
+            +     find_or_create_and_set_config(Configuration::MULTICONTESTS_KEY,
+            +                                   'boolean','false')
+            +   end
+            +
+            +   def set_indv_contest_mode
+            +     find_or_create_and_set_config(Configuration::SYSTEM_MODE_CONF_KEY,
+            +                                   'string','indv-contest')
                 end
+            +   def set_standard_mode
+            +     find_or_create_and_set_config(Configuration::SYSTEM_MODE_CONF_KEY,
+            +                                   'string','standard')
+            +   end
+            +
+            +   def set_contest_time_limit(limit)
+            +     find_or_create_and_set_config(Configuration::CONTEST_TIME_LIMIT_KEY,
+            +                                   'string',limit)
+            +     # clear old value
+            +     Configuration.contest_time_str = nil
+            +   end
               end

spec/controllers/main_controller_spec.rb ¶ +49

+            + require 'delorean'
+            +
               require File.dirname(__FILE__) + '/../spec_helper'
               require File.dirname(__FILE__) + '/../config_spec_helper'
               describe MainController, "when a user comes to list page" do
                 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
               end
               describe MainController, "when a logged in user comes to list page, with multicontests off" do
                 integrate_views
                 include ConfigSpecHelperMethods
                 fixtures :users
                 fixtures :problems
                 fixtures :contests
                 before(:each) do
                   disable_multicontest
                 end
                 it "should list available problems" do
                   john = users(:john)
                   get "list", {}, {:user_id => john.id}
                   response.should render_template 'main/list'
                   response.should have_text(/add/)
                   response.should have_text(/easy_problem/)
                   response.should have_text(/hard_problem/)
                 end
               end
               describe MainController, "when a logged in user comes to list page, with multicontests on" do
                 integrate_views
                 include ConfigSpecHelperMethods
                 fixtures :users
                 fixtures :problems
                 fixtures :contests
                 before(:each) do
                   enable_multicontest
                 end
                 it "should list only available public problems to users with no contest assigned" do
                   john = users(:john)
                   get "list", {}, {:user_id => john.id}
                   response.should render_template('main/list')
                   response.should have_text(/add/)
                   response.should_not have_text(/easy_problem/)
                   response.should_not have_text(/hard_problem/)
                 end
                 it "should list available problems on a specific contest" do
                   james = users(:james)
                   get "list", {}, {:user_id => james.id}
                   response.should render_template('main/list')
                   response.should have_text(/add/)
                   response.should have_text(/easy_problem/)
                   response.should_not have_text(/hard_problem/)
                 end
                 it "should shows available problems by contests" do
                   james = users(:james)
                   get "list", {}, {:user_id => james.id}
                   response.should render_template('main/list')
                   response.should have_text(Regexp.new('Contest A.*easy_problem', Regexp::MULTILINE))
                 end
                 it "should shows available problems by contests; problems belonging to more the one contest should appear many times" do
                   jack = users(:jack)
                   get "list", {}, {:user_id => jack.id}
                   response.should render_template('main/list')
                   response.should have_text(Regexp.new('Contest A.*easy_problem.*Contest B.*easy_problem', Regexp::MULTILINE))
                   response.should have_text(Regexp.new('Contest B.*hard_problem', Regexp::MULTILINE))
                 end
               end
               describe MainController, "when a user loads sources and compiler messages" do
                 before(:each) do
                   @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')
                   @user.should_receive(:update_start_time).at_most(:once)
                   @another_user = mock(User, :id => 2, :login => 'mary')
                   @another_user.should_receive(:update_start_time).at_most(:once)
                   User.should_receive(:find).
                     with(1).any_number_of_times.
                     and_return(@user)
                   User.should_receive(:find).
                     with(2).any_number_of_times.
                     and_return(@another_user)
                   Submission.should_receive(:find).
                     any_number_of_times.with(@submission.id.to_s).
                     and_return(@submission)
                 end
                 it "should let user sees her own source" do
                   @submission.should_receive(:download_filename).and_return("foo.c")
                   get 'source', {:id => @submission.id}, {:user_id => 1}
                   response.should be_success
                 end
                 it "should let user sees her own compiler message" do
                   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
                   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
                   get 'compiler_msg', {:id => @submission.id}, {:user_id => 2}
                   flash[:notice].should =~ /[Ee]rror/
                   response.should redirect_to(:action => 'list')
                 end
               end
+            + describe MainController, "during individual contest mode" do
+            +
+            +   integrate_views
+            +
+            +   include ConfigSpecHelperMethods
+            +
+            +   fixtures :users
+            +   fixtures :problems
+            +   fixtures :contests
+            +
+            +   before(:each) do
+            +     set_contest_time_limit('3:00')   # 3 hours
+            +     set_indv_contest_mode
+            +   end
+            +
+            +   it "should allow newly login user to see problem list" do
+            +     john = users(:john)
+            +     get "list", {}, {:user_id => john.id}
+            +
+            +     response.should render_template 'main/list'
+            +     response.should have_text(/add/)
+            +     response.should have_text(/easy_problem/)
+            +     response.should have_text(/hard_problem/)
+            +   end
+            +
+            +   it "should not show 'contest over' sign before the contest ends" do
+            +     john = users(:john)
+            +     get "list", {}, {:user_id => john.id}
+            +
+            +     Delorean.time_travel_to(179.minutes.since) do
+            +       get "list", {}, {:user_id => john.id}
+            +       response.should_not have_text(/OVER/)
+            +     end
+            +   end
+            +
+            +   it "should show 'contest over' sign after the contest ends" do
+            +     john = users(:john)
+            +     get "list", {}, {:user_id => john.id}
+            +
+            +     Delorean.time_travel_to(181.minutes.since) do
+            +       get "list", {}, {:user_id => john.id}
+            +       response.should have_text(/OVER/)
+            +     end
+            +   end
+            +
+            + end
+            +

test/fixtures/roles.yml ¶ +1

               # Read about fixtures at http://ar.rubyonrails.org/classes/Fixtures.html
               admin:
+            +   name: admin
                 rights: graders_right, user_admin_right, problems_right

test/fixtures/sites.yml ¶ +4 -4

               # Read about fixtures at http://ar.rubyonrails.org/classes/Fixtures.html
-            - one:
+            + first_site:
-            -   name: MyString
+            +   name: First site
                 started: false
                 start_time: 2008-04-09 14:08:28
-            - two:
+            + second_site:
-            -   name: MyString
+            +   name: Second site
                 started: false
                 start_time: 2008-04-09 14:08:28

test/fixtures/users.yml ¶ +4

               # Read about fixtures at http://ar.rubyonrails.org/classes/Fixtures.html
               <%
               User.public_class_method :encrypt
               salt = "abc"
               %>
               john:
                 login: john
                 full_name: john
                 hashed_password: <%= User.encrypt("hello",salt) %>
                 salt: <%= salt %>
+            +   activated: true
               mary:
                 login: mary
                 full_name: mary
                 hashed_password: <%= User.encrypt("goodbye",salt) %>
                 salt: <%= salt %>
                 roles: admin
+            +   activated: true
               james:
                 login: james
                 full_name: James
                 hashed_password: <%= User.encrypt("morning",salt) %>
                 salt: <%= salt %>
                 contests: contest_a
+            +   activated: true
               jack:
                 login: jack
                 full_name: Jack
                 hashed_password: <%= User.encrypt("morning",salt) %>
                 salt: <%= salt %>
                 contests: contest_a, contest_b
+            +   activated: true

test/functional/announcements_controller_test.rb removed ¶ -4

deleted file

test/functional/configurations_controller_test.rb removed ¶ -8

deleted file

test/functional/contest_management_controller_test.rb removed ¶ -8

deleted file

test/functional/contests_controller_test.rb removed ¶ -4

deleted file

test/functional/main_controller_test.rb removed ¶ -4

deleted file

test/functional/messages_controller_test.rb removed ¶ -8

deleted file

test/functional/problems_controller_test.rb removed ¶ -92

deleted file

test/functional/site_controller_test.rb removed ¶ -8

deleted file

test/functional/sites_controller_test.rb removed ¶ -4

deleted file

test/functional/tasks_controller_test.rb removed ¶ -8

deleted file

test/functional/test_controller_test.rb removed ¶ -8

deleted file

test/functional/users_controller_test.rb removed ¶ -18

deleted file

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

r294:069c049fbc3a - Sun, 28 Mar 2010 11:18:26 - 22 files changed: 191 inserted, 192 deleted

Sign in to your account

Commit r294:069c049fbc3a public

Author

r294:069c049fbc3a - Sun, 28 Mar 2010 11:18:26 - 22 files changed: 191 inserted, 192 deleted

Commit `r294:069c049fbc3a` public