Fakultas Ilmu Komputer UI

tests.py 84.6 KB
Newer Older
1
import json, tempfile, os, mock
2
import pandas as pd
3
from io import StringIO
4

5
6
from bs4 import BeautifulSoup
from datetime import datetime
7
from django.conf import settings
8
from django.contrib import messages as dj_messages
9
from django.contrib.auth import get_user_model
10
from django.core import serializers
11
from django.core.files import File
12
from django.core.exceptions import PermissionDenied, ValidationError
13
from django.core.files.uploadedfile import SimpleUploadedFile
14
from django.core.management import call_command
15
from django.urls import resolve, reverse
16
from django.db.utils import IntegrityError
17
18
19
from django.test import Client, RequestFactory, TestCase, TransactionTestCase
from pytz import timezone
from time import sleep
20

21
from administration.models import VerificationSetting, VerificationReport
22
from administration.utils import id_generator
23
from app.views import UploadMateriHTML, add_rating_materi
24
from authentication.models import User
25
from digipus.settings import TIME_ZONE
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
from .models import (
    Category,
    Comment,
    DownloadStatistics,
    Materi,
    Like,
    Rating,
    ReqMaterial,
    RatingContributor,
    ViewStatistics,
)

from .views import (
    DaftarKatalog,
    DashboardKontributorView,
    DetailMateri,
    ProfilKontributorView,
    SuksesLoginAdminView,
    SuksesLoginKontributorView,
    SuntingProfilView,
    ProfilAdminView,
    PostsView,
    SuntingProfilAdminView,
    RevisiMateriView,
    ReqMateriView,
    KatalogPerKontributorView,
    UploadMateriView,
    UploadMateriExcelView,
)
55
from app.forms import SuntingProfilForm
56
from app.utils.fileManagementUtil import get_random_filename, remove_image_exifdata
57

58
ERROR_403_MESSAGE = "Kamu harus login untuk mengakses halaman ini"
Saul Andre's avatar
Saul Andre committed
59

60
61
62
63
64
65
66
67
from django.test import LiveServerTestCase
from selenium import webdriver
from selenium.webdriver.chrome.options import Options
from selenium.webdriver.common.keys import Keys
from webdriver_manager.chrome import ChromeDriverManager
from selenium.common.exceptions import NoSuchElementException


68
69
70
class DaftarKatalogTest(TestCase):
    def test_daftar_katalog_url_exist(self):
        url = "/"
71
72
        response = Client().get(f"{url}")
        self.assertEqual(response.status_code, 200)
73
74

    def test_daftar_katalog_using_daftar_katalog_template(self):
75
76
77
        response = Client().get("/")
        self.assertTemplateUsed(response, "app/katalog_materi.html")

78
    def test_daftar_katalog_using_daftar_katalog_func(self):
79
        found = resolve("/")
80
81
82
83
        self.assertEqual(found.func.__name__, DaftarKatalog.as_view().__name__)

    def test_fields(self):
        materi = Materi()
84
85
86
        materi.title = "tes"
        materi.cover = "https://cache.umusic.com/_sites/billieeilish/v2/images/pic-red.jpg"
        materi.author = "input"
87
88
        materi.save()

89
90
91
        resp = Materi.objects.get(id=materi.id)
        self.assertEqual(resp, materi)

92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
    def test_materi_model_generate_search_vector_after_save(self):
        Materi(title="Eating book").save()

        search_vector_new_materi = list(Materi.objects.values_list("_search_vector", flat=True))
        expected_search_vector = ["'book':2A 'eat':1A"]

        self.assertSequenceEqual(search_vector_new_materi, expected_search_vector)

    def test_search_text_on_empty_database(self):
        search_query = "test"

        search_result = list(Materi.objects.search(search_query))
        expected_search_result = []

        self.assertSequenceEqual(search_result, expected_search_result)

    def test_search_text_on_unmatched_data(self):
        Materi(title="test satu sekarang").save()
        Materi(title="test dua nanti").save()

        search_query = "besok"

        search_result = list(Materi.objects.search(search_query))
        expected_search_result = []

        self.assertSequenceEqual(search_result, expected_search_result)

    def test_search_text_return_list_matched_by_rank(self):
        materi_2 = Materi(title="ini lumayan cocok lumayan cocok")
        materi_2.save()

        materi_1 = Materi(title="ini sangat cocok sangat cocok sangat cocok")
        materi_1.save()

        materi_4 = Materi(title="ini tidak")
        materi_4.save()

        materi_3 = Materi(title="ini sedikit cocok")
        materi_3.save()

        search_query = "ini cocok"

        search_result = list(Materi.objects.search(search_query))
        expected_search_result = [materi_1, materi_2, materi_3]

        self.assertSequenceEqual(search_result, expected_search_result)


