jro_apps/redmine Commit - r11633:8f7b69f77e7f

Removed some shoulda context....

Jean-Philippe Lang -

r11633:8f7b69f77e7f

parent child

Context file:

r11633:8f7b69f77e7f

Collapse all files

test/integration/api_test/projects_test.rb +55 -117

                 set_tmp_attachments_directory
               end
-              context "GET /projects" do
+              # TODO: A private project is needed because should_allow_api_authentication
-                context ".xml" do
+              # actually tests that authentication is *required*, not just allowed
-                  should "return projects" do
+              should_allow_api_authentication(:get, "/projects/2.xml")
+              should_allow_api_authentication(:get, "/projects/2.json")
+              should_allow_api_authentication(:post,
+                                              '/projects.xml',
+                                              {:project => {:name => 'API test', :identifier => 'api-test'}},
+                                              {:success_code => :created})
+              should_allow_api_authentication(:put,
+                                              '/projects/2.xml',
+                                              {:project => {:name => 'API update'}},
+                                              {:success_code => :ok})
+              should_allow_api_authentication(:delete,
+                                              '/projects/2.xml',
+                                              {},
+                                              {:success_code => :ok})
+              test "GET /projects.xml should return projects" do
                 get '/projects.xml'
                 assert_response :success
                 assert_equal 'application/xml', @response.content_type
                 assert_tag :tag => 'projects',
                   :child => {:tag => 'project', :child => {:tag => 'id', :content => '1'}}
               end
-                end
-                context ".json" do
+              test "GET /projects.json should return projects" do
-                  should "return projects" do
                 get '/projects.json'
                 assert_response :success
                 assert_equal 'application/json', @response.content_type
                 assert_kind_of Hash, json['projects'].first
                 assert json['projects'].first.has_key?('id')
               end
-                end
-              end
-              context "GET /projects/:id" do
-                context ".xml" do
-                  # TODO: A private project is needed because should_allow_api_authentication
-                  # actually tests that authentication is *required*, not just allowed
-                  should_allow_api_authentication(:get, "/projects/2.xml")
-                  should "return requested project" do
+              test "GET /projects/:id.xml should return the project" do
                 get '/projects/1.xml'
                 assert_response :success
                 assert_equal 'application/xml', @response.content_type
                 assert_no_tag 'issue_categories'
               end
-                  context "with hidden custom fields" do
+              test "GET /projects/:id.json should return the project" do
-                    setup do
+                get '/projects/1.json'
-                      ProjectCustomField.find_by_name('Development status').update_attribute :visible, false
+                json = ActiveSupport::JSON.decode(response.body)
+                assert_kind_of Hash, json
+                assert_kind_of Hash, json['project']
+                assert_equal 1, json['project']['id']
               end
-                    should "not display hidden custom fields" do
+              test "GET /projects/:id.xml with hidden custom fields should not display hidden custom fields" do
+                ProjectCustomField.find_by_name('Development status').update_attribute :visible, false
                 get '/projects/1.xml'
                 assert_response :success
                 assert_equal 'application/xml', @response.content_type
                 assert_no_tag 'custom_field',
                   :attributes => {:name => 'Development status'}
               end
-                  end
-                  should "return categories with include=issue_categories" do
+              test "GET /projects/:id.xml with include=issue_categories should return categories" do
                 get '/projects/1.xml?include=issue_categories'
                 assert_response :success
                 assert_equal 'application/xml', @response.content_type
                   }
               end
-                  should "return trackers with include=trackers" do
+              test "GET /projects/:id.xml with include=trackers should return trackers" do
                 get '/projects/1.xml?include=trackers'
                 assert_response :success
                 assert_equal 'application/xml', @response.content_type
                     }
                   }
               end
-                end
-                context ".json" do
-                  should_allow_api_authentication(:get, "/projects/2.json")
-                  should "return requested project" do
-                    get '/projects/1.json'
-                    json = ActiveSupport::JSON.decode(response.body)
+              test "POST /projects.xml with valid parameters should create the project" do
-                    assert_kind_of Hash, json
-                    assert_kind_of Hash, json['project']
-                    assert_equal 1, json['project']['id']
-                  end
-                end
-              end
-              context "POST /projects" do
-                context "with valid parameters" do
-                  setup do
                 Setting.default_projects_modules = ['issue_tracking', 'repository']
-                    @parameters = {:project => {:name => 'API test', :identifier => 'api-test'}}
-                  end
-                  context ".xml" do
-                    should_allow_api_authentication(:post,
-                                                    '/projects.xml',
-                                                    {:project => {:name => 'API test', :identifier => 'api-test'}},
-                                                    {:success_code => :created})
-                    should "create a project with the attributes" do
                 assert_difference('Project.count') do
