Fakultas Ilmu Komputer UI

tests.py 51.7 KB
Newer Older
1
import json, tempfile, os
2
from io import StringIO
3

4
from django.conf import settings
5
from django.contrib.auth import get_user_model
6
from django.core.exceptions import PermissionDenied, ValidationError
7
from django.core.files.uploadedfile import SimpleUploadedFile
8
from django.core.management import call_command
9
from django.db import IntegrityError
10
from django.test import Client, TestCase
11
12
from django.urls import resolve

13
from administration.models import VerificationSetting, VerificationReport
14
from administration.utils import id_generator
15
16
from app.forms import SuntingProfilForm
from app.views import UploadMateriView, add_rating_materi
17
from authentication.models import User
18
from .models import Category, Comment, Materi, Like, Rating
19
20
from .views import (DaftarKatalog, DashboardKontributorView, DetailMateri,
                    ProfilKontributorView, SuksesLoginAdminView,
21
                    SuksesLoginKontributorView, SuntingProfilView,
22
23
                    ProfilAdminView, PostsView, SuntingProfilAdminView, 
                    RevisiMateriView, KatalogPerKontributorView)
24
from app.forms import SuntingProfilForm
25
from app.utils.fileManagementUtil import get_random_filename, remove_image_exifdata
26

27
28
29
30

class DaftarKatalogTest(TestCase):
    def test_daftar_katalog_url_exist(self):
        url = "/"
31
32
        response = Client().get(f"{url}")
        self.assertEqual(response.status_code, 200)
33
34

    def test_daftar_katalog_using_daftar_katalog_template(self):
35
36
37
        response = Client().get("/")
        self.assertTemplateUsed(response, "app/katalog_materi.html")

38
    def test_daftar_katalog_using_daftar_katalog_func(self):
39
        found = resolve("/")
40
41
42
43
        self.assertEqual(found.func.__name__, DaftarKatalog.as_view().__name__)

    def test_fields(self):
        materi = Materi()
44
45
46
        materi.title = "tes"
        materi.cover = "https://cache.umusic.com/_sites/billieeilish/v2/images/pic-red.jpg"
        materi.author = "input"
47
48
        materi.save()

49
50
51
        resp = Materi.objects.get(id=materi.id)
        self.assertEqual(resp, materi)

52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
class DaftarKatalogPerKontributorTest(TestCase):
    def setUp(self):
        self.client = Client()
    
        self.contributor_credential = {
                "email": "kontributor@gov.id",
                "password": "passwordtest"
            }
        
        self.contributor_credential_2 = {
                "email": "kontributor2@gov.id",
                "password": "passwordtest"
            }

        self.contributor = get_user_model().objects.create_user(
            **self.contributor_credential, name="Kontributor 1", is_contributor=True)
        self.contributor2 = get_user_model().objects.create_user(
            **self.contributor_credential_2, name="Kontributor 2", is_contributor=True)
        
        self.cover = SimpleUploadedFile(
            "Cherprang_Areekul40_nJM9dGt.jpg", b"Test file")
        self.content = SimpleUploadedFile("Bahan_PA_RKK.pdf", b"Test file")

        Materi(title="Materi 1", author="Agas", uploader=self.contributor,
               publisher="Kelas SC", descriptions="Deskripsi Materi 1",
               status="APPROVE", cover=self.cover, content=self.content).save()
        Materi(title="Materi 2", author="Agas", uploader=self.contributor,
               publisher="Kelas SC", descriptions="Deskripsi Materi 2",
               status="APPROVE", cover=self.cover, content=self.content).save()
        Materi(title="Materi 3", author="Agas", uploader=self.contributor2,
               publisher="Kelas SC", descriptions="Deskripsi Materi 3",
               status="APPROVE", cover=self.cover, content=self.content).save()
        
        self.url = f"/profil/{self.contributor.email}/"
        
    def test_katalog_per_kontributor_url_exist(self):
        response = self.client.get(self.url)
        self.assertEqual(response.status_code, 200)

    def test_katalog_per_kontributor_using_katalog_kontri_template(self):
        response = self.client.get(self.url)
        self.assertTemplateUsed(response, "app/katalog_kontri.html")    

    def test_katalog_per_kontributor_using_katalog_per_kontributor_func(self):
        found = resolve(self.url)
        self.assertEqual(found.func.__name__, KatalogPerKontributorView.as_view().__name__)

    def test_katalog_per_kontributor_show_daftar_materi_kontributor(self):
        response = self.client.get(self.url)
        
        list_materi = Materi.objects.filter(uploader=self.contributor)        
        data = response.context_data['materi_list']
        self.assertEqual(len(list_materi), len(data))    

