cafe-grader-web Commit - r275:3720a1af46c5

cafe-grader-web

Commit `r275:3720a1af46c5` public

parent | child

Description:

started cleaning up tests, fixed fixtures loading error, removed error when contest time limit is uninitialized

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

r275:3720a1af46c5 - Tue, 02 Mar 2010 18:33:21 - 19 files changed: 76 inserted, 211 deleted

app/controllers/main_controller.rb ¶ +1 -1

                     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])
-            -     UserContestStat.update_user_start_time(user)
+            +     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 ¶ +28 -22

               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'
-            -   # set @@cache = true to only reload once.
+            +   cattr_accessor :cache
-            -   @@cache = false
+            +   cattr_accessor :config_cache
+            +   cattr_accessor :task_grading_info
+            +   cattr_accessor :contest_time_str
+            +   cattr_accessor :contest_time
-            -   @@configurations = nil
+            +   # set @@cache = true to only reload once.
-            -   @@task_grading_info = nil
+            +   Configuration.cache = false
+            +
+            +   Configuration.config_cache = nil
+            +   Configuration.task_grading_info = nil
                 def self.get(key)
-            -     if @@cache
+            +     if Configuration.cache
-            -       if @@configurations == nil
+            +       if Configuration.config_cache == nil
                       self.read_config
                     end
-            -       return @@configurations[key]
+            +       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
-            -     @@configurations = nil
+            +     Configuration.config_cache = nil
                 end
                 def self.cache?
-            -     @@cache
+            +     Configuration.cache
                 end
                 def self.enable_caching
-            -     @@cache = true
+            +     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 @@task_grading_info==nil
+            +     if Configuration.task_grading_info==nil
                     read_grading_info
                   end
-            -     return @@task_grading_info
+            +     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.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? @@contest_time_str
+            +     if not defined? Configuration.contest_time_str
-            -       @@contest_time_str = nil
+            +       Configuration.contest_time_str = nil
                   end
-            -     if @@contest_time_str != contest_time_str
+            +     if Configuration.contest_time_str != contest_time_str
-            -       @@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
-            -         @@contest_time = h.hour + m.minute
+            +         Configuration.contest_time = h.hour + m.minute
                     else
-            -         @@contest_time = nil
+            +         Configuration.contest_time = nil
                     end
                   end
-            -     return @@contest_time
+            +     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
-            -     @@configurations = {}
+            +     Configuration.config_cache = {}
                   Configuration.find(:all).each do |conf|
                     key = conf.key
                     val = conf.value
-            -       @@configurations[key] = Configuration.convert_type(val,conf.value_type)
+            +       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)
-            -     @@task_grading_info = YAML.load(f)
+            +     Configuration.task_grading_info = YAML.load(f)
                   f.close
                 end
               end

app/models/user.rb ¶ +12

                 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 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
+            +
                 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
                         self.site = Site.find_by_name('default')
                         if self.site==nil
                           self.site = Site.find(1)  # when 'default has be renamed'
                         end
                       end
                     rescue
                     end
                   end
                   def password_required?
                     self.hashed_password.blank? || !self.password.blank?
                   end

app/models/user_contest_stat.rb ¶ -9

@@ -1,14 +1,5
1	class UserContestStat < ActiveRecord::Base	1	class UserContestStat < ActiveRecord::Base
2		2
3	belongs_to :user	3	belongs_to :user
4		4
5	- def self.update_user_start_time(user)
6	- stat = user.contest_stat
7	- if stat == nil
8	- stat = UserContestStat.new(:user => user,
9	- :started_at => Time.now.gmtime)
10	- stat.save
11	- end
12	- end
13	-
14	end	5	end

db/migrate/020_add_graders_right_to_admin_role.rb ¶ +1 -1

               class AddGradersRightToAdminRole < ActiveRecord::Migration
                 def self.up
                   admin_role = Role.find_by_name('admin')
                   graders_right = Right.create(:name => 'graders_admin',
                                                :controller => 'graders',
                                                :action => 'all')
                   admin_role.rights << graders_right;
                   admin_role.save
                 end
                 def self.down
                   graders_right = Right.find_by_name('graders_admin')
-            -     graders_right.destroy
+            +     graders_right.destroy if graders_right
                 end
               end

db/migrate/025_add_site_to_user_and_add_default_site.rb ¶ +1 -1

                   default_site = Site.new({:name => 'default',
                                             :started => false})
                   default_site.save!
                   add_column :users, :site_id, :integer
                   User.reset_column_information
                   User.find(:all).each do |user|
                     class << user
                       def valid?
                         true
                       end
                     end
                     user.site_id = default_site.id
                     user.save
                   end
                 end
                 def self.down
                   remove_column :users, :site_id
                   default_site = Site.find_by_name('default')
