Fakultas Ilmu Komputer UI

tests.py 116 KB
Newer Older
1001
1002
1003
        with open(file_name, 'rb') as fp:
            response = self.client.post("/unggah_excel/", {'excel': fp})
        
1004
1005
1006
        messages = list(dj_messages.get_messages(response.wsgi_request))
        msg_text = messages[0].message

1007
        self.assertIn('Kategori', msg_text)
1008
1009

    def test_upload_excel_upload_file_success(self):
1010
1011
        self.client.login(email="kontributor@gov.id",
                          password="kontributor")
1012

1013
1014
1015
        Category(name='Computer Science').save()
        Category(name='Machine Learning').save()
        Category(name='Deep Learning').save()
1016
1017

        field_lengths = {
1018
1019
1020
            'title':50,
            'author':30,
            'publisher':30,
1021
1022
        }

1023
1024
        categories = ['Computer Science','Machine Learning','Deep Learning']
        
1025
1026
        file_name, data_frame = self.create_dummy_excel(field_lengths=field_lengths, categories=categories)

1027
1028
1029
1030
        with open(file_name, 'rb') as fp:
            response = self.client.post("/unggah_excel/", {'excel': fp})
        
        title = data_frame['Title'][0]
1031
1032
1033
        self.assertTrue(Materi.objects.get(title=title))

    def test_upload_excel_download_template(self):
1034
1035
        self.client.login(email="kontributor@gov.id",
                          password="kontributor")
1036
1037

        response = self.client.get("/unggah_excel/?template=1")
1038
1039
1040
        
        self.assertEquals(response['Content-Type'],'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet')
        self.assertEquals(response['Content-Disposition'],'attachment; filename=template.xlsx')
1041
1042
1043



1044
1045
1046
class DashboardKontributorViewTest(TestCase):
    def setUp(self):
        self.client = Client()
1047
1048
1049
1050
        self.kontributor = User.objects.create_contributor(email="kontributor@gov.id",
                                                           password="kontributor")
        self.admin = User.objects.create_admin(email="admin@gov.id",
                                               password="admin")
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
        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
1061
1062
        self.client.login(email="kontributor@gov.id",
                          password="kontributor")
1063
1064
1065
1066
1067
1068
1069
1070
        # Test
        response = self.client.get(self.url)
        self.assertTemplateUsed(response, self.template_name)
        # Logout
        self.client.logout()

    def test_dashboard_kontributor_url(self):
        # Login
1071
1072
        self.client.login(email="kontributor@gov.id",
                          password="kontributor")
1073
1074
1075
1076
1077
1078
1079
1080
1081
        # 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
1082
1083
        self.client.login(email="kontributor@gov.id",
                          password="kontributor")
1084
1085
1086
1087
1088
1089
1090
1091
        # Test
        response = self.client.get(self.url)
        self.assertEqual(response.status_code, 200)
        # Logout
        self.client.logout()

        # Admin
        # Login
1092
1093
        self.client.login(email="admin@gov.id",
                          password="admin")
1094
1095
1096
        # Test
        response = self.client.get(self.url)
        self.assertEqual(response.status_code, 403)
1097
1098
1099

        html = response.content.decode("utf-8")
        self.assertIn(ERROR_403_MESSAGE, html)
1100
1101
        # Logout
        self.client.logout()
1102

1103
1104
1105
1106
        # Anonim
        # Test
        response = self.client.get(self.url)
        self.assertEqual(response.status_code, 403)
1107

1108
1109
        html = response.content.decode("utf-8")
        self.assertIn(ERROR_403_MESSAGE, html)
1110

Selvy Fitriani's avatar
Selvy Fitriani committed
1111
1112
1113
class DeleteMateriTest(TestCase):
    def setUp(self):
        self.client = Client()
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
        self.admin_credential = {
            "email": "admin@gov.id",
            "password": id_generator()
        }
        self.superuser_credential = {
            "email": "superuser@gov.id",
            "password": id_generator()
        }
        self.contributor_credential = {
            "email": "contributor@gov.id",
            "password": id_generator()
        }

        self.admin = get_user_model().objects.create_user(
            **self.admin_credential, name="Admin", is_admin=True)
        self.superuser = get_user_model().objects.create_user(
            **self.superuser_credential, name="Superuser", is_admin=True, is_superuser=True)

Selvy Fitriani's avatar
Selvy Fitriani committed
1132
1133
1134
1135
        self.content = SimpleUploadedFile(
            "content.txt", b"Test")
        self.cover = SimpleUploadedFile(
            "flower.jpg", b"Test file")
1136
        self.contributor = User.objects.create_contributor(**self.contributor_credential)
Selvy Fitriani's avatar
Selvy Fitriani committed
1137
1138
1139
1140
1141
1142
        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()
        self.materi1 = Materi.objects.first()
        self.url = "/materi/" + str(self.materi1.id) + "/delete"