106

Saul Andre's avatar
Saul Andre committed
107
class DetailMateriTest(TestCase):
108
    def setUp(self):
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
        self.client = Client()
        self.admin_credential = {
            "email": "admin@gov.id",
            "password": "passwordtest"
        }
        self.contributor_credential = {
            "email": "kontributor@gov.id",
            "password": "passwordtest"
        }
        self.anonymous_credential = {
            "email": "anonymous@gov.id",
            "password": "passwordtest"
        }
        self.admin = get_user_model().objects.create_user(
            **self.admin_credential, name="Admin", is_admin=True)
        self.contributor = get_user_model().objects.create_user(
            **self.contributor_credential, name="Kontributor", is_contributor=True)
        self.anonymous = get_user_model().objects.create_user(
            **self.anonymous_credential, name="Anonymous"
        )
129
130
        self.cover = SimpleUploadedFile(
            "Cherprang_Areekul40_nJM9dGt.jpg", b"Test file")
131
132
133
134
        self.content = SimpleUploadedFile("Bahan_PA_RKK.pdf", b"Test file")

        Materi(title="Materi 1", author="Agas", uploader=self.contributor,
               publisher="Kelas SC", descriptions="Deskripsi Materi 1",
135
               status="APPROVE", cover=self.cover, content=self.content).save()
136
        self.materi1 = Materi.objects.first()
137
        self.url = "/materi/" + str(self.materi1.id) + "/"
138
139

    def test_detail_materi_url_exist(self):
140
        response = Client().get(self.url)
141
        self.assertEqual(response.status_code, 200)
142
143
144
        self.assertNotEqual(response.status_code, 404)

    def test_detail_materi_using_detail_materi_template(self):
145
        response = Client().get(self.url)
146
        self.assertTemplateUsed(response, 'app/detail_materi.html')
147

Saul Andre's avatar
Saul Andre committed
148
    def test_detail_materi_using_detail_materi_func(self):
149
        found = resolve(self.url)
Saul Andre's avatar
Saul Andre committed
150
        self.assertEqual(found.func.__name__, DetailMateri.as_view().__name__)
151

Saul Andre's avatar
Saul Andre committed
152
    def test_category_models_can_create_new_object(self):
153
154
        test = Category.objects.create(
            id="1", name="medis", description="kategori medis")
Saul Andre's avatar
Saul Andre committed
155
156
157
158
159
        countData = Category.objects.all().count()
        self.assertEqual(1, countData)
        self.assertNotEqual(0, countData)
        self.assertEqual(test.__str__(), "medis")
        self.assertNotEqual(test.__str__(), "saul")
Samuel Dimas's avatar
Samuel Dimas committed
160

Saul Andre's avatar
Saul Andre committed
161
    def test_comment_models_can_create_new_object(self):
162
        test = Comment.objects.create(
163
            username="saul", profile="121212", comment="232323")
Saul Andre's avatar
Saul Andre committed
164
165
166
167
168
        countData = Comment.objects.all().count()
        self.assertEqual(1, countData)
        self.assertNotEqual(0, countData)
        self.assertEqual(test.__str__(), "saul")
        self.assertNotEqual(test.__str__(), "userlain")
169

170
    def test_post_blank_comment(self):
171
172
173
174
        url = self.url
        self.client.login(**self.anonymous_credential)
        response = self.client.post(url, {"comment": ""})
        self.assertIn("error_message", response.context)
175
176
        self.assertIn("Anda belum menuliskan komentar",
                      response.context["error_message"])
177
178
179
180
181

    def test_comment_rendered_to_template(self):
        url = self.url
        self.client.login(**self.contributor_credential)
        self.client.post(url, {"comment": "This is my new comment"})
182
183
        response = Client().get(url)
        self.assertContains(response, "This is my new comment")
184

185
    def test_comment_by_admin(self):
186
187
188
189
        url = self.url
        self.client.login(**self.admin_credential)
        self.client.post(url, {"comment": "This is new comment by Admin"})
        response = self.client.get(url)
190
191
192
        self.assertContains(response, "Admin")

    def test_comment_by_kontributor(self):
193
194
        url = self.url
        self.client.login(**self.contributor_credential)
195
196
        self.client.post(
            url, {"comment": "This is new comment by Contributor"})
197
198
        response = self.client.get(url)
        self.assertContains(response, "Kontributor")