-            -     default_site.destroy
+            +     default_site.destroy if default_site
                 end
               end

db/schema.rb ¶ +13 -26

                   t.string   "task_type"
                   t.boolean  "terminated"
                 end
                 add_index "grader_processes", ["host", "pid"], :name => "index_grader_processes_on_ip_and_pid"
                 create_table "languages", :force => true do |t|
                   t.string "name",        :limit => 10
                   t.string "pretty_name"
                   t.string "ext",         :limit => 10
                   t.string "common_ext"
                 end
                 create_table "messages", :force => true do |t|
                   t.integer  "sender_id"
                   t.integer  "receiver_id"
                   t.integer  "replying_message_id"
                   t.text     "body"
                   t.boolean  "replied"
                   t.datetime "created_at"
                   t.datetime "updated_at"
                 end
                 create_table "problems", :force => true do |t|
-            -     t.string   "name",                 :limit => 30
+            +     t.string  "name",                 :limit => 30
-            -     t.string   "full_name"
+            +     t.string  "full_name"
-            -     t.integer  "full_score"
+            +     t.integer "full_score"
-            -     t.date     "date_added"
+            +     t.date    "date_added"
-            -     t.boolean  "available"
+            +     t.boolean "available"
-            -     t.string   "url"
+            +     t.string  "url"
-            -     t.integer  "description_id"
+            +     t.integer "description_id"
-            -     t.boolean  "test_allowed"
+            +     t.boolean "test_allowed"
-            -     t.boolean  "output_only"
+            +     t.boolean "output_only"
-            -     t.integer  "level",                              :default => 0
+            +     t.string  "description_filename"
-            -     t.datetime "updated_at"
-            -     t.string   "description_filename"
                 end
                 create_table "rights", :force => true do |t|
                   t.string "name"
                   t.string "controller"
                   t.string "action"
                 end
                 create_table "rights_roles", :id => false, :force => true do |t|
                   t.integer "right_id"
                   t.integer "role_id"
                 end
                 add_index "rights_roles", ["role_id"], :name => "index_rights_roles_on_role_id"
                 create_table "roles", :force => true do |t|
                   t.string "name"
                 end
                 create_table "roles_users", :id => false, :force => true do |t|
                   t.integer "role_id"
                   t.integer "user_id"
                 end
                 create_table "tasks", :force => true do |t|
                   t.integer  "submission_id"
                   t.datetime "created_at"
                   t.integer  "status"
                   t.datetime "updated_at"
                 end
                 create_table "test_pair_assignments", :force => true do |t|
                   t.integer  "user_id"
                   t.integer  "problem_id"
                   t.integer  "test_pair_id"
                   t.integer  "test_pair_number"
                   t.integer  "request_number"
                   t.datetime "created_at"
                   t.datetime "updated_at"
                   t.boolean  "submitted"
                 end
                 create_table "test_pairs", :force => true do |t|
                   t.integer  "problem_id"
                   t.text     "input",      :limit => 16777215
                   t.text     "solution",   :limit => 16777215
                   t.datetime "created_at"
                   t.datetime "updated_at"
-            -     t.integer  "number"
                 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 "user_contest_stats", :force => true do |t|
                   t.integer  "user_id"
                   t.datetime "started_at"
                   t.datetime "created_at"
                   t.datetime "updated_at"
                 end
                 create_table "users", :force => true do |t|
-            -     t.string   "login",               :limit => 50
+            +     t.string   "login",           :limit => 50
                   t.string   "full_name"
                   t.string   "hashed_password"
-            -     t.string   "salt",                :limit => 5
+            +     t.string   "salt",            :limit => 5
                   t.string   "alias"
                   t.string   "email"
                   t.integer  "site_id"
                   t.integer  "country_id"
-            -     t.boolean  "activated",                         :default => false
+            +     t.boolean  "activated",                     :default => false
                   t.datetime "created_at"
                   t.datetime "updated_at"
-            -     t.string   "member1_full_name"
-            -     t.string   "member2_full_name"
-            -     t.string   "member3_full_name"
-            -     t.boolean  "high_school"
-            -     t.string   "member1_school_name"
-            -     t.string   "member2_school_name"
-            -     t.string   "member3_school_name"
-            -     t.string   "school_name"
-            -     t.string   "province"
-            -     t.integer  "year"
                 end
                 add_index "users", ["login"], :name => "index_users_on_login", :unique => true
               end