1143
1144
1145
1146
1147
1148
1149
    def test_url_delete_materi_is_success_as_contributor(self):
        self.client.login(**self.contributor_credential)
        response = self.client.get(self.url)
        self.assertEqual(response.status_code, 302)
    
    def test_url_soft_delete_materi_is_success_as_admin(self):
        self.client.login(**self.admin_credential)
Selvy Fitriani's avatar
Selvy Fitriani committed
1150
1151
        response = self.client.get(self.url)
        self.assertEqual(response.status_code, 302) 
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
        self.materi1.refresh_from_db()
        self.assertNotEqual(self.materi1.deleted_at, None)
    
    def test_url_soft_delete_materi_is_success_as_superuser(self):
        self.client.login(**self.superuser_credential)
        response = self.client.get(self.url)
        self.assertEqual(response.status_code, 302)
        self.materi1.refresh_from_db()
        self.assertNotEqual(self.materi1.deleted_at, None)

1162
1163
1164
1165
1166
1167
1168
class ProfilViewTest(TestCase):
    @classmethod
    def setUpTestData(cls):
        cls.client = Client()
        cls.url = "/profil/"
        cls.template_name = "profil.html"
        cls.view = ProfilView
1169

1170
1171
        cls.contributor_credentials = {"email": "contributor@gov.id", "password": "justpass"}
        cls.contributor = User.objects.create_contributor(**cls.contributor_credentials)
1172

1173
1174
        cls.admin_credentials = {"email": "admin@gov.id", "password": "justpass"}
        cls.admin = User.objects.create_admin(**cls.admin_credentials)
1175

1176
    def test_returns_correct_profile_view(self):
1177
1178
1179
        found = resolve(self.url)
        self.assertEqual(found.func.__name__, self.view.as_view().__name__)

1180
1181
1182
1183
1184
1185
1186
    def _request_as_user(self, credentials):
        self.client = Client() 
        self.client.login(**credentials)
        return self.client.get(self.url)

    def test_returns_correct_template(self):
        response = self._request_as_user(self.contributor_credentials)
1187
1188
        self.assertTemplateUsed(response, self.template_name)

1189
1190
1191
    def test_unauthenticated_access_blocked(self):
        response = self._request_as_user({})
        self.assertEqual(response.status_code, 403)
1192

1193
1194
    def test_authorized_access_success(self):
        response = self._request_as_user(self.contributor_credentials)
1195
        self.assertEqual(response.status_code, 200)
1196
        self.assertIn("Profil Kontributor", response.content.decode())
1197

1198
1199
1200
        response = self._request_as_user(self.admin_credentials)
        self.assertEqual(response.status_code, 200)
        self.assertIn("Profil Admin", response.content.decode())
1201

1202

1203
class SuntingProfilViewTest(TestCase):
1204

1205
1206
1207
1208
1209
1210
    @classmethod
    def setUpTestData(cls):
        cls.client = Client()
        cls.url = "/sunting/"
        cls.template_name = "sunting.html"
        cls.view = SuntingProfilView
1211

1212
1213
        cls.contributor_credentials = {"email": "contributor@gov.id", "password": "justpass"}
        cls.contributor = User.objects.create_contributor(**cls.contributor_credentials)
1214

1215
1216
        cls.admin_credentials = {"email": "admin@gov.id", "password": "justpass"}
        cls.admin = User.objects.create_admin(**cls.admin_credentials)
1217

1218
1219
1220
1221
    def test_sunting_profile_view(self):
        found = resolve(self.url)
        self.assertEqual(found.func.__name__, self.view.as_view().__name__)

1222
1223
1224
1225
1226
1227
1228
    def _request_as_user(self, credentials):
        self.client = Client() 
        self.client.login(**credentials)
        return self.client.get(self.url)

    def test_returns_correct_template(self):
        self.client.login(**self.contributor_credentials)
1229
1230
1231
        response = self.client.get(self.url)
        self.assertTemplateUsed(response, self.template_name)

1232
1233
1234
    def test_unauthenticated_access_blocked(self):
        response = self._request_as_user({})
        self.assertEqual(response.status_code, 403)
1235

1236
1237
    def test_authorized_access_success(self):
        response = self._request_as_user(self.contributor_credentials)
1238
        self.assertEqual(response.status_code, 200)
1239
        self.assertIn("Sunting Profil Kontributor", response.content.decode())
1240

1241
1242
1243
        response = self._request_as_user(self.admin_credentials)
        self.assertEqual(response.status_code, 200)
        self.assertIn("Sunting Profil Admin", response.content.decode())
1244
1245
1246
1247
1248
1249
1250
1251
1252
1253

    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",
1254
            "instagram": "https://instagram.com/test_ig"
1255
1256
1257
1258
1259
1260
1261
        }
        form = SuntingProfilForm(data=form_data)

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


1262
1263
1264
class SuksesLoginKontributorTest(TestCase):
    def setUp(self):
        self.client = Client()