-                        post '/projects.xml', @parameters, credentials('admin')
+                  post '/projects.xml',
+                    {:project => {:name => 'API test', :identifier => 'api-test'}},
+                    credentials('admin')
                 end
                 project = Project.first(:order => 'id DESC')
                 assert_tag 'project', :child => {:tag => 'id', :content => project.id.to_s}
               end
-                    should "accept enabled_module_names attribute" do
+              test "POST /projects.xml should accept enabled_module_names attribute" do
-                      @parameters[:project].merge!({:enabled_module_names => ['issue_tracking', 'news', 'time_tracking']})
                 assert_difference('Project.count') do
-                        post '/projects.xml', @parameters, credentials('admin')
+                  post '/projects.xml',
+                    {:project => {:name => 'API test', :identifier => 'api-test', :enabled_module_names => ['issue_tracking', 'news', 'time_tracking']}},
+                    credentials('admin')
                 end
                 project = Project.first(:order => 'id DESC')
                 assert_equal ['issue_tracking', 'news', 'time_tracking'], project.enabled_module_names.sort
               end
-                    should "accept tracker_ids attribute" do
+              test "POST /projects.xml should accept tracker_ids attribute" do
-                      @parameters[:project].merge!({:tracker_ids => [1, 3]})
                 assert_difference('Project.count') do
-                        post '/projects.xml', @parameters, credentials('admin')
+                  post '/projects.xml',
+                    {:project => {:name => 'API test', :identifier => 'api-test', :tracker_ids => [1, 3]}},
+                    credentials('admin')
                 end
                 project = Project.first(:order => 'id DESC')
                 assert_equal [1, 3], project.trackers.map(&:id).sort
               end
-                  end
-                end
-                context "with invalid parameters" do
-                  setup do
-                    @parameters = {:project => {:name => 'API test'}}
-                  end
-                  context ".xml" do
+              test "POST /projects.xml with invalid parameters should return errors" do
-                    should "return errors" do
                 assert_no_difference('Project.count') do
-                        post '/projects.xml', @parameters, credentials('admin')
+                  post '/projects.xml', {:project => {:name => 'API test'}}, credentials('admin')
                 end
                 assert_response :unprocessable_entity
                 assert_equal 'application/xml', @response.content_type
                 assert_tag 'errors', :child => {:tag => 'error', :content => "Identifier can't be blank"}
               end
-                  end
-                end
-              end
-              context "PUT /projects/:id" do
-                context "with valid parameters" do
-                  setup do
-                    @parameters = {:project => {:name => 'API update'}}
-                  end
-                  context ".xml" do
+              test "PUT /projects/:id.xml with valid parameters should update the project" do
-                    should_allow_api_authentication(:put,
-                                                    '/projects/2.xml',
-                                                    {:project => {:name => 'API update'}},
-                                                    {:success_code => :ok})
-                    should "update the project" do
                 assert_no_difference 'Project.count' do
-                        put '/projects/2.xml', @parameters, credentials('jsmith')
+                  put '/projects/2.xml', {:project => {:name => 'API update'}}, credentials('jsmith')
                 end
                 assert_response :ok
                 assert_equal '', @response.body
                 assert_equal 'API update', project.name
               end
-                    should "accept enabled_module_names attribute" do
+              test "PUT /projects/:id.xml should accept enabled_module_names attribute" do
-                      @parameters[:project].merge!({:enabled_module_names => ['issue_tracking', 'news', 'time_tracking']})
                 assert_no_difference 'Project.count' do
-                        put '/projects/2.xml', @parameters, credentials('admin')
+                  put '/projects/2.xml', {:project => {:name => 'API update', :enabled_module_names => ['issue_tracking', 'news', 'time_tracking']}}, credentials('admin')
                 end
                 assert_response :ok
                 assert_equal '', @response.body
                 assert_equal ['issue_tracking', 'news', 'time_tracking'], project.enabled_module_names.sort
               end
-                    should "accept tracker_ids attribute" do
+              test "PUT /projects/:id.xml should accept tracker_ids attribute" do
-                      @parameters[:project].merge!({:tracker_ids => [1, 3]})
                 assert_no_difference 'Project.count' do
