jro_apps/redmine Commit - r9335:b960470d7817

Removed object_daddy dependency....

Jean-Philippe Lang -

r9335:b960470d7817

parent child

Context file:

r9335:b960470d7817

Collapse all files

Gemfile 0 -1

             group :test do
               gem "shoulda", "~> 2.10.3"
-              gem "edavis10-object_daddy", :require => "object_daddy"
               gem "mocha"
             end

test/object_daddy_helpers.rb +89 -5

@@ -15,26 +15,110 module ObjectDaddyHelpers
15		15
16	def User.add_to_project(user, project, roles)	16	def User.add_to_project(user, project, roles)
17	roles = [roles] unless roles.is_a?(Array)	17	roles = [roles] unless roles.is_a?(Array)
18	Member.~~gener~~ate!(:principal => user, :project => project, :roles => roles)	18	Member.create!(:principal => user, :project => project, :roles => roles)
		19	end
		20
		21	def User.generate!(attributes={})
		22	@generated_user_login \|\|= 'user0'
		23	@generated_user_login.succ!
		24	user = User.new(attributes)
		25	user.login = @generated_user_login if user.login.blank?
		26	user.mail = "#{@generated_user_login}@example.com" if user.mail.blank?
		27	user.firstname = "Bob" if user.firstname.blank?
		28	user.lastname = "Doe" if user.lastname.blank?
		29	yield user if block_given?
		30	user.save!
		31	user
		32	end
		33
		34	def Group.generate!(attributes={})
		35	@generated_group_name \|\|= 'Group 0'
		36	@generated_group_name.succ!
		37	group = Group.new(attributes)
		38	group.lastname = @generated_group_name if group.lastname.blank?
		39	yield group if block_given?
		40	group.save!
		41	group
		42	end
		43
		44	def Project.generate!(attributes={})
		45	@generated_project_identifier \|\|= 'project-0000'
		46	@generated_project_identifier.succ!
		47	project = Project.new(attributes)
		48	project.name = @generated_project_identifier if project.name.blank?
		49	project.identifier = @generated_project_identifier if project.identifier.blank?
		50	yield project if block_given?
		51	project.save!
		52	project
		53	end
		54
		55	def Tracker.generate!(attributes={})
		56	@generated_tracker_name \|\|= 'Tracker 0'
		57	@generated_tracker_name.succ!
		58	tracker = Tracker.new(attributes)
		59	tracker.name = @generated_tracker_name if tracker.name.blank?
		60	yield tracker if block_given?
		61	tracker.save!
		62	tracker
		63	end
		64
		65	def Role.generate!(attributes={})
		66	@generated_role_name \|\|= 'Role 0'
		67	@generated_role_name.succ!
		68	role = Role.new(attributes)
		69	role.name = @generated_role_name if role.name.blank?
		70	yield role if block_given?
		71	role.save!
		72	role
		73	end
		74
		75	def Issue.generate!(attributes={})
		76	issue = Issue.new(attributes)
		77	issue.subject = 'Generated' if issue.subject.blank?
		78	issue.author \|\|= User.find(2)
		79	yield issue if block_given?
		80	issue.save!
		81	issue
		82	end
		83
		84	def Version.generate!(attributes={})
		85	@generated_version_name \|\|= 'Version 0'
		86	@generated_version_name.succ!
		87	version = Version.new(attributes)
		88	version.name = @generated_version_name if version.name.blank?
		89	yield version if block_given?
		90	version.save!
		91	version
		92	end
		93
		94	def AuthSource.generate!(attributes={})
		95	@generated_auth_source_name \|\|= 'Auth 0'
		96	@generated_auth_source_name.succ!
		97	source = AuthSource.new(attributes)
		98	source.name = @generated_auth_source_name if source.name.blank?
		99	yield source if block_given?
		100	source.save!
		101	source
19	end	102	end
20		103
21	# Generate the default Query	104	# Generate the default Query
22	def Query.generate_default!(attributes={})	105	def Query.generate_default!(attributes={})
23	query = Query.~~spawn~~(attributes)	106	query = Query.new(attributes)
24	query.name \|\|= '_'	107	query.name = '_' if query.name.blank?
25	query.save!	108	query.save!
26	query	109	query
27	end	110	end
28		111
29	# Generate an issue for a project, using it's trackers	112	# Generate an issue for a project, using it's trackers
30	def Issue.generate_for_project!(project, attributes={})	113	def Issue.generate_for_project!(project, attributes={})
31	issue = Issue.~~spawn~~(attributes) do \|issue\|	114	issue = Issue.new(attributes) do \|issue\|
32	issue.project = project	115	issue.project = project
33	issue.tracker = project.trackers.first unless project.trackers.empty?	116	issue.tracker = project.trackers.first unless project.trackers.empty?
		117	issue.subject = 'Generated' if issue.subject.blank?
		118	issue.author \|\|= User.find(2)