1265
1266
1267
1268
        self.kontributor = User.objects.create_contributor(email="kontributor@gov.id",
                                                           password="kontributor")
        self.admin = User.objects.create_admin(email="admin@gov.id",
                                               password="admin")
1269
1270
1271
        self.url = "/sukses-kontributor/"
        self.view = SuksesLoginKontributorView
        self.template_name = "sukses_kontri.html"
1272

1273
1274
1275
1276
1277
1278
    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
1279
1280
        self.client.login(email="kontributor@gov.id",
                          password="kontributor")
1281
1282
1283
1284
1285
1286
1287
1288
        # 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
1289
1290
        self.client.login(email="kontributor@gov.id",
                          password="kontributor")
1291
1292
1293
1294
1295
1296
1297
1298
1299
        # 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
1300
1301
        self.client.login(email="kontributor@gov.id",
                          password="kontributor")
1302
1303
1304
1305
1306
1307
        # Test
        response = self.client.get(self.url)
        self.assertEqual(response.status_code, 200)
        # Logout
        self.client.logout()

1308

1309
1310
1311
class SuksesLoginAdminTest(TestCase):
    def setUp(self):
        self.client = Client()
1312
1313
1314
1315
        self.kontributor = User.objects.create_contributor(email="kontributor@gov.id",
                                                           password="kontributor")
        self.admin = User.objects.create_admin(email="admin@gov.id",
                                               password="admin")
1316
1317
1318
        self.url = "/sukses-admin/"
        self.view = SuksesLoginAdminView
        self.template_name = "sukses_admin.html"
1319

1320
1321
1322
1323
1324
1325
    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
1326
1327
        self.client.login(email="admin@gov.id",
                          password="admin")
1328
1329
1330
1331
1332
1333
1334
1335
        # 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
1336
1337
        self.client.login(email="admin@gov.id",
                          password="admin")
1338
1339
1340
1341
1342
1343
1344
1345
1346
        # 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
1347
1348
        self.client.login(email="admin@gov.id",
                          password="admin")
1349
1350
1351
1352
1353
        # Test
        response = self.client.get(self.url)
        self.assertEqual(response.status_code, 200)
        # Logout
        self.client.logout()
1354
1355
1356
1357


class LikeMateriTest(TestCase):
    def setUp(self):
1358
1359
1360
1361
        self.contributor_credential = {
            "email": "kontributor@gov.id",
            "password": id_generator()
        }
1362
1363
1364
1365
        self.contributor = get_user_model().objects.create_user(
            **self.contributor_credential, name="Kontributor", is_contributor=True
        )
        self.client = Client()
1366
        self.url_like = '/materi/like/'
1367
        content = b"Test file"
1368
1369
1370
1371
1372
1373
1374
1375
1376
1377
1378
        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()
1379
        self.materi1 = Materi.objects.first()
1380
        self.url_materi = f'/materi/{self.materi1.id}/'
1381
1382
1383
1384
1385
1386
1387
1388

    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
1389
        num_of_likes = Like.objects.filter(materi=self.materi1).count()
1390
1391
        self.assertEqual(num_of_likes, 0)

1392
        # Like a materi
1393
1394
1395
        response = self.client.get(self.url_materi)
        session_id = response.context["session_id"]
        materi_id = response.context["materi_data"].id
1396
1397
1398
1399
        payload = {
            'materi_id': materi_id,
            'session_id': session_id
        }
1400
        ajax_response = Client().post(self.url_like, payload)
1401
        num_of_likes = Like.objects.filter(materi=self.materi1).count()
1402
1403
1404
1405
        self.assertEqual(num_of_likes, 1)

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

1409
        # Like a materi
1410
1411
1412
        response = self.client.get(self.url_materi)
        session_id = response.context["session_id"]
        materi_id = response.context["materi_data"].id
1413
1414
1415
1416
        payload = {
            'materi_id': materi_id,
            'session_id': session_id
        }
1417
        ajax_response = Client().post(self.url_like, payload)
1418
        num_of_likes = Like.objects.filter(materi=self.materi1).count()
1419
1420
        self.assertEqual(num_of_likes, 1)

1421
        # Unlike a materi
1422
1423
1424
        response = self.client.get(self.url_materi)
        session_id = response.context["session_id"]
        materi_id = response.context["materi_data"].id
1425
1426
1427
1428
        payload = {
            'materi_id': materi_id,
            'session_id': session_id
        }
1429
        ajax_response = Client().post(self.url_like, payload)
1430
        num_of_likes = Like.objects.filter(materi=self.materi1).count()
1431
1432
1433
1434
        self.assertEqual(num_of_likes, 0)

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

1438
        # Client 1 like a materi
1439
1440
1441
        response = self.client.get(self.url_materi)
        session_id = response.context["session_id"]
        materi_id = response.context["materi_data"].id
1442
1443
1444
1445
        payload = {
            'materi_id': materi_id,
            'session_id': session_id
        }
1446
        ajax_response = Client().post(self.url_like, payload)
1447
        num_of_likes = Like.objects.filter(materi=self.materi1).count()