-                        put '/projects/2.xml', @parameters, credentials('admin')
+                  put '/projects/2.xml', {:project => {:name => 'API update', :tracker_ids => [1, 3]}}, credentials('admin')
                 end
                 assert_response :ok
                 assert_equal '', @response.body
                 project = Project.find(2)
                 assert_equal [1, 3], project.trackers.map(&:id).sort
               end
-                  end
-                end
-                context "with invalid parameters" do
-                  setup do
-                    @parameters = {:project => {:name => ''}}
-                  end
-                  context ".xml" do
+              test "PUT /projects/:id.xml with invalid parameters should return errors" do
-                    should "return errors" do
                 assert_no_difference('Project.count') do
-                        put '/projects/2.xml', @parameters, credentials('admin')
+                  put '/projects/2.xml', {:project => {:name => ''}}, credentials('admin')
                 end
                 assert_response :unprocessable_entity
                 assert_equal 'application/xml', @response.content_type
                 assert_tag 'errors', :child => {:tag => 'error', :content => "Name can't be blank"}
               end
-                  end
-                end
-              end
-              context "DELETE /projects/:id" do
-                context ".xml" do
-                  should_allow_api_authentication(:delete,
-                                                  '/projects/2.xml',
-                                                  {},
-                                                  {:success_code => :ok})
-                  should "delete the project" do
+              test "DELETE /projects/:id.xml should delete the project" do
                 assert_difference('Project.count',-1) do
                   delete '/projects/2.xml', {}, credentials('admin')
                 end
                 assert_nil Project.find_by_id(2)
               end
             end
-              end
-            end

test/integration/api_test/queries_test.rb +1 -6

                 Setting.rest_api_enabled = '1'
               end
-              context "/queries" do
+              test "GET /queries.xml should return queries" do
-                context "GET" do
-                  should "return queries" do
                 get '/queries.xml'
                 assert_response :success
                   }
               end
             end
-              end
-            end

test/integration/api_test/roles_test.rb +3 -17

                 Setting.rest_api_enabled = '1'
               end
-              context "/roles" do
+              test "GET /roles.xml should return the roles" do
-                context "GET" do
-                  context "xml" do
-                    should "return the roles" do
                 get '/roles.xml'
                 assert_response :success
                     }
                   }
               end
-                  end
-                  context "json" do
+              test "GET /roles.json should return the roles" do
-                    should "return the roles" do
                 get '/roles.json'
                 assert_response :success
                 assert_kind_of Array, json['roles']
                 assert_include({'id' => 2, 'name' => 'Developer'}, json['roles'])
               end
-                  end
-                end
-              end
-              context "/roles/:id" do
+              test "GET /roles/:id.xml should return the role" do
-                context "GET" do
-                  context "xml" do
-                    should "return the role" do
                 get '/roles/1.xml'
                 assert_response :success
                 end
               end
             end
-                end
-              end
-            end

test/integration/api_test/time_entries_test.rb +10 -32

                 Setting.rest_api_enabled = '1'
               end
-              context "GET /time_entries.xml" do
+              test "GET /time_entries.xml should return time entries" do
-                should "return time entries" do
                 get '/time_entries.xml', {}, credentials('jsmith')
                 assert_response :success
                 assert_equal 'application/xml', @response.content_type
                   :child => {:tag => 'time_entry', :child => {:tag => 'id', :content => '2'}}
               end
-                context "with limit" do
+              test "GET /time_entries.xml with limit should return limited results" do
-                  should "return limited results" do
                 get '/time_entries.xml?limit=2', {}, credentials('jsmith')
                 assert_response :success
                 assert_equal 'application/xml', @response.content_type
                 assert_tag :tag => 'time_entries',
                   :children => {:count => 2}
               end
-                end
-              end
-              context "GET /time_entries/2.xml" do
+              test "GET /time_entries/:id.xml should return the time entry" do
-                should "return requested time entry" do
                 get '/time_entries/2.xml', {}, credentials('jsmith')
                 assert_response :success
                 assert_equal 'application/xml', @response.content_type
                 assert_tag :tag => 'time_entry',
                   :child => {:tag => 'id', :content => '2'}
               end
-              end
-              context "POST /time_entries.xml" do
+              test "POST /time_entries.xml with issue_id should create time entry" do
-                context "with issue_id" do
-                  should "return create time entry" do
                 assert_difference 'TimeEntry.count' do
                   post '/time_entries.xml', {:time_entry => {:issue_id => '1', :spent_on => '2010-12-02', :hours => '3.5', :activity_id => '11'}}, credentials('jsmith')
                 end
                 assert_equal TimeEntryActivity.find(11), entry.activity
               end
