cafe-grader-web Commit - r278:a0c2d497b31a

cafe-grader-web

Commit `r278:a0c2d497b31a` public

parent | child

Description:

shows problems availabe in contests

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

r278:a0c2d497b31a - Wed, 03 Mar 2010 03:23:18 - 9 files changed: 224 inserted, 45 deleted

app/controllers/main_controller.rb ¶ +50 -4

                 before_filter :check_viewability, :except => [:index, :login]
                 append_before_filter :update_user_start_time, :except => [:index, :login]
                 # to prevent log in box to be shown when user logged out of the
                 # system only in some tab
                 prepend_before_filter :reject_announcement_refresh_when_logged_out, :only => [:announcements]
                 # COMMENTED OUT: filter in each action instead
                 # before_filter :verify_time_limit, :only => [:submit]
                 verify :method => :post, :only => [:submit],
                        :redirect_to => { :action => :index }
                 # COMMENT OUT: only need when having high load
                 # caches_action :index, :login
                 # NOTE: This method is not actually needed, 'config/routes.rb' has
                 # assigned action login as a default action.
                 def index
                   redirect_to :action => 'login'
                 end
                 def login
                   saved_notice = flash[:notice]
                   reset_session
                   flash.now[:notice] = saved_notice
                   # EXPERIMENT:
                   # Hide login if in single user mode and the url does not
                   # explicitly specify /login
                   #
                   # logger.info "PATH: #{request.path}"
                   # if Configuration['system.single_user_mode'] and
                   #     request.path!='/main/login'
                   #   @hidelogin = true
                   # end
                   @announcements = Announcement.find_for_frontpage
                   render :action => 'login', :layout => 'empty'
                 end
                 def list
                   prepare_list_information
                 end
                 def help
                   @user = User.find(session[:user_id])
                 end
                 def submit
                   user = User.find(session[:user_id])
                   @submission = Submission.new(params[:submission])
                   @submission.user = user
                   @submission.language_id = 0
                   if (params['file']) and (params['file']!='')
                     @submission.source = params['file'].read
                     @submission.source_filename = params['file'].original_filename
                   end
                   @submission.submitted_at = Time.new.gmtime
                   if Configuration.time_limit_mode? and user.contest_finished?
                     @submission.errors.add_to_base "The contest is over."
                     prepare_list_information
                     render :action => 'list' and return
                   end
                   if @submission.valid?
                     if @submission.save == false
               	flash[:notice] = 'Error saving your submission'
                     elsif Task.create(:submission_id => @submission.id,
                                       :status => Task::STATUS_INQUEUE) == false
               	flash[:notice] = 'Error adding your submission to task queue'
                     end
                   else
                     prepare_list_information
                     render :action => 'list' and return
                   end
                   redirect_to :action => 'list'
                 end
                 def source
                   submission = Submission.find(params[:id])
                   if submission.user_id == session[:user_id]
                     send_data(submission.source,
               		{:filename => submission.download_filename,
                                 :type => 'text/plain'})
                   else
                     flash[:notice] = 'Error viewing source'
                     redirect_to :action => 'list'
                   end
                 end
                 def compiler_msg
                   @submission = Submission.find(params[:id])
                   if @submission.user_id == session[:user_id]
                     render :action => 'compiler_msg', :layout => 'empty'
                   else
                     flash[:notice] = 'Error viewing source'
                     redirect_to :action => 'list'
                   end
                 end
                 def submission
                   @user = User.find(session[:user_id])
                   @problems = Problem.find_available_problems
                   if params[:id]==nil
                     @problem = nil
                     @submissions = nil
                   else
                     @problem = Problem.find_by_name(params[:id])
                     if not @problem.available
                       redirect_to :action => 'list'
                       flash[:notice] = 'Error: submissions for that problem are not viewable.'
                       return
                     end
                     @submissions = Submission.find_all_by_user_problem(@user.id, @problem.id)
                   end
                 end
                 def result
                   if !Configuration.show_grading_result
                     redirect_to :action => 'list' and return
                   end
                   @user = User.find(session[:user_id])
                   @submission = Submission.find(params[:id])
                   if @submission.user!=@user
                     flash[:notice] = 'You are not allowed to view result of other users.'
                     redirect_to :action => 'list' and return
                   end
                   prepare_grading_result(@submission)
                 end
                 def load_output
                   if !Configuration.show_grading_result or params[:num]==nil
                     redirect_to :action => 'list' and return
                   end
                   @user = User.find(session[:user_id])
                   @submission = Submission.find(params[:id])
                   if @submission.user!=@user
                     flash[:notice] = 'You are not allowed to view result of other users.'
                     redirect_to :action => 'list' and return
                   end
                   case_num = params[:num].to_i
                   out_filename = output_filename(@user.login,
                                                  @submission.problem.name,
                                                  @submission.id,
                                                  case_num)
                   if !FileTest.exists?(out_filename)
                     flash[:notice] = 'Output not found.'
                     redirect_to :action => 'list' and return
                   end
                   response.headers['Content-Type'] = "application/force-download"
                   response.headers['Content-Disposition'] = "attachment; filename=\"output-#{case_num}.txt\""
                   response.headers["X-Sendfile"] = out_filename
                   response.headers['Content-length'] = File.size(out_filename)
                   render :nothing => true
                 end
                 def error
                   @user = User.find(session[:user_id])
                 end
                 # announcement refreshing and hiding methods
                 def announcements
                   if params.has_key? 'recent'
                     prepare_announcements(params[:recent])
                   else
                     prepare_announcements
                   end
                   render(:partial => 'announcement',
                          :collection => @announcements,
                          :locals => {:announcement_effect => true})
                 end
                 protected
                 def prepare_announcements(recent=nil)
                   if Configuration.show_tasks_to?(@user)
                     @announcements = Announcement.find_published(true)
                   else
                     @announcements = Announcement.find_published
                   end
                   if recent!=nil
                     recent_id = recent.to_i
                     @announcements = @announcements.find_all { |a| a.id > recent_id }
                   end
                 end
