Files
KMH_IT_Assets/assets/tests.py
T

879 lines
38 KiB
Python
Raw Normal View History

import datetime
from django.test import TestCase, Client
from django.urls import reverse
from django.contrib.auth.models import User
from django.core.files.uploadedfile import SimpleUploadedFile
from assets.models import (
Employee, Category, Asset, AssetUnit, UnitLog, AssetAssignment,
ConfigurationItem, CIHistory, ConsumableItem, ConsumableTransaction
)
from assets.views import validate_uploaded_document
class ModelConstraintTests(TestCase):
"""Pengujian aturan model dasar dan constraint data."""
def setUp(self):
self.category = Category.objects.create(name="Aset Karyawan")
self.employee = Employee.objects.create(nik="EMP001", name="Budi Santoso", position="IT Support")
def test_employee_creation_and_str(self):
self.assertEqual(str(self.employee), "EMP001 - Budi Santoso")
self.assertEqual(self.employee.position, "IT Support")
def test_category_creation_and_str(self):
self.assertEqual(str(self.category), "Aset Karyawan")
def test_asset_and_unit_creation(self):
asset = Asset.objects.create(
category=self.category,
asset_code="NB-LENOVO",
name="ThinkPad T14",
brand="Lenovo",
uom="Unit",
qty=1
)
unit = AssetUnit.objects.create(
asset=asset,
unit_code="NB-LENOVO-001",
status="tersedia"
)
self.assertEqual(str(asset), "NB-LENOVO - ThinkPad T14")
self.assertEqual(str(unit), "NB-LENOVO-001")
self.assertIsNotNone(unit.id_uuid)
class AssetSyncLogicTests(TestCase):
"""Pengujian logika otomatis sinkronisasi kode unit saat kode aset induk diubah."""
def setUp(self):
self.category = Category.objects.create(name="Aset Network")
self.asset = Asset.objects.create(
category=self.category,
asset_code="SW-CISCO",
name="Switch Cisco 24 Port"
)
self.unit1 = AssetUnit.objects.create(asset=self.asset, unit_code="SW-CISCO-001")
self.unit2 = AssetUnit.objects.create(asset=self.asset, unit_code="SW-CISCO-002")
def test_asset_code_update_propagates_to_units(self):
# Mengubah kode aset induk dari SW-CISCO menjadi SW-CORE
self.asset.asset_code = "SW-CORE"
self.asset.save()
self.unit1.refresh_from_db()
self.unit2.refresh_from_db()
self.assertEqual(self.unit1.unit_code, "SW-CORE-001")
self.assertEqual(self.unit2.unit_code, "SW-CORE-002")
# Memastikan UnitLog tercatat untuk pembaruan kode otomatis
logs = UnitLog.objects.filter(unit=self.unit1)
self.assertTrue(logs.filter(notes__contains="diperbarui otomatis").exists())
class SecurityAndAccessControlTests(TestCase):
"""Pengujian kontrol akses dan proteksi autentikasi."""
def setUp(self):
self.client = Client()
self.user = User.objects.create_user(username="testadmin", password="password123")
self.category = Category.objects.create(name="Aset Karyawan")
self.asset = Asset.objects.create(category=self.category, asset_code="PC-DELL", name="OptiPlex 7090")
self.unit = AssetUnit.objects.create(asset=self.asset, unit_code="PC-DELL-001")
def test_anonymous_access_to_dashboard_redirects_to_login(self):
response = self.client.get(reverse('dashboard'))
self.assertEqual(response.status_code, 302)
self.assertIn('/login/', response.url)
def test_anonymous_access_to_asset_list_redirects_to_login(self):
response = self.client.get(reverse('asset_list'))
self.assertEqual(response.status_code, 302)
self.assertIn('/login/', response.url)
def test_asset_add_anonymous_access_is_blocked(self):
"""Verifikasi bahwa bug SEC-001 / TD-001 tertutup: POST /aset/add/ tanpa login wajib ditolak."""
payload = {
'category': self.category.id,
'asset_code': 'MOU-LOGI',
'name': 'Mouse Logitech B100',
'brand': 'Logitech',
'uom': 'Pcs'
}
response = self.client.post(reverse('asset_add'), data=payload)
# Wajib di-redirect ke login (302) dan data TIDAK boleh tersimpan
self.assertEqual(response.status_code, 302)
self.assertIn('/login/', response.url)
self.assertFalse(Asset.objects.filter(asset_code="MOU-LOGI").exists())
def test_authenticated_user_can_access_dashboard(self):
self.client.login(username="testadmin", password="password123")
response = self.client.get(reverse('dashboard'))
self.assertEqual(response.status_code, 200)
def test_public_qr_and_public_unit_detail_accessible_anonymously(self):
"""Halaman publik dan gambar QR code memang dirancang untuk scan publik."""
qr_url = reverse('unit_qr_code', kwargs={'uuid': self.unit.id_uuid})
detail_url = reverse('unit_public_detail', kwargs={'uuid': self.unit.id_uuid})
res_qr = self.client.get(qr_url)
self.assertEqual(res_qr.status_code, 200)
self.assertEqual(res_qr['Content-Type'], 'image/png')
res_detail = self.client.get(detail_url)
self.assertEqual(res_detail.status_code, 200)
class DistributionWorkflowTests(TestCase):
"""Pengujian siklus distribusi serah terima, mutasi, dan pengembalian aset."""
def setUp(self):
self.client = Client()
self.user = User.objects.create_user(username="testadmin", password="password123")
self.client.login(username="testadmin", password="password123")
self.category = Category.objects.create(name="Aset Karyawan")
self.asset = Asset.objects.create(category=self.category, asset_code="NB-DELL", name="Dell Latitude 5420")
self.unit = AssetUnit.objects.create(asset=self.asset, unit_code="NB-DELL-001", status="tersedia")
self.emp1 = Employee.objects.create(nik="K001", name="Ahmad")
self.emp2 = Employee.objects.create(nik="K002", name="Bambang")
def test_handover_flow(self):
"""Serah terima unit tersedia kepada karyawan."""
response = self.client.post(reverse('distribusi_handover'), data={
'unit': self.unit.id,
'employee': self.emp1.id,
'assigned_date': '2026-10-26',
'notes': 'Penyerahan laptop kerja baru'
})
self.assertEqual(response.status_code, 302)
self.unit.refresh_from_db()
self.assertEqual(self.unit.status, 'digunakan')
self.assertEqual(self.unit.assigned_to, self.emp1)
assignment = AssetAssignment.objects.filter(unit=self.unit, type='handover').first()
self.assertIsNotNone(assignment)
self.assertEqual(assignment.employee, self.emp1)
self.assertEqual(assignment.status, 'aktif')
# UnitLog harus tercatat
log = UnitLog.objects.filter(unit=self.unit, action='assigned').first()
self.assertIsNotNone(log)
self.assertEqual(log.employee, self.emp1)
def test_mutation_flow(self):
"""Mutasi unit dari karyawan 1 ke karyawan 2."""
# Setup handover awal
self.unit.status = 'digunakan'
self.unit.assigned_to = self.emp1
self.unit.save()
AssetAssignment.objects.create(
type='handover',
unit=self.unit,
employee=self.emp1,
assigned_date='2026-10-01',
status='aktif'
)
response = self.client.post(reverse('distribusi_mutation'), data={
'unit': self.unit.id,
'employee': self.emp2.id,
'assigned_date': '2026-10-26',
'notes': 'Mutasi departemen'
})
self.assertEqual(response.status_code, 302)
self.unit.refresh_from_db()
self.assertEqual(self.unit.assigned_to, self.emp2)
# Assignment lama harus tertutup
old_assignment = AssetAssignment.objects.filter(unit=self.unit, type='handover').first()
self.assertEqual(old_assignment.status, 'dikembalikan')
self.assertIsNotNone(old_assignment.returned_date)
# Assignment mutasi baru harus aktif
new_assignment = AssetAssignment.objects.filter(unit=self.unit, type='mutation').first()
self.assertEqual(new_assignment.from_employee, self.emp1)
self.assertEqual(new_assignment.employee, self.emp2)
self.assertEqual(new_assignment.status, 'aktif')
def test_return_flow(self):
"""Pengembalian unit ke gudang dan pembaruan status transaksi."""
self.unit.status = 'digunakan'
self.unit.assigned_to = self.emp1
self.unit.save()
active_assignment = AssetAssignment.objects.create(
type='handover',
unit=self.unit,
employee=self.emp1,
assigned_date='2026-10-01',
status='aktif'
)
response = self.client.post(reverse('distribusi_return'), data={
'unit': self.unit.id,
'assigned_date': '2026-10-26',
'notes': 'Resign'
})
self.assertEqual(response.status_code, 302)
self.unit.refresh_from_db()
self.assertEqual(self.unit.status, 'tersedia')
self.assertIsNone(self.unit.assigned_to)
# Assignment aktif harus tertutup
active_assignment.refresh_from_db()
self.assertEqual(active_assignment.status, 'dikembalikan')
self.assertEqual(str(active_assignment.returned_date), '2026-10-26')
# Transaksi return harus berstatus dikembalikan
return_assignment = AssetAssignment.objects.filter(unit=self.unit, type='return').first()
self.assertEqual(return_assignment.status, 'dikembalikan')
self.assertEqual(str(return_assignment.returned_date), '2026-10-26')
class EmployeeManagementTests(TestCase):
"""Pengujian master karyawan dan proteksi penghapusan."""
def setUp(self):
self.client = Client()
self.user = User.objects.create_user(username="testadmin", password="password123")
self.client.login(username="testadmin", password="password123")
self.category = Category.objects.create(name="Aset Karyawan")
self.asset = Asset.objects.create(category=self.category, asset_code="NB-HP", name="HP ProBook")
self.unit = AssetUnit.objects.create(asset=self.asset, unit_code="NB-HP-001", status="digunakan")
self.emp = Employee.objects.create(nik="NIK100", name="Doni")
self.unit.assigned_to = self.emp
self.unit.save()
def test_delete_employee_with_held_assets_is_prevented(self):
"""Karyawan yang masih memegang unit tidak boleh terhapus."""
response = self.client.post(reverse('employee_delete', kwargs={'emp_id': self.emp.id}))
self.assertEqual(response.status_code, 302)
# Karyawan harus tetap ada
self.assertTrue(Employee.objects.filter(id=self.emp.id).exists())
def test_delete_employee_without_assets_succeeds(self):
"""Karyawan bebas tanggungan aset dinonaktifkan secara aman (soft delete)."""
self.unit.assigned_to = None
self.unit.status = 'tersedia'
self.unit.save()
response = self.client.post(reverse('employee_delete', kwargs={'emp_id': self.emp.id}))
self.assertEqual(response.status_code, 302)
self.emp.refresh_from_db()
# Karyawan tetap ada di database untuk menjaga integritas transaksi masa lalu
self.assertTrue(Employee.objects.filter(id=self.emp.id).exists())
self.assertFalse(self.emp.is_active)
def test_reactivate_employee(self):
"""Karyawan yang dinonaktifkan dapat diaktifkan kembali."""
self.emp.is_active = False
self.emp.save()
response = self.client.post(reverse('employee_activate', kwargs={'emp_id': self.emp.id}))
self.assertEqual(response.status_code, 302)
self.emp.refresh_from_db()
self.assertTrue(self.emp.is_active)
class DocumentValidationTests(TestCase):
"""Pengujian validasi berkas upload BAST."""
def test_valid_document_extension_and_size(self):
doc = SimpleUploadedFile("bast.pdf", b"dummy content", content_type="application/pdf")
is_valid, err = validate_uploaded_document(doc)
self.assertTrue(is_valid)
self.assertIsNone(err)
def test_invalid_document_extension(self):
doc = SimpleUploadedFile("script.sh", b"echo evil", content_type="application/x-sh")
is_valid, err = validate_uploaded_document(doc)
self.assertFalse(is_valid)
self.assertIn("Format file tidak diizinkan", err)
def test_oversized_document(self):
big_content = b"0" * (6 * 1024 * 1024) # 6 MB
doc = SimpleUploadedFile("large_bast.pdf", big_content, content_type="application/pdf")
is_valid, err = validate_uploaded_document(doc)
self.assertFalse(is_valid)
self.assertIn("Ukuran file maksimal 5MB", err)
class UnitDeleteRouteTests(TestCase):
"""Pengujian fungsionalitas dan rute unit_delete yang baru didaftarkan."""
def setUp(self):
self.client = Client()
self.user = User.objects.create_user(username="testadmin", password="password123")
self.client.login(username="testadmin", password="password123")
self.category = Category.objects.create(name="Aset Network")
self.asset = Asset.objects.create(category=self.category, asset_code="AP-ARUBA", name="AP Aruba", qty=1)
self.unit = AssetUnit.objects.create(asset=self.asset, unit_code="AP-ARUBA-001")
def test_unit_delete_view_executes_successfully(self):
"""Verifikasi bahwa rute /unit/<id>/delete/ kini aktif dan berfungsi mengurangi asset.qty."""
delete_url = reverse('unit_delete', kwargs={'unit_id': self.unit.id})
response = self.client.post(delete_url)
self.assertEqual(response.status_code, 302)
self.assertFalse(AssetUnit.objects.filter(id=self.unit.id).exists())
self.asset.refresh_from_db()
self.assertEqual(self.asset.qty, 0)
class PaginationIntegrationTests(TestCase):
"""Pengujian pagination 25 item per halaman pada tabel data besar."""
def setUp(self):
self.client = Client()
self.user = User.objects.create_user(username="testadmin", password="password123")
self.client.login(username="testadmin", password="password123")
self.category = Category.objects.create(name="Aset Karyawan")
# Buat 30 aset untuk menguji pagination (> 25)
for i in range(1, 31):
Asset.objects.create(
category=self.category,
asset_code=f"AST-{i:03d}",
name=f"Laptop Seri {i}"
)
def test_asset_list_pagination(self):
"""Memastikan asset_list membatasi 25 item di halaman 1 dan 5 item di halaman 2."""
response = self.client.get(reverse('asset_list') + '?tab=karyawan')
self.assertEqual(response.status_code, 200)
self.assertIn('page_obj', response.context)
page1 = response.context['page_obj']
self.assertEqual(len(page1), 25)
self.assertTrue(page1.has_next())
# Halaman 2
response2 = self.client.get(reverse('asset_list') + '?tab=karyawan&page=2')
self.assertEqual(response2.status_code, 200)
page2 = response2.context['page_obj']
self.assertEqual(len(page2), 5)
self.assertFalse(page2.has_next())
class RoleBasedAccessControlTests(TestCase):
"""Pengujian hak akses dan restriksi peran pengguna (RBAC)."""
def setUp(self):
from django.contrib.auth.models import Group
self.client = Client()
# Groups
self.grp_operator, _ = Group.objects.get_or_create(name='Teknisi IT')
self.grp_auditor, _ = Group.objects.get_or_create(name='Auditor')
# Users
self.admin_user = User.objects.create_superuser(username="superadmin", password="password123")
self.operator_user = User.objects.create_user(username="teknisi1", password="password123")
self.operator_user.groups.add(self.grp_operator)
self.auditor_user = User.objects.create_user(username="auditor1", password="password123")
self.auditor_user.groups.add(self.grp_auditor)
self.category = Category.objects.create(name="Aset Kantor")
def test_superadmin_can_access_backup(self):
"""Superadmin berhak mengakses halaman backup database."""
self.client.login(username="superadmin", password="password123")
response = self.client.get(reverse('backup_database'))
self.assertEqual(response.status_code, 200)
def test_operator_blocked_from_backup(self):
"""Teknisi / Operator dilarang mengakses halaman backup database (403 Forbidden)."""
self.client.login(username="teknisi1", password="password123")
response = self.client.get(reverse('backup_database'))
self.assertEqual(response.status_code, 403)
def test_auditor_can_view_but_cannot_mutate(self):
"""Auditor dapat melihat daftar aset tetapi dilarang menambah aset (403 Forbidden)."""
self.client.login(username="auditor1", password="password123")
# Melihat daftar: diizinkan (200 OK)
view_response = self.client.get(reverse('asset_list'))
self.assertEqual(view_response.status_code, 200)
# Mencoba menambah aset: ditolak (403 Forbidden)
post_response = self.client.post(reverse('asset_add'), data={
'category': self.category.id,
'asset_code': 'PC-AUDIT',
'name': 'Komputer Audit'
})
self.assertEqual(post_response.status_code, 403)
class ConfigurationItemWorkflowTests(TestCase):
"""Pengujian fungsional dan integritas modul Configuration Item (CMDB)."""
def setUp(self):
from django.contrib.auth.models import Group
self.client = Client()
# Admin user
self.admin = User.objects.create_superuser(username="ci_admin", password="password123")
self.client.login(username="ci_admin", password="password123")
# Master Aset & Karyawan
self.category = Category.objects.create(name="Aset Karyawan")
self.asset = Asset.objects.create(category=self.category, asset_code="PC-HP", name="HP EliteDesk")
self.unit = AssetUnit.objects.create(asset=self.asset, unit_code="PC-HP-001", status="tersedia")
self.emp = Employee.objects.create(nik="NIK-CI-01", name="Rizky Pratama", is_active=True)
# CI Contoh
self.ci_ssd = ConfigurationItem.objects.create(
ci_code="CI-STR-099",
name="SSD Kingston NV2 1TB",
category="storage",
brand="Kingston",
serial_number="SN-KNG-1234",
status="available",
location="Gudang IT"
)
self.ci_ram = ConfigurationItem.objects.create(
ci_code="CI-MEM-099",
name="RAM Kingston 16GB DDR4",
category="memory",
brand="Kingston",
status="available",
location="Gudang IT"
)
def test_create_ci_with_auto_code(self):
"""Memverifikasi penambahan CI dengan auto-generate kode CI."""
response = self.client.post(reverse('ci_create'), data={
'name': 'Monitor Dell 24 Inch',
'category': 'peripheral',
'brand': 'Dell',
'model_series': 'P2419H',
'serial_number': 'SN-DELL-P2419',
'condition': 'new',
'status': 'available',
'location': 'Gudang IT'
})
self.assertEqual(response.status_code, 302)
new_ci = ConfigurationItem.objects.filter(serial_number='SN-DELL-P2419').first()
self.assertIsNotNone(new_ci)
self.assertTrue(new_ci.ci_code.startswith('CI-PER-'))
# Pastikan history created terbentuk
self.assertTrue(CIHistory.objects.filter(ci=new_ci, action='created').exists())
def test_ci_assign_to_asset_unit(self):
"""Memasang komponen ke unit perangkat PC/Laptop secara transaksional."""
response = self.client.post(reverse('ci_assign', kwargs={'ci_id': self.ci_ssd.id}), data={
'usage_type': 'asset',
'target_id': self.unit.id,
'notes': 'Pemasangan storage OS utama'
})
self.assertEqual(response.status_code, 302)
self.ci_ssd.refresh_from_db()
self.assertEqual(self.ci_ssd.status, 'in_use')
self.assertEqual(self.ci_ssd.installed_on, self.unit)
self.assertIsNone(self.ci_ssd.assigned_to)
# Timeline CIHistory terekam
last_history = self.ci_ssd.history.first()
self.assertEqual(last_history.action, 'installed')
self.assertEqual(last_history.related_unit, self.unit)
# UnitLog pada unit induk juga merekam pemasangan komponen
self.assertTrue(UnitLog.objects.filter(unit=self.unit, notes__contains=self.ci_ssd.ci_code).exists())
def test_ci_assign_to_employee(self):
"""Mengalokasikan komponen peripheral langsung ke karyawan."""
response = self.client.post(reverse('ci_assign', kwargs={'ci_id': self.ci_ram.id}), data={
'usage_type': 'employee',
'target_id': self.emp.id,
'notes': 'Penyerahan langsung'
})
self.assertEqual(response.status_code, 302)
self.ci_ram.refresh_from_db()
self.assertEqual(self.ci_ram.status, 'in_use')
self.assertEqual(self.ci_ram.assigned_to, self.emp)
self.assertIsNone(self.ci_ram.installed_on)
def test_ci_remove_from_unit(self):
"""Pelepasan komponen dari unit dan pengembalian ke gudang."""
# Pasang terlebih dahulu
self.ci_ssd.installed_on = self.unit
self.ci_ssd.status = 'in_use'
self.ci_ssd.save()
response = self.client.post(reverse('ci_remove', kwargs={'ci_id': self.ci_ssd.id}), data={
'new_status': 'available',
'new_condition': 'good',
'location': 'Rak A-1',
'notes': 'Dilepas untuk backup data'
})
self.assertEqual(response.status_code, 302)
self.ci_ssd.refresh_from_db()
self.assertEqual(self.ci_ssd.status, 'available')
self.assertIsNone(self.ci_ssd.installed_on)
self.assertEqual(self.ci_ssd.location, 'Rak A-1')
# Verifikasi log pelepasan
last_history = self.ci_ssd.history.first()
self.assertEqual(last_history.action, 'removed')
def test_ci_replace_and_upgrade_flow(self):
"""Workflow penggantian / upgrade komponen pada suatu perangkat."""
# Pasang SSD lama di unit
self.ci_ssd.installed_on = self.unit
self.ci_ssd.status = 'in_use'
self.ci_ssd.save()
# Siapkan SSD baru sebagai pengganti
replacement_ssd = ConfigurationItem.objects.create(
ci_code="CI-STR-100",
name="SSD Samsung 990 Pro 2TB",
category="storage",
status="available",
location="Gudang IT"
)
response = self.client.post(reverse('ci_replace', kwargs={'ci_id': self.ci_ssd.id}), data={
'replacement_ci_id': replacement_ssd.id,
'reason': 'Peningkatan Kapasitas / Performa',
'old_ci_status': 'available',
'old_ci_condition': 'good',
'old_ci_location': 'Gudang IT',
'notes': 'Upgrade storage ke 2TB'
})
self.assertEqual(response.status_code, 302)
# Komponen lama lepas
self.ci_ssd.refresh_from_db()
self.assertIsNone(self.ci_ssd.installed_on)
self.assertEqual(self.ci_ssd.status, 'available')
# Komponen baru terpasang di unit
replacement_ssd.refresh_from_db()
self.assertEqual(replacement_ssd.installed_on, self.unit)
self.assertEqual(replacement_ssd.status, 'in_use')
# Riwayat tercatat pada kedua item
self.assertTrue(CIHistory.objects.filter(ci=self.ci_ssd, action='replaced').exists())
self.assertTrue(CIHistory.objects.filter(ci=replacement_ssd, action='installed').exists())
def test_prevent_double_assignment(self):
"""Mencegah assignment ganda pada komponen yang sedang in_use."""
self.ci_ssd.status = 'in_use'
self.ci_ssd.installed_on = self.unit
self.ci_ssd.save()
response = self.client.post(reverse('ci_assign', kwargs={'ci_id': self.ci_ssd.id}), data={
'usage_type': 'employee',
'target_id': self.emp.id,
})
self.assertEqual(response.status_code, 302)
self.ci_ssd.refresh_from_db()
# Harus tetap terpasang pada unit, tidak pindah ke karyawan
self.assertEqual(self.ci_ssd.installed_on, self.unit)
def test_ci_report_damage(self):
"""Melaporkan keluhan kerusakan teknis pada komponen."""
response = self.client.post(reverse('ci_report_damage', kwargs={'ci_id': self.ci_ssd.id}), data={
'action_type': 'repair_in',
'condition': 'damaged',
'notes': 'Sektor bad sector terdeteksi pada SMART check'
})
self.assertEqual(response.status_code, 302)
self.ci_ssd.refresh_from_db()
self.assertEqual(self.ci_ssd.status, 'under_repair')
self.assertEqual(self.ci_ssd.condition, 'damaged')
self.assertTrue(CIHistory.objects.filter(ci=self.ci_ssd, action='repair_in').exists())
class ConsumableModuleTests(TestCase):
"""Pengujian komprehensif alur bisnis, integritas saldo, dan keamanan modul Consumable Item."""
def setUp(self):
self.client = Client()
self.admin_user = User.objects.create_superuser('admin_test', '[email protected]', 'password123')
self.operator_user = User.objects.create_user('tech_operator', '[email protected]', 'password123', is_staff=False)
self.auditor_user = User.objects.create_user('auditor_user', '[email protected]', 'password123', is_staff=False)
from django.contrib.auth.models import Group
grp_op, _ = Group.objects.get_or_create(name='Teknisi IT')
self.operator_user.groups.add(grp_op)
grp_audit, _ = Group.objects.get_or_create(name='Auditor')
self.auditor_user.groups.add(grp_audit)
self.client.login(username='admin_test', password='password123')
# Master data pendukung
self.emp = Employee.objects.create(nik="EMP-NET-01", name="Rian Jaringan", position="Network Engineer")
self.cat = Category.objects.create(name="Aset Network")
self.asset = Asset.objects.create(category=self.cat, asset_code="SW-HP", name="Switch HP 24P")
self.unit = AssetUnit.objects.create(asset=self.asset, unit_code="SW-HP-001", status="digunakan")
# Item uji coba
self.item_cable = ConsumableItem.objects.create(
item_code="CNS-CAB-001",
name="Kabel UTP Cat6 Belden",
category="cable",
brand="Belden",
specification="UTP Cat6 24AWG Solid Copper",
base_unit="meter",
purchase_unit="roll",
conversion_rate=305,
stock_available=305,
minimum_stock=50,
location="Gudang Induk (GI)",
last_purchase_price=1800000
)
self.item_rj45 = ConsumableItem.objects.create(
item_code="CNS-CON-001",
name="Konektor RJ45 Cat6",
category="connector",
brand="AMP / CommScope",
base_unit="pcs",
stock_available=10,
minimum_stock=20,
location="Ruang Server / IT"
)
def test_consumable_model_status_property(self):
"""Memverifikasi kalkulasi status stok: available, low_stock, dan out_of_stock."""
# Stok kabel 305 > min 50 -> available
self.assertEqual(self.item_cable.stock_status, 'available')
self.assertEqual(self.item_cable.stock_status_display, 'Tersedia')
# Stok RJ45 10 <= min 20 -> low_stock
self.assertEqual(self.item_rj45.stock_status, 'low_stock')
self.assertEqual(self.item_rj45.stock_status_display, 'Menipis')
# Habiskan stok
self.item_rj45.stock_available = 0
self.item_rj45.save()
self.assertEqual(self.item_rj45.stock_status, 'out_of_stock')
self.assertEqual(self.item_rj45.stock_status_display, 'Habis')
def test_consumable_list_view(self):
"""Halaman list dapat diakses, menghitung KPI summary, dan merender data aktual."""
response = self.client.get(reverse('consumable_list'))
self.assertEqual(response.status_code, 200)
self.assertContains(response, "Kabel UTP Cat6 Belden")
self.assertContains(response, "Konektor RJ45 Cat6")
self.assertEqual(response.context['counts']['total'], 2)
self.assertEqual(response.context['counts']['low_stock'], 1)
def test_consumable_create_with_initial_stock(self):
"""Menambah item baru dengan stok awal > 0 wajib mencatat entri buku besar otomatis."""
response = self.client.post(reverse('consumable_create'), data={
'item_code': 'CNS-MNT-001',
'name': 'Thermal Paste Arctic MX-4',
'category': 'maintenance',
'brand': 'Arctic',
'specification': 'Thermal Compound 4g 8.5W/mK',
'base_unit': 'tube',
'initial_stock': '5',
'minimum_stock': '2',
'location': 'Workshop IT',
'last_purchase_price': '125000',
})
self.assertEqual(response.status_code, 302)
new_item = ConsumableItem.objects.filter(item_code='CNS-MNT-001').first()
self.assertIsNotNone(new_item)
self.assertEqual(new_item.stock_available, 5)
# Cek ledger otomatis
trx = ConsumableTransaction.objects.filter(item=new_item, transaction_type='in').first()
self.assertIsNotNone(trx)
self.assertEqual(trx.quantity_base, 5)
self.assertEqual(trx.source_destination, 'Stok Awal Terotorisasi')
def test_consumable_edit_preserves_stock_integrity(self):
"""Edit master item memperbarui metadata namun tidak mengubah saldo stok fisik sembarangan."""
old_stock = self.item_cable.stock_available
response = self.client.post(reverse('consumable_edit', kwargs={'item_id': self.item_cable.id}), data={
'name': 'Kabel UTP Cat6 Belden High Performance',
'category': 'cable',
'brand': 'Belden USA',
'specification': '24 AWG Solid Copper Pure',
'base_unit': 'meter',
'purchase_unit': 'roll',
'conversion_rate': '305',
'minimum_stock': '40',
'location': 'Gudang Induk (GI)',
'last_purchase_price': '1850000',
})
self.assertEqual(response.status_code, 302)
self.item_cable.refresh_from_db()
self.assertEqual(self.item_cable.name, 'Kabel UTP Cat6 Belden High Performance')
self.assertEqual(self.item_cable.brand, 'Belden USA')
self.assertEqual(self.item_cable.minimum_stock, 40)
# Saldo stok tetap terjaga
self.assertEqual(self.item_cable.stock_available, old_stock)
def test_barang_masuk_purchase_unit_conversion(self):
"""Barang masuk dengan satuan pembelian dikonversi ke satuan dasar secara akurat."""
# Stok awal kabel: 305 meter. Masuk 2 roll (2 * 305 = 610 meter).
response = self.client.post(reverse('consumable_in'), data={
'item_id': self.item_cable.id,
'quantity': '2',
'unit_type': 'purchase',
'transaction_date': '2026-10-26',
'source_destination': 'Pembelian PT. KMH',
'supplier': 'PT. Trikom Mandiri',
'reference_no': 'PO-IT-2026-101',
'notes': 'Stok kabel tambahan untuk proyek Adit 2'
})
self.assertEqual(response.status_code, 302)
self.item_cable.refresh_from_db()
self.assertEqual(self.item_cable.stock_available, 305 + 610)
# Verifikasi ledger
trx = ConsumableTransaction.objects.filter(item=self.item_cable, transaction_type='in').first()
self.assertIsNotNone(trx)
self.assertEqual(trx.quantity, 2)
self.assertEqual(trx.unit, 'roll')
self.assertEqual(trx.quantity_base, 610)
self.assertEqual(trx.stock_before, 305)
self.assertEqual(trx.stock_after, 915)
def test_barang_keluar_success_with_asset_and_ticket(self):
"""Barang keluar memotong stok secara atomik dan terintegrasi dengan tiket & unit aset."""
response = self.client.post(reverse('consumable_out'), data={
'item_id': self.item_cable.id,
'quantity': '45',
'unit_type': 'base',
'transaction_date': '2026-10-26',
'recipient_employee': self.emp.id,
'related_unit': self.unit.id,
'ticket_number': 'WO-NET-2026-088',
'source_destination': 'Tarik kabel koneksi Switch HP-001 ke Ruang Kontrol',
'notes': 'Patching jalur LAN'
})
self.assertEqual(response.status_code, 302)
self.item_cable.refresh_from_db()
self.assertEqual(self.item_cable.stock_available, 305 - 45)
trx = ConsumableTransaction.objects.filter(item=self.item_cable, transaction_type='out').first()
self.assertIsNotNone(trx)
self.assertEqual(trx.quantity_base, 45)
self.assertEqual(trx.recipient_employee, self.emp)
self.assertEqual(trx.related_unit, self.unit)
self.assertEqual(trx.ticket_number, 'WO-NET-2026-088')
self.assertEqual(trx.stock_before, 305)
self.assertEqual(trx.stock_after, 260)
def test_barang_keluar_insufficient_stock_prevented(self):
"""Negative test: pengeluaran melebihi stok ditolak dan tidak boleh menghasilkan saldo negatif."""
stock_awal = self.item_rj45.stock_available # 10 pcs
response = self.client.post(reverse('consumable_out'), data={
'item_id': self.item_rj45.id,
'quantity': '25', # Minta 25 dari 10
'unit_type': 'base',
'transaction_date': '2026-10-26',
'recipient_employee': self.emp.id,
'source_destination': 'Terminasi kabel',
})
self.assertEqual(response.status_code, 302)
# Saldo stok tidak berubah
self.item_rj45.refresh_from_db()
self.assertEqual(self.item_rj45.stock_available, stock_awal)
# Tidak ada transaksi keluar yang tercatat
self.assertFalse(ConsumableTransaction.objects.filter(item=self.item_rj45, transaction_type='out').exists())
def test_stock_opname_adjustment(self):
"""Stock Opname menghitung selisih fisik vs sistem dan membukukan penyesuaian."""
# Stok awal RJ45 sistem: 10. Hasil fisik lapangan: 8 (selisih -2).
response = self.client.post(reverse('consumable_adjust'), data={
'item_id': self.item_rj45.id,
'actual_stock': '8',
'transaction_date': '2026-10-26',
'reason': 'Hasil audit fisik akhir bulan: 2 pcs rusak pecah pada pengunci'
})
self.assertEqual(response.status_code, 302)
self.item_rj45.refresh_from_db()
self.assertEqual(self.item_rj45.stock_available, 8)
trx = ConsumableTransaction.objects.filter(item=self.item_rj45, transaction_type='adjustment').first()
self.assertIsNotNone(trx)
self.assertEqual(trx.stock_before, 10)
self.assertEqual(trx.stock_after, 8)
self.assertIn("Selisih -2", trx.notes)
def test_transaction_reversal_workflow(self):
"""Mekanisme reversal membatalkan efek transaksi asal dan membuat entri pembalik yang dapat diaudit."""
# Lakukan pengeluaran 5 pcs RJ45
self.client.post(reverse('consumable_out'), data={
'item_id': self.item_rj45.id,
'quantity': '5',
'unit_type': 'base',
'transaction_date': '2026-10-26',
'recipient_employee': self.emp.id,
'source_destination': 'Uji coba terminasi',
})
self.item_rj45.refresh_from_db()
self.assertEqual(self.item_rj45.stock_available, 5)
out_trx = ConsumableTransaction.objects.filter(item=self.item_rj45, transaction_type='out').first()
# Eksekusi Reversal
response = self.client.post(reverse('consumable_transaction_reverse', kwargs={'trx_id': out_trx.id}), data={
'reversal_reason': 'Salah input teknisi, barang batal dikeluarkan'
})
self.assertEqual(response.status_code, 302)
# Stok kembali pulih ke 10
self.item_rj45.refresh_from_db()
self.assertEqual(self.item_rj45.stock_available, 10)
# Transaksi asal ditandai reversed
out_trx.refresh_from_db()
self.assertTrue(out_trx.is_reversed)
self.assertIsNotNone(out_trx.reversed_by)
# Transaksi reversal tercatat di buku besar
rev_trx = out_trx.reversed_by
self.assertEqual(rev_trx.transaction_type, 'reversal')
self.assertEqual(rev_trx.stock_before, 5)
self.assertEqual(rev_trx.stock_after, 10)
def test_auditor_permission_restriction(self):
"""Role Auditor (Read-Only) diblokir dari aksi penambahan atau pengubahan stok."""
self.client.logout()
self.client.login(username='auditor_user', password='password123')
# Mencoba posting barang masuk
response = self.client.post(reverse('consumable_in'), data={
'item_id': self.item_cable.id,
'quantity': '10',
'unit_type': 'base',
})
# Harus ditolak dengan 403 Forbidden oleh @operator_required
self.assertEqual(response.status_code, 403)
def test_export_excel_and_pdf(self):
"""Endpoint export Excel dan PDF mengembalikan berkas dengan status 200 dan content type valid."""
res_excel = self.client.get(reverse('consumable_export_excel'))
self.assertEqual(res_excel.status_code, 200)
self.assertIn('spreadsheetml', res_excel['Content-Type'])
res_pdf = self.client.get(reverse('consumable_export_pdf'))
self.assertEqual(res_pdf.status_code, 200)
self.assertEqual(res_pdf['Content-Type'], 'application/pdf')