140
141
142
class DaftarKatalogPerKontributorTest(TestCase):
    def setUp(self):
        self.client = Client()
Muhamad Lutfi Arif's avatar
Muhamad Lutfi Arif committed
143

144
        self.contributor_credential = {"email": "kontributor@gov.id", "password": "passwordtest"}
Muhamad Lutfi Arif's avatar
Muhamad Lutfi Arif committed
145

146
        self.contributor_credential_2 = {"email": "kontributor2@gov.id", "password": "passwordtest"}
147
148

        self.contributor = get_user_model().objects.create_user(
149
150
            **self.contributor_credential, name="Kontributor 1", is_contributor=True
        )
151
        self.contributor2 = get_user_model().objects.create_user(
152
153
            **self.contributor_credential_2, name="Kontributor 2", is_contributor=True
        )
Muhamad Lutfi Arif's avatar
Muhamad Lutfi Arif committed
154

155
        self.cover = SimpleUploadedFile("Cherprang_Areekul40_nJM9dGt.jpg", b"Test file")
156
157
        self.content = SimpleUploadedFile("Bahan_PA_RKK.pdf", b"Test file")

158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
        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()
Muhamad Lutfi Arif's avatar
Muhamad Lutfi Arif committed
188

189
        self.url = f"/profil/{self.contributor.email}/"
Muhamad Lutfi Arif's avatar
Muhamad Lutfi Arif committed
190

191
192
193
194
195
196
    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)
Muhamad Lutfi Arif's avatar
Muhamad Lutfi Arif committed
197
        self.assertTemplateUsed(response, "app/katalog_kontri.html")
198
199
200
201
202
203
204

    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)
Muhamad Lutfi Arif's avatar
Muhamad Lutfi Arif committed
205
206

        list_materi = Materi.objects.filter(uploader=self.contributor)
207
        data = response.context_data["materi_list"]
Muhamad Lutfi Arif's avatar
Muhamad Lutfi Arif committed
208
        self.assertEqual(len(list_materi), len(data))
209

210

Saul Andre's avatar
Saul Andre committed
211
class DetailMateriTest(TestCase):
212
    def setUp(self):
213
        self.client = Client()
214
215
216
217
        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)
218
        self.contributor = get_user_model().objects.create_user(
219
            **self.contributor_credential, name="Kontributor", is_contributor=True
220
        )
221
222
        self.anonymous = get_user_model().objects.create_user(**self.anonymous_credential, name="Anonymous")
        self.cover = SimpleUploadedFile("ExampleCover921.jpg", b"Test file")
223
        self.content = SimpleUploadedFile("ExampleFile921.pdf", b"Test file")
224

225
226
227
228
229
230
231
232
233
234
        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()
235
        self.materi1 = Materi.objects.first()
236
        self.url = "/materi/" + str(self.materi1.id) + "/"
237

238
239
240
241
242
243
244
245
246
247
248
249
        self.materi_with_published_date = Materi.objects.create(
            title="Materi 1",
            author="Agas",
            uploader=self.contributor,
            publisher="Kelas SC",
            descriptions="Deskripsi Materi 1",
            status="APPROVE",
            cover=self.cover,
            content=self.content,
            date_modified=datetime.now(),
            date_created=datetime.now(),
        )
250
        self.materi_with_published_date_url = "/materi/" + str(self.materi_with_published_date.id) + "/"