-                  should "accept custom fields" do
+              test "POST /time_entries.xml with issue_id should accept custom fields" do
                 field = TimeEntryCustomField.create!(:name => 'Test', :field_format => 'string')
                 assert_difference 'TimeEntry.count' do
                 entry = TimeEntry.first(:order => 'id DESC')
                 assert_equal 'accepted', entry.custom_field_value(field)
               end
-                end
-                context "with project_id" do
+              test "POST /time_entries.xml with project_id should create time entry" do
-                  should "return create time entry" do
                 assert_difference 'TimeEntry.count' do
                   post '/time_entries.xml', {:time_entry => {:project_id => '1', :spent_on => '2010-12-02', :hours => '3.5', :activity_id => '11'}}, credentials('jsmith')
                 end
                 assert_equal 3.5, entry.hours
                 assert_equal TimeEntryActivity.find(11), entry.activity
               end
-                end
-                context "with invalid parameters" do
+              test "POST /time_entries.xml with invalid parameters should return errors" do
-                  should "return errors" do
                 assert_no_difference 'TimeEntry.count' do
                   post '/time_entries.xml', {:time_entry => {:project_id => '1', :spent_on => '2010-12-02', :activity_id => '11'}}, credentials('jsmith')
                 end
                 assert_tag 'errors', :child => {:tag => 'error', :content => "Hours can't be blank"}
               end
-                end
-              end
-              context "PUT /time_entries/2.xml" do
+              test "PUT /time_entries/:id.xml with valid parameters should update time entry" do
-                context "with valid parameters" do
-                  should "update time entry" do
                 assert_no_difference 'TimeEntry.count' do
                   put '/time_entries/2.xml', {:time_entry => {:comments => 'API Update'}}, credentials('jsmith')
                 end
                 assert_equal '', @response.body
                 assert_equal 'API Update', TimeEntry.find(2).comments
               end
-                end
-                context "with invalid parameters" do
+              test "PUT /time_entries/:id.xml with invalid parameters should return errors" do
-                  should "return errors" do
                 assert_no_difference 'TimeEntry.count' do
                   put '/time_entries/2.xml', {:time_entry => {:hours => '', :comments => 'API Update'}}, credentials('jsmith')
                 end
                 assert_tag 'errors', :child => {:tag => 'error', :content => "Hours can't be blank"}
               end
-                end
-              end
-              context "DELETE /time_entries/2.xml" do
+              test "DELETE /time_entries/:id.xml should destroy time entry" do
-                should "destroy time entry" do
                 assert_difference 'TimeEntry.count', -1 do
                   delete '/time_entries/2.xml', {}, credentials('jsmith')
                 end
                 assert_nil TimeEntry.find_by_id(2)
               end
             end
-            end

test/integration/api_test/token_authentication_test.rb 0 -7

               end
               # Using the NewsController because it's a simple API.
-              context "get /news" do
-                context "in :xml format" do
               should_allow_key_based_auth(:get, "/news.xml")
-                end
-                context "in :json format" do
               should_allow_key_based_auth(:get, "/news.json")
             end
-              end
-            end

test/integration/api_test/trackers_test.rb +1 -6

                 Setting.rest_api_enabled = '1'
               end
-              context "/trackers" do
+              test "GET /trackers.xml should return trackers" do
-                context "GET" do
-                  should "return trackers" do
                 get '/trackers.xml'
                 assert_response :success
                   }
               end
             end
-              end
-            end

test/integration/api_test/users_test.rb +96 -152

@@ -24,14 +24,46 class Redmine::ApiTest::UsersTest < Redmine::ApiTest::Base
24	Setting.rest_api_enabled = '1'	24	Setting.rest_api_enabled = '1'
25	end	25	end
26		26
27	context "GET /users" do
28	should_allow_api_authentication(:get, "/users.xml")	27	should_allow_api_authentication(:get, "/users.xml")
29	should_allow_api_authentication(:get, "/users.json")	28	should_allow_api_authentication(:get, "/users.json")
30	end	29	should_allow_api_authentication(:post,
		30	'/users.xml',
		31	{:user => {
		32	:login => 'foo', :firstname => 'Firstname', :lastname => 'Lastname',
		33	:mail => 'foo@example.net', :password => 'secret123'
		34	}},
		35	{:success_code => :created})
		36	should_allow_api_authentication(:post,
		37	'/users.json',
		38	{:user => {
		39	:login => 'foo', :firstname => 'Firstname', :lastname => 'Lastname',
		40	:mail => 'foo@example.net'
		41	}},
		42	{:success_code => :created})
		43	should_allow_api_authentication(:put,
		44	'/users/2.xml',
		45	{:user => {
		46	:login => 'jsmith', :firstname => 'John', :lastname => 'Renamed',
		47	:mail => 'jsmith@somenet.foo'
		48	}},
		49	{:success_code => :ok})
		50	should_allow_api_authentication(:put,
		51	'/users/2.json',
		52	{:user => {
		53	:login => 'jsmith', :firstname => 'John', :lastname => 'Renamed',
		54	:mail => 'jsmith@somenet.foo'
		55	}},
		56	{:success_code => :ok})
		57	should_allow_api_authentication(:delete,
		58	'/users/2.xml',
		59	{},
		60	{:success_code => :ok})
		61	should_allow_api_authentication(:delete,
		62	'/users/2.xml',
		63	{},
		64	{:success_code => :ok})