199
200

    def test_comment_by_anonymous(self):
201
202
203
204
205
        url = self.url
        self.client.get("/logout/")
        self.client.login(**self.anonymous_credential)
        self.client.post(url, {"comment": "This is new comment by Anonymous"})
        response = self.client.get(url)
206
        self.assertContains(response, "Anonymous")
207

208
    def test_detail_materi_contains_form_comment(self):
209
        response = self.client.get(self.url)
210
        self.assertContains(response, "Beri komentar...")
211

212
213
214
    def test_delete_comments_by_admin(self):
        url = self.url
        self.client.post(url, {"comment": "This is new comment by Anonymous"})
215
216
        deleteURL = "/delete/" + str(self.materi1.id) + "/" + str(
            Comment.objects.get(comment="This is new comment by Anonymous").id)
217
        self.client.get(deleteURL)
218
219
        self.assertEqual(Comment.objects.all().filter(
            comment="This is new comment by Anonymous").count(), 0)
220

221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265

class PostsViewTest(TestCase):

    @classmethod
    def generate_posts_data(cls, user):
        POST_COUNT = 3
        COMMENTS_COUNT_PER_POST = [1, 0, 3]

        assert POST_COUNT == len(COMMENTS_COUNT_PER_POST)

        sample_file = SimpleUploadedFile("Test.jpg", b"Test file")
        sample_category = Category.objects.create(name="Test Category")

        post_comment_group_dict = {}
        for _ in range(POST_COUNT):
            post = Materi.objects.create(
                uploader=user,
                cover=sample_file,
                content=sample_file,
            )
            post.categories.add(sample_category)

            post_comment_group_dict[post.id] = {
                "data": post,
                "comments": [],
            }

        for i, post_id in enumerate(post_comment_group_dict):
            post = post_comment_group_dict[post_id]["data"]

            for _ in range(COMMENTS_COUNT_PER_POST[i]):
                comment = Comment.objects.create(materi=post)
                post_comment_group_dict[post_id]["comments"].append(comment)

            # order by latest (-timestamp)
            post_comment_group_dict[post_id]["comments"].reverse()

        return post_comment_group_dict

    @classmethod
    def setUpTestData(cls):
        cls.url = '/posts/'
        cls.user_credentials = {
            "email": "user@email.com",
            "password": "justpass"
266
        }
267
268
        cls.user = User.objects.create_user(**cls.user_credentials, is_contributor=True)
        cls.data = cls.generate_posts_data(cls.user)
269

270
271
272
273
274
275
276
    def _request_as_user(self):
        self.client.login(**self.user_credentials)
        return self.client.get(self.url)

    def test_url_resolves_to_posts_view(self):
        found = resolve(self.url)
        self.assertEqual(found.func.__name__, PostsView.as_view().__name__)
277

278
279
    def test_returns_200_on_authenticated_access(self):
        response = self._request_as_user()
280
281
        self.assertEqual(response.status_code, 200)

282
    def test_returns_403_on_unauthenticated_access(self):
283
        response = self.client.get(self.url)
284
285
        self.assertRaises(PermissionDenied)
        self.assertEqual(response.status_code, 403)
286

287
288
289
    def test_returns_correct_template(self):
        response = self._request_as_user()
        self.assertTemplateUsed(response, "user_uploaded_posts.html")
290

291
292
    def test_success_returns_correct_comment_post_groupings_by_context(self):
        post_comment_group_dict = self.data
293

294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
        response = self._request_as_user()

        response_user = response.context_data["user"]
        self.assertEqual(response_user, self.user)

        response_data = response.context_data["posts"]
        actual_data = post_comment_group_dict
        self.assertDictEqual(response_data, actual_data)

    def test_html_contains_grouped_posts_and_comments(self):
        response = self._request_as_user()

        posts = list(self.data.keys())
        comments = {
            i: [comment.id for comment in self.data[post_id]["comments"]]
            for i, post_id in enumerate(posts)
        }

        self.assertRegex(
313
            str(response.content),
314
            rf'.*(<div id="post-{posts[2]}">)' + \
315
316
317
            rf'.*(<div id="post-{posts[2]}-comment-{comments[2][0]}">)' + \
            rf'.*(<div id="post-{posts[2]}-comment-{comments[2][1]}">)' + \
            rf'.*(<div id="post-{posts[2]}-comment-{comments[2][2]}">)' + \
318
319
            rf'.*(<div id="post-{posts[1]}">)' + \
            rf'.*(<div id="post-{posts[0]}">)' + \
320
            rf'.*(<div id="post-{posts[0]}-comment-{comments[0][0]}">)'
321
        )