34	yield issue if block_given?	119	yield issue if block_given?
35	end	120	end
36	issue.save!	121	issue.save!
37	issue	122	issue
38	end	123	end
39
40	end	124	end

test/test_helper.rb +23 -12

                 context "should allow http basic auth using a username and password for #{http_method} #{url}" do
                   context "with a valid HTTP authentication" do
                     setup do
-                      @user = User.generate_with_protected!(:password => 'my_password', :password_confirmation => 'my_password', :admin => true) # Admin so they can access the project
+                      @user = User.generate! do |user|
+                        user.admin = true
+                        user.password = 'my_password'
+                      end
                       send(http_method, url, parameters, credentials(@user.login, 'my_password'))
                     end
                   context "with an invalid HTTP authentication" do
                     setup do
-                      @user = User.generate_with_protected!
+                      @user = User.generate!
                       send(http_method, url, parameters, credentials(@user.login, 'wrong_password'))
                     end
                 context "should allow http basic auth with a key for #{http_method} #{url}" do
                   context "with a valid HTTP authentication using the API token" do
                     setup do
-                      @user = User.generate_with_protected!(:admin => true)
+                      @user = User.generate! do |user|
-                      @token = Token.generate!(:user => @user, :action => 'api')
+                        user.admin = true
+                      end
+                      @token = Token.create!(:user => @user, :action => 'api')
                       send(http_method, url, parameters, credentials(@token.value, 'X'))
                     end
                   context "with an invalid HTTP authentication" do
                     setup do
-                      @user = User.generate_with_protected!
+                      @user = User.generate!
-                      @token = Token.generate!(:user => @user, :action => 'feeds')
+                      @token = Token.create!(:user => @user, :action => 'feeds')
                       send(http_method, url, parameters, credentials(@token.value, 'X'))
                     end
                 context "should allow key based auth using key=X for #{http_method} #{url}" do
                   context "with a valid api token" do
                     setup do
-                      @user = User.generate_with_protected!(:admin => true)
+                      @user = User.generate! do |user|
-                      @token = Token.generate!(:user => @user, :action => 'api')
+                        user.admin = true
+                      end
+                      @token = Token.create!(:user => @user, :action => 'api')
                       # Simple url parse to add on ?key= or &key=
                       request_url = if url.match(/\?/)
                                       url + "&key=#{@token.value}"
                   context "with an invalid api token" do
                     setup do
-                      @user = User.generate_with_protected!
+                      @user = User.generate! do |user|
-                      @token = Token.generate!(:user => @user, :action => 'feeds')
+                        user.admin = true
+                      end
+                      @token = Token.create!(:user => @user, :action => 'feeds')
                       # Simple url parse to add on ?key= or &key=
                       request_url = if url.match(/\?/)
                                       url + "&key=#{@token.value}"
                 context "should allow key based auth using X-Redmine-API-Key header for #{http_method} #{url}" do
                   setup do
-                    @user = User.generate_with_protected!(:admin => true)
+                    @user = User.generate! do |user|
-                    @token = Token.generate!(:user => @user, :action => 'api')
+                      user.admin = true
+                    end
+                    @token = Token.create!(:user => @user, :action => 'api')
                     send(http_method, url, parameters, {'X-Redmine-API-Key' => @token.value.to_s})
                   end

test/unit/issue_test.rb +2 -2

                 tracker = Tracker.find(1)
                 user = User.find(2)
-                issue = Issue.generate!(:tracker => tracker, :status => status, :project_id => 1)
+                issue = Issue.generate!(:tracker => tracker, :status => status, :project_id => 1, :author_id => 1)
                 assert_equal [1, 2], issue.new_statuses_allowed_to(user).map(&:id)
                 issue = Issue.generate!(:tracker => tracker, :status => status, :project_id => 1, :author => user)
                 assert_equal [1, 2, 3, 5], issue.new_statuses_allowed_to(user).map(&:id)
-                issue = Issue.generate!(:tracker => tracker, :status => status, :project_id => 1, :assigned_to => user)
+                issue = Issue.generate!(:tracker => tracker, :status => status, :project_id => 1, :author_id => 1, :assigned_to => user)
                 assert_equal [1, 2, 4, 5], issue.new_statuses_allowed_to(user).map(&:id)
                 issue = Issue.generate!(:tracker => tracker, :status => status, :project_id => 1, :author => user, :assigned_to => user)

test/unit/lib/redmine/ciphering_test.rb +10 -10

               def test_password_should_be_encrypted
                 Redmine::Configuration.with 'database_cipher_key' => 'secret' do
