Coverage for basic_pages/tests.py: 30%

1from django.test import TestCase, Client 

2from django.urls import reverse 

3from django.conf import settings 

4from django.http import HttpResponse 

5from django import forms 

6from django.contrib.auth.models import User 

7#from django.core.mail import outbox 

8 

9import datetime 

10 

11from .views import ContactForm 

12from .views import CookieManager 

13 

14 

15 

16class HomeViewTest(TestCase): 

17 """ 

18 Test cases for the Home View. 

19 

20 This class contains unit tests to verify the behavior of the home view, 

21 including status codes, templates used, response content, context variables, 

22 and handling of anonymous and authenticated users. 

23 """ 

24 

25 def setUp(self): 

26 """ 

27 Set up any initial data or configurations if needed. 

28 

29 This method is called before each test. It can be used to create 

30 test users, set up test data, etc. 

31 """ 

32 pass 

33 

34 def test_home_view_status_code(self): 

35 """ 

36 Test that the home view returns a status code of 200 (OK). 

37 

38 The client makes a GET request to the 'home_page' URL and asserts 

39 that the response has a status code of 200. 

40 """ 

41 client = Client() 

42 response = client.get(reverse('home_page')) 

43 self.assertEqual(response.status_code, 200) 

44 

45 def test_home_view_template_used(self): 

46 """ 

47 Test that the correct template is used for rendering the home view. 

48 

49 The client makes a GET request to the 'home_page' URL and asserts 

50 that the 'home_page.html' template was used in the response. 

51 """ 

52 client = Client() 

53 response = client.get(reverse('home_page')) 

54 self.assertTemplateUsed(response, 'home_page.html') 

55 

56 def test_home_view_response_content(self): 

57 """ 

58 Test that the response content contains expected text. 

59 

60 The client makes a GET request to the 'home_page' URL and asserts 

61 that the response content includes the byte string b'This site is a working example of skills'. 

62 """ 

63 client = Client() 

64 response = client.get(reverse('home_page')) 

65 self.assertIn(b'This site is a working example of skills', response.content) 

66 

67 def test_home_view_context_variables(self): 

68 """ 

69 Test that the correct context variables are passed to the template. 

70 

71 The client makes a GET request to the 'home_page' URL and asserts 

72 that the context variable 'page_title' equals 'Home'. 

73 """ 

74 client = Client() 

75 response = client.get(reverse('home_page')) 

76 # Assuming you pass a context variable named 'page_title' 

77 self.assertEqual(response.context['page_title'], 'Home') 

78 

79 def test_home_view_anonymous_user(self): 

80 """ 

81 Test that the home view renders correctly for an anonymous user. 

82 

83 The client makes a GET request to the 'home_page' URL without logging 

84 in and asserts that the response content includes the expected text. 

85 """ 

86 client = Client() 

87 response = client.get(reverse('home_page')) 

88 # Check if the template is correctly rendered for an anonymous user 

89 self.assertIn(b'This site is a working example of skills', response.content) 

90 

91 def test_home_view_authenticated_user(self): 

92 """ 

93 Test that the home view renders correctly for an authenticated user. 

94 

95 A test user is created and logged in. The client then makes a GET request 

96 to the 'home_page' URL and asserts that the response content includes 

97 the expected text. Additional checks can be added for authenticated users, 

98 such as checking for the presence of a logout link. 

99 """ 

100 # Create a test user 

101 user = User.objects.create_user(username='testuser', password='testpassword') 

102 client = Client() 

103 client.login(username='testuser', password='testpassword') 

104 response = client.get(reverse('home_page')) 

105 # Check if the template is correctly rendered for an authenticated user 

106 self.assertIn(b'This site is a working example of skills', response.content) 

107 # You can add more checks specific to authenticated users, e.g., presence of logout link 

108 

109 def test_home_view_url_parameters(self): 

110 """ 

111 Test that the home view handles URL parameters correctly. 

112 

113 The client makes a GET request to the 'home_page' URL with query 

114 parameters. It asserts that the response has a status code of 200. 

115 Additional checks can be added for specific parameters and expected behavior. 

116 """ 

117 # If your view handles URL parameters, test it with various inputs 

118 client = Client() 

119 response = client.get(reverse('home_page') + '?param1=value1&param2=value2') 

120 self.assertEqual(response.status_code, 200) 

121 # Add more checks as needed for the specific parameters and expected behavior 

122 

123 def tearDown(self): 

124 """ 

125 Clean up any data or configurations if needed. 

126 

127 This method is called after each test. It can be used to delete 

128 test users, clean up test data, etc. 

129 """ 

130 pass 

131 

132 

133class AboutViewTest(TestCase): 

134 def setUp(self): 

135 """ 

136 Set up any common resources for the tests. 

137 For example, create a user for testing authenticated views. 

138 """ 