251
252
253
254
255
256
257
258
        VerificationReport.objects.create(
            report='{"feedback": "Something", "kriteria": [{"title": "Kriteria 1", "status": true},'
            + ' {"title": "Kriteria 2", "status": true}, {"title": "Kriteria 3", "status": true}]}',
            timestamp="2020-10-09 06:21:33",
            status="Diterima",
            materi=self.materi_with_published_date,
            user=self.materi_with_published_date.uploader,
        )
259

260
    def test_detail_materi_url_exist(self):
261
        response = Client().get(self.url)
262
        self.assertEqual(response.status_code, 200)
263
264
265
        self.assertNotEqual(response.status_code, 404)

    def test_detail_materi_using_detail_materi_template(self):
266
        response = Client().get(self.url)
267
        self.assertTemplateUsed(response, "app/detail_materi.html")
268

Saul Andre's avatar
Saul Andre committed
269
    def test_detail_materi_using_detail_materi_func(self):
270
        found = resolve(self.url)
Saul Andre's avatar
Saul Andre committed
271
        self.assertEqual(found.func.__name__, DetailMateri.as_view().__name__)
272

Saul Andre's avatar
Saul Andre committed
273
    def test_category_models_can_create_new_object(self):
274
        test = Category.objects.create(id="1", name="medis", description="kategori medis")
Saul Andre's avatar
Saul Andre committed
275
276
277
278
279
        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
280

Saul Andre's avatar
Saul Andre committed
281
    def test_comment_models_can_create_new_object(self):
282
        test = Comment.objects.create(username="saul", profile="121212", comment="232323")
Saul Andre's avatar
Saul Andre committed
283
284
285
286
287
        countData = Comment.objects.all().count()
        self.assertEqual(1, countData)
        self.assertNotEqual(0, countData)
        self.assertEqual(test.__str__(), "saul")
        self.assertNotEqual(test.__str__(), "userlain")
288

289
    def test_post_blank_comment(self):
290
291
292
293
        url = self.url
        self.client.login(**self.anonymous_credential)
        response = self.client.post(url, {"comment": ""})
        self.assertIn("error_message", response.context)
294
        self.assertIn("Anda belum menuliskan komentar", response.context["error_message"])
295
296
297
298
299

    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"})
300
301
        response = Client().get(url)
        self.assertContains(response, "This is my new comment")
302

303
    def test_comment_by_admin(self):
304
305
306
307
        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)
308
309
310
        self.assertContains(response, "Admin")

    def test_comment_by_kontributor(self):
311
312
        url = self.url
        self.client.login(**self.contributor_credential)
313
        self.client.post(url, {"comment": "This is new comment by Contributor"})
314
315
        response = self.client.get(url)
        self.assertContains(response, "Kontributor")
316
317

    def test_comment_by_anonymous(self):
318
319
320
321
322
        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)
323
        self.assertContains(response, "Anonymous")
324

325
    def test_detail_materi_contains_form_comment(self):
326
        response = self.client.get(self.url)
327
        self.assertContains(response, "Beri komentar...")
328

329
330
331
    def test_delete_comments_by_admin(self):
        url = self.url
        self.client.post(url, {"comment": "This is new comment by Anonymous"})
332
333
334
335
336
337
        deleteURL = (
            "/delete/"
            + str(self.materi1.id)
            + "/"
            + str(Comment.objects.get(comment="This is new comment by Anonymous").id)
        )
338
        self.client.get(deleteURL)
339
        self.assertEqual(Comment.objects.all().filter(comment="This is new comment by Anonymous").count(), 0)
340

341
    def test_tombol_citasiAPA(self):
342
        response = self.client.get(self.url)
343
        self.assertContains(response, "Citate APA")
344

345
    def test_hasil_citasi_APA_materi_has_no_published_date(self):
346
        response = self.client.get(self.url)
347
348
        expected = self.materi1.author + " . (n.d) . " + self.materi1.title + " . " + self.materi1.publisher
        self.assertIn(expected, response.context["citationAPA"])
349

350
351
    def test_hasil_citasi_APA_materi_has_published_date(self):
        response = self.client.get(self.materi_with_published_date_url)