1448
1449
        self.assertEqual(num_of_likes, 1)

1450
        # Client 2 like a materi
1451
1452
1453
        response = Client().get(self.url_materi)
        session_id = response.context["session_id"]
        materi_id = response.context["materi_data"].id
1454
1455
1456
1457
        payload = {
            'materi_id': materi_id,
            'session_id': session_id
        }
1458
        ajax_response = Client().post(self.url_like, payload)
1459
        num_of_likes = Like.objects.filter(materi=self.materi1).count()
1460
1461
1462
1463
        self.assertEqual(num_of_likes, 2)

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

1467
        # missing session id
1468
1469
1470
        response = self.client.get(self.url_materi)
        materi_id = response.context["materi_data"].id
        payload = {
1471
            'materi_id': materi_id,
1472
1473
        }
        ajax_response = Client().post(self.url_like, payload)
1474
        ajax_response = json.loads(ajax_response.content)
1475
        num_of_likes = Like.objects.filter(materi=self.materi1).count()
1476
1477
        self.assertEqual(num_of_likes, 0)
        self.assertEqual(ajax_response.get("success", None), False)
1478
1479

        # missing materi id
1480
1481
        response = self.client.get(self.url_materi)
        session_id = response.context["session_id"]
1482
1483
1484
        payload = {
            'session_id': session_id
        }
1485
        ajax_response = Client().post(self.url_like, payload)
1486
        ajax_response = json.loads(ajax_response.content)
1487
        num_of_likes = Like.objects.filter(materi=self.materi1).count()
1488
1489
1490
1491
1492
1493
        self.assertEqual(num_of_likes, 0)
        self.assertEqual(ajax_response.get("success", None), False)


class ViewMateriStatissticsTest(TestCase):
    def setUp(self):
1494
1495
1496
1497
        self.contributor_credential = {
            "email": "kontributor@gov.id",
            "password": id_generator()
        }
1498
1499
1500
1501
1502
        self.contributor = get_user_model().objects.create_user(
            **self.contributor_credential, name="Kontributor", is_contributor=True
        )
        self.client = Client()
        content = b"Test file"
1503
1504
1505
1506
1507
1508
1509
1510
1511
1512
1513
        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()
1514
1515
1516
        self.materi1 = Materi.objects.first()
        self.url = f"/materi/{self.materi1.id}/view"

1517
    # Test single view
1518
1519
1520
1521
1522
1523
1524
1525
1526
1527
1528
1529
1530
1531
1532
    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)

1533

1534
1535
class DownloadMateriStatissticsTest(TestCase):
    def setUp(self):
1536
1537
1538
1539
        self.contributor_credential = {
            "email": "kontributor@gov.id",
            "password": id_generator()
        }
1540
1541
1542
1543
1544
        self.contributor = get_user_model().objects.create_user(
            **self.contributor_credential, name="Kontributor", is_contributor=True
        )
        self.client = Client()
        content = b"Test file"
1545
1546
1547
1548
1549
1550
1551
1552
1553
1554
1555
        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()
1556
1557
1558
        self.materi1 = Materi.objects.first()
        self.url = f"/materi/{self.materi1.id}/unduh"

1559
    # Test single download
1560
1561
1562
1563
1564
1565
1566
1567
1568
1569
1570
1571
1572
    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()
1573
1574
        self.assertEqual(num_of_downloads, 2)

1575

1576
1577
1578
1579
1580
1581
class RevisiMateriTest(TestCase):
    def setUp(self):
        self.client = Client()
        self.view = RevisiMateriView
        self.template_name = "revisi.html"

1582
1583
1584
1585
        self.contributor_credential = {
            "email": "kontributor@gov.id",
            "password": id_generator()
        }
1586
1587
1588
        self.contributor = get_user_model().objects.create_user(
            **self.contributor_credential, name="Kontributor", is_contributor=True
        )
1589
1590
1591
1592
1593
1594
1595
1596
1597
1598
1599
        self.cover = SimpleUploadedFile(
            "cover.jpg",
            b"Test file"
        )
        self.content = SimpleUploadedFile(
            "content.txt",
            b"Test file"
        )
        Materi(title="Materi 1", author="Agas", uploader=self.contributor,
               publisher="Kelas SC", descriptions="Deskripsi Materi 1",
               status="REVISION", cover=self.cover, content=self.content).save()
1600
1601
1602
1603
1604
1605
1606
1607
1608
1609
1610
1611
1612
1613
1614
1615
1616
1617
1618
1619
1620
1621
1622
1623
1624
1625
1626
1627
1628
1629
1630
1631
1632
1633

        self.materi1 = Materi.objects.first()
        self.url = "/revisi/materi/" + str(self.materi1.id) + "/"

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

    def test_revisi_materi_template(self):
        # Login
        self.client.login(**self.contributor_credential)
        # Test
        response = self.client.get(self.url)
        self.assertTemplateUsed(response, self.template_name)
        # Logout
        self.client.logout()

    def test_revisi_materi_url(self):
        # Login
        self.client.login(**self.contributor_credential)
        # Test
        response = self.client.get(self.url)
        self.assertEqual(response.status_code, 200)
        # Logout
        self.client.logout()

    def test_revisi_materi_access(self):
        # Kontributor
        # Login
        self.client.login(**self.contributor_credential)
        # Test
        response = self.client.get(self.url)
        self.assertEqual(response.status_code, 200)
        # Logout