+            +   def problem_list_by_user_contests(user)
+            +     contest_problems = []
+            +     pin = {}
+            +     user.contests.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 problem_list_for_user(user, contest_problems=nil)
+            +     if not Configuration.multicontests?
+            +       return Problem.find_available_problems
+            +     else
+            +       if contest_problems==nil
+            +         contest_problems = problem_list_by_user_contests(user)
+            +       end
+            +
+            +       problems = []
+            +       collected = {}
+            +       contest_problems.each do |cp|
+            +         cp[:problems].each do |problem|
+            +           if not collected[problem.id]
+            +             problems << problem
+            +             collected[problem.id] = true
+            +           end
+            +         end
+            +       end
+            +       return problems
+            +     end
+            +   end
+            +
                 def prepare_list_information
-            -     @problems = Problem.find_available_problems
-            -     @prob_submissions = Array.new
                   @user = User.find(session[:user_id])
+            +     if not Configuration.multicontests?
+            +       @problems = problem_list_for_user(@user)
+            +     else
+            +       @contest_problems = problem_list_by_user_contests(@user)
+            +       @problems = problem_list_for_user(@user, @contest_problems)
+            +     end
+            +     @prob_submissions = {}
                   @problems.each do |p|
                     sub = Submission.find_last_by_user_and_problem(@user.id,p.id)
                     if sub!=nil
-            -         @prob_submissions << { :count => sub.number, :submission => sub }
+            +         @prob_submissions[p.id] = { :count => sub.number, :submission => sub }
                     else