322

323

324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
class TemplateLoaderTest(TestCase):
    def test_template_loader_url_exist(self):
        url = "/test-page.html"
        response = Client().get(url)
        self.assertEqual(response.status_code, 200)

    def test_template_loader_using_template_loader_template(self):
        url = "/test-page.html"
        response = Client().get(url)
        expected_template_name = "test-page.html"
        self.assertTemplateUsed(response, expected_template_name)

    def test_template_loader_using_template_loader_func(self):
        url = "/test-page.html"
        found = resolve(url)
        expected_view_name = "pages"
        self.assertEqual(found.func.__name__, expected_view_name)

    def test_template_loader_handle_non_existent_html(self):
        url = "/test.html"
        expected_template_name = "error-404.html"
        response = Client().get(url)
346
        self.assertEqual(response.status_code, 200)
347
        self.assertTemplateUsed(response, expected_template_name)
348

349

350
351
class UploadPageTest(TestCase):
    def setUp(self):
352
        self.client = Client()
353
354
355
356
357
        self.user = User.objects._create_user(email="kontributor@gov.id",
                                              password="kontributor", is_contributor=True)

    def test_upload_page_using_login_func(self):
        found = resolve("/unggah/")
358
359
        self.assertEqual(found.func.__name__,
                         UploadMateriView.as_view().__name__)
360
361

    def test_uplaod_page_url_is_exist(self):
362
        # Positive test
363
364
365
        self.client.login(email="kontributor@gov.id",
                          password="kontributor")
        response = self.client.get("/unggah/")
366
        self.assertEqual(response.status_code, 200)
367
368
369

        # Negative tests
        self.client.login(email="kontributor@gov.id",
370
                          password="kontributor")
371
372
373
374
375
376
        response = Client().get("/fake/")
        self.assertEqual(response.status_code, 404)

    def test_upload_page_template(self):
        url = "/unggah/"
        self.client.login(email="kontributor@gov.id",
377
                          password="kontributor")
378
379
        response = self.client.get(url)
        expected_template_name = "unggah.html"
380
        self.assertTemplateUsed(response, expected_template_name)
381
382
383

    def test_upload_page_title(self):
        self.client.login(email="kontributor@gov.id",
384
                          password="kontributor")
385
386
387
388
389
390
391
392
393
394
        response = self.client.get("/unggah/")

        # Positive tests
        self.assertContains(response, "Unggah Materi")

        # Negative tests
        self.assertNotContains(response, "Anything")

    def test_upload_page_form_field(self):
        self.client.login(email="kontributor@gov.id",
395
                          password="kontributor")
396
397
398
399
400
401
402
        response = self.client.get("/unggah/")

        # Positive tests
        self.assertContains(response, "title")

        # Negative tests
        self.assertNotContains(response, "anything")
403

404

405
406
407
408
class DashboardKontributorViewTest(TestCase):
    def setUp(self):
        self.client = Client()
        self.kontributor = User.objects.create_contributor(email="kontributor@gov.id",
409
                                                           password="kontributor")
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
        self.admin = User.objects.create_admin(email="admin@gov.id",
                                               password="admin")
        self.url = "/dashboard/"
        self.view = DashboardKontributorView
        self.template_name = "dashboard.html"

    def test_dashboard_kontributor_view(self):
        found = resolve(self.url)
        self.assertEqual(found.func.__name__, self.view.as_view().__name__)

    def test_dashboard_kontributor_template(self):
        # Login
        self.client.login(email="kontributor@gov.id",
                          password="kontributor")
        # Test
        response = self.client.get(self.url)
        self.assertTemplateUsed(response, self.template_name)
        # Logout
        self.client.logout()

    def test_dashboard_kontributor_url(self):
        # Login
        self.client.login(email="kontributor@gov.id",
                          password="kontributor")
        # Test
        response = self.client.get(self.url)
        self.assertEqual(response.status_code, 200)
        # Logout
        self.client.logout()

    def test_dashboard_kontributor_access(self):
        # Kontributor
        # Login
        self.client.login(email="kontributor@gov.id",
                          password="kontributor")
        # Test
        response = self.client.get(self.url)
        self.assertEqual(response.status_code, 200)
        # Logout
        self.client.logout()

        # Admin
        # Login
        self.client.login(email="admin@gov.id",
                          password="admin")
        # Test
        response = self.client.get(self.url)
        self.assertEqual(response.status_code, 403)
        # Logout
        self.client.logout()