1634
        self.client.logout()
1635
    
1636
class GenerateDummyCommandTest(TestCase):
1637

1638
1639
1640
1641
1642
1643
1644
1645
    def setUp(self):
        self.material_numbers = [5, 10, 25, 100]
        self.invalid_material_numbers = [-100, -10, -1, 0, 1, 2, 3, 4]
        self.stdout = StringIO()

    def test_command_output_with_given_num_of_materi(self):
        for num_of_materi in self.material_numbers:
            call_command("generatedummy", num_of_materi, stdout=self.stdout)
1646
1647
1648
1649
            self.assertIn(
                f"Successfully created {num_of_materi} materi",
                self.stdout.getvalue()
            )
1650
1651
1652
1653
1654
1655
1656
1657
1658
1659
1660
1661
1662
1663

    def test_command_should_generate_materi_objects(self):
        for num_of_materi in self.material_numbers:
            call_command("generatedummy", num_of_materi, stdout=self.stdout)
            self.assertEqual(Materi.objects.count(), num_of_materi)
            Materi.objects.all().delete()

    def test_command_should_raise_exception_if_invalid_values_are_given(self):
        with self.assertRaises(IndexError):
            for num_of_materi in self.invalid_material_numbers:
                call_command("generatedummy", num_of_materi)


class RemoveDummyCommandTest(TestCase):
1664

1665
1666
1667
1668
1669
1670
    def test_calling_remove_dummy_command_should_remove_generated_dummy_objects(self):
        stdout = StringIO()
        call_command("generatedummy", 50)

        call_command("removedummy", stdout=stdout)

Steven Kusuman's avatar
Steven Kusuman committed
1671
        self.assertIn("Successfully remove all dummy object", stdout.getvalue())
1672
1673
1674
1675
1676
1677
1678
1679
1680
        self.assertEqual(User.objects.count(), 0)
        self.assertEqual(Category.objects.count(), 0)
        self.assertEqual(Materi.objects.count(), 0)
        self.assertEqual(VerificationSetting.objects.count(), 0)
        self.assertEqual(VerificationReport.objects.count(), 0)


class RatingMateriTest(TestCase):
    def setUp(self):
1681
1682
1683
1684
1685
1686
1687
1688
1689
1690
1691
1692
        self.contributor_credential = {
            "email": "kontributor@gov.id",
            "password": id_generator()
        }
        self.user_one_credential = {
            "email": "user_one@user.id",
            "password": id_generator()
        }
        self.user_two_credential = {
            "email": "user_two@user.id",
            "password": id_generator()
        }
1693
1694
1695
1696
1697
        self.contributor = get_user_model().objects.create_user(
            **self.contributor_credential, name="Kontributor", is_contributor=True
        )
        self.user_one = get_user_model().objects.create_user(**self.user_one_credential, name="User One")
        self.user_two = get_user_model().objects.create_user(**self.user_two_credential, name="User Two")
1698
1699
1700
1701
1702
1703
1704
1705
1706
1707
1708
1709
1710
1711
        self.cover = SimpleUploadedFile(
            "cover.jpg",
            b"Test file"
        )
        self.content = SimpleUploadedFile(
            "content.txt",
            b"Test file"
        )
        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()
        Materi(title="Materi Dua", author="Author", uploader=self.contributor,
               publisher="Publisher", descriptions="Deskripsi Materi Dua",
               status="APPROVE", cover=self.cover, content=self.content).save()
1712
1713
        self.materi1 = Materi.objects.all()[0]
        self.materi2 = Materi.objects.all()[1]
1714
1715
        self.url_rate = '/materi/rate/'
        self.url_materi = '/materi/{}/'.format(self.materi1.id)
1716
1717
1718
1719
1720
1721
1722
1723
1724
1725
1726
1727

    def test_rating_model_can_be_created_with_proper_parameter(self):
        Rating(materi=self.materi1, user=self.user_one, score=5).save()
        rating = Rating.objects.first()
        self.assertEqual(rating.materi, self.materi1)
        self.assertEqual(rating.user, self.user_one)
        self.assertTrue(0 < rating.score < 6)
        self.assertEqual(rating.__str__(), "Material:Materi 1 | User:User One | Rating:5")

    def test_rating_model_should_not_be_created_with_rating_more_than_5(self):
        with self.assertRaises(ValidationError) as context:
            Rating(materi=self.materi1, user=self.user_one, score=6).save()
1728
        self.assertTrue('Rating score must be integer between 1-5' in str(context.exception))
