83ac67fea2
- Add tests/ directory with pytest configuration - Add conftest.py with database fixtures (test_db, sample data) - Add test_core.py: 21 tests for core operations (tablet, user, loan CRUD) - Add test_edge_cases.py: 14 tests for edge cases (duplicates, invalid IDs, etc.) - Add test_minimal_app.py: 11 tests for actual application functions - Update pyproject.toml with pytest and coverage configuration - Total: 46 tests covering core functionality and edge cases Tests cover: - Tablet CRUD operations - User CRUD operations - Loan/return workflows - Duplicate prevention (serial numbers, identifications) - Invalid ID handling - Already loaned device prevention - Non-existent loan handling - Multiple loans per user (one-to-many relationship) - Non-loanable device CRUD operations To run: python3 -m pytest tests/ -v
481 lines
18 KiB
Python
481 lines
18 KiB
Python
"""
|
|
Unit tests for core tablet management functions
|
|
Tests loan logic, validation, and database operations
|
|
"""
|
|
|
|
import pytest
|
|
import sqlite3
|
|
from datetime import datetime
|
|
import sys
|
|
import os
|
|
|
|
# Import the functions from minimal_app (they work with any db connection)
|
|
sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
|
|
|
|
|
|
def get_tablet_count(conn):
|
|
"""Helper to get tablet count"""
|
|
cursor = conn.cursor()
|
|
cursor.execute("SELECT COUNT(*) FROM tablets")
|
|
return cursor.fetchone()[0]
|
|
|
|
|
|
def get_user_count(conn):
|
|
"""Helper to get user count"""
|
|
cursor = conn.cursor()
|
|
cursor.execute("SELECT COUNT(*) FROM users")
|
|
return cursor.fetchone()[0]
|
|
|
|
|
|
def get_loan_count(conn):
|
|
"""Helper to get loan count"""
|
|
cursor = conn.cursor()
|
|
cursor.execute("SELECT COUNT(*) FROM loans")
|
|
return cursor.fetchone()[0]
|
|
|
|
|
|
class TestTabletOperations:
|
|
"""Tests for tablet CRUD operations"""
|
|
|
|
def test_add_tablet_success(self, db_conn):
|
|
"""Test adding a new tablet successfully"""
|
|
cursor = db_conn.cursor()
|
|
|
|
# Add a tablet
|
|
cursor.execute('''
|
|
INSERT INTO tablets (brand, model, serial_number, status)
|
|
VALUES (?, ?, ?, 'available')
|
|
''', ('TestBrand', 'TestModel', 'TEST001'))
|
|
db_conn.commit()
|
|
|
|
# Verify it was added
|
|
cursor.execute("SELECT * FROM tablets WHERE serial_number = 'TEST001'")
|
|
tablet = cursor.fetchone()
|
|
|
|
assert tablet is not None
|
|
assert tablet['brand'] == 'TestBrand'
|
|
assert tablet['model'] == 'TestModel'
|
|
assert tablet['serial_number'] == 'TEST001'
|
|
assert tablet['status'] == 'available'
|
|
|
|
def test_add_tablet_duplicate_serial(self, db_conn):
|
|
"""Test that duplicate serial numbers are rejected"""
|
|
cursor = db_conn.cursor()
|
|
|
|
# Add first tablet
|
|
cursor.execute('''
|
|
INSERT INTO tablets (brand, model, serial_number, status)
|
|
VALUES (?, ?, ?, 'available')
|
|
''', ('Brand1', 'Model1', 'DUP001'))
|
|
db_conn.commit()
|
|
|
|
# Try to add duplicate
|
|
with pytest.raises(sqlite3.IntegrityError):
|
|
cursor.execute('''
|
|
INSERT INTO tablets (brand, model, serial_number, status)
|
|
VALUES (?, ?, ?, 'available')
|
|
''', ('Brand2', 'Model2', 'DUP001'))
|
|
db_conn.commit()
|
|
|
|
def test_tablet_status_update(self, db_conn):
|
|
"""Test updating tablet status"""
|
|
cursor = db_conn.cursor()
|
|
|
|
# Add a tablet
|
|
cursor.execute('''
|
|
INSERT INTO tablets (brand, model, serial_number, status)
|
|
VALUES (?, ?, ?, 'available')
|
|
''', ('Brand', 'Model', 'STATUS001'))
|
|
db_conn.commit()
|
|
|
|
# Update status
|
|
cursor.execute("UPDATE tablets SET status = 'loaned' WHERE serial_number = 'STATUS001'")
|
|
db_conn.commit()
|
|
|
|
# Verify update
|
|
cursor.execute("SELECT status FROM tablets WHERE serial_number = 'STATUS001'")
|
|
status = cursor.fetchone()['status']
|
|
|
|
assert status == 'loaned'
|
|
|
|
|
|
class TestUserOperations:
|
|
"""Tests for user CRUD operations"""
|
|
|
|
def test_add_user_success(self, db_conn):
|
|
"""Test adding a new user successfully"""
|
|
cursor = db_conn.cursor()
|
|
|
|
cursor.execute('''
|
|
INSERT INTO users (name, identification)
|
|
VALUES (?, ?)
|
|
''', ('Test User', 'TESTID001'))
|
|
db_conn.commit()
|
|
|
|
cursor.execute("SELECT * FROM users WHERE identification = 'TESTID001'")
|
|
user = cursor.fetchone()
|
|
|
|
assert user is not None
|
|
assert user['name'] == 'Test User'
|
|
assert user['identification'] == 'TESTID001'
|
|
|
|
def test_add_user_duplicate_identification(self, db_conn):
|
|
"""Test that duplicate user identifications are rejected"""
|
|
cursor = db_conn.cursor()
|
|
|
|
# Add first user
|
|
cursor.execute('''
|
|
INSERT INTO users (name, identification)
|
|
VALUES (?, ?)
|
|
''', ('User1', 'DUPID001'))
|
|
db_conn.commit()
|
|
|
|
# Try to add duplicate
|
|
with pytest.raises(sqlite3.IntegrityError):
|
|
cursor.execute('''
|
|
INSERT INTO users (name, identification)
|
|
VALUES (?, ?)
|
|
''', ('User2', 'DUPID001'))
|
|
db_conn.commit()
|
|
|
|
def test_user_with_contact_info(self, db_conn):
|
|
"""Test adding user with email and phone"""
|
|
cursor = db_conn.cursor()
|
|
|
|
cursor.execute('''
|
|
INSERT INTO users (name, email, phone, identification)
|
|
VALUES (?, ?, ?, ?)
|
|
''', ('Contact User', 'test@email.com', '1234567890', 'CONTACT001'))
|
|
db_conn.commit()
|
|
|
|
cursor.execute("SELECT * FROM users WHERE identification = 'CONTACT001'")
|
|
user = cursor.fetchone()
|
|
|
|
assert user['email'] == 'test@email.com'
|
|
assert user['phone'] == '1234567890'
|
|
|
|
|
|
class TestLoanOperations:
|
|
"""Tests for loan operations - the core business logic"""
|
|
|
|
def test_loan_tablet_success(self, populated_db):
|
|
"""Test loaning an available tablet to a user"""
|
|
cursor = populated_db.cursor()
|
|
|
|
# Get an available tablet and user
|
|
cursor.execute("SELECT id FROM tablets WHERE status = 'available' LIMIT 1")
|
|
tablet = cursor.fetchone()
|
|
cursor.execute("SELECT id FROM users LIMIT 1")
|
|
user = cursor.fetchone()
|
|
|
|
assert tablet is not None
|
|
assert user is not None
|
|
|
|
tablet_id = tablet['id']
|
|
user_id = user['id']
|
|
|
|
# Loan the tablet
|
|
loan_date = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
|
|
cursor.execute("UPDATE tablets SET status = 'loaned' WHERE id = ?", (tablet_id,))
|
|
cursor.execute('''
|
|
INSERT INTO loans (tablet_id, user_id, loan_date, status)
|
|
VALUES (?, ?, ?, 'active')
|
|
''', (tablet_id, user_id, loan_date))
|
|
populated_db.commit()
|
|
|
|
# Verify tablet status changed
|
|
cursor.execute("SELECT status FROM tablets WHERE id = ?", (tablet_id,))
|
|
status = cursor.fetchone()['status']
|
|
assert status == 'loaned'
|
|
|
|
# Verify loan was created
|
|
cursor.execute("SELECT * FROM loans WHERE tablet_id = ? AND user_id = ?", (tablet_id, user_id))
|
|
loan = cursor.fetchone()
|
|
assert loan is not None
|
|
assert loan['status'] == 'active'
|
|
assert loan['return_date'] is None
|
|
|
|
def test_loan_already_loaned_tablet(self, populated_db):
|
|
"""Test that loaning an already loaned tablet fails gracefully"""
|
|
cursor = populated_db.cursor()
|
|
|
|
# Get a loaned tablet (SN004 should be loaned from sample data)
|
|
cursor.execute("SELECT id FROM tablets WHERE status = 'loaned' LIMIT 1")
|
|
tablet = cursor.fetchone()
|
|
cursor.execute("SELECT id FROM users LIMIT 1")
|
|
user = cursor.fetchone()
|
|
|
|
if tablet and user:
|
|
tablet_id = tablet['id']
|
|
user_id = user['id']
|
|
|
|
# Try to loan it again (should check status first)
|
|
cursor.execute("SELECT status FROM tablets WHERE id = ?", (tablet_id,))
|
|
status = cursor.fetchone()['status']
|
|
|
|
# This should be 'loaned', so we shouldn't be able to loan it
|
|
assert status == 'loaned'
|
|
|
|
# The application logic should prevent this
|
|
# In the actual app, this would be checked before inserting
|
|
# Here we verify the status is still loaned
|
|
cursor.execute("SELECT status FROM tablets WHERE id = ?", (tablet_id,))
|
|
final_status = cursor.fetchone()['status']
|
|
assert final_status == 'loaned'
|
|
|
|
def test_return_tablet_success(self, populated_db):
|
|
"""Test returning a loaned tablet"""
|
|
cursor = populated_db.cursor()
|
|
|
|
# Get an active loan
|
|
cursor.execute("SELECT * FROM loans WHERE status = 'active' LIMIT 1")
|
|
loan = cursor.fetchone()
|
|
|
|
if loan:
|
|
loan_id = loan['id']
|
|
tablet_id = loan['tablet_id']
|
|
|
|
# Return the tablet
|
|
return_date = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
|
|
cursor.execute('''
|
|
UPDATE loans SET status = 'returned', return_date = ? WHERE id = ?
|
|
''', (return_date, loan_id))
|
|
cursor.execute("UPDATE tablets SET status = 'available' WHERE id = ?", (tablet_id,))
|
|
populated_db.commit()
|
|
|
|
# Verify loan status changed
|
|
cursor.execute("SELECT status, return_date FROM loans WHERE id = ?", (loan_id,))
|
|
updated_loan = cursor.fetchone()
|
|
assert updated_loan['status'] == 'returned'
|
|
assert updated_loan['return_date'] is not None
|
|
|
|
# Verify tablet status changed
|
|
cursor.execute("SELECT status FROM tablets WHERE id = ?", (tablet_id,))
|
|
tablet_status = cursor.fetchone()['status']
|
|
assert tablet_status == 'available'
|
|
|
|
def test_return_nonexistent_loan(self, db_conn):
|
|
"""Test returning a loan that doesn't exist"""
|
|
cursor = db_conn.cursor()
|
|
|
|
# Try to return a non-existent loan
|
|
cursor.execute("SELECT tablet_id FROM loans WHERE id = ? AND status = 'active'", (9999,))
|
|
loan = cursor.fetchone()
|
|
|
|
# Should be None since loan doesn't exist
|
|
assert loan is None
|
|
|
|
|
|
class TestEdgeCases:
|
|
"""Tests for edge cases and error conditions"""
|
|
|
|
def test_loan_to_nonexistent_user(self, db_conn):
|
|
"""Test loaning to a user that doesn't exist"""
|
|
cursor = db_conn.cursor()
|
|
|
|
# Add a tablet
|
|
cursor.execute('''
|
|
INSERT INTO tablets (brand, model, serial_number, status)
|
|
VALUES (?, ?, ?, 'available')
|
|
''', ('Brand', 'Model', 'EDGE001'))
|
|
db_conn.commit()
|
|
|
|
cursor.execute("SELECT id FROM tablets WHERE serial_number = 'EDGE001'")
|
|
tablet = cursor.fetchone()
|
|
|
|
# Try to loan to non-existent user (ID 9999)
|
|
# Note: SQLite doesn't enforce foreign keys by default unless we enable it
|
|
# The application should validate this at the application level
|
|
# For now, we verify that the user doesn't exist
|
|
cursor.execute("SELECT id FROM users WHERE id = 9999")
|
|
user = cursor.fetchone()
|
|
assert user is None # User doesn't exist
|
|
|
|
# In a real app with FK enforcement, this would raise IntegrityError
|
|
# For SQLite without FK enforcement, we just verify the user check
|
|
|
|
def test_loan_nonexistent_tablet(self, db_conn):
|
|
"""Test loaning a tablet that doesn't exist"""
|
|
cursor = db_conn.cursor()
|
|
|
|
# Add a user
|
|
cursor.execute('''
|
|
INSERT INTO users (name, identification)
|
|
VALUES (?, ?)
|
|
''', ('Test User', 'EDGEID001'))
|
|
db_conn.commit()
|
|
|
|
cursor.execute("SELECT id FROM users WHERE identification = 'EDGEID001'")
|
|
user = cursor.fetchone()
|
|
|
|
# Try to loan non-existent tablet (ID 9999)
|
|
# Note: SQLite doesn't enforce foreign keys by default unless we enable it
|
|
# The application should validate this at the application level
|
|
# For now, we verify that the tablet doesn't exist
|
|
cursor.execute("SELECT id FROM tablets WHERE id = 9999")
|
|
tablet_check = cursor.fetchone()
|
|
assert tablet_check is None # Tablet doesn't exist
|
|
|
|
# In a real app with FK enforcement, this would raise IntegrityError
|
|
# For SQLite without FK enforcement, we just verify the tablet check
|
|
|
|
def test_empty_database_operations(self, db_conn):
|
|
"""Test operations on empty database"""
|
|
cursor = db_conn.cursor()
|
|
|
|
# Query empty tables
|
|
cursor.execute("SELECT COUNT(*) FROM tablets")
|
|
tablet_count = cursor.fetchone()[0]
|
|
assert tablet_count == 0
|
|
|
|
cursor.execute("SELECT COUNT(*) FROM users")
|
|
user_count = cursor.fetchone()[0]
|
|
assert user_count == 0
|
|
|
|
cursor.execute("SELECT COUNT(*) FROM loans")
|
|
loan_count = cursor.fetchone()[0]
|
|
assert loan_count == 0
|
|
|
|
def test_multiple_loans_same_user(self, db_conn):
|
|
"""Test that one user can have multiple loans (one-to-many relationship)"""
|
|
cursor = db_conn.cursor()
|
|
|
|
# Add user
|
|
cursor.execute('''
|
|
INSERT INTO users (name, identification)
|
|
VALUES (?, ?)
|
|
''', ('MultiLoan User', 'MULTI001'))
|
|
db_conn.commit()
|
|
cursor.execute("SELECT id FROM users WHERE identification = 'MULTI001'")
|
|
user = cursor.fetchone()
|
|
|
|
# Add multiple tablets
|
|
for i in range(3):
|
|
cursor.execute('''
|
|
INSERT INTO tablets (brand, model, serial_number, status)
|
|
VALUES (?, ?, ?, 'available')
|
|
''', (f'Brand{i}', f'Model{i}', f'MULTI{i:03d}'))
|
|
db_conn.commit()
|
|
|
|
# Loan all tablets to the same user
|
|
cursor.execute("SELECT id FROM tablets WHERE serial_number LIKE 'MULTI%'")
|
|
tablets = cursor.fetchall()
|
|
|
|
loan_date = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
|
|
for tablet in tablets:
|
|
cursor.execute("UPDATE tablets SET status = 'loaned' WHERE id = ?", (tablet['id'],))
|
|
cursor.execute('''
|
|
INSERT INTO loans (tablet_id, user_id, loan_date, status)
|
|
VALUES (?, ?, ?, 'active')
|
|
''', (tablet['id'], user['id'], loan_date))
|
|
db_conn.commit()
|
|
|
|
# Verify user has multiple loans
|
|
cursor.execute("SELECT COUNT(*) FROM loans WHERE user_id = ?", (user['id'],))
|
|
loan_count = cursor.fetchone()[0]
|
|
assert loan_count == 3
|
|
|
|
def test_serial_number_uniqueness_across_tables(self, db_conn):
|
|
"""Test that serial numbers are unique within their respective tables"""
|
|
cursor = db_conn.cursor()
|
|
|
|
# Add tablet with serial number
|
|
cursor.execute('''
|
|
INSERT INTO tablets (brand, model, serial_number, status)
|
|
VALUES (?, ?, ?, 'available')
|
|
''', ('Brand', 'Model', 'UNIQUE001'))
|
|
db_conn.commit()
|
|
|
|
# Add non-loanable device with same serial number (should be allowed - different tables)
|
|
cursor.execute('''
|
|
INSERT INTO non_loanable_devices
|
|
(brand, model, serial_number, device_type, status)
|
|
VALUES (?, ?, ?, ?, 'available')
|
|
''', ('Brand', 'Model', 'UNIQUE001', 'projector'))
|
|
db_conn.commit()
|
|
|
|
# Both should exist (different tables)
|
|
cursor.execute("SELECT COUNT(*) FROM tablets WHERE serial_number = 'UNIQUE001'")
|
|
tablet_count = cursor.fetchone()[0]
|
|
cursor.execute("SELECT COUNT(*) FROM non_loanable_devices WHERE serial_number = 'UNIQUE001'")
|
|
device_count = cursor.fetchone()[0]
|
|
|
|
assert tablet_count == 1
|
|
assert device_count == 1
|
|
|
|
# But duplicate within same table should fail
|
|
with pytest.raises(sqlite3.IntegrityError):
|
|
cursor.execute('''
|
|
INSERT INTO tablets (brand, model, serial_number, status)
|
|
VALUES (?, ?, ?, 'available')
|
|
''', ('Brand2', 'Model2', 'UNIQUE001'))
|
|
db_conn.commit()
|
|
|
|
|
|
class TestQueryOperations:
|
|
"""Tests for query and filtering operations"""
|
|
|
|
def test_query_available_tablets(self, populated_db):
|
|
"""Test querying available tablets"""
|
|
cursor = populated_db.cursor()
|
|
|
|
cursor.execute("SELECT * FROM tablets WHERE status = 'available'")
|
|
available = cursor.fetchall()
|
|
|
|
# Should have at least the sample available tablets
|
|
assert len(available) >= 3 # SN001, SN002, SN003 from sample
|
|
|
|
def test_query_loaned_tablets(self, populated_db):
|
|
"""Test querying loaned tablets"""
|
|
cursor = populated_db.cursor()
|
|
|
|
cursor.execute("SELECT * FROM tablets WHERE status = 'loaned'")
|
|
loaned = cursor.fetchall()
|
|
|
|
# Should have at least SN004 from sample data
|
|
assert len(loaned) >= 1
|
|
|
|
def test_query_active_loans(self, populated_db):
|
|
"""Test querying active loans"""
|
|
cursor = populated_db.cursor()
|
|
|
|
cursor.execute("SELECT * FROM loans WHERE status = 'active'")
|
|
active = cursor.fetchall()
|
|
|
|
# Should have at least 1 active loan from sample
|
|
assert len(active) >= 1
|
|
|
|
def test_query_returned_loans(self, populated_db):
|
|
"""Test querying returned loans"""
|
|
cursor = populated_db.cursor()
|
|
|
|
cursor.execute("SELECT * FROM loans WHERE status = 'returned'")
|
|
returned = cursor.fetchall()
|
|
|
|
# Should have at least 1 returned loan from sample
|
|
assert len(returned) >= 1
|
|
|
|
def test_query_loans_by_user(self, populated_db):
|
|
"""Test querying loans by user"""
|
|
cursor = populated_db.cursor()
|
|
|
|
cursor.execute("SELECT id FROM users LIMIT 1")
|
|
user = cursor.fetchone()
|
|
|
|
if user:
|
|
cursor.execute("SELECT * FROM loans WHERE user_id = ?", (user['id'],))
|
|
loans = cursor.fetchall()
|
|
|
|
# User should have at least 0 loans
|
|
assert isinstance(loans, list)
|
|
|
|
def test_query_tablets_by_brand(self, populated_db):
|
|
"""Test querying tablets by brand"""
|
|
cursor = populated_db.cursor()
|
|
|
|
cursor.execute("SELECT * FROM tablets WHERE brand = 'Samsung'")
|
|
samsung = cursor.fetchall()
|
|
|
|
# Should find Samsung tablet from sample data
|
|
assert len(samsung) >= 1
|
|
assert samsung[0]['brand'] == 'Samsung'
|