460

461
462
463
464
        # Anonim
        # Test
        response = self.client.get(self.url)
        self.assertEqual(response.status_code, 403)
465

466

467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
class ProfilAdminTest(TestCase):
    def setUp(self):
        self.client = Client()
        self.kontributor = User.objects.create_contributor(email="kontributor@gov.id",
                                                           password="kontributor")
        self.admin = User.objects.create_admin(email="admin@gov.id",
                                               password="admin")
        self.url = "/profil-admin/"
        self.view = ProfilAdminView
        self.template_name = "profil-admin.html"

    def test_profil_Admin_view(self):
        found = resolve(self.url)
        self.assertEqual(found.func.__name__, self.view.as_view().__name__)

    def test_profil_admin_template(self):
        # Login
        self.client.login(email="admin@gov.id",
                          password="admin")
        # Test
        response = self.client.get(self.url)
        self.assertTemplateUsed(response, self.template_name)
        # Logout
        self.client.logout()

    def test_profil_admin_url(self):
        # Login
        response = self.client.get(self.url)
        self.assertNotEqual(response.status_code, 200)

        self.client.login(email="admin@gov.id",
                          password="admin")
        # Test
        response = self.client.get(self.url)
        self.assertEqual(response.status_code, 200)
        # Logout
        self.client.logout()
504

505

506
507
508
509
class ProfilKontributorTest(TestCase):
    def setUp(self):
        self.client = Client()
        self.kontributor = User.objects.create_contributor(email="kontributor@gov.id",
510
                                                           password="kontributor")
511
512
513
514
515
        self.admin = User.objects.create_admin(email="admin@gov.id",
                                               password="admin")
        self.url = "/profil/"
        self.view = ProfilKontributorView
        self.template_name = "profil.html"
516

517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
    def test_profil_kontributor_view(self):
        found = resolve(self.url)
        self.assertEqual(found.func.__name__, self.view.as_view().__name__)

    def test_profil_kontributor_template(self):
        # Login
        self.client.login(email="kontributor@gov.id",
                          password="kontributor")
        # Test
        response = self.client.get(self.url)
        self.assertTemplateUsed(response, self.template_name)
        # Logout
        self.client.logout()

    def test_profil_kontributor_url(self):
        # Login
        self.client.login(email="kontributor@gov.id",
                          password="kontributor")
        # Test
        response = self.client.get(self.url)
        self.assertEqual(response.status_code, 200)
        # Logout
        self.client.logout()

    def test_profil_kontributor_access(self):
        # Kontributor
        # Login
        self.client.login(email="kontributor@gov.id",
                          password="kontributor")
        # Test
        response = self.client.get(self.url)
        self.assertEqual(response.status_code, 200)
        # Logout
        self.client.logout()

        # Admin
        # Login
        self.client.login(email="admin@gov.id",
                          password="admin")
        # Test
        response = self.client.get(self.url)
        self.assertEqual(response.status_code, 403)
        # Logout
        self.client.logout()
561

562
563
564
565
        # Anonim
        # Test
        response = self.client.get(self.url)
        self.assertEqual(response.status_code, 403)
566
567


568
569
570
571
class SuntingProfilTest(TestCase):
    def setUp(self):
        self.client = Client()
        self.kontributor = User.objects.create_contributor(email="kontributor@gov.id",
572
                                                           password="kontributor")
573
574
575
576
577
        self.admin = User.objects.create_admin(email="admin@gov.id",
                                               password="admin")
        self.url = "/sunting/"
        self.view = SuntingProfilView
        self.template_name = "sunting.html"
578

579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
    def test_sunting_profile_view(self):
        found = resolve(self.url)
        self.assertEqual(found.func.__name__, self.view.as_view().__name__)

    def test_sunting_profile_template(self):
        # Login
        self.client.login(email="kontributor@gov.id",
                          password="kontributor")
        # Test
        response = self.client.get(self.url)
        self.assertTemplateUsed(response, self.template_name)
        # Logout
        self.client.logout()

    def test_sunting_profile_url(self):
        # Login
        self.client.login(email="kontributor@gov.id",
                          password="kontributor")
        # Test
        response = self.client.get(self.url)
        self.assertEqual(response.status_code, 200)
        # Logout
        self.client.logout()

    def test_sunting_profile_access(self):
        # Kontributor
        # Login
        self.client.login(email="kontributor@gov.id",
                          password="kontributor")
        # Test
        response = self.client.get(self.url)
        self.assertEqual(response.status_code, 200)
        # Logout
