Fakultas Ilmu Komputer UI

tests.py 119 KB
Newer Older
1001
        file_path = os.path.join(settings.MEDIA_ROOT, 'dummy.xlsx')
1002

1003
        writer = pd.ExcelWriter(file_path, engine='xlsxwriter') #pylint: disable=abstract-class-instantiated
1004
1005
1006
1007
1008
1009
        data_frame.to_excel(writer, index=0)
        writer.save()

        return file_path, data_frame

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

        field_lengths = {
1014
1015
            'author':30,
            'publisher':30,
1016
1017
1018
        }
        file_name, data_frame = self.create_dummy_excel(field_lengths=field_lengths)

1019
1020
1021
        with open(file_name, 'rb') as fp:
            response = self.client.post("/unggah_excel/", {'excel': fp})
        
1022
1023
1024
        messages = list(dj_messages.get_messages(response.wsgi_request))
        msg_text = messages[0].message

1025
        self.assertIn('Title', msg_text)
1026
1027

    def test_upload_excel_upload_file_author_error(self):
1028
1029
        self.client.login(email="kontributor@gov.id",
                          password="kontributor")
1030
1031

        field_lengths = {
1032
1033
            'title':50,
            'publisher':30,
1034
1035
1036
        }
        file_name, data_frame = self.create_dummy_excel(field_lengths=field_lengths)

1037
1038
1039
        with open(file_name, 'rb') as fp:
            response = self.client.post("/unggah_excel/", {'excel': fp})
        
1040
1041
1042
        messages = list(dj_messages.get_messages(response.wsgi_request))
        msg_text = messages[0].message

1043
1044
        self.assertIn('Author', msg_text)

1045
1046

    def test_upload_excel_upload_file_publisher_error(self):
1047
1048
        self.client.login(email="kontributor@gov.id",
                          password="kontributor")
1049
1050

        field_lengths = {
1051
1052
            'title':50,
            'author':30,
1053
1054
1055
        }
        file_name, data_frame = self.create_dummy_excel(field_lengths=field_lengths)

1056
1057
1058
        with open(file_name, 'rb') as fp:
            response = self.client.post("/unggah_excel/", {'excel': fp})
        
1059
1060
1061
        messages = list(dj_messages.get_messages(response.wsgi_request))
        msg_text = messages[0].message

1062
        self.assertIn('Publisher', msg_text)
1063
1064

    def test_upload_excel_upload_file_categories_error(self):
1065
1066
        self.client.login(email="kontributor@gov.id",
                          password="kontributor")
1067
1068

        field_lengths = {
1069
1070
1071
            'title':50,
            'author':30,
            'publisher':30,
1072
1073
1074
        }
        file_name, data_frame = self.create_dummy_excel(field_lengths=field_lengths)

1075
1076
1077
        with open(file_name, 'rb') as fp:
            response = self.client.post("/unggah_excel/", {'excel': fp})
        
1078
1079
1080
        messages = list(dj_messages.get_messages(response.wsgi_request))
        msg_text = messages[0].message

1081
        self.assertIn('Kategori', msg_text)
1082
1083

    def test_upload_excel_upload_file_success(self):
1084
1085
        self.client.login(email="kontributor@gov.id",
                          password="kontributor")
1086

1087
1088
1089
        Category(name='Computer Science').save()
        Category(name='Machine Learning').save()
        Category(name='Deep Learning').save()
1090
1091

        field_lengths = {
1092
1093
1094
            'title':50,
            'author':30,
            'publisher':30,
1095
1096
        }

1097
1098
        categories = ['Computer Science','Machine Learning','Deep Learning']
        
1099
1100
        file_name, data_frame = self.create_dummy_excel(field_lengths=field_lengths, categories=categories)

1101
1102
1103
1104
        with open(file_name, 'rb') as fp:
            response = self.client.post("/unggah_excel/", {'excel': fp})
        
        title = data_frame['Title'][0]
1105
1106
1107
        self.assertTrue(Materi.objects.get(title=title))

    def test_upload_excel_download_template(self):
1108
1109
        self.client.login(email="kontributor@gov.id",
                          password="kontributor")