-            -         @prob_submissions << { :count => 0, :submission => nil }
+            +         @prob_submissions[p.id] = { :count => 0, :submission => nil }
                     end
                   end
                   prepare_announcements
                 end
                 def check_viewability
                   @user = User.find(session[:user_id])
                   if (!Configuration.show_tasks_to?(@user)) and
                       ((action_name=='submission') or (action_name=='submit'))
                     redirect_to :action => 'list' and return
                   end
                 end
                 def prepare_grading_result(submission)
                   if Configuration.task_grading_info.has_key? submission.problem.name
                     grading_info = Configuration.task_grading_info[submission.problem.name]
                   else
                     # guess task info from problem.full_score
                     cases = submission.problem.full_score / 10
                     grading_info = {
                       'testruns' => cases,
                       'testcases' => cases
                     }
                   end
                   @test_runs = []
                   if grading_info['testruns'].is_a? Integer
                     trun_count = grading_info['testruns']
                     trun_count.times do |i|
                       @test_runs << [ read_grading_result(@user.login,
                                                           submission.problem.name,
                                                           submission.id,
                                                           i+1) ]
                     end
                   else
                     grading_info['testruns'].keys.sort.each do |num|
                       run = []
                       testrun = grading_info['testruns'][num]
                       testrun.each do |c|
                         run << read_grading_result(@user.login,
                                                    submission.problem.name,
                                                    submission.id,
                                                    c)
                       end
                       @test_runs << run
                     end
                   end
                 end
                 def grading_result_dir(user_name, problem_name, submission_id, case_num)
                   return "#{GRADING_RESULT_DIR}/#{user_name}/#{problem_name}/#{submission_id}/test-result/#{case_num}"
                 end
                 def output_filename(user_name, problem_name, submission_id, case_num)
                   dir = grading_result_dir(user_name,problem_name, submission_id, case_num)
                   return "#{dir}/output.txt"
                 end
                 def read_grading_result(user_name, problem_name, submission_id, case_num)
                   dir = grading_result_dir(user_name,problem_name, submission_id, case_num)
                   result_file_name = "#{dir}/result"
                   if !FileTest.exists?(result_file_name)
                     return {:num => case_num, :msg => 'program did not run'}
                   else
                     results = File.open(result_file_name).readlines
                     run_stat = extract_running_stat(results)
                     output_filename = "#{dir}/output.txt"
                     if FileTest.exists?(output_filename)
                       output_file = true
                       output_size = File.size(output_filename)
                     else
                       output_file = false
                       output_size = 0
                     end
                     return {
                       :num => case_num,
                       :msg => results[0],
                       :run_stat => run_stat,
                       :output => output_file,
                       :output_size => output_size
                     }
                   end
                 end
                 # copied from grader/script/lib/test_request_helper.rb
                 def extract_running_stat(results)
                   running_stat_line = results[-1]
                   # extract exit status line
                   run_stat = ""
                   if !(/[Cc]orrect/.match(results[0]))
                     run_stat = results[0].chomp
                   else
                     run_stat = 'Program exited normally'
                   end
                   logger.info "Stat line: #{running_stat_line}"
                   # extract running time
                   if res = /r(.*)u(.*)s/.match(running_stat_line)
                     seconds = (res[1].to_f + res[2].to_f)
                     time_stat = "Time used: #{seconds} sec."
                   else
                     seconds = nil
                     time_stat = "Time used: n/a sec."
                   end
                   # extract memory usage
                   if res = /s(.*)m/.match(running_stat_line)
                     memory_used = res[1].to_i
                   else
                     memory_used = -1
                   end
                   return {
                     :msg => "#{run_stat}\n#{time_stat}",
                     :running_time => seconds,
                     :exit_status => run_stat,
                     :memory_usage => memory_used
                   }
                 end
                 def update_user_start_time
                   user = User.find(session[:user_id])
                   user.update_start_time
                 end
                 def reject_announcement_refresh_when_logged_out
                   if not session[:user_id]
                     render :text => 'Access forbidden', :status => 403
                   end
                 end
               end

app/models/configuration.rb ¶ +4

               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'
                 cattr_accessor :cache
                 cattr_accessor :config_cache
                 cattr_accessor :task_grading_info
                 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 = 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==nil
                     read_grading_info
                   end
                   return Configuration.task_grading_info
                 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?
+            +     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']
                   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 = YAML.load(f)
                   f.close
                 end
               end

app/models/problem.rb ¶ +3 -1

               class Problem < ActiveRecord::Base
                 belongs_to :description
                 has_and_belongs_to_many :contests
                 has_many :test_pairs, :dependent => :delete_all
                 validates_presence_of :name
                 validates_format_of :name, :with => /^\w+$/
                 validates_presence_of :full_name