31		65
32	context "GET /users/2" do	66	test "GET /users/:id.xml should return the user" do
33	context ".xml" do
34	should "return requested user" do
35	get '/users/2.xml'	67	get '/users/2.xml'
36		68
37	assert_response :success	69	assert_response :success
@@ -39,20 +71,7 class Redmine::ApiTest::UsersTest < Redmine::ApiTest::Base
39	:child => {:tag => 'id', :content => '2'}	71	:child => {:tag => 'id', :content => '2'}
40	end	72	end
41		73
42	context "with include=memberships" do	74	test "GET /users/:id.json should return the user" do
43	should "include memberships" do
44	get '/users/2.xml?include=memberships'
45
46	assert_response :success
47	assert_tag :tag => 'memberships',
48	:parent => {:tag => 'user'},
49	:children => {:count => 1}
50	end
51	end
52	end
53
54	context ".json" do
55	should "return requested user" do
56	get '/users/2.json'	75	get '/users/2.json'
57		76
58	assert_response :success	77	assert_response :success
@@ -62,8 +81,16 class Redmine::ApiTest::UsersTest < Redmine::ApiTest::Base
62	assert_equal 2, json['user']['id']	81	assert_equal 2, json['user']['id']
63	end	82	end
64		83
65	context "with include=memberships" do	84	test "GET /users/:id.xml with include=memberships should include memberships" do
66	~~should~~ ~~"include~~ memberships" do	85	get '/users/2.xml?include=memberships'
		86
		87	assert_response :success
		88	assert_tag :tag => 'memberships',
		89	:parent => {:tag => 'user'},
		90	:children => {:count => 1}
		91	end
		92
		93	test "GET /users/:id.json with include=memberships should include memberships" do