1110
1111

        response = self.client.get("/unggah_excel/?template=1")
1112
1113
1114
        
        self.assertEquals(response['Content-Type'],'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet')
        self.assertEquals(response['Content-Disposition'],'attachment; filename=template.xlsx')
1115
1116
1117



1118
1119
1120
class DashboardKontributorViewTest(TestCase):
    def setUp(self):
        self.client = Client()
1121
1122
1123
1124
        self.kontributor = User.objects.create_contributor(email="kontributor@gov.id",
                                                           password="kontributor")
        self.admin = User.objects.create_admin(email="admin@gov.id",
                                               password="admin")
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
        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
1135
1136
        self.client.login(email="kontributor@gov.id",
                          password="kontributor")
1137
1138
1139
1140
1141
1142
1143
1144
        # Test
        response = self.client.get(self.url)
        self.assertTemplateUsed(response, self.template_name)
        # Logout
        self.client.logout()

    def test_dashboard_kontributor_url(self):
        # Login
1145
1146
        self.client.login(email="kontributor@gov.id",
                          password="kontributor")
1147
1148
1149
1150
1151
1152
1153
1154
1155
        # 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
1156
1157
        self.client.login(email="kontributor@gov.id",
                          password="kontributor")
1158
1159
1160
1161
1162
1163
1164
1165
        # Test
        response = self.client.get(self.url)
        self.assertEqual(response.status_code, 200)
        # Logout
        self.client.logout()

        # Admin
        # Login
1166
1167
        self.client.login(email="admin@gov.id",
                          password="admin")
1168
1169
1170
        # Test
        response = self.client.get(self.url)
        self.assertEqual(response.status_code, 403)
1171
1172
1173

        html = response.content.decode("utf-8")
        self.assertIn(ERROR_403_MESSAGE, html)
1174
1175
        # Logout
        self.client.logout()
1176

1177
1178
1179
1180
        # Anonim
        # Test
        response = self.client.get(self.url)
        self.assertEqual(response.status_code, 403)
1181

1182
1183
        html = response.content.decode("utf-8")
        self.assertIn(ERROR_403_MESSAGE, html)
1184

Selvy Fitriani's avatar
Selvy Fitriani committed
1185
1186
1187
class DeleteMateriTest(TestCase):
    def setUp(self):
        self.client = Client()
1188
1189
1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
        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
1206
1207
1208
1209
        self.content = SimpleUploadedFile(
            "content.txt", b"Test")
        self.cover = SimpleUploadedFile(
            "flower.jpg", b"Test file")
1210
        self.contributor = User.objects.create_contributor(**self.contributor_credential)
Selvy Fitriani's avatar
Selvy Fitriani committed
1211
1212
1213
1214
1215
1216
        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"

1217
1218
1219
1220
1221
1222
1223
    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
1224
1225
        response = self.client.get(self.url)
        self.assertEqual(response.status_code, 302) 
1226
1227
1228
1229
1230
1231
1232
1233
1234
1235
        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)

1236
1237
1238
1239
1240
1241
1242
class ProfilViewTest(TestCase):
    @classmethod
    def setUpTestData(cls):
        cls.client = Client()
        cls.url = "/profil/"
        cls.template_name = "profil.html"
        cls.view = ProfilView
1243

1244
1245
        cls.contributor_credentials = {"email": "contributor@gov.id", "password": "justpass"}
        cls.contributor = User.objects.create_contributor(**cls.contributor_credentials)
1246

1247
1248
        cls.admin_credentials = {"email": "admin@gov.id", "password": "justpass"}
        cls.admin = User.objects.create_admin(**cls.admin_credentials)
1249

1250
    def test_returns_correct_profile_view(self):
1251
1252
1253
        found = resolve(self.url)
        self.assertEqual(found.func.__name__, self.view.as_view().__name__)

1254
1255
1256
1257
1258
1259
1260
    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)
1261
1262
        self.assertTemplateUsed(response, self.template_name)

1263
1264
1265
    def test_unauthenticated_access_blocked(self):
        response = self._request_as_user({})
        self.assertEqual(response.status_code, 403)
1266

1267
1268
    def test_authorized_access_success(self):
        response = self._request_as_user(self.contributor_credentials)