+            +   named_scope :available, :conditions => {:available => true}
+            +
                 DEFAULT_TIME_LIMIT = 1
                 DEFAULT_MEMORY_LIMIT = 32
                 def self.find_available_problems
-            -     find(:all, :conditions => {:available => true}, :order => "date_added DESC")
+            +     Problem.available.all(:order => "date_added DESC")
                 end
                 def self.create_from_import_form_params(params, old_problem=nil)
                   problem = old_problem || Problem.new
                   import_params = Problem.extract_params_and_check(params, problem)
                   if not problem.valid?
                     return problem, 'Error importing'
                   end
                   problem.full_score = 100
                   problem.date_added = Time.new
                   problem.test_allowed = true
                   problem.output_only = false
                   problem.available = false
                   if not problem.save
                     return problem, 'Error importing'
                   end
                   import_to_db = params.has_key? :import_to_db
                   importer = TestdataImporter.new(problem)
                   if not importer.import_from_file(import_params[:file],
                                                    import_params[:time_limit],
                                                    import_params[:memory_limit],
                                                    import_to_db)
                     problem.errors.add_to_base('Import error.')
                   end
                   return problem, importer.log_msg
                 end
                 def self.download_file_basedir
                   return "#{RAILS_ROOT}/data/tasks"
                 end
                 protected
                 def self.to_i_or_default(st, default)
                   if st!=''
                     st.to_i
                   else
                     default
                   end
                 end
                 def self.extract_params_and_check(params, problem)
                   time_limit = Problem.to_i_or_default(params[:time_limit],
                                                        DEFAULT_TIME_LIMIT)
                   memory_limit = Problem.to_i_or_default(params[:memory_limit],
                                                          DEFAULT_MEMORY_LIMIT)
                   if time_limit==0 and time_limit_s!='0'
                     problem.errors.add_to_base('Time limit format errors.')
                   elsif time_limit<=0 or time_limit >60
                     problem.errors.add_to_base('Time limit out of range.')
                   end
                   if memory_limit==0 and memory_limit_s!='0'
                     problem.errors.add_to_base('Memory limit format errors.')
                   elsif memory_limit<=0 or memory_limit >512
                     problem.errors.add_to_base('Memory limit out of range.')
                   end
                   if params[:file]==nil or params[:file]==''
                     problem.errors.add_to_base('No testdata file.')
                   end
                   file = params[:file]
                   if problem.errors.length!=0
                     return problem
                   end
                   problem.name = params[:name]
                   if params[:full_name]!=''
                     problem.full_name = params[:full_name]
                   else
                     problem.full_name = params[:name]
                   end
                   return {
                     :time_limit => time_limit,
                     :memory_limit => memory_limit,
                     :file => file
                   }
                 end
               end

app/views/main/_problem.html.erb ¶ +2 -2

               <tr class="info-<%= (problem_counter%2==0) ? "even" : "odd" %>">
                 <td>
                   <%= "#{problem_counter+1}" %>
                 </td>
                 <td>
                   <%= "#{problem.full_name} (#{problem.name})" %>
                   <%= link_to_description_if_any "[#{t 'main.problem_desc'}]", problem %>
                 </td>
                 <td align="center">
-            -     <%= @prob_submissions[problem_counter][:count] %>
+            +     <%= @prob_submissions[problem.id][:count] %>
                 </td>
                 <td>
                   <%= render :partial => 'submission_short',
                              :locals => {
-            -                  :submission => @prob_submissions[problem_counter][:submission],
+            +                  :submission => @prob_submissions[problem.id][:submission],
                                :problem_name => problem.name }%>
                 </td>
               </tr>

app/views/main/list.html.haml ¶ +20 -7

               - content_for :head do
                 = javascript_include_tag :defaults
                 = javascript_include_tag 'announcement_refresh.js'
               = user_title_bar(@user)
               .announcementbox{:style => (@announcements.length==0 ? "display:none" : "")}
                 %span{:class => 'title'}
                   Announcements
                 #announcementbox-body
                   = render :partial => 'announcement', :collection => @announcements
               - if Configuration.show_submitbox_to?(@user)
                 .submitbox
                   = error_messages_for 'submission'
                   = render :partial => 'submission_box'
               %hr/
               - if (Configuration.contest_mode?) and (@user.site!=nil) and (@user.site.started!=true)
                 %p=t 'main.start_soon'
               - if Configuration.show_tasks_to?(@user)