1729
1730
1731
1732

    def test_rating_model_should_not_be_created_with_rating_less_than_1(self):
        with self.assertRaises(ValidationError) as context:
            Rating(materi=self.materi1, user=self.user_one, score=0).save()
1733
        self.assertTrue('Rating score must be integer between 1-5' in str(context.exception))
1734
1735
1736
1737
1738
1739
1740
1741
1742
1743
1744
1745
1746
1747
1748
1749
1750
1751
1752
1753
1754
1755
1756
1757
1758

    def test_one_materi_should_be_able_to_be_related_to_multiple_rating(self):
        Rating(materi=self.materi1, user=self.user_one, score=1).save()
        Rating(materi=self.materi1, user=self.user_two, score=2).save()
        rating_one = Rating.objects.get(user=self.user_one)
        rating_two = Rating.objects.get(user=self.user_two)
        self.assertEqual(rating_one.materi, self.materi1)
        self.assertEqual(rating_two.materi, self.materi1)
        self.assertEqual(rating_one.user, self.user_one)
        self.assertEqual(rating_two.user, self.user_two)

    def test_one_user_should_be_able_to_be_related_to_two_rating(self):
        Rating(materi=self.materi1, user=self.user_one, score=3).save()
        Rating(materi=self.materi2, user=self.user_one, score=3).save()
        rating_one = Rating.objects.filter(materi=self.materi1).first()
        rating_two = Rating.objects.filter(materi=self.materi2).first()
        self.assertEqual(rating_one.materi, self.materi1)
        self.assertEqual(rating_two.materi, self.materi2)
        self.assertEqual(rating_one.user, self.user_one)
        self.assertEqual(rating_two.user, self.user_one)

    def test_two_rating_should_not_have_same_user_and_materi(self):
        with self.assertRaises(IntegrityError) as context:
            Rating(materi=self.materi1, user=self.user_one, score=1).save()
            Rating(materi=self.materi1, user=self.user_one, score=2).save()
1759
        self.assertTrue('already exists' in str(context.exception))
1760
1761
1762
1763
1764
1765
1766
1767
1768
1769
1770
1771

    def test_materi_in_rating_should_not_be_null(self):
        with self.assertRaises(IntegrityError):
            Rating(user=self.user_one, score=1).save()

    def test_user_in_rating_should_not_be_null(self):
        with self.assertRaises(IntegrityError):
            Rating(materi=self.materi1, score=1).save()

    def test_score_in_rating_should_not_be_null(self):
        with self.assertRaises(TypeError):
            Rating(materi=self.materi1, user=self.user_one).save()
1772

1773
1774
1775
1776
1777
1778
1779
1780
1781
1782
1783
1784
    def test_rating_materi_url_use_add_rating_materi_function(self):
        found = resolve(self.url_rate)
        self.assertEqual(found.func, add_rating_materi)

    def test_rating_materi_get_method_should_return_403_forbidden(self):
        response = self.client.get(self.url_rate)
        response_json = json.loads(response.content)
        self.assertEqual(response_json.get("success", None), False)
        self.assertEqual(response_json.get("msg", None), "Forbidden")
        self.assertEqual(response.status_code, 403)

    def test_rating_materi_post_not_authenticated_should_return_403_forbidden(self):
1785
        response = self.client.post(self.url_rate, {'materi_id': 1, 'rating_score': 5})
1786
1787
1788
1789
1790
1791
        response_json = json.loads(response.content)
        self.assertEqual(response_json.get("success", None), False)
        self.assertEqual(response_json.get("msg", None), "Forbidden")
        self.assertEqual(response.status_code, 403)

    def test_rating_materi_not_authenticated_post_wrong_param_should_return_403_forbidden(self):
1792
        for data in [{}, {'materi_id': 1}, {'rating_score': 1}, {'rating_score': 'STRING', 'materi_id': 'STRING'}]:
1793
1794
1795
1796
1797
1798
1799
1800
            response = self.client.post(self.url_rate, data)
            response_json = json.loads(response.content)
            self.assertEqual(response_json.get("success", None), False)
            self.assertEqual(response_json.get("msg", None), "Forbidden")
            self.assertEqual(response.status_code, 403)

    def test_rating_materi_authenticated_post_missing_param(self):
        self.client.login(**self.user_one_credential)
1801
        for data in [{'rating_score': 1}, {'materi_id': 1}, {}]:
1802
1803
1804
1805
1806
1807
1808
1809
            response = self.client.post(self.url_rate, data)
            response_json = json.loads(response.content)
            self.assertEqual(response_json.get("success", None), False)
            self.assertEqual(response_json.get("msg", None), "Missing param")
            self.assertEqual(response.status_code, 422)

    def test_rating_materi_authenticated_materi_id_doesnt_exist_should_return_422(self):
        self.client.login(**self.user_one_credential)
1810
        response = self.client.post(self.url_rate, {'materi_id': 123456, 'rating_score': 5})