352
353
354
355
356
357
358
359
360
361
362
363
        published_date = self.materi_with_published_date.published_date.strftime("%Y-%m-%d %H:%M")
        expected = (
            self.materi_with_published_date.author
            + " . ("
            + published_date
            + ") . "
            + self.materi_with_published_date.title
            + " . "
            + self.materi_with_published_date.publisher
        )
        self.assertIn(expected, response.context["citationAPA"])

364
365
366
367
368
369
370
371
372
373
374
    def test_citation_IEEE_button(self):
        response = self.client.get(self.url)
        self.assertContains(response, "Citate IEEE")

    def test_citation_IEEE_materi_has_no_published_date(self):
        response = self.client.get(self.url)
        current_date = datetime.now()
        current_day = str(current_date.day)
        current_month = current_date.strftime("%b")
        current_year = str(current_date.year)

375
376
377
378
379
380
381
382
383
384
385
386
387
388
        expected = (
            "Agas, "
            + "Materi 1. "
            + "Kelas SC, n.d. "
            + "Accessed on: "
            + current_month
            + ". "
            + current_day
            + ", "
            + current_year
            + ". [Online]. "
            + "Available: http://testserver"
            + self.url
        )
389
390
391
392
393
394
395
396
        self.assertIn(expected, response.context["citationIEEE"])

    def test_citation_IEEE_materi_has_published_date(self):
        response = self.client.get(self.materi_with_published_date_url)
        current_date = datetime.now()
        current_day = str(current_date.day)
        current_month = current_date.strftime("%b")
        current_year = str(current_date.year)
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
        published_date = self.materi_with_published_date.published_date.strftime("%Y")

        expected = (
            "Agas, "
            + "Materi 1. "
            + "Kelas SC, "
            + published_date
            + ". "
            + "Accessed on: "
            + current_month
            + ". "
            + current_day
            + ", "
            + current_year
            + ". [Online]. "
            + "Available: http://testserver"
            + self.materi_with_published_date_url
        )
415
        self.assertIn(expected, response.context["citationIEEE"])
416

417
418
    def test_tombol_bagikan_google_drive(self):
        response = Client().get(self.url)
419
        self.assertContains(response, "Google Drive")
420

421
    @mock.patch("app.views.upload_to_gdrive")
422
    def test_save_to_gdrive_with_nonexistent_materi(self, mock_upload_to_gdrive):
423
        response = self.client.get("/materi/%s/save-to-gdrive/" % 0)
424
425
426
        mock_upload_to_gdrive.assert_not_called()
        self.assertEqual(response.status_code, 404)

427
    @mock.patch("app.views.upload_to_gdrive")
428
    def test_save_to_gdrive_with_valid_materi(self, mock_upload_to_gdrive):
429
        response = self.client.get("/materi/%s/save-to-gdrive/" % self.materi1.id, follow=True)
430
431
        last_url, status_code = response.redirect_chain[-1]
        mock_upload_to_gdrive.assert_called_once()
432
        self.assertEqual(last_url, "/materi/%d/" % self.materi1.id)
433
434
        self.assertEqual(status_code, 302)

435

436
class PostsViewTest(TestCase):
437
438
439
440
    @classmethod
    def generate_posts_data(cls, user):
        POST_COUNT = 3
        COMMENTS_COUNT_PER_POST = [1, 0, 3]
441
        LIKES_COUNT_PER_POST = [5, 4, 2]
442
443
444
445
446
447
448

        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 = {}
449
        for i in range(POST_COUNT):
450
            post = Materi.objects.create(uploader=user, cover=sample_file, content=sample_file,)
451
452
453
454
455
456
457
            post.categories.add(sample_category)

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

458
            for j in range(LIKES_COUNT_PER_POST[i]):
459
                Like.objects.create(
460
                    timestamp=datetime.now(), materi=post, session_id=("dummysession-" + str(i) + "-" + str(j))
461
                )
462

463
464
465
466
467
468
469
470
471
472
473
474
475
476
        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):
477
478
        cls.url = "/posts/"
        cls.user_credentials = {"email": "user@email.com", "password": "justpass"}