-                  r = Repository::Subversion.generate!(:password => 'foo')
+                  r = Repository::Subversion.create!(:password => 'foo', :url => 'file:///tmp', :identifier => 'svn')
                   assert_equal 'foo', r.password
                   assert r.read_attribute(:password).match(/\Aaes-256-cbc:.+\Z/)
                 end
               def test_password_should_be_clear_with_blank_key
                 Redmine::Configuration.with 'database_cipher_key' => '' do
-                  r = Repository::Subversion.generate!(:password => 'foo')
+                  r = Repository::Subversion.create!(:password => 'foo', :url => 'file:///tmp', :identifier => 'svn')
                   assert_equal 'foo', r.password
                   assert_equal 'foo', r.read_attribute(:password)
                 end
               def test_password_should_be_clear_with_nil_key
                 Redmine::Configuration.with 'database_cipher_key' => nil do
-                  r = Repository::Subversion.generate!(:password => 'foo')
+                  r = Repository::Subversion.create!(:password => 'foo', :url => 'file:///tmp', :identifier => 'svn')
                   assert_equal 'foo', r.password
                   assert_equal 'foo', r.read_attribute(:password)
                 end
               def test_blank_password_should_be_clear
                 Redmine::Configuration.with 'database_cipher_key' => 'secret' do
-                  r = Repository::Subversion.generate!(:password => '')
+                  r = Repository::Subversion.create!(:password => '', :url => 'file:///tmp', :identifier => 'svn')
                   assert_equal '', r.password
                   assert_equal '', r.read_attribute(:password)
                 end
               def test_unciphered_password_should_be_readable
                 Redmine::Configuration.with 'database_cipher_key' => nil do
-                  r = Repository::Subversion.generate!(:password => 'clear')
+                  r = Repository::Subversion.create!(:password => 'clear', :url => 'file:///tmp', :identifier => 'svn')
                 end
                 Redmine::Configuration.with 'database_cipher_key' => 'secret' do
               def test_ciphered_password_with_no_cipher_key_configured_should_be_returned_ciphered
                 Redmine::Configuration.with 'database_cipher_key' => 'secret' do
-                  r = Repository::Subversion.generate!(:password => 'clear')
+                  r = Repository::Subversion.create!(:password => 'clear', :url => 'file:///tmp', :identifier => 'svn')
                 end
                 Redmine::Configuration.with 'database_cipher_key' => '' do
               def test_encrypt_all
                 Repository.delete_all
                 Redmine::Configuration.with 'database_cipher_key' => nil do
-                  Repository::Subversion.generate!(:password => 'foo')
+                  Repository::Subversion.create!(:password => 'foo', :url => 'file:///tmp', :identifier => 'foo')
-                  Repository::Subversion.generate!(:password => 'bar')
+                  Repository::Subversion.create!(:password => 'bar', :url => 'file:///tmp', :identifier => 'bar')
                 end
                 Redmine::Configuration.with 'database_cipher_key' => 'secret' do
               def test_decrypt_all
                 Repository.delete_all
                 Redmine::Configuration.with 'database_cipher_key' => 'secret' do
-                  Repository::Subversion.generate!(:password => 'foo')
+                  Repository::Subversion.create!(:password => 'foo', :url => 'file:///tmp', :identifier => 'foo')
-                  Repository::Subversion.generate!(:password => 'bar')
+                  Repository::Subversion.create!(:password => 'bar', :url => 'file:///tmp', :identifier => 'bar')
                   assert Repository.decrypt_all(:password)
                   r = Repository.first(:order => 'id DESC')

test/unit/lib/redmine/helpers/gantt_test.rb 0 -1

                   context "assigned to a shared version of another project" do
                     setup do
                       p = Project.generate!
-                      p.trackers << @tracker
                       p.enabled_module_names = [:issue_tracking]
                       @shared_version = Version.generate!(:sharing => 'system')
                       p.versions << @shared_version

test/unit/project_test.rb +9 -9

                 project = Project.find(1)
                 system_activity = TimeEntryActivity.find_by_name('Design')
                 assert system_activity.active?
-                overridden_activity = TimeEntryActivity.generate!(:project => project, :parent => system_activity, :active => false)
+                overridden_activity = TimeEntryActivity.create!(:name => "Project", :project => project, :parent => system_activity, :active => false)
                 assert overridden_activity.save!
                 assert !project.activities.include?(overridden_activity), "Inactive Project specific Activity not found"
                                                  :tracker_id => 1,
                                                  :assigned_to_id => 2,
                                                  :project_id => @source_project.id)