1811
1812
1813
1814
1815
1816
1817
        response_json = json.loads(response.content)
        self.assertEqual(response_json.get("success", None), False)
        self.assertEqual(response_json.get("msg", None), "Materi does not exist")
        self.assertEqual(response.status_code, 422)

    def test_rating_materi_authenticated_param_wrong_data_type_should_return_422(self):
        self.client.login(**self.user_one_credential)
1818
        response = self.client.post(self.url_rate, {'materi_id': "STRING", 'rating_score': 5})
1819
1820
1821
1822
1823
        response_json = json.loads(response.content)
        self.assertEqual(response_json.get("success", None), False)
        self.assertEqual(response_json.get("msg", None), "materi_id must be an integer")
        self.assertEqual(response.status_code, 422)

1824
        response = self.client.post(self.url_rate, {'materi_id': 1, 'rating_score': "STRING"})
1825
1826
1827
1828
1829
1830
1831
1832
1833
        response_json = json.loads(response.content)
        self.assertEqual(response_json.get("success", None), False)
        self.assertEqual(response_json.get("msg", None), "rating_score must be an integer")
        self.assertEqual(response.status_code, 422)

    def test_rating_score_should_be_between_1_and_5(self):
        self.client.login(**self.user_one_credential)
        for i in range(1, 6):
            Rating.objects.all().delete()
1834
            response = self.client.post(self.url_rate, {'materi_id': self.materi1.id, 'rating_score': i})
1835
1836
1837
1838
1839
1840
1841
            response_json = json.loads(response.content)
            # self.assertEqual(response_json.get("success", None), True)
            self.assertEqual(response_json.get("msg", None), "Rating successfully created")
            self.assertEqual(response.status_code, 201)

        for i in [-100, -7, -6, -1, 0, 6, 7, 100]:
            Rating.objects.all().delete()
1842
            response = self.client.post(self.url_rate, {'materi_id': self.materi1.id, 'rating_score': i})
1843
1844
1845
1846
1847
1848
1849
1850
            response_json = json.loads(response.content)
            # self.assertEqual(response_json.get("success", None), False)
            self.assertEqual(response_json.get("msg", None), "Rating must be an integer from 1 to 5")
            self.assertEqual(response.status_code, 422)

    def test_user_should_not_able_to_rate_materi_twice(self):
        self.client.login(**self.user_one_credential)
        Rating.objects.all().delete()
1851
1852
        self.client.post(self.url_rate, {'materi_id': self.materi1.id, 'rating_score': 1})
        response = self.client.post(self.url_rate, {'materi_id': self.materi1.id, 'rating_score': 2})
1853
1854
1855
1856
1857
1858
1859
1860
        response_json = json.loads(response.content)
        # self.assertEqual(response_json.get("success", None), False)
        self.assertEqual(response_json.get("msg", None), "Rating already exist")
        self.assertEqual(response.status_code, 409)

    def test_user_authenticated_visit_unrated_should_get_0_materi_rating_score_context(self):
        self.client.login(**self.user_one_credential)
        response = self.client.get(self.url_materi)
1861
        self.assertEqual(0, response.context.get('materi_rating_score'))
1862
1863
1864

    def test_user_not_authenticated_visit_unrated_should_get_0_materi_rating_score_context(self):
        response = self.client.get(self.url_materi)
1865
        self.assertEqual(0, response.context.get('materi_rating_score'))
1866
1867
1868
1869
1870

    def test_user_authenticated_visit_rated_should_get_correct_materi_rating_score_context(self):
        self.client.login(**self.user_one_credential)
        Rating(materi=self.materi1, user=self.user_one, score=1).save()
        response = self.client.get(self.url_materi)
1871
        self.assertEqual(1, response.context.get('materi_rating_score'))
1872
1873
1874
1875

class fileManagementUtilTest(TestCase):
    def setUp(self):
        self.filename = "image_with_exif_data.gif"
1876
1877
        self.file_content = open(settings.BASE_DIR + "/app/test_files/" +
                self.filename, "rb").read()
1878
1879
1880
1881
1882
1883
1884
1885
1886
1887
1888
1889
1890
1891
1892
1893
1894
1895
1896
1897

    def test_get_random_filename_isCorrect(self):
        generated_name = get_random_filename(self.filename)

        self.assertTrue(generated_name != self.filename)
        # 40 from 36 expected name length + 4 from extension
        self.assertEqual(len(generated_name), 40)
        self.assertTrue(generated_name[-4:] == ".gif")

    def test_remove_image_exifdata_isCorrect(self):
        with tempfile.TemporaryDirectory() as d:
            image_with_exif_data_path = os.path.join(d, self.filename)
            img = open(image_with_exif_data_path, "wb")
            img.write(self.file_content)
            img.close()

            remove_image_exifdata(image_with_exif_data_path)
            sanitized_img = open(image_with_exif_data_path, "rb").read()

            self.assertTrue(len(sanitized_img) < len(self.file_content))