479
480
481
482
483
484
485
486
        cls.user = User.objects.create_user(**cls.user_credentials, is_contributor=True)
        cls.data = cls.generate_posts_data(cls.user)

    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):
487
        found = resolve(self.url)
488
        self.assertEqual(found.func.__name__, PostsView.as_view().__name__)
489

490
491
492
    def test_returns_200_on_authenticated_access(self):
        response = self._request_as_user()
        self.assertEqual(response.status_code, 200)
493

494
    def test_returns_403_on_unauthenticated_access(self):
495
        response = self.client.get(self.url)
496
        self.assertRaises(PermissionDenied)
497
        self.assertEqual(response.status_code, 403)
498

499
500
501
        html = response.content.decode("utf-8")
        self.assertIn(ERROR_403_MESSAGE, html)

502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
    def test_returns_correct_template(self):
        response = self._request_as_user()
        self.assertTemplateUsed(response, "user_uploaded_posts.html")

    def test_success_returns_correct_comment_post_groupings_by_context(self):
        post_comment_group_dict = self.data

        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())
522
        comments = {i: [comment.id for comment in self.data[post_id]["comments"]] for i, post_id in enumerate(posts)}
523
524

        self.assertRegex(
525
            str(response.content),
526
527
528
529
530
531
532
            rf'.*(<div id="post-{posts[2]}">)'
            + 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]}">)'
            + rf'.*(<div id="post-{posts[1]}">)'
            + rf'.*(<div id="post-{posts[0]}">)'
            + rf'.*(<div id="post-{posts[0]}-comment-{comments[0][0]}">)',
533
534
        )

535
536
537
538
539
540
541
    def test_like_count_written_correctly_on_template(self):
        response = self._request_as_user()

        for _, post_id in enumerate(self.data):
            post = self.data[post_id]["data"]

            self.assertContains(
542
                response, '<span id="post-like-count-' + str(post.id) + '">' + str(post.like_count) + "</span>",
543
            )
544

545

546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
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)
568
        self.assertEqual(response.status_code, 200)
569
        self.assertTemplateUsed(response, expected_template_name)
570

571

572
573
class UploadPageTest(TestCase):
    def setUp(self):
574
        self.client = Client()
575
576
        self.user = User.objects._create_user(email="kontributor@gov.id", password="kontributor", is_contributor=True)
        self.admin = User.objects.create_admin(email="admin@gov.id", password="admin")
577
578
579

    def test_upload_page_using_login_func(self):
        found = resolve("/unggah/")
580
        self.assertEqual(found.func.__name__, UploadMateriView.as_view().__name__)
581

Steven Kusuman's avatar
Steven Kusuman committed
582
    def test_upload_page_url_is_exist(self):
583
        # Positive test
584
        self.client.login(email="kontributor@gov.id", password="kontributor")
585
        response = self.client.get("/unggah/")
586
        self.assertEqual(response.status_code, 200)
587
588

        # Negative tests
589
        self.client.login(email="kontributor@gov.id", password="kontributor")
590
591
592
        response = Client().get("/fake/")
        self.assertEqual(response.status_code, 404)

593
594
    def test_upload_page_url_admin_doesnt_exist(self):
        self.client.login(email="admin@gov.id", password="admin")
Steven Kusuman's avatar
Steven Kusuman committed
595
596
597
        response = self.client.get("/unggah/")
        self.assertEqual(response.status_code, 403)

598
599
    def test_upload_page_url_admin_cant_upload(self):
        self.client.login(email="admin@gov.id", password="admin")
Steven Kusuman's avatar
Steven Kusuman committed
600
601
602
        response = self.client.post("/unggah/")
        self.assertEqual(response.status_code, 403)

603
604
    def test_upload_page_template(self):
        url = "/unggah/"
605
        self.client.login(email="kontributor@gov.id", password="kontributor")
606
607
        response = self.client.get(url)
        expected_template_name = "unggah.html"
608
        self.assertTemplateUsed(response, expected_template_name)
609
610

    def test_upload_page_title(self):
611
        self.client.login(email="kontributor@gov.id", password="kontributor")
612
613
614
615
616
617
618
619
620
        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):