spec/controllers/main_controller_spec.rb ¶ +1

               describe MainController 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')
                   @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)
+            +     @user.should_receive(:update_start_time)
                   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/

spec/spec_helper.rb ¶ +1 -1

               # This file is copied to ~/spec when you run 'ruby script/generate rspec'
               # from the project root directory.
               ENV["RAILS_ENV"] ||= 'test'
               require File.expand_path(File.join(File.dirname(__FILE__),'..','config','environment'))
               require 'spec/autorun'
               require 'spec/rails'
               # Uncomment the next line to use webrat's matchers
               #require 'webrat/integrations/rspec-rails'
               # Requires supporting files with custom matchers and macros, etc,
               # in ./support/ and its subdirectories.
               Dir[File.expand_path(File.join(File.dirname(__FILE__),'support','**','*.rb'))].each {|f| require f}
               Spec::Runner.configure do |config|
                 # If you're not using ActiveRecord you should remove these
                 # lines, delete config/database.yml and disable :active_record
                 # in your config/boot.rb
                 config.use_transactional_fixtures = true
                 config.use_instantiated_fixtures  = false
-            -   config.fixture_path = RAILS_ROOT + '/spec/fixtures/'
+            +   config.fixture_path = RAILS_ROOT + '/test/fixtures/'
                 # == Fixtures
                 #
                 # You can declare fixtures for each example_group like this:
                 #   describe "...." do
                 #     fixtures :table_a, :table_b
                 #
                 # Alternatively, if you prefer to declare them only once, you can
                 # do so right here. Just uncomment the next line and replace the fixture
                 # names with your fixtures.
                 #
                 # config.global_fixtures = :table_a, :table_b
                 #
                 # If you declare global fixtures, be aware that they will be declared
                 # for all of your examples, even those that don't use them.
                 #
                 # You can also declare which fixtures to use (for example fixtures for test/fixtures):
                 #
                 # config.fixture_path = RAILS_ROOT + '/spec/fixtures/'
                 #
                 # == Mock Framework
                 #
                 # RSpec uses it's own mocking framework by default. If you prefer to
                 # use mocha, flexmock or RR, uncomment the appropriate line:

test/fixtures/users.yml ¶ +7 -5

               # Read about fixtures at http://ar.rubyonrails.org/classes/Fixtures.html
               <%
               User.public_class_method :encrypt
-            - SALT = "abc"
+            + salt = "abc"
               %>
               john:
                 login: john
-            -   hashed_password: <%= User.encrypt("hello",SALT) %>
+            +   full_name: john
-            -   salt: <%= SALT %>
+            +   hashed_password: <%= User.encrypt("hello",salt) %>
+            +   salt: <%= salt %>
               mary:
                 login: mary
-            -   hashed_password: <%= User.encrypt("goodbye",SALT) %>
+            +   full_name: mary
-            -   salt: <%= SALT %>
+            +   hashed_password: <%= User.encrypt("goodbye",salt) %>
+            +   salt: <%= salt %>
                 roles: admin

test/functional/announcements_controller_test.rb ¶ -41

@@ -1,45 +1,4
1	require File.dirname(__FILE__) + '/../test_helper'	1	require File.dirname(__FILE__) + '/../test_helper'
2		2
3	class AnnouncementsControllerTest < ActionController::TestCase	3	class AnnouncementsControllerTest < ActionController::TestCase
4	- def test_should_get_index
5	- get :index
6	- assert_response :success
7	- assert_not_nil assigns(:announcements)
8	- end
9	-
10	- def test_should_get_new
11	- get :new
12	- assert_response :success
13	- end
14	-
15	- def test_should_create_announcement
16	- assert_difference('Announcement.count') do
17	- post :create, :announcement => { }
18	- end
19	-
20	- assert_redirected_to announcement_path(assigns(:announcement))
21	- end
22	-
23	- def test_should_show_announcement
24	- get :show, :id => announcements(:one).id
25	- assert_response :success
26	- end
27	-
28	- def test_should_get_edit
29	- get :edit, :id => announcements(:one).id
30	- assert_response :success
31	- end
32	-
33	- def test_should_update_announcement
34	- put :update, :id => announcements(:one).id, :announcement => { }
35	- assert_redirected_to announcement_path(assigns(:announcement))
36	- end
37	-
38	- def test_should_destroy_announcement
39	- assert_difference('Announcement.count', -1) do
40	- delete :destroy, :id => announcements(:one).id
41	- end
42	-
43	- assert_redirected_to announcements_path
44	- end
45	end	4	end

test/functional/contests_controller_test.rb ¶ -41