612
613
        self.client.logout()

614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
    def test_sunting_profile_access_anonymous(self):
        # Test
        response = self.client.get(self.url)
        self.assertEqual(response.status_code, 403)

    def test_sunting_profile_autofocus(self):
        form_data = {
            "email": "kontributor@gov.id",
            "name": "kontributor",
            "instansi": "instansi",
            "nik": "nik",
            "alamat": "alamat",
            "nomor_telpon": "123456789",
            "twitter": "Twit",
            "instagram": "https://instagram.com/test_ig"
        }
        form = SuntingProfilForm(data=form_data)

        # Test
        self.assertEqual(form.fields["twitter"].widget.attrs.get("autofocus"), "")
        self.assertEqual(form.fields["instagram"].widget.attrs.get("autofocus"), None)


637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
class SuntingProfilAdminTest(TestCase):
    def setUp(self):
        self.client = Client()
        self.kontributor = User.objects.create_contributor(email="kontributor@gov.id",
                                                           password="kontributor")
        self.admin = User.objects.create_admin(email="admin@gov.id",
                                               password="admin")
        self.url = "/sunting-admin/"
        self.view = SuntingProfilAdminView
        self.template_name = "sunting_admin.html"

    def test_sunting_profile_admin_view(self):
        found = resolve(self.url)
        self.assertEqual(found.func.__name__, self.view.as_view().__name__)

    def test_sunting_profile_admin_template(self):
        # Login
        self.client.login(email="admin@gov.id",
                          password="admin")
        # Test
        response = self.client.get(self.url)
        self.assertTemplateUsed(response, self.template_name)
        # Logout
        self.client.logout()

    def test_sunting_profile_admin_url(self):
        # Login
        self.client.login(email="admin@gov.id",
                          password="admin")
        # Test
        response = self.client.get(self.url)
        self.assertEqual(response.status_code, 200)
        # Logout
        self.client.logout()

    def test_sunting_profile_admin_access(self):
        # Kontributor
        # Login
        self.client.login(email="admin@gov.id",
                          password="admin")
        # Test
        response = self.client.get(self.url)
        self.assertEqual(response.status_code, 200)
        # Logout
        self.client.logout()

683

684
685
686
687
class SuksesLoginKontributorTest(TestCase):
    def setUp(self):
        self.client = Client()
        self.kontributor = User.objects.create_contributor(email="kontributor@gov.id",
688
                                                           password="kontributor")
689
690
691
692
693
        self.admin = User.objects.create_admin(email="admin@gov.id",
                                               password="admin")
        self.url = "/sukses-kontributor/"
        self.view = SuksesLoginKontributorView
        self.template_name = "sukses_kontri.html"
694

695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
    def test_sukses_login_kontributor_view(self):
        found = resolve(self.url)
        self.assertEqual(found.func.__name__, self.view.as_view().__name__)

    def test_sukses_login_kontributor_template(self):
        # Login
        self.client.login(email="kontributor@gov.id",
                          password="kontributor")
        # Test
        response = self.client.get(self.url)
        self.assertTemplateUsed(response, self.template_name)
        # Logout
        self.client.logout()

    def test_sukses_login_kontributor_url(self):
        # Login
        self.client.login(email="kontributor@gov.id",
                          password="kontributor")
        # Test
        response = self.client.get(self.url)
        self.assertEqual(response.status_code, 200)
        # Logout
        self.client.logout()

    def test_sukses_login_kontributor_access(self):
        # Kontributor
        # Login
        self.client.login(email="kontributor@gov.id",
                          password="kontributor")
        # Test
        response = self.client.get(self.url)
        self.assertEqual(response.status_code, 200)
        # Logout
        self.client.logout()

730

731
732
733
734
class SuksesLoginAdminTest(TestCase):
    def setUp(self):
        self.client = Client()
        self.kontributor = User.objects.create_contributor(email="kontributor@gov.id",
735
                                                           password="kontributor")
736
737
738
739
740
        self.admin = User.objects.create_admin(email="admin@gov.id",
                                               password="admin")
        self.url = "/sukses-admin/"
        self.view = SuksesLoginAdminView
        self.template_name = "sukses_admin.html"
741