621
        self.client.login(email="kontributor@gov.id", password="kontributor")
622
623
624
625
626
627
628
        response = self.client.get("/unggah/")

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

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

630

631
632
633
class UploadExcelPageTest(TestCase):
    def setUp(self):
        self.client = Client()
634
        self.user = User.objects._create_user(email="kontributor@gov.id", password="kontributor", is_contributor=True)
635
636
637

    def test_upload_excel_page_using_login_func(self):
        found = resolve("/unggah_excel/")
638
        self.assertEqual(found.func.__name__, UploadMateriExcelView.as_view().__name__)
639
640
641

    def test_uplaod_excel_page_url_is_exist(self):
        # Positive test
642
        self.client.login(email="kontributor@gov.id", password="kontributor")
643
644
645
646
        response = self.client.get("/unggah_excel/")
        self.assertEqual(response.status_code, 200)

        # Negative tests
647
        self.client.login(email="kontributor@gov.id", password="kontributor")
648
649
650
651
652
        response = Client().get("/fake/")
        self.assertEqual(response.status_code, 404)

    def test_upload_excel_page_template(self):
        url = "/unggah_excel/"
653
        self.client.login(email="kontributor@gov.id", password="kontributor")
654
655
656
657
658
        response = self.client.get(url)
        expected_template_name = "unggah_excel.html"
        self.assertTemplateUsed(response, expected_template_name)

    def test_upload_excel_page_title(self):
659
        self.client.login(email="kontributor@gov.id", password="kontributor")
660
661
662
663
664
665
666
667
668
        response = self.client.get("/unggah_excel/")

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

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

    def test_upload_excel_page_form_field(self):
669
        self.client.login(email="kontributor@gov.id", password="kontributor")
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
        response = self.client.get("/unggah_excel/")

        # Positive tests
        self.assertContains(response, "File (*.xlsx)")

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

    def create_dummy_excel(self, field_lengths={}, categories=[]):
        title1 = "Hands-On Machine Learning with Scikit-Learn and TensorFlow: Concepts, Tools, and Techniques to Build Intelligent Systems"
        author1 = "Aurelien Geron, Aurelien Geron, Aurelien Geron"
        publisher1 = "O'Reilly Media, O'Reilly Media, O'Reilly Media"
        categories1 = "Machine Learning,Deep Learning,Computer Science"
        description1 = "A series of Deep Learning breakthroughs have boosted the whole field of machine learning over the last decade. Now that machine learning is thriving, even programmers who know close to nothing about this technology can use simple, efficient tools to implement programs capable of learning from data. This practical book shows you how."

685
686
        if "title" in field_lengths:
            title1 = title1[: field_lengths["title"]]
687

688
689
        if "author" in field_lengths:
            author1 = author1[: field_lengths["author"]]
690

691
692
        if "publisher" in field_lengths:
            publisher1 = publisher1[: field_lengths["publisher"]]
693
694

        if len(categories) > 0:
695
696
697
698
699
700
701
702
703
704
705
            categories1 = ",".join(categories)

        data_frame = pd.DataFrame(
            {
                "Title": [title1],
                "Author": [author1],
                "Publisher": [publisher1],
                "Categories": [categories1],
                "Description": [description1],
            }
        )
706

707
        file_path = os.path.join(settings.MEDIA_ROOT, "dummy.xlsx")
708

709
        writer = pd.ExcelWriter(file_path, engine="xlsxwriter")  # pylint: disable=abstract-class-instantiated
710
711
712
713
714
715
        data_frame.to_excel(writer, index=0)
        writer.save()

        return file_path, data_frame

    def test_upload_excel_upload_file_title_error(self):
716
        self.client.login(email="kontributor@gov.id", password="kontributor")
717
718

        field_lengths = {
719
720
            "author": 30,
            "publisher": 30,
721
722
723
        }
        file_name, data_frame = self.create_dummy_excel(field_lengths=field_lengths)

724
725
726
        with open(file_name, "rb") as fp:
            response = self.client.post("/unggah_excel/", {"excel": fp})

727
728
729
        messages = list(dj_messages.get_messages(response.wsgi_request))
        msg_text = messages[0].message