@@ -1,45 +1,4
1	require 'test_helper'	1	require 'test_helper'
2		2
3	class ContestsControllerTest < ActionController::TestCase	3	class ContestsControllerTest < ActionController::TestCase
4	- test "should get index" do
5	- get :index
6	- assert_response :success
7	- assert_not_nil assigns(:contests)
8	- end
9	-
10	- test "should get new" do
11	- get :new
12	- assert_response :success
13	- end
14	-
15	- test "should create contest" do
16	- assert_difference('Contest.count') do
17	- post :create, :contest => { }
18	- end
19	-
20	- assert_redirected_to contest_path(assigns(:contest))
21	- end
22	-
23	- test "should show contest" do
24	- get :show, :id => contests(:one).to_param
25	- assert_response :success
26	- end
27	-
28	- test "should get edit" do
29	- get :edit, :id => contests(:one).to_param
30	- assert_response :success
31	- end
32	-
33	- test "should update contest" do
34	- put :update, :id => contests(:one).to_param, :contest => { }
35	- assert_redirected_to contest_path(assigns(:contest))
36	- end
37	-
38	- test "should destroy contest" do
39	- assert_difference('Contest.count', -1) do
40	- delete :destroy, :id => contests(:one).to_param
41	- end
42	-
43	- assert_redirected_to contests_path
44	- end
45	end	4	end

test/functional/login_controller_test.rb ¶ +1 -1

               require File.dirname(__FILE__) + '/../test_helper'
               require 'login_controller'
               # Re-raise errors caught by the controller.
               class LoginController; def rescue_action(e) raise e end; end
-            - class LoginControllerTest < Test::Unit::TestCase
+            + class LoginControllerTest < ActionController::TestCase
                 fixtures :users
                 def setup
                   @controller = LoginController.new
                   @request    = ActionController::TestRequest.new
                   @response   = ActionController::TestResponse.new
                 end
                 # Replace this with your real tests.
                 def test_should_hide_index
                   get :index
                   assert_redirected_to :controller => 'main', :action => 'login'
                 end
                 def test_should_login_user_and_set_session
                   john = users(:john)
                   post :login, :login => 'john', :password => "hello"
                   assert_redirected_to :controller => 'main', :action => 'list'
                   assert_equal john.id, session[:user_id]
                 end
                 def test_should_reject_user_with_wrong_password

test/functional/main_controller_test.rb ¶ +4 -16

-            - require File.dirname(__FILE__) + '/../test_helper'
+            + require File.dirname(__FILE__) +  '/../test_helper'
-            - require 'main_controller'
-            - # Re-raise errors caught by the controller.
+            + class MainControllerTest < ActionController::TestCase
-            - class MainController; def rescue_action(e) raise e end; end
+            +   fixtures :users
-            - class MainControllerTest < Test::Unit::TestCase
                 fixtures :problems
-            -   fixtures :users
-            -   def setup
-            -     @controller = MainController.new
-            -     @request    = ActionController::TestRequest.new
-            -     @response   = ActionController::TestResponse.new
-            -   end
-            -   # Replace this with your real tests.
                 def test_should_redirect_new_user_to_login
                   get :list
-            -     assert_redirected_to :action => 'login'
+            +     assert_redirected_to :controller => 'main', :action => 'login'
                 end
                 def test_should_list_available_problems_if_logged_in
                   john = users(:john)
                   get :list, {}, {:user_id => john.id}
                   assert_template 'main/list'
                   assert_select "table tr:nth-child(2)", :text => /\(add\)/
                 end
               end

test/functional/problems_controller_test.rb ¶ +1 -1

               require File.dirname(__FILE__) + '/../test_helper'
               require 'problems_controller'
               # Re-raise errors caught by the controller.
               class ProblemsController; def rescue_action(e) raise e end; end
-            - class ProblemsControllerTest < Test::Unit::TestCase
+            + class ProblemsControllerTest < ActionController::TestCase
                 fixtures :problems
                 def setup
                   @controller = ProblemsController.new
                   @request    = ActionController::TestRequest.new
                   @response   = ActionController::TestResponse.new
                   @first_id = problems(:first).id
                 end
                 def test_index
                   get :index
                   assert_response :success
                   assert_template 'list'
                 end
                 def test_list
                   get :list
                   assert_response :success
                   assert_template 'list'
                   assert_not_nil assigns(:problems)
                 end

test/functional/sites_controller_test.rb ¶ -41