-                  source_relation = IssueRelation.generate!(:issue_from => Issue.find(4),
+                  source_relation = IssueRelation.create!(:issue_from => Issue.find(4),
                                                             :issue_to => second_issue,
                                                             :relation_type => "relates")
-                  source_relation_cross_project = IssueRelation.generate!(:issue_from => Issue.find(1),
+                  source_relation_cross_project = IssueRelation.create!(:issue_from => Issue.find(1),
                                                                           :issue_to => second_issue,
                                                                           :relation_type => "duplicates")
                   @role = Role.generate!
                   @user_with_membership_notification = User.generate!(:mail_notification => 'selected')
-                  Member.generate!(:project => @project, :roles => [@role], :principal => @user_with_membership_notification, :mail_notification => true)
+                  Member.create!(:project => @project, :roles => [@role], :principal => @user_with_membership_notification, :mail_notification => true)
                   @all_events_user = User.generate!(:mail_notification => 'all')
-                  Member.generate!(:project => @project, :roles => [@role], :principal => @all_events_user)
+                  Member.create!(:project => @project, :roles => [@role], :principal => @all_events_user)
                   @no_events_user = User.generate!(:mail_notification => 'none')
-                  Member.generate!(:project => @project, :roles => [@role], :principal => @no_events_user)
+                  Member.create!(:project => @project, :roles => [@role], :principal => @no_events_user)
                   @only_my_events_user = User.generate!(:mail_notification => 'only_my_events')
-                  Member.generate!(:project => @project, :roles => [@role], :principal => @only_my_events_user)
+                  Member.create!(:project => @project, :roles => [@role], :principal => @only_my_events_user)
                   @only_assigned_user = User.generate!(:mail_notification => 'only_assigned')
-                  Member.generate!(:project => @project, :roles => [@role], :principal => @only_assigned_user)
+                  Member.create!(:project => @project, :roles => [@role], :principal => @only_assigned_user)
                   @only_owned_user = User.generate!(:mail_notification => 'only_owner')
-                  Member.generate!(:project => @project, :roles => [@role], :principal => @only_owned_user)
+                  Member.create!(:project => @project, :roles => [@role], :principal => @only_owned_user)
                 end
                 should "include members with a mail notification" do

test/unit/query_test.rb +3 -1

               end
               def test_issue_count_with_archived_issues
-                p = Project.generate!( :status => Project::STATUS_ARCHIVED )
+                p = Project.generate! do |project|
+                  project.status = Project::STATUS_ARCHIVED
+                end
                 i = Issue.generate!( :project => p, :tracker => p.trackers.first )
                 assert !i.visible?

test/unit/user_test.rb +13 -9

               def test_destroy_should_nullify_changesets
                 changeset = Changeset.create!(
-                  :repository => Repository::Subversion.generate!(
+                  :repository => Repository::Subversion.create!(
-                    :project_id => 1
+                    :project_id => 1,
+                    :url => 'file:///tmp',
+                    :identifier => 'tmp'
                   ),
                   :revision => '12',
                   :committed_on => Time.now,
                 end
                 should "select the exact matching user first" do
-                  case_sensitive_user = User.generate_with_protected!(
+                  case_sensitive_user = User.generate! do |user|
-                                               :login => 'changed', :password => 'admin',
+                    user.password = "admin"
-                                               :password_confirmation => 'admin')
+                  end
                   # bypass validations to make it appear like existing data
                   case_sensitive_user.update_attribute(:login, 'ADMIN')
                 should "return the existing api token value" do
                   user = User.generate_with_protected!
-                  token = Token.generate!(:action => 'api')
+                  token = Token.create!(:action => 'api')
                   user.api_token = token
                   assert user.save
                 should "return nil if the key is found for an inactive user" do
                   user = User.generate_with_protected!(:status => User::STATUS_LOCKED)
-                  token = Token.generate!(:action => 'api')
+                  token = Token.create!(:action => 'api')
                   user.api_token = token
                   user.save
                 should "return the user if the key is found for an active user" do
                   user = User.generate_with_protected!(:status => User::STATUS_ACTIVE)
-                  token = Token.generate!(:action => 'api')
+                  token = Token.create!(:action => 'api')
                   user.api_token = token
                   user.save
               end
               def test_own_account_deletable_should_be_true_for_an_admin_if_other_admin_exists
-                User.generate_with_protected(:admin => true)
+                User.generate! do |user|
+                  user.admin = true
+                end
                 with_settings :unsubscribe => '1' do
                   assert_equal true, User.find(1).own_account_deletable?

test/unit/testing_test.rb removed 0 -46

NO CONTENT: file was removed

General Comments 0

Write
Preview

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

No TODOs yet

	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
g 0-9	Goto bookmarked items from 0-9
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 access permissions settings
t s	Toggle sidebar on some pages