-            -   %table.info
+            +   - if not Configuration.multicontests?
-            -     %tr.info-head
+            +     %table.info
-            -       %th
+            +       %tr.info-head
-            -       %th Tasks
+            +         %th
-            -       %th # of sub(s)
+            +         %th Tasks
-            -       %th Results
+            +         %th # of sub(s)
-            -     = render :partial => 'problem', :collection => @problems
+            +         %th Results
+            +       = render :partial => 'problem', :collection => @problems
+            +   - else
+            +     - @contest_problems.each do |cp|
+            +       %h2{:class =>'contest-title'}
+            +         = "#{cp[:contest] ? cp[:contest].title : 'Public problems'}"
+            +       %table.info
+            +         %tr.info-head
+            +           %th
+            +           %th Tasks
+            +           %th # of sub(s)
+            +           %th Results
+            +         = render :partial => 'problem', :collection => cp[:problems]
+            +
               %hr/
               %script{:type => 'text/javascript'}
                 = "Announcement.refreshUrl = '#{url_for :controller => 'main', :action => 'announcements'}';"
                 Announcement.registerRefreshEventTimer();

spec/controllers/main_controller_spec.rb ¶ +118 -15

@@ -1,56 +1,159
1	-
2	require File.dirname(__FILE__) + '/../spec_helper'	1	require File.dirname(__FILE__) + '/../spec_helper'
3		2
4	- describe MainController do	3	+ module ConfigHelperMethods
		4	+ def enable_multicontest
		5	+ c = Configuration.new(:key => 'system.multicontests',
		6	+ :value_type => 'boolean',
		7	+ :value => 'true')
		8	+ c.save
		9	+ end
		10	+
		11	+ def disable_multicontest
		12	+ c = Configuration.new(:key => 'system.multicontests',
		13	+ :value_type => 'boolean',
		14	+ :value => 'false')
		15	+ c.save
		16	+ end
		17	+ end
		18	+
		19	+ describe MainController, "when a user comes to list page" do
		20	+
		21	+ it "should redirect user to login page when unlogged-in user try to access main/list" do
		22	+ get 'list'
		23	+ response.should redirect_to(:action => 'login')
		24	+ end
		25	+
		26	+ end
		27	+
		28	+ describe MainController, "when a logged in user comes to list page, with multicontests off" do
		29	+ integrate_views
		30	+
		31	+ include ConfigHelperMethods
		32	+
		33	+ fixtures :users
		34	+ fixtures :problems
		35	+ fixtures :contests
		36	+
		37	+ before(:each) do
		38	+ disable_multicontest
		39	+ end
		40	+
		41	+ it "should list available problems" do
		42	+ john = users(:john)
		43	+ get "list", {}, {:user_id => john.id}
		44	+
		45	+ response.should render_template 'main/list'
		46	+ response.should have_text(/add/)
		47	+ response.should have_text(/easy_problem/)
		48	+ response.should have_text(/hard_problem/)
		49	+ end
		50	+
		51	+ end
		52	+
		53	+ describe MainController, "when a logged in user comes to list page, with multicontests on" do
		54	+ integrate_views
		55	+
		56	+ include ConfigHelperMethods
		57	+
		58	+ fixtures :users
		59	+ fixtures :problems
		60	+ fixtures :contests
		61	+
		62	+ before(:each) do
		63	+ enable_multicontest
		64	+ end
		65	+
		66	+ it "should list only available public problems to users with no contest assigned" do
		67	+ john = users(:john)
		68	+ get "list", {}, {:user_id => john.id}
		69	+
		70	+ response.should render_template('main/list')
		71	+ response.should have_text(/add/)
		72	+ response.should_not have_text(/easy_problem/)
		73	+ response.should_not have_text(/hard_problem/)
		74	+ end
		75	+
		76	+ it "should list available problems on a specific contest" do
		77	+ james = users(:james)
		78	+ get "list", {}, {:user_id => james.id}
		79	+
		80	+ response.should render_template('main/list')
		81	+ response.should have_text(/add/)
		82	+ response.should have_text(/easy_problem/)
		83	+ response.should_not have_text(/hard_problem/)
		84	+ end
		85	+
		86	+ it "should shows available problems by contests" do
		87	+ james = users(:james)
		88	+ get "list", {}, {:user_id => james.id}
		89	+
		90	+ response.should render_template('main/list')
		91	+ response.should have_text(Regexp.new('Contest A.*easy_problem', Regexp::MULTILINE))
		92	+ end
		93	+
		94	+ it "should shows available problems by contests; problems belonging to more the one contest should appear many times" do
		95	+ jack = users(:jack)
		96	+ get "list", {}, {:user_id => jack.id}
		97	+
		98	+ response.should render_template('main/list')
		99	+ response.should have_text(Regexp.new('Contest A.easy_problem.Contest B.*easy_problem', Regexp::MULTILINE))
		100	+ response.should have_text(Regexp.new('Contest B.*hard_problem', Regexp::MULTILINE))
		101	+ end
		102	+ end
		103	+
		104	+ describe MainController, "when a user loads sources and compiler messages" do