67	get '/users/2.json?include=memberships'	94	get '/users/2.json?include=memberships'
68		95
69	assert_response :success	96	assert_response :success
@@ -75,26 +102,19 class Redmine::ApiTest::UsersTest < Redmine::ApiTest::Base
75	"roles"=>[{"name"=>"Manager", "id"=>1}]	102	"roles"=>[{"name"=>"Manager", "id"=>1}]
76	}], json['user']['memberships']	103	}], json['user']['memberships']
77	end	104	end
78	end
79	end
80	end
81		105
82	context "GET /users/current" do	106	test "GET /users/current.xml should require authentication" do
83	context ".xml" do
84	should "require authentication" do
85	get '/users/current.xml'	107	get '/users/current.xml'
86		108
87	assert_response 401	109	assert_response 401
88	end	110	end
89		111
90	~~should~~ "return current user" do	112	test "GET /users/current.xml should return current user" do
91	get '/users/current.xml', {}, credentials('jsmith')	113	get '/users/current.xml', {}, credentials('jsmith')
92		114
93	assert_tag :tag => 'user',	115	assert_tag :tag => 'user',
94	:child => {:tag => 'id', :content => '2'}	116	:child => {:tag => 'id', :content => '2'}
95	end	117	end
96	end
97	end
98		118
99	test "GET /users/:id should not return login for other user" do	119	test "GET /users/:id should not return login for other user" do
100	get '/users/3.xml', {}, credentials('jsmith')	120	get '/users/3.xml', {}, credentials('jsmith')
@@ -132,30 +152,15 class Redmine::ApiTest::UsersTest < Redmine::ApiTest::Base
132	assert_tag 'user', :child => {:tag => 'status', :content => User.find(1).status.to_s}	152	assert_tag 'user', :child => {:tag => 'status', :content => User.find(1).status.to_s}
133	end	153	end
134		154
135	context "POST /users" do	155	test "POST /users.xml with valid parameters should create the user" do
136	context "with valid parameters" do	156	assert_difference('User.count') do
137	setup do	157	post '/users.xml', {
138	@parameters = {
139	:user => {	158	:user => {
140	:login => 'foo', :firstname => 'Firstname', :lastname => 'Lastname',	159	:login => 'foo', :firstname => 'Firstname', :lastname => 'Lastname',
141	:mail => 'foo@example.net', :password => 'secret123',	160	:mail => 'foo@example.net', :password => 'secret123',
142	:mail_notification => 'only_assigned'	161	:mail_notification => 'only_assigned'}
143	}	162	},
144	}	163	credentials('admin')
145	end
146
147	context ".xml" do
148	should_allow_api_authentication(:post,
149	'/users.xml',
150	{:user => {
151	:login => 'foo', :firstname => 'Firstname', :lastname => 'Lastname',
152	:mail => 'foo@example.net', :password => 'secret123'
153	}},
154	{:success_code => :created})
155
156	should "create a user with the attributes" do
157	assert_difference('User.count') do
158	post '/users.xml', @parameters, credentials('admin')
159	end	164	end
160		165
161	user = User.first(:order => 'id DESC')	166	user = User.first(:order => 'id DESC')
@@ -171,20 +176,16 class Redmine::ApiTest::UsersTest < Redmine::ApiTest::Base
171	assert_equal 'application/xml', @response.content_type	176	assert_equal 'application/xml', @response.content_type
172	assert_tag 'user', :child => {:tag => 'id', :content => user.id.to_s}	177	assert_tag 'user', :child => {:tag => 'id', :content => user.id.to_s}
173	end	178	end
174	end
175
176	context ".json" do
177	should_allow_api_authentication(:post,
178	'/users.json',
179	{:user => {
180	:login => 'foo', :firstname => 'Firstname', :lastname => 'Lastname',
181	:mail => 'foo@example.net'
182	}},
183	{:success_code => :created})
184		179
185	should "create a user with the attributes" do	180	test "POST /users.json with valid parameters should create the user" do
186	assert_difference('User.count') do	181	assert_difference('User.count') do
187	post '/users.json', @parameters, credentials('admin')	182	post '/users.json', {
		183	:user => {
		184	:login => 'foo', :firstname => 'Firstname', :lastname => 'Lastname',
		185	:mail => 'foo@example.net', :password => 'secret123',
		186	:mail_notification => 'only_assigned'}
		187	},
		188	credentials('admin')