139 self.client = Client() 

140 self.user = User.objects.create_user(username='testuser', password='password123') 

141 self.containsText = '<p>Welcome to Syber Builders!</p>' 

142 

143 def test_about_view_get_request(self): 

144 # Send GET request to the about view 

145 response = self.client.get(reverse('about_page')) 

146 

147 # Check if the response is successful (status code 200) 

148 self.assertEqual(response.status_code, 200) 

149 

150 # Check if the correct template was used 

151 self.assertTemplateUsed(response, 'about_page.html') 

152 

153 # Check if the response contains expected HTML content 

154 self.assertContains(response, self.containsText) 

155 

156 def test_about_view_authenticated_user(self): 

157 """ 

158 Test how your view behaves for authenticated users. 

159 """ 

160 # Log in the user 

161 self.client.login(username='testuser', password='password123') 

162 

163 # Send GET request to the about view 

164 response = self.client.get(reverse('about_page')) 

165 

166 # Check if the response is successful (status code 200) 

167 self.assertEqual(response.status_code, 200) 

168 

169 # Optionally, check context data for authenticated users 

170 self.assertIn('user', response.context) 

171 self.assertEqual(response.context['user'].username, 'testuser') 

172 

173 def test_about_view_anonymous_user(self): 

174 """ 

175 Test how your view behaves for anonymous users. 

176 """ 

177 # Send GET request to the about view without logging in 

178 response = self.client.get(reverse('about_page')) 

179 

180 # Check if the response is successful (status code 200) 

181 self.assertEqual(response.status_code, 200) 

182 

183 def test_about_view_response_content(self): 

184 """ 

185 Test if the response contains specific HTML content. 

186 """ 

187 # Send GET request to the about view 

188 response = self.client.get(reverse('about_page')) 

189 

190 # Check if the response contains expected HTML content 

191 self.assertContains(response, self.containsText) 

192 

193 def test_about_view_custom_headers(self): 

194 """ 

195 Test how your view behaves with custom headers. 

196 """ 

197 # Send GET request to the about view with custom headers 

198 response = self.client.get(reverse('about_page'), HTTP_X_CUSTOM_HEADER='custom_value') 

199 

200 # Check if the response is successful (status code 200) 

201 self.assertEqual(response.status_code, 200) 

202 

203 def test_about_view_performance(self): 

204 """ 

205 Test the performance of the about view. 

206 """ 

207 import time 

208 

209 start_time = time.time() 

210 for _ in range(10): # Run the request multiple times to measure average response time 

211 self.client.get(reverse('about_page')) 

212 end_time = time.time() 

213 

214 avg_response_time = (end_time - start_time) / 10 

215 print(f"Average Response Time: {avg_response_time} seconds") 

216 self.assertLess(avg_response_time, 0.5) # Adjust this threshold as needed 

217 

218 def test_about_view_context_data(self): 

219 """ 

220 Test the context data passed to the template. 

221 """ 

222 # Send GET request to the about view 

223 response = self.client.get(reverse('about_page')) 

224 

225 # Check if specific context data is present 

226 self.assertIn('title', response.context) 

227 self.assertEqual(response.context['title'], 'Syber Builders About Page') 

228 

229 

230 

231class AboutViewTest(TestCase): 

232 def setUp(self): 

233 """ 

234 Set up any common resources for the tests. 

235 For example, create a user for testing authenticated views. 

236 """ 

237 self.client = Client() 

238 self.user = User.objects.create_user(username='testuser', password='password123') 

239 

240 def test_about_view_get_request(self): 

241 # Send GET request to the about view 

242 response = self.client.get(reverse('about_page')) 

243 

244 # Check if the response is successful (status code 200) 

245 self.assertEqual(response.status_code, 200) 

246 

247 # Check if the correct template was used 

248 self.assertTemplateUsed(response, 'about_page.html') 

249 

250 def test_about_view_authenticated_user(self): 

251 """ 

252 Test how your view behaves for authenticated users. 

253 """ 

254 # Log in the user 

255 self.client.login(username='testuser', password='password123') 

256 

257 # Send GET request to the about view 

258 response = self.client.get(reverse('about_page')) 

259 

260 # Check if the response is successful (status code 200) 

261 self.assertEqual(response.status_code, 200) 

262 

263 # Optionally, check context data for authenticated users 

264 self.assertIn('user', response.context) 

265 self.assertEqual(response.context['user'].username, 'testuser') 

266 

267 def test_about_view_anonymous_user(self): 

268 """ 

269 Test how your view behaves for anonymous users. 

270 """ 

271 # Send GET request to the about view without logging in 

272 response = self.client.get(reverse('about_page')) 

273 

274 # Check if the response is successful (status code 200) 