1269
        self.assertEqual(response.status_code, 200)
1270
        self.assertIn("Profil Kontributor", response.content.decode())
1271

1272
1273
1274
        response = self._request_as_user(self.admin_credentials)
        self.assertEqual(response.status_code, 200)
        self.assertIn("Profil Admin", response.content.decode())
1275

1276

1277
class SuntingProfilViewTest(TestCase):
1278

1279
1280
1281
1282
1283
1284
    @classmethod
    def setUpTestData(cls):
        cls.client = Client()
        cls.url = "/sunting/"
        cls.template_name = "sunting.html"
        cls.view = SuntingProfilView
1285

1286
1287
        cls.contributor_credentials = {"email": "contributor@gov.id", "password": "justpass"}
        cls.contributor = User.objects.create_contributor(**cls.contributor_credentials)
1288

1289
1290
        cls.admin_credentials = {"email": "admin@gov.id", "password": "justpass"}
        cls.admin = User.objects.create_admin(**cls.admin_credentials)
1291

1292
1293
1294
1295
    def test_sunting_profile_view(self):
        found = resolve(self.url)
        self.assertEqual(found.func.__name__, self.view.as_view().__name__)

1296
1297
1298
1299
1300
1301
1302
    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)
1303
1304
1305
        response = self.client.get(self.url)
        self.assertTemplateUsed(response, self.template_name)

1306
1307
1308
    def test_unauthenticated_access_blocked(self):
        response = self._request_as_user({})
        self.assertEqual(response.status_code, 403)
1309

1310
1311
    def test_authorized_access_success(self):
        response = self._request_as_user(self.contributor_credentials)
1312
        self.assertEqual(response.status_code, 200)
1313
        self.assertIn("Sunting Profil Kontributor", response.content.decode())
1314

1315
1316
1317
        response = self._request_as_user(self.admin_credentials)
        self.assertEqual(response.status_code, 200)
        self.assertIn("Sunting Profil Admin", response.content.decode())
1318
1319
1320
1321
1322
1323
1324
1325
1326
1327

    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",
1328
            "instagram": "https://instagram.com/test_ig"
1329
1330
1331
1332
1333
1334
1335
        }
        form = SuntingProfilForm(data=form_data)

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


1336
1337
1338
class SuksesLoginKontributorTest(TestCase):
    def setUp(self):
        self.client = Client()
1339
1340
1341
1342
        self.kontributor = User.objects.create_contributor(email="kontributor@gov.id",
                                                           password="kontributor")
        self.admin = User.objects.create_admin(email="admin@gov.id",
                                               password="admin")
1343
1344
1345
        self.url = "/sukses-kontributor/"
        self.view = SuksesLoginKontributorView
        self.template_name = "sukses_kontri.html"
1346

1347
1348
1349
1350
1351
1352
    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
1353
1354
        self.client.login(email="kontributor@gov.id",
                          password="kontributor")
1355
1356
1357
1358
1359
1360
1361
1362
        # 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
1363
1364
        self.client.login(email="kontributor@gov.id",
                          password="kontributor")
1365
1366
1367
1368
1369
1370
1371
1372
1373
        # 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
1374
1375
        self.client.login(email="kontributor@gov.id",
                          password="kontributor")
1376
1377
1378
1379
1380
1381
        # Test
        response = self.client.get(self.url)
        self.assertEqual(response.status_code, 200)
        # Logout
        self.client.logout()

1382

1383
1384
1385
class SuksesLoginAdminTest(TestCase):
    def setUp(self):
        self.client = Client()
1386
1387
1388
1389
        self.kontributor = User.objects.create_contributor(email="kontributor@gov.id",
                                                           password="kontributor")
        self.admin = User.objects.create_admin(email="admin@gov.id",
                                               password="admin")
1390
1391
1392
        self.url = "/sukses-admin/"
        self.view = SuksesLoginAdminView
        self.template_name = "sukses_admin.html"
1393

1394
1395
1396
1397
1398
1399
    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
1400
1401
        self.client.login(email="admin@gov.id",
                          password="admin")
1402
1403
1404
1405
1406
1407
1408
1409
        # 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