730
        self.assertIn("Title", msg_text)
731
732

    def test_upload_excel_upload_file_author_error(self):
733
        self.client.login(email="kontributor@gov.id", password="kontributor")
734
735

        field_lengths = {
736
737
            "title": 50,
            "publisher": 30,
738
739
740
        }
        file_name, data_frame = self.create_dummy_excel(field_lengths=field_lengths)

741
742
743
        with open(file_name, "rb") as fp:
            response = self.client.post("/unggah_excel/", {"excel": fp})

744
745
746
        messages = list(dj_messages.get_messages(response.wsgi_request))
        msg_text = messages[0].message

747
        self.assertIn("Author", msg_text)
748
749

    def test_upload_excel_upload_file_publisher_error(self):
750
        self.client.login(email="kontributor@gov.id", password="kontributor")
751
752

        field_lengths = {
753
754
            "title": 50,
            "author": 30,
755
756
757
        }
        file_name, data_frame = self.create_dummy_excel(field_lengths=field_lengths)

758
759
760
        with open(file_name, "rb") as fp:
            response = self.client.post("/unggah_excel/", {"excel": fp})

761
762
763
        messages = list(dj_messages.get_messages(response.wsgi_request))
        msg_text = messages[0].message

764
        self.assertIn("Publisher", msg_text)
765
766

    def test_upload_excel_upload_file_categories_error(self):
767
        self.client.login(email="kontributor@gov.id", password="kontributor")
768
769

        field_lengths = {
770
771
772
            "title": 50,
            "author": 30,
            "publisher": 30,
773
774
775
        }
        file_name, data_frame = self.create_dummy_excel(field_lengths=field_lengths)

776
777
778
        with open(file_name, "rb") as fp:
            response = self.client.post("/unggah_excel/", {"excel": fp})

779
780
781
        messages = list(dj_messages.get_messages(response.wsgi_request))
        msg_text = messages[0].message

782
        self.assertIn("Kategori", msg_text)
783
784

    def test_upload_excel_upload_file_success(self):
785
        self.client.login(email="kontributor@gov.id", password="kontributor")
786

787
788
789
        Category(name="Computer Science").save()
        Category(name="Machine Learning").save()
        Category(name="Deep Learning").save()
790
791

        field_lengths = {
792
793
794
            "title": 50,
            "author": 30,
            "publisher": 30,
795
796
        }

797
798
        categories = ["Computer Science", "Machine Learning", "Deep Learning"]

799
800
        file_name, data_frame = self.create_dummy_excel(field_lengths=field_lengths, categories=categories)

801
802
803
804
        with open(file_name, "rb") as fp:
            response = self.client.post("/unggah_excel/", {"excel": fp})

        title = data_frame["Title"][0]
805
806
807
        self.assertTrue(Materi.objects.get(title=title))

    def test_upload_excel_download_template(self):
808
        self.client.login(email="kontributor@gov.id", password="kontributor")
809
810
811

        response = self.client.get("/unggah_excel/?template=1")

812
813
814
815
        self.assertEquals(
            response["Content-Type"], "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
        )
        self.assertEquals(response["Content-Disposition"], "attachment; filename=template.xlsx")
816
817


818
819
820
class DashboardKontributorViewTest(TestCase):
    def setUp(self):
        self.client = Client()
821
822
        self.kontributor = User.objects.create_contributor(email="kontributor@gov.id", password="kontributor")
        self.admin = User.objects.create_admin(email="admin@gov.id", password="admin")
823
824
825
826
827
828
829
830
831
832
        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
833
        self.client.login(email="kontributor@gov.id", password="kontributor")
834
835
836
837
838
839
840
841
        # Test
        response = self.client.get(self.url)
        self.assertTemplateUsed(response, self.template_name)
        # Logout
        self.client.logout()

    def test_dashboard_kontributor_url(self):
        # Login
842
        self.client.login(email="kontributor@gov.id", password="kontributor")
843
844
845
846
847
848
849
850
851
        # 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
852
        self.client.login(email="kontributor@gov.id", password="kontributor")