275 self.assertEqual(response.status_code, 200) 

276 

277 def test_about_view_performance(self): 

278 """ 

279 Test the performance of the about view. 

280 """ 

281 import time 

282 

283 start_time = time.time() 

284 for _ in range(100): 

285 self.client.get(reverse('about_page')) 

286 end_time = time.time() 

287 

288 # Ensure that the average response time is below a certain threshold 

289 avg_response_time = (end_time - start_time) / 100 

290 self.assertLess(avg_response_time, 0.05) # Adjust this threshold as needed 

291 

292 

293 

294class ContactFormTest(TestCase): 

295 def setUp(self): 

296 self.client = Client() 

297 self.user = User.objects.create_user(username='testuser', password='password123') 

298 

299 def test_contact_form_validation_empty_email(self): 

300 # Create a form instance with invalid data (empty email) 

301 form_data = { 

302 'email': '', 

303 'subject': 'Test Subject', 

304 'message': 'This is a test message.' 

305 } 

306 form = ContactForm(data=form_data) 

307 

308 # Check if the form is not valid and has errors on the email field 

309 self.assertFalse(form.is_valid()) 

310 self.assertIn('email', form.errors) 

311 self.assertEqual(form.errors['email'][0], "This field is required.") 

312 

313 def test_contact_form_validation_invalid_email(self): 

314 # Create a form instance with invalid data (invalid email format) 

315 form_data = { 

316 'email': 'invalid-email', 

317 'subject': 'Test Subject', 

318 'message': 'This is a test message.' 

319 } 

320 form = ContactForm(data=form_data) 

321 

322 # Check if the form is not valid and has errors on the email field 

323 self.assertFalse(form.is_valid()) 

324 self.assertIn('email', form.errors) 

325 self.assertEqual(form.errors['email'][0], "Enter a valid email address.") 

326 

327 def test_contact_form_validation_empty_subject(self): 

328 # Create a form instance with invalid data (empty subject) 

329 form_data = { 

330 'email': 'test@example.com', 

331 'subject': '', 

332 'message': 'This is a test message.' 

333 } 

334 form = ContactForm(data=form_data) 

335 

336 # Check if the form is not valid and has errors on the subject field 

337 self.assertFalse(form.is_valid()) 

338 self.assertIn('subject', form.errors) 

339 self.assertEqual(form.errors['subject'][0], "This field is required.") 

340 

341 def test_contact_form_validation_empty_message(self): 

342 # Create a form instance with invalid data (empty message) 

343 form_data = { 

344 'email': 'test@example.com', 

345 'subject': 'Test Subject', 

346 'message': '' 

347 } 

348 form = ContactForm(data=form_data) 

349 

350 # Check if the form is not valid and has errors on the message field 

351 self.assertFalse(form.is_valid()) 

352 self.assertIn('message', form.errors) 

353 self.assertEqual(form.errors['message'][0], "This field is required.") 

354 

355 

356class SuccessViewTest(TestCase): 

357 def setUp(self): 

358 # Set up any necessary data for the tests (e.g., create users) 

359 self.client = Client() 

360 

361 def test_success_view(self): 

362 # Send GET request to the success view 

363 response = self.client.get(reverse('success_page')) 

364 

365 # Check if the response is successful (status code 200) 

366 self.assertEqual(response.status_code, 200) 

367 

368 # Check if the correct template was used 

369 self.assertTemplateUsed(response, 'success_page.html') 

370 

371 def test_success_view_authenticated_user(self): 

372 # Log in a user (optional: create and log in a user if needed) 

373 # user = User.objects.create_user(username='testuser', password='12345') 

374 # self.client.login(username='testuser', password='12345') 

375 

376 # Send GET request to the success view 

377 response = self.client.get(reverse('success_page')) 

378 

379 # Check if the response is successful (status code 200) 

380 self.assertEqual(response.status_code, 200) 

381 

382 # Check if the correct template was used 

383 self.assertTemplateUsed(response, 'success_page.html') 

384 

385 def test_success_view_unauthenticated_user(self): 

386 # Send GET request to the success view without authentication 

387 response = self.client.get(reverse('success_page')) 

388 

389 # Check if the response is successful (status code 200) 

390 self.assertEqual(response.status_code, 200) 

391 

392 # Check if the correct template was used 

393 self.assertTemplateUsed(response, 'success_page.html') 

394 

395 def test_success_view_with_query_params(self): 

396 # Send GET request to the success view with query parameters 

397 response = self.client.get(reverse('success_page'), {'param': 'value'}) 

398 

399 # Check if the response is successful (status code 200) 

400 self.assertEqual(response.status_code, 200) 

401 

402 # Check if the correct template was used 

403 self.assertTemplateUsed(response, 'success_page.html') 

404