@@ -1,45 +1,4
1	require File.dirname(__FILE__) + '/../test_helper'	1	require File.dirname(__FILE__) + '/../test_helper'
2		2
3	class SitesControllerTest < ActionController::TestCase	3	class SitesControllerTest < ActionController::TestCase
4	- def test_should_get_index
5	- get :index
6	- assert_response :success
7	- assert_not_nil assigns(:sites)
8	- end
9	-
10	- def test_should_get_new
11	- get :new
12	- assert_response :success
13	- end
14	-
15	- def test_should_create_site
16	- assert_difference('Site.count') do
17	- post :create, :site => { }
18	- end
19	-
20	- assert_redirected_to site_path(assigns(:site))
21	- end
22	-
23	- def test_should_show_site
24	- get :show, :id => sites(:one).id
25	- assert_response :success
26	- end
27	-
28	- def test_should_get_edit
29	- get :edit, :id => sites(:one).id
30	- assert_response :success
31	- end
32	-
33	- def test_should_update_site
34	- put :update, :id => sites(:one).id, :site => { }
35	- assert_redirected_to site_path(assigns(:site))
36	- end
37	-
38	- def test_should_destroy_site
39	- assert_difference('Site.count', -1) do
40	- delete :destroy, :id => sites(:one).id
41	- end
42	-
43	- assert_redirected_to sites_path
44	- end
45	end	4	end

test/functional/user_admin_controller_test.rb ¶ +1 -1

               require File.dirname(__FILE__) + '/../test_helper'
               require 'user_admin_controller'
               # Re-raise errors caught by the controller.
               class UserAdminController; def rescue_action(e) raise e end; end
-            - class UserAdminControllerTest < Test::Unit::TestCase
+            + class UserAdminControllerTest < ActionController::TestCase
                 fixtures :users
                 fixtures :roles
                 fixtures :rights
                 def setup
                   @controller = UserAdminController.new
                   @request    = ActionController::TestRequest.new
                   @response   = ActionController::TestResponse.new
                   @first_id = users(:john).id
                   @admin_id = users(:mary).id
                 end
                 def test_should_not_allow_new_user_to_see
                   get :list
                   assert_redirected_to :controller => 'main', :action => 'login'
                 end
                 def test_should_not_allow_normal_user_to_see
                   john = users(:john)
                   get :list, {}, {:user_id => john.id}
                   assert_redirected_to :controller => 'main', :action => 'login'
                 end

test/functional/users_controller_test.rb ¶ +1 -1

               require File.dirname(__FILE__) + '/../test_helper'
               require 'users_controller'
               # Re-raise errors caught by the controller.
               class UsersController; def rescue_action(e) raise e end; end
-            - class UsersControllerTest < Test::Unit::TestCase
+            + class UsersControllerTest < ActionController::TestCase
                 def setup
                   @controller = UsersController.new
                   @request    = ActionController::TestRequest.new
                   @response   = ActionController::TestResponse.new
                 end
                 # Replace this with your real tests.
                 def test_truth
                   assert true
                 end
               end

test/test_helper.rb ¶ +3 -2

               ENV["RAILS_ENV"] = "test"
               require File.expand_path(File.dirname(__FILE__) + "/../config/environment")
               require 'test_help'
-            - class Test::Unit::TestCase
+            + class ActiveSupport::TestCase
                 # Transactional fixtures accelerate your tests by wrapping each test method
                 # in a transaction that's rolled back on completion.  This ensures that the
                 # test database remains unchanged so your fixtures don't have to be reloaded
                 # between every test method.  Fewer database queries means faster tests.
                 #
                 # Read Mike Clark's excellent walkthrough at
                 #   http://clarkware.com/cgi/blosxom/2005/10/24#Rails10FastTesting
                 #
                 # Every Active Record database supports transactions except MyISAM tables
                 # in MySQL.  Turn off transactional fixtures in this case; however, if you
                 # don't care one way or the other, switching from MyISAM to InnoDB tables
                 # is recommended.
-            -   self.use_transactional_fixtures = true
+            +   self.use_transactional_fixtures = false
                 # Instantiated fixtures are slow, but give you @david where otherwise you
                 # would need people(:david).  If you don't want to migrate your existing
                 # test cases which use the @david style and don't mind the speed hit (each
                 # instantiated fixtures translates to a database query per test method),
                 # then set this back to true.
                 self.use_instantiated_fixtures  = false
                 # Add more helper methods to be used by all tests here...
               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

r275:3720a1af46c5 - Tue, 02 Mar 2010 18:33:21 - 19 files changed: 76 inserted, 211 deleted

Sign in to your account

Commit r275:3720a1af46c5 public

Author

r275:3720a1af46c5 - Tue, 02 Mar 2010 18:33:21 - 19 files changed: 76 inserted, 211 deleted

Commit `r275:3720a1af46c5` public