742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
    def test_sukses_login_admin_view(self):
        found = resolve(self.url)
        self.assertEqual(found.func.__name__, self.view.as_view().__name__)

    def test_sukses_login_admin_template(self):
        # Login
        self.client.login(email="admin@gov.id",
                          password="admin")
        # Test
        response = self.client.get(self.url)
        self.assertTemplateUsed(response, self.template_name)
        # Logout
        self.client.logout()

    def test_sukses_login_admin_url(self):
        # Login
        self.client.login(email="admin@gov.id",
                          password="admin")
        # Test
        response = self.client.get(self.url)
        self.assertEqual(response.status_code, 200)
        # Logout
        self.client.logout()

    def test_sukses_login_admin_access(self):
        # Kontributor
        # Login
        self.client.login(email="admin@gov.id",
                          password="admin")
        # Test
        response = self.client.get(self.url)
        self.assertEqual(response.status_code, 200)
        # Logout
        self.client.logout()
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810


class LikeMateriTest(TestCase):
    def setUp(self):
        self.contributor_credential = {
            "email": "kontributor@gov.id",
            "password": id_generator()
        }
        self.contributor = get_user_model().objects.create_user(
            **self.contributor_credential, name="Kontributor", is_contributor=True
        )
        self.client = Client()
        self.url_like = '/materi/like/'
        content = b"Test file"
        self.cover = SimpleUploadedFile(
            "cover.jpg",
            content
        )
        self.content = SimpleUploadedFile(
            "content.txt",
            content
        )
        Materi(title="Materi 1", author="Agas", uploader=self.contributor,
               publisher="Kelas SC", descriptions="Deskripsi Materi 1",
               status="PENDING", cover=self.cover, content=self.content).save()
        self.materi1 = Materi.objects.first()
        self.url_materi = f'/materi/{self.materi1.id}/'

    def test_get_method(self):
        response = self.client.get(self.url_like)
        response = json.loads(response.content)
        self.assertEqual(response.get("success", None), False)

    def test_like_materi(self):
        # Verify that materi doesn't have any like to start with
811
        num_of_likes = Like.objects.filter(materi=self.materi1).count()
812
813
        self.assertEqual(num_of_likes, 0)

814
        # Like a materi
815
816
817
818
819
820
821
822
        response = self.client.get(self.url_materi)
        session_id = response.context["session_id"]
        materi_id = response.context["materi_data"].id
        payload = {
            'materi_id': materi_id,
            'session_id': session_id
        }
        ajax_response = Client().post(self.url_like, payload)
823
        num_of_likes = Like.objects.filter(materi=self.materi1).count()
824
825
826
827
        self.assertEqual(num_of_likes, 1)

    def test_unlike_materi(self):
        # Verify that materi doesn't have any like to start with
828
        num_of_likes = Like.objects.filter(materi=self.materi1).count()
829
830
        self.assertEqual(num_of_likes, 0)

831
        # Like a materi
832
833
834
835
836
837
838
839
        response = self.client.get(self.url_materi)
        session_id = response.context["session_id"]
        materi_id = response.context["materi_data"].id
        payload = {
            'materi_id': materi_id,
            'session_id': session_id
        }
        ajax_response = Client().post(self.url_like, payload)
840
        num_of_likes = Like.objects.filter(materi=self.materi1).count()
841
842
        self.assertEqual(num_of_likes, 1)

843
        # Unlike a materi
844
845
846
847
848
849
850
851
        response = self.client.get(self.url_materi)
        session_id = response.context["session_id"]
        materi_id = response.context["materi_data"].id
        payload = {
            'materi_id': materi_id,
            'session_id': session_id
        }
        ajax_response = Client().post(self.url_like, payload)
852
        num_of_likes = Like.objects.filter(materi=self.materi1).count()
853
854
855
856
        self.assertEqual(num_of_likes, 0)

    def test_2_client_like_materi(self):
        # Verify that materi doesn't have any like to start with
857
        num_of_likes = Like.objects.filter(materi=self.materi1).count()
858
859
        self.assertEqual(num_of_likes, 0)

860
        # Client 1 like a materi
861
862
863
864
865
866
867
868
        response = self.client.get(self.url_materi)
        session_id = response.context["session_id"]
        materi_id = response.context["materi_data"].id
        payload = {
            'materi_id': materi_id,
            'session_id': session_id
        }
        ajax_response = Client().post(self.url_like, payload)
869
        num_of_likes = Like.objects.filter(materi=self.materi1).count()
870
871
        self.assertEqual(num_of_likes, 1)

872
        # Client 2 like a materi
873
874
875
876
877
878
879
880
        response = Client().get(self.url_materi)
        session_id = response.context["session_id"]
        materi_id = response.context["materi_data"].id
        payload = {
            'materi_id': materi_id,
            'session_id': session_id
        }
        ajax_response = Client().post(self.url_like, payload)