1410
1411
        self.client.login(email="admin@gov.id",
                          password="admin")
1412
1413
1414
1415
1416
1417
1418
1419
1420
        # 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
1421
1422
        self.client.login(email="admin@gov.id",
                          password="admin")
1423
1424
1425
1426
1427
        # Test
        response = self.client.get(self.url)
        self.assertEqual(response.status_code, 200)
        # Logout
        self.client.logout()
1428
1429
1430
1431


class LikeMateriTest(TestCase):
    def setUp(self):
1432
1433
1434
1435
        self.contributor_credential = {
            "email": "kontributor@gov.id",
            "password": id_generator()
        }
1436
1437
1438
1439
        self.contributor = get_user_model().objects.create_user(
            **self.contributor_credential, name="Kontributor", is_contributor=True
        )
        self.client = Client()
1440
        self.url_like = '/materi/like/'
1441
        content = b"Test file"
1442
1443
1444
1445
1446
1447
1448
1449
1450
1451
1452
        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()
1453
        self.materi1 = Materi.objects.first()
1454
        self.url_materi = f'/materi/{self.materi1.id}/'
1455
1456
1457
1458
1459
1460
1461
1462

    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
1463
        num_of_likes = Like.objects.filter(materi=self.materi1).count()
1464
1465
        self.assertEqual(num_of_likes, 0)

1466
        # Like a materi
1467
1468
1469
        response = self.client.get(self.url_materi)
        session_id = response.context["session_id"]
        materi_id = response.context["materi_data"].id
1470
1471
1472
1473
        payload = {
            'materi_id': materi_id,
            'session_id': session_id
        }
1474
        ajax_response = Client().post(self.url_like, payload)
1475
        num_of_likes = Like.objects.filter(materi=self.materi1).count()
1476
1477
1478
1479
        self.assertEqual(num_of_likes, 1)

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

1483
        # Like a materi
1484
1485
1486
        response = self.client.get(self.url_materi)
        session_id = response.context["session_id"]
        materi_id = response.context["materi_data"].id
1487
1488
1489
1490
        payload = {
            'materi_id': materi_id,
            'session_id': session_id
        }
1491
        ajax_response = Client().post(self.url_like, payload)
1492
        num_of_likes = Like.objects.filter(materi=self.materi1).count()
1493
1494
        self.assertEqual(num_of_likes, 1)

1495
        # Unlike a materi
1496
1497
1498
        response = self.client.get(self.url_materi)
        session_id = response.context["session_id"]
        materi_id = response.context["materi_data"].id
1499
1500
1501
1502
        payload = {
            'materi_id': materi_id,
            'session_id': session_id
        }
1503
        ajax_response = Client().post(self.url_like, payload)
1504
        num_of_likes = Like.objects.filter(materi=self.materi1).count()
1505
1506
1507
1508
        self.assertEqual(num_of_likes, 0)

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

1512
        # Client 1 like a materi
1513
1514
1515
        response = self.client.get(self.url_materi)
        session_id = response.context["session_id"]
        materi_id = response.context["materi_data"].id
1516
1517
1518
1519
        payload = {
            'materi_id': materi_id,
            'session_id': session_id
        }
1520
        ajax_response = Client().post(self.url_like, payload)
1521
        num_of_likes = Like.objects.filter(materi=self.materi1).count()
1522
1523
        self.assertEqual(num_of_likes, 1)

1524
        # Client 2 like a materi
1525
1526
1527
        response = Client().get(self.url_materi)
        session_id = response.context["session_id"]
        materi_id = response.context["materi_data"].id
1528
1529
1530
1531
        payload = {
            'materi_id': materi_id,
            'session_id': session_id
        }
1532
        ajax_response = Client().post(self.url_like, payload)
1533
        num_of_likes = Like.objects.filter(materi=self.materi1).count()
1534
1535
1536
1537
        self.assertEqual(num_of_likes, 2)

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

1541
        # missing session id
1542
1543
1544
        response = self.client.get(self.url_materi)
        materi_id = response.context["materi_data"].id
        payload = {
1545
            'materi_id': materi_id,
1546
1547
        }
        ajax_response = Client().post(self.url_like, payload)