5		105
6	before(:each) do	106	before(:each) do
7	@problem = mock(Problem, :name => 'test', :output_only => false)	107	@problem = mock(Problem, :name => 'test', :output_only => false)
8	@language = mock(Language, :name => 'cpp', :ext => 'cpp')	108	@language = mock(Language, :name => 'cpp', :ext => 'cpp')
9	@submission = mock(Submission,	109	@submission = mock(Submission,
10	:id => 1,	110	:id => 1,
11	:user_id => 1,	111	:user_id => 1,
12	:problem => @problem,	112	:problem => @problem,
13	:language => @language,	113	:language => @language,
14	:source => 'sample source',	114	:source => 'sample source',
15	:compiler_message => 'none')	115	:compiler_message => 'none')
		116	+
16	@user = mock(User, :id => 1, :login => 'john')	117	@user = mock(User, :id => 1, :login => 'john')
		118	+ @user.should_receive(:update_start_time).at_most(:once)
		119	+
17	@another_user = mock(User, :id => 2, :login => 'mary')	120	@another_user = mock(User, :id => 2, :login => 'mary')
18	- end	121	+ @another_user.should_receive(:update_start_time).at_most(:once)
19		122
20	- it "should redirect user to login page when unlogged-in user try to access main/list" do	123	+ User.should_receive(:find).
21	- get 'list'	124	+ with(1).any_number_of_times.
22	- response.should redirect_to(:action => 'login')	125	+ and_return(@user)
		126	+ User.should_receive(:find).
		127	+ with(2).any_number_of_times.
		128	+ and_return(@another_user)
		129	+ Submission.should_receive(:find).
		130	+ any_number_of_times.with(@submission.id.to_s).
		131	+ and_return(@submission)