188	end	189	end
189		190
190	user = User.first(:order => 'id DESC')	191	user = User.first(:order => 'id DESC')
@@ -201,18 +202,10 class Redmine::ApiTest::UsersTest < Redmine::ApiTest::Base
201	assert_kind_of Hash, json['user']	202	assert_kind_of Hash, json['user']
202	assert_equal user.id, json['user']['id']	203	assert_equal user.id, json['user']['id']
203	end	204	end
204	end
205	end
206		205
207	context "with invalid parameters" do	206	test "POST /users.xml with with invalid parameters should return errors" do
208	setup do
209	@parameters = {:user => {:login => 'foo', :lastname => 'Lastname', :mail => 'foo'}}
210	end
211
212	context ".xml" do
213	should "return errors" do
214	assert_no_difference('User.count') do	207	assert_no_difference('User.count') do
215	post '/users.xml', @parameters, credentials('admin')	208	post '/users.xml', {:user => {:login => 'foo', :lastname => 'Lastname', :mail => 'foo'}}, credentials('admin')
216	end	209	end
217		210
218	assert_response :unprocessable_entity	211	assert_response :unprocessable_entity
@@ -222,12 +215,10 class Redmine::ApiTest::UsersTest < Redmine::ApiTest::Base
222	:content => "First name can't be blank"	215	:content => "First name can't be blank"
223	}	216	}
224	end	217	end
225	end
226		218
227	context ".json" do	219	test "POST /users.json with with invalid parameters should return errors" do
228	should "return errors" do
229	assert_no_difference('User.count') do	220	assert_no_difference('User.count') do
230	post '/users.json', @parameters, credentials('admin')	221	post '/users.json', {:user => {:login => 'foo', :lastname => 'Lastname', :mail => 'foo'}}, credentials('admin')
231	end	222	end
232		223
233	assert_response :unprocessable_entity	224	assert_response :unprocessable_entity
@@ -237,33 +228,15 class Redmine::ApiTest::UsersTest < Redmine::ApiTest::Base
237	assert json.has_key?('errors')	228	assert json.has_key?('errors')
238	assert_kind_of Array, json['errors']	229	assert_kind_of Array, json['errors']
239	end	230	end
240	end
241	end
242	end
243		231
244	context "PUT /users/2" do	232	test "PUT /users/:id.xml with valid parameters should update the user" do
245	context "with valid parameters" do	233	assert_no_difference('User.count') do
246	setup do	234	put '/users/2.xml', {
247	@parameters = {
248	:user => {	235	:user => {
249	:login => 'jsmith', :firstname => 'John', :lastname => 'Renamed',	236	:login => 'jsmith', :firstname => 'John', :lastname => 'Renamed',
250	:mail => 'jsmith@somenet.foo'	237	:mail => 'jsmith@somenet.foo'}
251	}	238	},
252	}	239	credentials('admin')
253	end
254
255	context ".xml" do
256	should_allow_api_authentication(:put,
257	'/users/2.xml',
258	{:user => {
259	:login => 'jsmith', :firstname => 'John', :lastname => 'Renamed',
260	:mail => 'jsmith@somenet.foo'
261	}},
262	{:success_code => :ok})
263
264	should "update user with the attributes" do
265	assert_no_difference('User.count') do
266	put '/users/2.xml', @parameters, credentials('admin')
267	end	240	end
268		241
269	user = User.find(2)	242	user = User.find(2)
@@ -276,20 +249,15 class Redmine::ApiTest::UsersTest < Redmine::ApiTest::Base
276	assert_response :ok	249	assert_response :ok
277	assert_equal '', @response.body	250	assert_equal '', @response.body
278	end	251	end
279	end
280		252
281	context ".json" do	253	test "PUT /users/:id.json with valid parameters should update the user" do
282	should_allow_api_authentication(:put,
283	'/users/2.json',
284	{:user => {
285	:login => 'jsmith', :firstname => 'John', :lastname => 'Renamed',
286	:mail => 'jsmith@somenet.foo'
287	}},
288	{:success_code => :ok})
289
290	should "update user with the attributes" do
291	assert_no_difference('User.count') do	254	assert_no_difference('User.count') do
292	put '/users/2.json', @parameters, credentials('admin')	255	put '/users/2.json', {
		256	:user => {
		257	:login => 'jsmith', :firstname => 'John', :lastname => 'Renamed',
		258	:mail => 'jsmith@somenet.foo'}
		259	},
		260	credentials('admin')
293	end	261	end
294		262
295	user = User.find(2)	263	user = User.find(2)
@@ -302,23 +270,15 class Redmine::ApiTest::UsersTest < Redmine::ApiTest::Base
302	assert_response :ok	270	assert_response :ok
303	assert_equal '', @response.body	271	assert_equal '', @response.body
304	end	272	end
305	end
306	end
307		273
308	~~contex~~t "with invalid parameters" do	274	test "PUT /users/:id.xml with invalid parameters" do
309	setup do	275	assert_no_difference('User.count') do
310	@parameters = {	276	put '/users/2.xml', {
311	:user => {	277	:user => {
312	:login => 'jsmith', :firstname => '', :lastname => 'Lastname',	278	:login => 'jsmith', :firstname => '', :lastname => 'Lastname',
313	:mail => 'foo'	279	:mail => 'foo'}
314	}	280	},
315	}	281	credentials('admin')
316	end
317
318	context ".xml" do
319	should "return errors" do
320	assert_no_difference('User.count') do
321	put '/users/2.xml', @parameters, credentials('admin')
322	end	282	end
323		283
324	assert_response :unprocessable_entity	284	assert_response :unprocessable_entity
@@ -328,12 +288,15 class Redmine::ApiTest::UsersTest < Redmine::ApiTest::Base
328	:content => "First name can't be blank"	288	:content => "First name can't be blank"
329	}	289	}
330	end	290	end
331	end
332		291
333	context ".json" do	292	test "PUT /users/:id.json with invalid parameters" do
334	should "return errors" do
335	assert_no_difference('User.count') do	293	assert_no_difference('User.count') do
336	put '/users/2.json', @parameters, credentials('admin')	294	put '/users/2.json', {
		295	:user => {
		296	:login => 'jsmith', :firstname => '', :lastname => 'Lastname',
		297	:mail => 'foo'}
		298	},
		299	credentials('admin')