1548
        ajax_response = json.loads(ajax_response.content)
1549
        num_of_likes = Like.objects.filter(materi=self.materi1).count()
1550
1551
        self.assertEqual(num_of_likes, 0)
        self.assertEqual(ajax_response.get("success", None), False)
1552
1553

        # missing materi id
1554
1555
        response = self.client.get(self.url_materi)
        session_id = response.context["session_id"]
1556
1557
1558
        payload = {
            'session_id': session_id
        }
1559
        ajax_response = Client().post(self.url_like, payload)
1560
        ajax_response = json.loads(ajax_response.content)
1561
        num_of_likes = Like.objects.filter(materi=self.materi1).count()
1562
1563
1564
1565
1566
1567
        self.assertEqual(num_of_likes, 0)
        self.assertEqual(ajax_response.get("success", None), False)


class ViewMateriStatissticsTest(TestCase):
    def setUp(self):
1568
1569
1570
1571
        self.contributor_credential = {
            "email": "kontributor@gov.id",
            "password": id_generator()
        }
1572
1573
1574
1575
1576
        self.contributor = get_user_model().objects.create_user(
            **self.contributor_credential, name="Kontributor", is_contributor=True
        )
        self.client = Client()
        content = b"Test file"
1577
1578
1579
1580
1581
1582
1583
1584
1585
1586
1587
        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()
1588
1589
1590
        self.materi1 = Materi.objects.first()
        self.url = f"/materi/{self.materi1.id}/view"

1591
    # Test single view
1592
1593
1594
1595
1596
1597
1598
1599
1600
1601
1602
1603
1604
1605
1606
    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)

1607

1608
1609
class DownloadMateriStatissticsTest(TestCase):
    def setUp(self):
1610
1611
1612
1613
        self.contributor_credential = {
            "email": "kontributor@gov.id",
            "password": id_generator()
        }
1614
1615
1616
1617
1618
        self.contributor = get_user_model().objects.create_user(
            **self.contributor_credential, name="Kontributor", is_contributor=True
        )
        self.client = Client()
        content = b"Test file"
1619
1620
1621
1622
1623
1624
1625
1626
1627
1628
1629
        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()
1630
1631
1632
        self.materi1 = Materi.objects.first()
        self.url = f"/materi/{self.materi1.id}/unduh"

1633
    # Test single download
1634
1635
1636
1637
1638
1639
1640
1641
1642
1643
1644
1645
1646
    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()
1647
1648
        self.assertEqual(num_of_downloads, 2)

1649

1650
1651
1652
1653
1654
1655
class RevisiMateriTest(TestCase):
    def setUp(self):
        self.client = Client()
        self.view = RevisiMateriView
        self.template_name = "revisi.html"

1656
1657
1658
1659
        self.contributor_credential = {
            "email": "kontributor@gov.id",
            "password": id_generator()
        }
1660
1661
1662
        self.contributor = get_user_model().objects.create_user(
            **self.contributor_credential, name="Kontributor", is_contributor=True
        )
1663
1664
1665
1666
1667
1668
1669
1670
1671
1672
1673
        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()
1674
1675
1676
1677
1678
1679
1680
1681
1682
1683
1684
1685
1686
1687
1688
1689
1690
1691
1692
1693
1694
1695
1696
1697
1698
1699
1700
1701
1702
1703
1704
1705
1706
1707

        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
1708
        self.client.logout()
1709
    
1710
class GenerateDummyCommandTest(TestCase):
1711

1712
1713
1714
1715
1716
1717
1718
1719
    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)
1720
1721
1722
1723
            self.assertIn(
                f"Successfully created {num_of_materi} materi",
                self.stdout.getvalue()
            )
1724
1725
1726
1727
1728
1729
1730
1731
1732
1733
1734
1735
1736
1737

    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):
1738

1739
1740
1741
1742
1743
1744
    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
1745
        self.assertIn("Successfully remove all dummy object", stdout.getvalue())
1746
1747
1748
1749
1750
1751
1752
1753
1754
        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):
1755
1756
1757
1758
1759
1760
1761
1762
1763
1764
1765
1766
        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()
        }
