test: add comprehensive unit test suite
- 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
This commit is contained in:
ijuanes
parent
d3d1fb1b32
commit
83ac67fea2
7 changed files with 1575 additions and 0 deletions
3
tests/__init__.py
Normal file
3
tests/__init__.py
Normal file
|
|
@ -0,0 +1,3 @@
|
|||
"""
|
||||
Unit tests for Tablet Management System
|
||||
"""
|
||||
181
tests/conftest.py
Normal file
181
tests/conftest.py
Normal file
|
|
@ -0,0 +1,181 @@
|
|||
"""
|
||||
Pytest configuration and fixtures for Tablet Management System tests
|
||||
"""
|
||||
|
||||
import pytest
|
||||
import sqlite3
|
||||
import os
|
||||
import sys
|
||||
from datetime import datetime
|
||||
|
||||
# Add project root to path for imports
|
||||
sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def test_db_path():
|
||||
"""Path to test database"""
|
||||
return 'test_tablets.db'
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def init_test_db(test_db_path):
|
||||
"""Initialize a fresh test database with schema"""
|
||||
# Remove existing test database if it exists
|
||||
if os.path.exists(test_db_path):
|
||||
os.remove(test_db_path)
|
||||
|
||||
conn = sqlite3.connect(test_db_path)
|
||||
cursor = conn.cursor()
|
||||
|
||||
# Create tables
|
||||
cursor.execute('''
|
||||
CREATE TABLE IF NOT EXISTS tablets (
|
||||
id INTEGER PRIMARY KEY AUTOINCREMENT,
|
||||
brand TEXT NOT NULL,
|
||||
model TEXT NOT NULL,
|
||||
serial_number TEXT UNIQUE NOT NULL,
|
||||
status TEXT DEFAULT 'available',
|
||||
notes TEXT
|
||||
)
|
||||
''')
|
||||
|
||||
cursor.execute('''
|
||||
CREATE TABLE IF NOT EXISTS users (
|
||||
id INTEGER PRIMARY KEY AUTOINCREMENT,
|
||||
name TEXT NOT NULL,
|
||||
email TEXT,
|
||||
phone TEXT,
|
||||
identification TEXT UNIQUE
|
||||
)
|
||||
''')
|
||||
|
||||
cursor.execute('''
|
||||
CREATE TABLE IF NOT EXISTS loans (
|
||||
id INTEGER PRIMARY KEY AUTOINCREMENT,
|
||||
tablet_id INTEGER NOT NULL,
|
||||
user_id INTEGER NOT NULL,
|
||||
loan_date TEXT NOT NULL,
|
||||
return_date TEXT,
|
||||
status TEXT DEFAULT 'active',
|
||||
FOREIGN KEY (tablet_id) REFERENCES tablets (id),
|
||||
FOREIGN KEY (user_id) REFERENCES users (id)
|
||||
)
|
||||
''')
|
||||
|
||||
cursor.execute('''
|
||||
CREATE TABLE IF NOT EXISTS non_loanable_devices (
|
||||
id INTEGER PRIMARY KEY AUTOINCREMENT,
|
||||
brand TEXT NOT NULL,
|
||||
model TEXT NOT NULL,
|
||||
serial_number TEXT UNIQUE NOT NULL,
|
||||
device_type TEXT NOT NULL,
|
||||
location TEXT,
|
||||
status TEXT DEFAULT 'available',
|
||||
notes TEXT,
|
||||
purchase_date TEXT,
|
||||
purchase_cost REAL
|
||||
)
|
||||
''')
|
||||
|
||||
conn.commit()
|
||||
conn.close()
|
||||
|
||||
yield test_db_path
|
||||
|
||||
# Cleanup: remove test database
|
||||
if os.path.exists(test_db_path):
|
||||
os.remove(test_db_path)
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def db_conn(init_test_db):
|
||||
"""Get a database connection to the test database"""
|
||||
conn = sqlite3.connect(init_test_db)
|
||||
conn.row_factory = sqlite3.Row
|
||||
yield conn
|
||||
conn.close()
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def sample_tablets(db_conn):
|
||||
"""Insert sample tablets into test database"""
|
||||
cursor = db_conn.cursor()
|
||||
|
||||
tablets = [
|
||||
('Samsung', 'Galaxy Tab S7', 'SN001', 'available'),
|
||||
('Apple', 'iPad Pro', 'SN002', 'available'),
|
||||
('Lenovo', 'Tab P11', 'SN003', 'available'),
|
||||
('Microsoft', 'Surface Pro', 'SN004', 'loaned'),
|
||||
]
|
||||
|
||||
for brand, model, serial, status in tablets:
|
||||
cursor.execute('''
|
||||
INSERT INTO tablets (brand, model, serial_number, status)
|
||||
VALUES (?, ?, ?, ?)
|
||||
''', (brand, model, serial, status))
|
||||
|
||||
db_conn.commit()
|
||||
return tablets
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def sample_users(db_conn):
|
||||
"""Insert sample users into test database"""
|
||||
cursor = db_conn.cursor()
|
||||
|
||||
users = [
|
||||
('John Doe', 'john@example.com', '1234567890', 'ID001'),
|
||||
('Jane Smith', 'jane@example.com', '0987654321', 'ID002'),
|
||||
('Bob Johnson', 'bob@example.com', '5551234567', 'ID003'),
|
||||
]
|
||||
|
||||
for name, email, phone, identification in users:
|
||||
cursor.execute('''
|
||||
INSERT INTO users (name, email, phone, identification)
|
||||
VALUES (?, ?, ?, ?)
|
||||
''', (name, email, phone, identification))
|
||||
|
||||
db_conn.commit()
|
||||
return users
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def sample_loans(db_conn, sample_tablets, sample_users):
|
||||
"""Insert sample loans into test database"""
|
||||
cursor = db_conn.cursor()
|
||||
|
||||
# Get tablet and user IDs
|
||||
cursor.execute("SELECT id FROM tablets WHERE serial_number = 'SN004'")
|
||||
loaned_tablet = cursor.fetchone()
|
||||
|
||||
cursor.execute("SELECT id FROM users WHERE identification = 'ID001'")
|
||||
user1 = cursor.fetchone()
|
||||
|
||||
cursor.execute("SELECT id FROM users WHERE identification = 'ID002'")
|
||||
user2 = cursor.fetchone()
|
||||
|
||||
if loaned_tablet and user1:
|
||||
# Active loan for SN004 to user1
|
||||
loan_date = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
|
||||
cursor.execute('''
|
||||
INSERT INTO loans (tablet_id, user_id, loan_date, status)
|
||||
VALUES (?, ?, ?, 'active')
|
||||
''', (loaned_tablet['id'], user1['id'], loan_date))
|
||||
|
||||
if user2:
|
||||
# Returned loan for SN001 to user2
|
||||
loan_date = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
|
||||
return_date = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
|
||||
cursor.execute('''
|
||||
INSERT INTO loans (tablet_id, user_id, loan_date, return_date, status)
|
||||
VALUES (?, ?, ?, ?, 'returned')
|
||||
''', (1, user2['id'], loan_date, return_date))
|
||||
|
||||
db_conn.commit()
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def populated_db(db_conn, sample_tablets, sample_users, sample_loans):
|
||||
"""Database with all sample data loaded"""
|
||||
return db_conn
|
||||
2
tests/requirements.txt
Normal file
2
tests/requirements.txt
Normal file
|
|
@ -0,0 +1,2 @@
|
|||
pytest==8.3.2
|
||||
pytest-cov==5.0.0
|
||||
481
tests/test_core.py
Normal file
481
tests/test_core.py
Normal file
|
|
@ -0,0 +1,481 @@
|
|||
"""
|
||||
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'
|
||||
513
tests/test_edge_cases.py
Normal file
513
tests/test_edge_cases.py
Normal file
|
|
@ -0,0 +1,513 @@
|
|||
"""
|
||||
Edge case tests for Tablet Management System
|
||||
Tests critical scenarios: already loaned devices, non-existent loans, duplicates, etc.
|
||||
"""
|
||||
|
||||
import pytest
|
||||
import sqlite3
|
||||
from datetime import datetime
|
||||
import sys
|
||||
import os
|
||||
|
||||
sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
|
||||
|
||||
|
||||
class TestLoanEdgeCases:
|
||||
"""Critical edge cases for loan operations"""
|
||||
|
||||
def test_loan_device_already_loaned(self, db_conn):
|
||||
"""
|
||||
CRITICAL: Test that a device already loaned cannot be loaned again
|
||||
This prevents the same physical device from being loaned to multiple users
|
||||
"""
|
||||
cursor = db_conn.cursor()
|
||||
|
||||
# Add a tablet
|
||||
cursor.execute('''
|
||||
INSERT INTO tablets (brand, model, serial_number, status)
|
||||
VALUES (?, ?, ?, 'available')
|
||||
''', ('Brand', 'Model', 'ALREADY_LOANED'))
|
||||
db_conn.commit()
|
||||
|
||||
cursor.execute("SELECT id FROM tablets WHERE serial_number = 'ALREADY_LOANED'")
|
||||
tablet = cursor.fetchone()
|
||||
|
||||
# Add a user
|
||||
cursor.execute('''
|
||||
INSERT INTO users (name, identification)
|
||||
VALUES (?, ?)
|
||||
''', ('User1', 'USER1'))
|
||||
db_conn.commit()
|
||||
cursor.execute("SELECT id FROM users WHERE identification = 'USER1'")
|
||||
user1 = cursor.fetchone()
|
||||
|
||||
# Add another user
|
||||
cursor.execute('''
|
||||
INSERT INTO users (name, identification)
|
||||
VALUES (?, ?)
|
||||
''', ('User2', 'USER2'))
|
||||
db_conn.commit()
|
||||
cursor.execute("SELECT id FROM users WHERE identification = 'USER2'")
|
||||
user2 = cursor.fetchone()
|
||||
|
||||
# Loan to first user
|
||||
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'], user1['id'], loan_date))
|
||||
db_conn.commit()
|
||||
|
||||
# Verify tablet is loaned
|
||||
cursor.execute("SELECT status FROM tablets WHERE id = ?", (tablet['id'],))
|
||||
status = cursor.fetchone()['status']
|
||||
assert status == 'loaned'
|
||||
|
||||
# Try to loan to second user - should check status first
|
||||
# In the actual application, this would be prevented by checking status
|
||||
cursor.execute("SELECT status FROM tablets WHERE id = ?", (tablet['id'],))
|
||||
current_status = cursor.fetchone()['status']
|
||||
|
||||
# The application logic should prevent this
|
||||
assert current_status == 'loaned'
|
||||
|
||||
# If we tried to loan it anyway (without checking), we'd get a constraint error
|
||||
# because the tablet status is already 'loaned'
|
||||
# The proper app logic checks status before allowing loan
|
||||
|
||||
def test_return_nonexistent_loan_id(self, db_conn):
|
||||
"""
|
||||
CRITICAL: Test returning a loan that doesn't exist
|
||||
Should handle gracefully without crashing
|
||||
"""
|
||||
cursor = db_conn.cursor()
|
||||
|
||||
# Try to return a non-existent loan
|
||||
loan_id = 99999
|
||||
cursor.execute("SELECT tablet_id FROM loans WHERE id = ? AND status = 'active'", (loan_id,))
|
||||
loan = cursor.fetchone()
|
||||
|
||||
# Should return None (no such loan)
|
||||
assert loan is None
|
||||
|
||||
# The application should handle this by showing an error message
|
||||
# rather than crashing
|
||||
|
||||
def test_return_already_returned_loan(self, db_conn):
|
||||
"""
|
||||
CRITICAL: Test returning a loan that's already been returned
|
||||
Should handle gracefully
|
||||
"""
|
||||
cursor = db_conn.cursor()
|
||||
|
||||
# Add tablet and user
|
||||
cursor.execute('''
|
||||
INSERT INTO tablets (brand, model, serial_number, status)
|
||||
VALUES (?, ?, ?, 'available')
|
||||
''', ('Brand', 'Model', 'ALREADY_RETURNED'))
|
||||
db_conn.commit()
|
||||
cursor.execute("SELECT id FROM tablets WHERE serial_number = 'ALREADY_RETURNED'")
|
||||
tablet = cursor.fetchone()
|
||||
|
||||
cursor.execute('''
|
||||
INSERT INTO users (name, identification)
|
||||
VALUES (?, ?)
|
||||
''', ('User', 'RETURN_USER'))
|
||||
db_conn.commit()
|
||||
cursor.execute("SELECT id FROM users WHERE identification = 'RETURN_USER'")
|
||||
user = cursor.fetchone()
|
||||
|
||||
# Create and return a loan
|
||||
loan_date = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
|
||||
return_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, return_date, status)
|
||||
VALUES (?, ?, ?, ?, 'returned')
|
||||
''', (tablet['id'], user['id'], loan_date, return_date))
|
||||
cursor.execute("UPDATE tablets SET status = 'available' WHERE id = ?", (tablet['id'],))
|
||||
db_conn.commit()
|
||||
|
||||
# Get the loan ID
|
||||
cursor.execute("SELECT id FROM loans WHERE tablet_id = ?", (tablet['id'],))
|
||||
loan = cursor.fetchone()
|
||||
loan_id = loan['id']
|
||||
|
||||
# Try to return it again
|
||||
cursor.execute("SELECT tablet_id FROM loans WHERE id = ? AND status = 'active'", (loan_id,))
|
||||
active_loan = cursor.fetchone()
|
||||
|
||||
# Should be None because status is 'returned', not 'active'
|
||||
assert active_loan is None
|
||||
|
||||
def test_loan_with_invalid_tablet_id(self, db_conn):
|
||||
"""
|
||||
CRITICAL: Test loaning with an invalid/non-existent tablet ID
|
||||
Should fail gracefully
|
||||
"""
|
||||
cursor = db_conn.cursor()
|
||||
|
||||
# Add a user
|
||||
cursor.execute('''
|
||||
INSERT INTO users (name, identification)
|
||||
VALUES (?, ?)
|
||||
''', ('User', 'INVALID_USER'))
|
||||
db_conn.commit()
|
||||
cursor.execute("SELECT id FROM users WHERE identification = 'INVALID_USER'")
|
||||
user = cursor.fetchone()
|
||||
|
||||
# Try to loan with invalid tablet ID
|
||||
invalid_tablet_id = 99999
|
||||
loan_date = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
|
||||
|
||||
# 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 = ?", (invalid_tablet_id,))
|
||||
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_loan_with_invalid_user_id(self, db_conn):
|
||||
"""
|
||||
CRITICAL: Test loaning with an invalid/non-existent user ID
|
||||
Should fail gracefully
|
||||
"""
|
||||
cursor = db_conn.cursor()
|
||||
|
||||
# Add a tablet
|
||||
cursor.execute('''
|
||||
INSERT INTO tablets (brand, model, serial_number, status)
|
||||
VALUES (?, ?, ?, 'available')
|
||||
''', ('Brand', 'Model', 'INVALID_LOAN'))
|
||||
db_conn.commit()
|
||||
cursor.execute("SELECT id FROM tablets WHERE serial_number = 'INVALID_LOAN'")
|
||||
tablet = cursor.fetchone()
|
||||
|
||||
# Try to loan with invalid user ID
|
||||
invalid_user_id = 99999
|
||||
loan_date = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
|
||||
|
||||
# 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 = ?", (invalid_user_id,))
|
||||
user_check = cursor.fetchone()
|
||||
assert user_check 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
|
||||
|
||||
|
||||
class TestDuplicatePrevention:
|
||||
"""Tests for preventing duplicate entries"""
|
||||
|
||||
def test_duplicate_tablet_serial_number(self, db_conn):
|
||||
"""
|
||||
CRITICAL: Test that duplicate tablet serial numbers are prevented
|
||||
Serial numbers must be unique for tracking
|
||||
"""
|
||||
cursor = db_conn.cursor()
|
||||
|
||||
# Add first tablet
|
||||
cursor.execute('''
|
||||
INSERT INTO tablets (brand, model, serial_number, status)
|
||||
VALUES (?, ?, ?, 'available')
|
||||
''', ('Brand1', 'Model1', 'DUP_SERIAL'))
|
||||
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', 'DUP_SERIAL'))
|
||||
db_conn.commit()
|
||||
|
||||
def test_duplicate_user_identification(self, db_conn):
|
||||
"""
|
||||
CRITICAL: Test that duplicate user identifications are prevented
|
||||
User identifications must be unique
|
||||
"""
|
||||
cursor = db_conn.cursor()
|
||||
|
||||
# Add first user
|
||||
cursor.execute('''
|
||||
INSERT INTO users (name, identification)
|
||||
VALUES (?, ?)
|
||||
''', ('User1', 'DUP_ID'))
|
||||
db_conn.commit()
|
||||
|
||||
# Try to add duplicate
|
||||
with pytest.raises(sqlite3.IntegrityError):
|
||||
cursor.execute('''
|
||||
INSERT INTO users (name, identification)
|
||||
VALUES (?, ?)
|
||||
''', ('User2', 'DUP_ID'))
|
||||
db_conn.commit()
|
||||
|
||||
def test_duplicate_non_loanable_device_serial(self, db_conn):
|
||||
"""
|
||||
CRITICAL: Test that duplicate non-loanable device serials are prevented
|
||||
"""
|
||||
cursor = db_conn.cursor()
|
||||
|
||||
# Add first device
|
||||
cursor.execute('''
|
||||
INSERT INTO non_loanable_devices
|
||||
(brand, model, serial_number, device_type, status)
|
||||
VALUES (?, ?, ?, ?, 'available')
|
||||
''', ('Brand', 'Model', 'DUP_DEVICE_SERIAL', 'projector'))
|
||||
db_conn.commit()
|
||||
|
||||
# Try to add duplicate
|
||||
with pytest.raises(sqlite3.IntegrityError):
|
||||
cursor.execute('''
|
||||
INSERT INTO non_loanable_devices
|
||||
(brand, model, serial_number, device_type, status)
|
||||
VALUES (?, ?, ?, ?, 'available')
|
||||
''', ('Brand2', 'Model2', 'DUP_DEVICE_SERIAL', 'monitor'))
|
||||
db_conn.commit()
|
||||
|
||||
|
||||
class TestDataIntegrity:
|
||||
"""Tests for data integrity constraints"""
|
||||
|
||||
def test_foreign_key_tablet_deletion(self, db_conn):
|
||||
"""
|
||||
Test that deleting a tablet with active loans is handled
|
||||
SQLite defaults to allowing this, but we should be aware
|
||||
"""
|
||||
cursor = db_conn.cursor()
|
||||
|
||||
# Add tablet and user
|
||||
cursor.execute('''
|
||||
INSERT INTO tablets (brand, model, serial_number, status)
|
||||
VALUES (?, ?, ?, 'available')
|
||||
''', ('Brand', 'Model', 'FK_TEST'))
|
||||
db_conn.commit()
|
||||
cursor.execute("SELECT id FROM tablets WHERE serial_number = 'FK_TEST'")
|
||||
tablet = cursor.fetchone()
|
||||
|
||||
cursor.execute('''
|
||||
INSERT INTO users (name, identification)
|
||||
VALUES (?, ?)
|
||||
''', ('User', 'FK_USER'))
|
||||
db_conn.commit()
|
||||
cursor.execute("SELECT id FROM users WHERE identification = 'FK_USER'")
|
||||
user = cursor.fetchone()
|
||||
|
||||
# Create active loan
|
||||
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))
|
||||
db_conn.commit()
|
||||
|
||||
# SQLite allows this by default (no ON DELETE RESTRICT)
|
||||
# In production, we might want to add CASCADE or RESTRICT
|
||||
# For now, just verify the loan exists
|
||||
cursor.execute("SELECT COUNT(*) FROM loans WHERE tablet_id = ?", (tablet['id'],))
|
||||
loan_count = cursor.fetchone()[0]
|
||||
assert loan_count == 1
|
||||
|
||||
def test_null_serial_number_prevention(self, db_conn):
|
||||
"""
|
||||
Test that NULL serial numbers are prevented
|
||||
Serial numbers are required (NOT NULL constraint)
|
||||
"""
|
||||
cursor = db_conn.cursor()
|
||||
|
||||
# Try to add tablet with NULL serial number
|
||||
with pytest.raises(sqlite3.IntegrityError):
|
||||
cursor.execute('''
|
||||
INSERT INTO tablets (brand, model, serial_number, status)
|
||||
VALUES (?, ?, ?, 'available')
|
||||
''', ('Brand', 'Model', None))
|
||||
db_conn.commit()
|
||||
|
||||
def test_null_identification_prevention(self, db_conn):
|
||||
"""
|
||||
Test that NULL user identifications are prevented
|
||||
Identifications are required (NOT NULL constraint)
|
||||
"""
|
||||
cursor = db_conn.cursor()
|
||||
|
||||
# Try to add user with NULL identification
|
||||
# Note: identification is NOT marked as NOT NULL in the schema
|
||||
# This test verifies the current behavior
|
||||
cursor.execute('''
|
||||
INSERT INTO users (name, identification)
|
||||
VALUES (?, ?)
|
||||
''', ('User', None))
|
||||
db_conn.commit()
|
||||
|
||||
# This should work because identification is not NOT NULL
|
||||
# But in practice, we should have this constraint
|
||||
cursor.execute("SELECT COUNT(*) FROM users WHERE identification IS NULL")
|
||||
count = cursor.fetchone()[0]
|
||||
# This will be 1, showing that NULL is currently allowed
|
||||
# In production, we should add NOT NULL constraint
|
||||
|
||||
def test_empty_string_serial_number(self, db_conn):
|
||||
"""
|
||||
Test handling of empty string serial numbers
|
||||
Empty strings are different from NULL
|
||||
"""
|
||||
cursor = db_conn.cursor()
|
||||
|
||||
# Add tablet with empty string serial number
|
||||
cursor.execute('''
|
||||
INSERT INTO tablets (brand, model, serial_number, status)
|
||||
VALUES (?, ?, ?, 'available')
|
||||
''', ('Brand', 'Model', ''))
|
||||
db_conn.commit()
|
||||
|
||||
# This should work (empty string is allowed unless we add CHECK constraint)
|
||||
cursor.execute("SELECT COUNT(*) FROM tablets WHERE serial_number = ''")
|
||||
count = cursor.fetchone()[0]
|
||||
assert count == 1
|
||||
|
||||
# In production, we might want to prevent empty strings
|
||||
# with a CHECK constraint: CHECK(serial_number <> '')
|
||||
|
||||
|
||||
class TestConcurrentScenarioSimulations:
|
||||
"""Simulate scenarios that could cause issues in concurrent environments"""
|
||||
|
||||
def test_loan_return_loan_sequence(self, db_conn):
|
||||
"""
|
||||
Test the sequence: loan -> return -> loan again
|
||||
This simulates a device being loaned multiple times over its lifetime
|
||||
"""
|
||||
cursor = db_conn.cursor()
|
||||
|
||||
# Add tablet and user
|
||||
cursor.execute('''
|
||||
INSERT INTO tablets (brand, model, serial_number, status)
|
||||
VALUES (?, ?, ?, 'available')
|
||||
''', ('Brand', 'Model', 'SEQUENCE_TEST'))
|
||||
db_conn.commit()
|
||||
cursor.execute("SELECT id FROM tablets WHERE serial_number = 'SEQUENCE_TEST'")
|
||||
tablet = cursor.fetchone()
|
||||
|
||||
cursor.execute('''
|
||||
INSERT INTO users (name, identification)
|
||||
VALUES (?, ?)
|
||||
''', ('User', 'SEQUENCE_USER'))
|
||||
db_conn.commit()
|
||||
cursor.execute("SELECT id FROM users WHERE identification = 'SEQUENCE_USER'")
|
||||
user = cursor.fetchone()
|
||||
|
||||
# First loan
|
||||
loan_date1 = 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_date1))
|
||||
db_conn.commit()
|
||||
|
||||
# Return
|
||||
return_date = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
|
||||
cursor.execute("SELECT id FROM loans WHERE tablet_id = ?", (tablet['id'],))
|
||||
loan1 = cursor.fetchone()
|
||||
cursor.execute('''
|
||||
UPDATE loans SET status = 'returned', return_date = ? WHERE id = ?
|
||||
''', (return_date, loan1['id']))
|
||||
cursor.execute("UPDATE tablets SET status = 'available' WHERE id = ?", (tablet['id'],))
|
||||
db_conn.commit()
|
||||
|
||||
# Second loan
|
||||
loan_date2 = 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_date2))
|
||||
db_conn.commit()
|
||||
|
||||
# Verify we have 2 loans for this tablet
|
||||
cursor.execute("SELECT COUNT(*) FROM loans WHERE tablet_id = ?", (tablet['id'],))
|
||||
loan_count = cursor.fetchone()[0]
|
||||
assert loan_count == 2
|
||||
|
||||
# Verify 1 active, 1 returned
|
||||
cursor.execute("SELECT COUNT(*) FROM loans WHERE tablet_id = ? AND status = 'active'", (tablet['id'],))
|
||||
active_count = cursor.fetchone()[0]
|
||||
cursor.execute("SELECT COUNT(*) FROM loans WHERE tablet_id = ? AND status = 'returned'", (tablet['id'],))
|
||||
returned_count = cursor.fetchone()[0]
|
||||
|
||||
assert active_count == 1
|
||||
assert returned_count == 1
|
||||
|
||||
def test_multiple_users_multiple_tablets(self, db_conn):
|
||||
"""
|
||||
Test complex scenario with multiple users and tablets
|
||||
Ensures the many-to-many relationship works correctly
|
||||
"""
|
||||
cursor = db_conn.cursor()
|
||||
|
||||
# Add 3 users
|
||||
users = []
|
||||
for i in range(3):
|
||||
cursor.execute('''
|
||||
INSERT INTO users (name, identification)
|
||||
VALUES (?, ?)
|
||||
''', (f'User{i}', f'MULTI_USER_{i}'))
|
||||
db_conn.commit()
|
||||
cursor.execute("SELECT id FROM users WHERE identification = ?", (f'MULTI_USER_{i}',))
|
||||
users.append(cursor.fetchone())
|
||||
|
||||
# Add 5 tablets
|
||||
tablets = []
|
||||
for i in range(5):
|
||||
cursor.execute('''
|
||||
INSERT INTO tablets (brand, model, serial_number, status)
|
||||
VALUES (?, ?, ?, 'available')
|
||||
''', (f'Brand{i}', f'Model{i}', f'MULTI_TABLET_{i}'))
|
||||
db_conn.commit()
|
||||
cursor.execute("SELECT id FROM tablets WHERE serial_number = ?", (f'MULTI_TABLET_{i}',))
|
||||
tablets.append(cursor.fetchone())
|
||||
|
||||
# Loan tablets to users in a pattern
|
||||
# User 0: tablets 0, 1
|
||||
# User 1: tablets 2, 3
|
||||
# User 2: tablet 4
|
||||
loan_date = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
|
||||
|
||||
loans_map = {
|
||||
users[0]['id']: [tablets[0]['id'], tablets[1]['id']],
|
||||
users[1]['id']: [tablets[2]['id'], tablets[3]['id']],
|
||||
users[2]['id']: [tablets[4]['id']],
|
||||
}
|
||||
|
||||
for user_id, tablet_ids in loans_map.items():
|
||||
for tablet_id in tablet_ids:
|
||||
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 counts
|
||||
cursor.execute("SELECT COUNT(*) FROM loans")
|
||||
total_loans = cursor.fetchone()[0]
|
||||
assert total_loans == 5 # 2 + 2 + 1
|
||||
|
||||
# Verify each user has correct number of loans
|
||||
for user_id, expected_tablet_ids in loans_map.items():
|
||||
cursor.execute("SELECT COUNT(*) FROM loans WHERE user_id = ?", (user_id,))
|
||||
count = cursor.fetchone()[0]
|
||||
assert count == len(expected_tablet_ids)
|
||||
|
||||
# Verify all loaned tablets have correct status
|
||||
cursor.execute("SELECT COUNT(*) FROM tablets WHERE status = 'loaned'")
|
||||
loaned_count = cursor.fetchone()[0]
|
||||
assert loaned_count == 5
|
||||
365
tests/test_minimal_app.py
Normal file
365
tests/test_minimal_app.py
Normal file
|
|
@ -0,0 +1,365 @@
|
|||
"""
|
||||
Unit tests for the actual application functions from minimal_app.py
|
||||
Tests the real business logic with proper imports
|
||||
"""
|
||||
|
||||
import pytest
|
||||
import sqlite3
|
||||
import sys
|
||||
import os
|
||||
from datetime import datetime
|
||||
|
||||
# Add project root to path
|
||||
sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
|
||||
|
||||
# Import functions from minimal_app
|
||||
from minimal_app import (
|
||||
add_tablet, add_user, loan_tablet, return_tablet,
|
||||
show_available_tablets, show_active_loans, show_loan_history,
|
||||
add_non_loanable_device, show_non_loanable_devices, delete_non_loanable_device
|
||||
)
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def test_db_path():
|
||||
"""Path to test database"""
|
||||
return 'test_minimal_app.db'
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def init_test_db(test_db_path):
|
||||
"""Initialize a fresh test database with schema (same as minimal_app)"""
|
||||
# Remove existing test database if it exists
|
||||
if os.path.exists(test_db_path):
|
||||
os.remove(test_db_path)
|
||||
|
||||
# Use the same init_db function from minimal_app
|
||||
from minimal_app import init_db
|
||||
# Temporarily rename the database
|
||||
original_db = 'tablets.db'
|
||||
if os.path.exists(original_db):
|
||||
os.rename(original_db, f'{original_db}.backup')
|
||||
|
||||
try:
|
||||
# Create test database
|
||||
os.environ['TEST_DB'] = test_db_path
|
||||
init_db()
|
||||
yield test_db_path
|
||||
finally:
|
||||
# Cleanup
|
||||
if os.path.exists(test_db_path):
|
||||
os.remove(test_db_path)
|
||||
if os.path.exists(f'{original_db}.backup'):
|
||||
os.rename(f'{original_db}.backup', original_db)
|
||||
if 'TEST_DB' in os.environ:
|
||||
del os.environ['TEST_DB']
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def clean_db():
|
||||
"""Fixture that ensures we have a clean database for each test"""
|
||||
# This is simpler - just create a temp database for each test
|
||||
import tempfile
|
||||
import shutil
|
||||
|
||||
# Create temp directory for database
|
||||
temp_dir = tempfile.mkdtemp()
|
||||
db_path = os.path.join(temp_dir, 'test.db')
|
||||
|
||||
# Initialize database
|
||||
conn = sqlite3.connect(db_path)
|
||||
cursor = conn.cursor()
|
||||
|
||||
cursor.execute('''
|
||||
CREATE TABLE IF NOT EXISTS tablets (
|
||||
id INTEGER PRIMARY KEY AUTOINCREMENT,
|
||||
brand TEXT NOT NULL,
|
||||
model TEXT NOT NULL,
|
||||
serial_number TEXT UNIQUE NOT NULL,
|
||||
status TEXT DEFAULT 'available'
|
||||
)
|
||||
''')
|
||||
|
||||
cursor.execute('''
|
||||
CREATE TABLE IF NOT EXISTS users (
|
||||
id INTEGER PRIMARY KEY AUTOINCREMENT,
|
||||
name TEXT NOT NULL,
|
||||
identification TEXT UNIQUE
|
||||
)
|
||||
''')
|
||||
|
||||
cursor.execute('''
|
||||
CREATE TABLE IF NOT EXISTS loans (
|
||||
id INTEGER PRIMARY KEY AUTOINCREMENT,
|
||||
tablet_id INTEGER NOT NULL,
|
||||
user_id INTEGER NOT NULL,
|
||||
loan_date TEXT NOT NULL,
|
||||
return_date TEXT,
|
||||
status TEXT DEFAULT 'active',
|
||||
FOREIGN KEY (tablet_id) REFERENCES tablets (id),
|
||||
FOREIGN KEY (user_id) REFERENCES users (id)
|
||||
)
|
||||
''')
|
||||
|
||||
cursor.execute('''
|
||||
CREATE TABLE IF NOT EXISTS non_loanable_devices (
|
||||
id INTEGER PRIMARY KEY AUTOINCREMENT,
|
||||
brand TEXT NOT NULL,
|
||||
model TEXT NOT NULL,
|
||||
serial_number TEXT UNIQUE NOT NULL,
|
||||
device_type TEXT NOT NULL,
|
||||
location TEXT,
|
||||
status TEXT DEFAULT 'available',
|
||||
notes TEXT,
|
||||
purchase_date TEXT,
|
||||
purchase_cost REAL
|
||||
)
|
||||
''')
|
||||
|
||||
conn.commit()
|
||||
conn.close()
|
||||
|
||||
# Temporarily replace the database
|
||||
original_db = 'tablets.db'
|
||||
backup_path = f'{original_db}.test_backup'
|
||||
|
||||
# Backup original if exists
|
||||
if os.path.exists(original_db):
|
||||
if os.path.exists(backup_path):
|
||||
os.remove(backup_path)
|
||||
os.rename(original_db, backup_path)
|
||||
|
||||
# Copy temp db to tablets.db location
|
||||
shutil.copy(db_path, original_db)
|
||||
|
||||
yield original_db
|
||||
|
||||
# Cleanup
|
||||
if os.path.exists(original_db):
|
||||
os.remove(original_db)
|
||||
if os.path.exists(backup_path):
|
||||
os.rename(backup_path, original_db)
|
||||
shutil.rmtree(temp_dir, ignore_errors=True)
|
||||
|
||||
|
||||
class TestMinimalAppFunctions:
|
||||
"""Test the actual functions from minimal_app.py"""
|
||||
|
||||
def test_add_tablet_function(self, clean_db):
|
||||
"""Test the add_tablet function"""
|
||||
add_tablet('TestBrand', 'TestModel', 'TEST_SN_001')
|
||||
|
||||
# Verify it was added
|
||||
conn = sqlite3.connect(clean_db)
|
||||
cursor = conn.cursor()
|
||||
cursor.execute("SELECT * FROM tablets WHERE serial_number = 'TEST_SN_001'")
|
||||
tablet = cursor.fetchone()
|
||||
conn.close()
|
||||
|
||||
assert tablet is not None
|
||||
assert tablet[1] == 'TestBrand' # brand is index 1
|
||||
assert tablet[2] == 'TestModel' # model is index 2
|
||||
assert tablet[3] == 'TEST_SN_001' # serial_number is index 3
|
||||
|
||||
def test_add_tablet_duplicate(self, clean_db, capsys):
|
||||
"""Test that duplicate serial numbers are rejected"""
|
||||
add_tablet('Brand1', 'Model1', 'DUP_SN')
|
||||
add_tablet('Brand2', 'Model2', 'DUP_SN')
|
||||
|
||||
captured = capsys.readouterr()
|
||||
assert 'already exists' in captured.out
|
||||
|
||||
def test_add_user_function(self, clean_db):
|
||||
"""Test the add_user function"""
|
||||
add_user('Test User', 'TEST_ID_001')
|
||||
|
||||
conn = sqlite3.connect(clean_db)
|
||||
cursor = conn.cursor()
|
||||
cursor.execute("SELECT * FROM users WHERE identification = 'TEST_ID_001'")
|
||||
user = cursor.fetchone()
|
||||
conn.close()
|
||||
|
||||
assert user is not None
|
||||
assert user[1] == 'Test User' # name is index 1
|
||||
assert user[2] == 'TEST_ID_001' # identification is index 2
|
||||
|
||||
def test_add_user_duplicate(self, clean_db, capsys):
|
||||
"""Test that duplicate user identifications are rejected"""
|
||||
add_user('User1', 'DUP_ID')
|
||||
add_user('User2', 'DUP_ID')
|
||||
|
||||
captured = capsys.readouterr()
|
||||
assert 'already exists' in captured.out
|
||||
|
||||
def test_loan_tablet_function(self, clean_db):
|
||||
"""Test the loan_tablet function"""
|
||||
# Add tablet and user
|
||||
add_tablet('LoanBrand', 'LoanModel', 'LOAN_SN_001')
|
||||
add_user('LoanUser', 'LOAN_ID_001')
|
||||
|
||||
conn = sqlite3.connect(clean_db)
|
||||
cursor = conn.cursor()
|
||||
|
||||
cursor.execute("SELECT id FROM tablets WHERE serial_number = 'LOAN_SN_001'")
|
||||
tablet_id = cursor.fetchone()[0]
|
||||
cursor.execute("SELECT id FROM users WHERE identification = 'LOAN_ID_001'")
|
||||
user_id = cursor.fetchone()[0]
|
||||
conn.close()
|
||||
|
||||
# Loan the tablet
|
||||
loan_tablet(tablet_id, user_id)
|
||||
|
||||
# Verify loan was created and tablet status changed
|
||||
conn = sqlite3.connect(clean_db)
|
||||
cursor = conn.cursor()
|
||||
|
||||
cursor.execute("SELECT status FROM tablets WHERE id = ?", (tablet_id,))
|
||||
status = cursor.fetchone()[0]
|
||||
assert status == 'loaned'
|
||||
|
||||
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[5] == 'active' # status is index 5
|
||||
|
||||
conn.close()
|
||||
|
||||
def test_loan_already_loaned_tablet(self, clean_db, capsys):
|
||||
"""Test loaning a tablet that's already loaned"""
|
||||
add_tablet('Brand', 'Model', 'ALREADY_LOANED_SN')
|
||||
add_user('User1', 'USER1_ID')
|
||||
add_user('User2', 'USER2_ID')
|
||||
|
||||
conn = sqlite3.connect(clean_db)
|
||||
cursor = conn.cursor()
|
||||
|
||||
cursor.execute("SELECT id FROM tablets WHERE serial_number = 'ALREADY_LOANED_SN'")
|
||||
tablet_id = cursor.fetchone()[0]
|
||||
cursor.execute("SELECT id FROM users WHERE identification = 'USER1_ID'")
|
||||
user1_id = cursor.fetchone()[0]
|
||||
cursor.execute("SELECT id FROM users WHERE identification = 'USER2_ID'")
|
||||
user2_id = cursor.fetchone()[0]
|
||||
conn.close()
|
||||
|
||||
# Loan to first user
|
||||
loan_tablet(tablet_id, user1_id)
|
||||
|
||||
# Try to loan to second user - should fail
|
||||
loan_tablet(tablet_id, user2_id)
|
||||
|
||||
captured = capsys.readouterr()
|
||||
assert 'not available' in captured.out
|
||||
|
||||
def test_return_tablet_function(self, clean_db):
|
||||
"""Test the return_tablet function"""
|
||||
add_tablet('ReturnBrand', 'ReturnModel', 'RETURN_SN_001')
|
||||
add_user('ReturnUser', 'RETURN_ID_001')
|
||||
|
||||
conn = sqlite3.connect(clean_db)
|
||||
cursor = conn.cursor()
|
||||
|
||||
cursor.execute("SELECT id FROM tablets WHERE serial_number = 'RETURN_SN_001'")
|
||||
tablet_id = cursor.fetchone()[0]
|
||||
cursor.execute("SELECT id FROM users WHERE identification = 'RETURN_ID_001'")
|
||||
user_id = cursor.fetchone()[0]
|
||||
conn.close()
|
||||
|
||||
# Loan the tablet
|
||||
loan_tablet(tablet_id, user_id)
|
||||
|
||||
# Get loan ID
|
||||
conn = sqlite3.connect(clean_db)
|
||||
cursor = conn.cursor()
|
||||
cursor.execute("SELECT id FROM loans WHERE tablet_id = ?", (tablet_id,))
|
||||
loan_id = cursor.fetchone()[0]
|
||||
conn.close()
|
||||
|
||||
# Return the tablet
|
||||
return_tablet(loan_id)
|
||||
|
||||
# Verify return
|
||||
conn = sqlite3.connect(clean_db)
|
||||
cursor = conn.cursor()
|
||||
|
||||
cursor.execute("SELECT status FROM tablets WHERE id = ?", (tablet_id,))
|
||||
status = cursor.fetchone()[0]
|
||||
assert status == 'available'
|
||||
|
||||
cursor.execute("SELECT status, return_date FROM loans WHERE id = ?", (loan_id,))
|
||||
loan = cursor.fetchone()
|
||||
assert loan[0] == 'returned'
|
||||
assert loan[1] is not None # return_date should be set
|
||||
|
||||
conn.close()
|
||||
|
||||
def test_return_nonexistent_loan(self, clean_db, capsys):
|
||||
"""Test returning a loan that doesn't exist"""
|
||||
return_tablet(99999)
|
||||
|
||||
captured = capsys.readouterr()
|
||||
assert 'not found' in captured.out or 'Loan' in captured.out
|
||||
|
||||
def test_show_available_tablets(self, clean_db, capsys):
|
||||
"""Test showing available tablets"""
|
||||
add_tablet('Avail1', 'Model1', 'AVAIL_SN_001')
|
||||
add_tablet('Avail2', 'Model2', 'AVAIL_SN_002')
|
||||
|
||||
show_available_tablets()
|
||||
|
||||
captured = capsys.readouterr()
|
||||
assert 'Available Tablets' in captured.out
|
||||
assert 'AVAIL_SN_001' in captured.out
|
||||
assert 'AVAIL_SN_002' in captured.out
|
||||
|
||||
def test_show_active_loans(self, clean_db, capsys):
|
||||
"""Test showing active loans"""
|
||||
add_tablet('LoanBrand', 'LoanModel', 'ACTIVE_LOAN_SN')
|
||||
add_user('LoanUser', 'ACTIVE_LOAN_ID')
|
||||
|
||||
conn = sqlite3.connect(clean_db)
|
||||
cursor = conn.cursor()
|
||||
|
||||
cursor.execute("SELECT id FROM tablets WHERE serial_number = 'ACTIVE_LOAN_SN'")
|
||||
tablet_id = cursor.fetchone()[0]
|
||||
cursor.execute("SELECT id FROM users WHERE identification = 'ACTIVE_LOAN_ID'")
|
||||
user_id = cursor.fetchone()[0]
|
||||
conn.close()
|
||||
|
||||
loan_tablet(tablet_id, user_id)
|
||||
show_active_loans()
|
||||
|
||||
captured = capsys.readouterr()
|
||||
assert 'Active Loans' in captured.out
|
||||
assert 'ACTIVE_LOAN_SN' in captured.out
|
||||
|
||||
def test_non_loanable_device_crud(self, clean_db, capsys):
|
||||
"""Test CRUD operations for non-loanable devices"""
|
||||
# Add
|
||||
add_non_loanable_device('Projector', 'P100', 'PROJ_001', 'projector', 'Room A')
|
||||
captured = capsys.readouterr()
|
||||
assert 'Added non-loanable device' in captured.out
|
||||
|
||||
# Show
|
||||
show_non_loanable_devices()
|
||||
captured = capsys.readouterr()
|
||||
assert 'PROJ_001' in captured.out
|
||||
|
||||
# Get ID for delete
|
||||
conn = sqlite3.connect(clean_db)
|
||||
cursor = conn.cursor()
|
||||
cursor.execute("SELECT id FROM non_loanable_devices WHERE serial_number = 'PROJ_001'")
|
||||
device_id = cursor.fetchone()[0]
|
||||
conn.close()
|
||||
|
||||
# Delete
|
||||
delete_non_loanable_device(device_id)
|
||||
captured = capsys.readouterr()
|
||||
assert 'deleted' in captured.out
|
||||
|
||||
# Verify deletion
|
||||
conn = sqlite3.connect(clean_db)
|
||||
cursor = conn.cursor()
|
||||
cursor.execute("SELECT * FROM non_loanable_devices WHERE serial_number = 'PROJ_001'")
|
||||
device = cursor.fetchone()
|
||||
conn.close()
|
||||
assert device is None
|
||||
Loading…
Add table
Add a link
Reference in a new issue