853
854
855
856
857
858
859
860
        # Test
        response = self.client.get(self.url)
        self.assertEqual(response.status_code, 200)
        # Logout
        self.client.logout()

        # Admin
        # Login
861
        self.client.login(email="admin@gov.id", password="admin")
862
863
864
        # Test
        response = self.client.get(self.url)
        self.assertEqual(response.status_code, 403)
865
866
867

        html = response.content.decode("utf-8")
        self.assertIn(ERROR_403_MESSAGE, html)
868
869
        # Logout
        self.client.logout()
870

871
872
873
874
        # Anonim
        # Test
        response = self.client.get(self.url)
        self.assertEqual(response.status_code, 403)
875

876
877
        html = response.content.decode("utf-8")
        self.assertIn(ERROR_403_MESSAGE, html)
878

879

880
881
882
class ProfilAdminTest(TestCase):
    def setUp(self):
        self.client = Client()
883
884
        self.kontributor = User.objects.create_contributor(email="kontributor@gov.id", password="kontributor")
        self.admin = User.objects.create_admin(email="admin@gov.id", password="admin")
885
886
887
888
889
890
891
892
893
894
        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
895
        self.client.login(email="admin@gov.id", password="admin")
896
897
898
899
900
901
902
903
904
905
906
        # 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)

907
        self.client.login(email="admin@gov.id", password="admin")
908
909
910
911
912
        # Test
        response = self.client.get(self.url)
        self.assertEqual(response.status_code, 200)
        # Logout
        self.client.logout()
913

914

915
916
917
class ProfilKontributorTest(TestCase):
    def setUp(self):
        self.client = Client()
918
919
        self.kontributor = User.objects.create_contributor(email="kontributor@gov.id", password="kontributor")
        self.admin = User.objects.create_admin(email="admin@gov.id", password="admin")
920
921
922
        self.url = "/profil/"
        self.view = ProfilKontributorView
        self.template_name = "profil.html"
923

924
925
926
927
928
929
    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
930
        self.client.login(email="kontributor@gov.id", password="kontributor")
931
932
933
934
935
936
937
938
        # Test
        response = self.client.get(self.url)
        self.assertTemplateUsed(response, self.template_name)
        # Logout
        self.client.logout()

    def test_profil_kontributor_url(self):
        # Login
939
        self.client.login(email="kontributor@gov.id", password="kontributor")
940
941
942
943
944
945
946
947
948
        # 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
949
        self.client.login(email="kontributor@gov.id", password="kontributor")
950
951
952
953
954
955
956
957
        # Test
        response = self.client.get(self.url)
        self.assertEqual(response.status_code, 200)
        # Logout
        self.client.logout()

        # Admin
        # Login
958
        self.client.login(email="admin@gov.id", password="admin")
959
960
961
        # Test
        response = self.client.get(self.url)
        self.assertEqual(response.status_code, 403)
962
963
964

        html = response.content.decode("utf-8")
        self.assertIn(ERROR_403_MESSAGE, html)
965
966
        # Logout
        self.client.logout()
967

968
969
970
971
        # Anonim
        # Test
        response = self.client.get(self.url)
        self.assertEqual(response.status_code, 403)
972

973
974
975
        html = response.content.decode("utf-8")
        self.assertIn(ERROR_403_MESSAGE, html)

976

977
978
979
class SuntingProfilTest(TestCase):
    def setUp(self):
        self.client = Client()
980
981
        self.kontributor = User.objects.create_contributor(email="kontributor@gov.id", password="kontributor")
        self.admin = User.objects.create_admin(email="admin@gov.id", password="admin")
982
983
984
        self.url = "/sunting/"
        self.view = SuntingProfilView
        self.template_name = "sunting.html"
985

986
987
988
989
990
991
    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
992
        self.client.login(email="kontributor@gov.id", password="kontributor")
993
994
995
996
997
998
999
1000
        # Test
        response = self.client.get(self.url)
        self.assertTemplateUsed(response, self.template_name)
        # Logout
        self.client.logout()

    def test_sunting_profile_url(self):
        # Login
For faster browsing, not all history is shown. View entire blame