1898
            self.assertTrue(b'<exif:' not in sanitized_img)
Muhamad Lutfi Arif's avatar
Muhamad Lutfi Arif committed
1899
1900
1901
1902

class RequestMateriTest(TestCase):
    def setUp(self):
        self.client = Client()
1903
1904
1905
1906
1907
1908
1909
1910
1911
1912
1913
1914
1915
1916
        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)
Muhamad Lutfi Arif's avatar
Muhamad Lutfi Arif committed
1917
        self.contributor = get_user_model().objects.create_user(
1918
1919
1920
            **self.contributor_credential, name="Kontributor", is_contributor=True)
        self.anonymous = get_user_model().objects.create_user(
            **self.anonymous_credential, name="Anonymous"
Muhamad Lutfi Arif's avatar
Muhamad Lutfi Arif committed
1921
1922
1923
1924
1925
1926
1927
1928
1929
1930
1931
1932
1933
1934
1935
1936
1937
1938
        )
        self.url = "/req-materi/"
        self.template_name = "req_materi.html"

    def test_req_materi_url_resolves_to_get_req_materi_view(self):
        found = resolve(self.url)
        self.assertEqual(found.func.__name__, ReqMateriView.as_view().__name__)

    def test_uses_req_material_template(self):
        self.client.login(**self.contributor_credential)
        response = self.client.get(self.url)
        self.assertTemplateUsed(response, self.template_name)
        self.client.logout()

    def test_redirect_to_login_page_is_not_authenticated(self):
        response = self.client.get(self.url)

        self.assertEqual(response.status_code, 302)
1939
        self.assertEqual(response['location'], '/login/')
Muhamad Lutfi Arif's avatar
Muhamad Lutfi Arif committed
1940
1941
1942
1943
1944
1945
1946
1947
1948
1949

    def test_saving_and_retrieving_material_requests(self):
        first_material_request = ReqMaterial(title="Material 1").save()
        second_material_request = ReqMaterial(title="Material 2").save()
        saved_material_request = ReqMaterial.objects.all()
        self.assertEqual(saved_material_request.count(), 2)

    def test_can_save_a_POST_request_and_return_correct_response_message(self):
        self.client.login(**self.contributor_credential)

1950
1951
1952
1953
        response = self.client.post(self.url,
                         data={
                             'title': 'Requested Material'
                         })
Muhamad Lutfi Arif's avatar
Muhamad Lutfi Arif committed
1954
1955
1956
        self.assertEqual(ReqMaterial.objects.count(), 1)

        new_material_request = ReqMaterial.objects.first()
1957
        self.assertEqual(new_material_request.title, 'Requested Material')
Muhamad Lutfi Arif's avatar
Muhamad Lutfi Arif committed
1958

1959
        self.assertIn('Permintaan materi berhasil dikirimkan', response.content.decode())
Muhamad Lutfi Arif's avatar
Muhamad Lutfi Arif committed
1960
1961
1962
1963
1964
1965
1966
1967
        self.client.logout()

    def test_given_no_title_should_not_save_request_and_return_correct_response_message(self):
        self.client.login(**self.contributor_credential)

        response = self.client.post(self.url)
        self.assertEqual(ReqMaterial.objects.count(), 0)

1968
        self.assertIn('Missing parameter', response.content.decode())
Muhamad Lutfi Arif's avatar
Muhamad Lutfi Arif committed
1969
        self.client.logout()
1970
1971
1972
1973


class RatingContributorTest(TransactionTestCase):
    def setUp(self):
1974
1975
1976
1977
        self.contributor_credential = {
            "email": "kontributor@gov.id",
            "password": id_generator()
        }
1978
1979
1980
1981
1982
1983
1984
1985
1986
1987
1988
1989
1990
1991
1992
1993
1994
1995
1996
1997
1998
1999
2000
        self.contributor = get_user_model().objects.create_user(
            **self.contributor_credential, name="Kontributor", is_contributor=True
        )

    def test_add_rating_contributor(self):
        RatingContributor.objects.create(score=3, user=self.contributor)
        self.assertEqual(1, RatingContributor.objects.count())

    def test_add_rating_contributor_should_failed_when_negative(self):
        with self.assertRaises(ValidationError):
            RatingContributor.objects.create(score=-1, user=self.contributor)
        self.assertEqual(0, RatingContributor.objects.count())

    def test_add_rating_contributor_should_failed_when_bigger_than_five(self):
        with self.assertRaises(ValidationError):
            RatingContributor.objects.create(score=6, user=self.contributor)
        self.assertEqual(0, RatingContributor.objects.count())

    def test_submit_form_correct_rating_contributor_should_added(self):
        url = f"/profil/{self.contributor.email}/"
        self.client.post(url, data={"user": self.contributor.id, "score": 5})
        self.assertEqual(1, RatingContributor.objects.filter(user=self.contributor.id).count())
        self.client.post(url, data={"user": self.contributor.id, "score": 1})
For faster browsing, not all history is shown. View entire blame