881
        num_of_likes = Like.objects.filter(materi=self.materi1).count()
882
883
884
885
        self.assertEqual(num_of_likes, 2)

    def test_incomplete_like_parameter(self):
        # Verify that materi doesn't have any like to start with
886
        num_of_likes = Like.objects.filter(materi=self.materi1).count()
887
888
        self.assertEqual(num_of_likes, 0)

889
        # missing session id
890
891
892
893
894
895
        response = self.client.get(self.url_materi)
        materi_id = response.context["materi_data"].id
        payload = {
            'materi_id': materi_id,
        }
        ajax_response = Client().post(self.url_like, payload)
896
        ajax_response = json.loads(ajax_response.content)
897
        num_of_likes = Like.objects.filter(materi=self.materi1).count()
898
899
        self.assertEqual(num_of_likes, 0)
        self.assertEqual(ajax_response.get("success", None), False)
900
901

        # missing materi id
902
903
904
905
906
907
        response = self.client.get(self.url_materi)
        session_id = response.context["session_id"]
        payload = {
            'session_id': session_id
        }
        ajax_response = Client().post(self.url_like, payload)
908
        ajax_response = json.loads(ajax_response.content)
909
        num_of_likes = Like.objects.filter(materi=self.materi1).count()
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
        self.assertEqual(num_of_likes, 0)
        self.assertEqual(ajax_response.get("success", None), False)


class ViewMateriStatissticsTest(TestCase):
    def setUp(self):
        self.contributor_credential = {
            "email": "kontributor@gov.id",
            "password": id_generator()
        }
        self.contributor = get_user_model().objects.create_user(
            **self.contributor_credential, name="Kontributor", is_contributor=True
        )
        self.client = Client()
        content = b"Test file"
        self.cover = SimpleUploadedFile(
            "cover.jpg",
            content
        )
        self.content = SimpleUploadedFile(
            "content.txt",
            content
        )
        Materi(title="Materi 1", author="Agas", uploader=self.contributor,
               publisher="Kelas SC", descriptions="Deskripsi Materi 1",
               status="PENDING", cover=self.cover, content=self.content).save()
        self.materi1 = Materi.objects.first()
        self.url = f"/materi/{self.materi1.id}/view"

939
    # Test single view
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
    def test_count_one_materi_view(self):
        response = self.client.get(self.url)
        num_of_views = self.materi1.baca.all().count()
        self.assertEqual(num_of_views, 1)

    # Test more than one view
    def test_count_more_than_one_materi_view(self):
        response = self.client.get(self.url)
        num_of_views = self.materi1.baca.all().count()
        self.assertEqual(num_of_views, 1)

        response = Client().get(self.url)
        num_of_views = self.materi1.baca.all().count()
        self.assertEqual(num_of_views, 2)

955

956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
class DownloadMateriStatissticsTest(TestCase):
    def setUp(self):
        self.contributor_credential = {
            "email": "kontributor@gov.id",
            "password": id_generator()
        }
        self.contributor = get_user_model().objects.create_user(
            **self.contributor_credential, name="Kontributor", is_contributor=True
        )
        self.client = Client()
        content = b"Test file"
        self.cover = SimpleUploadedFile(
            "cover.jpg",
            content
        )
        self.content = SimpleUploadedFile(
            "content.txt",
            content
        )
        Materi(title="Materi 1", author="Agas", uploader=self.contributor,
               publisher="Kelas SC", descriptions="Deskripsi Materi 1",
               status="PENDING", cover=self.cover, content=self.content).save()
        self.materi1 = Materi.objects.first()
        self.url = f"/materi/{self.materi1.id}/unduh"

981
    # Test single download
982
983
984
985
986
987
988
989
990
991
992
993
994
    def test_count_one_materi_download(self):
        response = self.client.get(self.url)
        num_of_downloads = self.materi1.unduh.all().count()
        self.assertEqual(num_of_downloads, 1)

    # Test more than one download
    def test_count_more_than_one_materi_download(self):
        response = self.client.get(self.url)
        num_of_downloads = self.materi1.unduh.all().count()
        self.assertEqual(num_of_downloads, 1)

        response = Client().get(self.url)
        num_of_downloads = self.materi1.unduh.all().count()
995
996
        self.assertEqual(num_of_downloads, 2)

997

998
999
1000
class RevisiMateriTest(TestCase):
    def setUp(self):
        self.client = Client()