1767
1768
1769
1770
1771
        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")
1772
1773
1774
1775
1776
1777
1778
1779
1780
1781
1782
1783
1784
1785
        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()
1786
1787
        self.materi1 = Materi.objects.all()[0]
        self.materi2 = Materi.objects.all()[1]
1788
1789
        self.url_rate = '/materi/rate/'
        self.url_materi = '/materi/{}/'.format(self.materi1.id)
1790
1791
1792
1793
1794
1795
1796
1797
1798
1799
1800
1801

    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()
1802
        self.assertTrue('Rating score must be integer between 1-5' in str(context.exception))
1803
1804
1805
1806

    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()
1807
        self.assertTrue('Rating score must be integer between 1-5' in str(context.exception))
1808
1809
1810
1811
1812
1813
1814
1815
1816
1817
1818
1819
1820
1821
1822
1823
1824
1825
1826
1827
1828
1829
1830
1831
1832

    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()
1833
        self.assertTrue('already exists' in str(context.exception))
1834
1835
1836
1837
1838
1839
1840
1841
1842
1843
1844
1845

    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()
1846

1847
1848
1849
1850
1851
1852
1853
1854
1855
1856
1857
1858
    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):
1859
        response = self.client.post(self.url_rate, {'materi_id': 1, 'rating_score': 5})
1860
1861
1862
1863
1864
1865
        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):
1866
        for data in [{}, {'materi_id': 1}, {'rating_score': 1}, {'rating_score': 'STRING', 'materi_id': 'STRING'}]:
1867
1868
1869
1870
1871
1872
1873
1874
            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)
1875
        for data in [{'rating_score': 1}, {'materi_id': 1}, {}]:
1876
1877
1878
1879
1880
1881
1882
1883
            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)
1884
        response = self.client.post(self.url_rate, {'materi_id': 123456, 'rating_score': 5})
1885
1886
1887
1888
1889
1890
1891
        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)
1892
        response = self.client.post(self.url_rate, {'materi_id': "STRING", 'rating_score': 5})
1893
1894
1895
1896
1897
        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)

1898
        response = self.client.post(self.url_rate, {'materi_id': 1, 'rating_score': "STRING"})
1899
1900
1901
1902
1903
1904
1905
1906
1907
        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()
1908
            response = self.client.post(self.url_rate, {'materi_id': self.materi1.id, 'rating_score': i})
1909
1910
1911
1912
1913
1914
1915
            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()
1916
            response = self.client.post(self.url_rate, {'materi_id': self.materi1.id, 'rating_score': i})
1917
1918
1919
1920
1921
1922
1923
1924
            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()
1925
1926
        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})
1927
1928
1929
1930
1931
1932
1933
1934
        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)
1935
        self.assertEqual(0, response.context.get('materi_rating_score'))
1936
1937
1938

    def test_user_not_authenticated_visit_unrated_should_get_0_materi_rating_score_context(self):
        response = self.client.get(self.url_materi)
1939
        self.assertEqual(0, response.context.get('materi_rating_score'))
1940
1941
1942
1943
1944

    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)
1945
        self.assertEqual(1, response.context.get('materi_rating_score'))
1946
1947
1948
1949

class fileManagementUtilTest(TestCase):
    def setUp(self):
        self.filename = "image_with_exif_data.gif"
1950
1951
        self.file_content = open(settings.BASE_DIR + "/app/test_files/" +
                self.filename, "rb").read()
1952
1953
1954
1955
1956
1957
1958
1959
1960
1961
1962
1963
1964
1965
1966
1967
1968
1969
1970
1971

    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))
1972
            self.assertTrue(b'<exif:' not in sanitized_img)
Muhamad Lutfi Arif's avatar
Muhamad Lutfi Arif committed
1973
1974
1975
1976

class RequestMateriTest(TestCase):
    def setUp(self):
        self.client = Client()
1977
1978
1979
1980
1981
1982
1983
1984
1985
1986
1987
1988
1989
1990
        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
1991
        self.contributor = get_user_model().objects.create_user(
1992
1993
1994
            **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
1995
1996
1997
1998
1999
2000
        )
        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)
For faster browsing, not all history is shown. View entire blame