23	end	132	end
24		133
25	it "should let user sees her own source" do	134	it "should let user sees her own source" do
26	- Submission.should_receive(:~~find~~).~~with~~(~~@submission~~.id.~~to_s~~).and_return(~~@submission~~)	135	+ @submission.should_receive(:download_filename).and_return("foo.c")
27	- User.should_receive(:find).with(1).and_return(@user)
28	- @user.should_receive(:update_start_time)
29	get 'source', {:id => @submission.id}, {:user_id => 1}	136	get 'source', {:id => @submission.id}, {:user_id => 1}
30	response.should be_success	137	response.should be_success
31	end	138	end
32		139
33	it "should let user sees her own compiler message" do	140	it "should let user sees her own compiler message" do
34	- Submission.should_receive(:find).with(@submission.id.to_s).and_return(@submission)
35	- User.should_receive(:find).with(1).and_return(@user)
36	get 'compiler_msg', {:id => @submission.id}, {:user_id => 1}	141	get 'compiler_msg', {:id => @submission.id}, {:user_id => 1}
37	response.should be_success	142	response.should be_success
38	end	143	end
39		144
40	it "should not let user sees other user's source" do	145	it "should not let user sees other user's source" do
41	- Submission.should_receive(:find).with(@submission.id.to_s).and_return(@submission)
42	- User.should_receive(:find).with(2).and_return(@another_user)
43	get 'source', {:id => @submission.id}, {:user_id => 2}	146	get 'source', {:id => @submission.id}, {:user_id => 2}
44	flash[:notice].should =~ /[Ee]rror/	147	flash[:notice].should =~ /[Ee]rror/
45	response.should redirect_to(:action => 'list')	148	response.should redirect_to(:action => 'list')
46	end	149	end
47		150
48	it "should not let user sees other user's compiler message" do	151	it "should not let user sees other user's compiler message" do
49	- Submission.should_receive(:find).with(@submission.id.to_s).and_return(@submission)
50	- User.should_receive(:find).with(2).and_return(@another_user)
51	get 'compiler_msg', {:id => @submission.id}, {:user_id => 2}	152	get 'compiler_msg', {:id => @submission.id}, {:user_id => 2}
52	flash[:notice].should =~ /[Ee]rror/	153	flash[:notice].should =~ /[Ee]rror/
53	response.should redirect_to(:action => 'list')	154	response.should redirect_to(:action => 'list')
54	end	155	end
55		156
56	end	157	end
		158	+
		159	+

test/fixtures/problems.yml ¶ +13

               # Read about fixtures at http://ar.rubyonrails.org/classes/Fixtures.html
               one:
                 id: 1
                 name: add
                 full_name: add_full_name
                 available: true
+            +
               two:
                 id: 2
                 name: subtract
                 full_name: subtract_full_name
                 available: false
+            +
+            + easy:
+            +   name: easy_problem
+            +   full_name: Easy Problem
+            +   available: true
+            +   contests: contest_a, contest_b
+            +
+            + hard:
+            +   name: hard_problem
+            +   full_name: Hard Problem
+            +   available: true
+            +   contests: contest_b

test/fixtures/users.yml ¶ +14

               # 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 %>
+            +
               mary:
                 login: mary
                 full_name: mary
                 hashed_password: <%= User.encrypt("goodbye",salt) %>
                 salt: <%= salt %>
                 roles: admin
+            + james:
+            +   login: james
+            +   full_name: James
+            +   hashed_password: <%= User.encrypt("morning",salt) %>
+            +   salt: <%= salt %>
+            +   contests: contest_a
+            +
+            + jack:
+            +   login: jack
+            +   full_name: Jack
+            +   hashed_password: <%= User.encrypt("morning",salt) %>
+            +   salt: <%= salt %>
+            +   contests: contest_a, contest_b

test/functional/main_controller_test.rb ¶ -16

@@ -1,20 +1,4
1	require File.dirname(__FILE__) + '/../test_helper'	1	require File.dirname(__FILE__) + '/../test_helper'
2		2
3	class MainControllerTest < ActionController::TestCase	3	class MainControllerTest < ActionController::TestCase
4	- fixtures :users
5	- fixtures :problems
6	-
7	- def test_should_redirect_new_user_to_login
8	- get :list
9	- assert_redirected_to :controller => 'main', :action => 'login'
10	- end
11	-
12	- def test_should_list_available_problems_if_logged_in
13	- john = users(:john)
14	- get :list, {}, {:user_id => john.id}
15	-
16	- assert_template 'main/list'
17	- assert_select "table tr:nth-child(2)", :text => /\(add\)/
18	- end
19	-
20	end	4	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

r278:a0c2d497b31a - Wed, 03 Mar 2010 03:23:18 - 9 files changed: 224 inserted, 45 deleted

Sign in to your account

Commit r278:a0c2d497b31a public

Author

r278:a0c2d497b31a - Wed, 03 Mar 2010 03:23:18 - 9 files changed: 224 inserted, 45 deleted

Commit `r278:a0c2d497b31a` public