337	end	300	end
338		301
339	assert_response :unprocessable_entity	302	assert_response :unprocessable_entity
@@ -343,18 +306,8 class Redmine::ApiTest::UsersTest < Redmine::ApiTest::Base
343	assert json.has_key?('errors')	306	assert json.has_key?('errors')
344	assert_kind_of Array, json['errors']	307	assert_kind_of Array, json['errors']
345	end	308	end
346	end
347	end
348	end
349
350	context "DELETE /users/2" do
351	context ".xml" do
352	should_allow_api_authentication(:delete,
353	'/users/2.xml',
354	{},
355	{:success_code => :ok})
356		309
357	~~should~~ "delete user" do	310	test "DELETE /users/:id.xml should delete the user" do
358	assert_difference('User.count', -1) do	311	assert_difference('User.count', -1) do
359	delete '/users/2.xml', {}, credentials('admin')	312	delete '/users/2.xml', {}, credentials('admin')
360	end	313	end
@@ -362,15 +315,8 class Redmine::ApiTest::UsersTest < Redmine::ApiTest::Base
362	assert_response :ok	315	assert_response :ok
363	assert_equal '', @response.body	316	assert_equal '', @response.body
364	end	317	end
365	end
366		318
367	context ".json" do	319	test "DELETE /users/:id.json should delete the user" do
368	should_allow_api_authentication(:delete,
369	'/users/2.xml',
370	{},
371	{:success_code => :ok})
372
373	should "delete user" do
374	assert_difference('User.count', -1) do	320	assert_difference('User.count', -1) do
375	delete '/users/2.json', {}, credentials('admin')	321	delete '/users/2.json', {}, credentials('admin')
376	end	322	end
@@ -379,5 +325,3 class Redmine::ApiTest::UsersTest < Redmine::ApiTest::Base
379	assert_equal '', @response.body	325	assert_equal '', @response.body
380	end	326	end
381	end	327	end
382	end
383	end

test/integration/api_test/versions_test.rb +8 -24

                 Setting.rest_api_enabled = '1'
               end
-              context "/projects/:project_id/versions" do
+              test "GET /projects/:project_id/versions.xml should return project versions" do
-                context "GET" do
-                  should "return project versions" do
                 get '/projects/1/versions.xml'
                 assert_response :success
                     }
                   }
               end
-                end
-                context "POST" do
+              test "POST /projects/:project_id/versions.xml should create the version" do
-                  should "create the version" do
                 assert_difference 'Version.count' do
                   post '/projects/1/versions.xml', {:version => {:name => 'API test'}}, credentials('jsmith')
                 end
                 assert_tag 'version', :child => {:tag => 'id', :content => version.id.to_s}
               end
-                  should "create the version with due date" do
+              test "POST /projects/:project_id/versions.xml should create the version with due date" do
                 assert_difference 'Version.count' do
                   post '/projects/1/versions.xml', {:version => {:name => 'API test', :due_date => '2012-01-24'}}, credentials('jsmith')
                 end
                 assert_tag 'version', :child => {:tag => 'id', :content => version.id.to_s}
               end
-                  should "create the version with custom fields" do
+              test "POST /projects/:project_id/versions.xml should create the version with custom fields" do
                 field = VersionCustomField.generate!
                 assert_difference 'Version.count' do
                 assert_select 'version>custom_fields>custom_field[id=?]>value', field.id.to_s, 'Some value'
               end
-                  context "with failure" do
+              test "POST /projects/:project_id/versions.xml with failure should return the errors" do
-                    should "return the errors" do
                 assert_no_difference('Version.count') do
                   post '/projects/1/versions.xml', {:version => {:name => ''}}, credentials('jsmith')
                 end
                 assert_response :unprocessable_entity
                 assert_tag :errors, :child => {:tag => 'error', :content => "Name can't be blank"}
               end
-                  end
-                end
-              end
-              context "/versions/:id" do
+              test "GET /versions/:id.xml should return the version" do
-                context "GET" do
-                  should "return the version" do
                 get '/versions/2.xml'
                 assert_response :success
                   assert_select 'sharing', :text => 'none'
                 end
               end
-                end
-                context "PUT" do
+              test "PUT /versions/:id.xml should update the version" do
-                  should "update the version" do
                 put '/versions/2.xml', {:version => {:name => 'API update'}}, credentials('jsmith')
                 assert_response :ok
                 assert_equal '', @response.body
                 assert_equal 'API update', Version.find(2).name
               end
-                end
-                context "DELETE" do
+              test "DELETE /versions/:id.xml should destroy the version" do
-                  should "destroy the version" do
                 assert_difference 'Version.count', -1 do
                   delete '/versions/3.xml', {}, credentials('jsmith')
                 end
                 assert_nil Version.find_by_id(3)
               end
             end
-              end
-            end

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