344 lines
10 KiB
Python
344 lines
10 KiB
Python
"""
|
|
Basic tests for Stegasoo library.
|
|
"""
|
|
|
|
import io
|
|
import sys
|
|
from pathlib import Path
|
|
|
|
import pytest
|
|
|
|
# Add src to path for development
|
|
sys.path.insert(0, str(Path(__file__).parent.parent / 'src'))
|
|
|
|
import stegasoo
|
|
from stegasoo import (
|
|
generate_credentials,
|
|
generate_pin,
|
|
generate_phrase,
|
|
validate_pin,
|
|
validate_message,
|
|
encode,
|
|
decode,
|
|
DAY_NAMES,
|
|
)
|
|
from stegasoo.steganography import get_output_format, get_image_format
|
|
|
|
|
|
class TestKeygen:
|
|
"""Test credential generation."""
|
|
|
|
def test_generate_pin_default(self):
|
|
pin = generate_pin()
|
|
assert len(pin) == 6
|
|
assert pin.isdigit()
|
|
assert pin[0] != '0'
|
|
|
|
def test_generate_pin_lengths(self):
|
|
for length in range(6, 10):
|
|
pin = generate_pin(length)
|
|
assert len(pin) == length
|
|
|
|
def test_generate_phrase_default(self):
|
|
phrase = generate_phrase()
|
|
words = phrase.split()
|
|
assert len(words) == 3
|
|
|
|
def test_generate_phrase_lengths(self):
|
|
for length in range(3, 13):
|
|
phrase = generate_phrase(length)
|
|
words = phrase.split()
|
|
assert len(words) == length
|
|
|
|
def test_generate_credentials_pin_only(self):
|
|
creds = generate_credentials(use_pin=True, use_rsa=False)
|
|
assert creds.pin is not None
|
|
assert creds.rsa_key_pem is None
|
|
assert len(creds.phrases) == 7
|
|
assert set(creds.phrases.keys()) == set(DAY_NAMES)
|
|
|
|
def test_generate_credentials_rsa_only(self):
|
|
creds = generate_credentials(use_pin=False, use_rsa=True)
|
|
assert creds.pin is None
|
|
assert creds.rsa_key_pem is not None
|
|
assert '-----BEGIN PRIVATE KEY-----' in creds.rsa_key_pem
|
|
|
|
def test_generate_credentials_both(self):
|
|
creds = generate_credentials(use_pin=True, use_rsa=True)
|
|
assert creds.pin is not None
|
|
assert creds.rsa_key_pem is not None
|
|
|
|
def test_generate_credentials_neither_fails(self):
|
|
with pytest.raises(ValueError):
|
|
generate_credentials(use_pin=False, use_rsa=False)
|
|
|
|
def test_entropy_calculation(self):
|
|
creds = generate_credentials(
|
|
use_pin=True,
|
|
use_rsa=True,
|
|
pin_length=6,
|
|
rsa_bits=2048,
|
|
words_per_phrase=3
|
|
)
|
|
assert creds.phrase_entropy == 33 # 3 * 11
|
|
assert creds.pin_entropy == 19 # floor(6 * 3.32)
|
|
assert creds.rsa_entropy == 128
|
|
assert creds.total_entropy == 33 + 19 + 128
|
|
|
|
|
|
class TestValidation:
|
|
"""Test input validation."""
|
|
|
|
def test_validate_pin_valid(self):
|
|
result = validate_pin("123456")
|
|
assert result.is_valid
|
|
|
|
def test_validate_pin_empty_ok(self):
|
|
result = validate_pin("")
|
|
assert result.is_valid
|
|
|
|
def test_validate_pin_too_short(self):
|
|
result = validate_pin("12345")
|
|
assert not result.is_valid
|
|
assert "6-9" in result.error_message
|
|
|
|
def test_validate_pin_too_long(self):
|
|
result = validate_pin("1234567890")
|
|
assert not result.is_valid
|
|
|
|
def test_validate_pin_leading_zero(self):
|
|
result = validate_pin("012345")
|
|
assert not result.is_valid
|
|
assert "zero" in result.error_message.lower()
|
|
|
|
def test_validate_pin_non_digits(self):
|
|
result = validate_pin("12345a")
|
|
assert not result.is_valid
|
|
|
|
def test_validate_message_valid(self):
|
|
result = validate_message("Hello, world!")
|
|
assert result.is_valid
|
|
|
|
def test_validate_message_empty(self):
|
|
result = validate_message("")
|
|
assert not result.is_valid
|
|
|
|
def test_validate_message_too_long(self):
|
|
result = validate_message("x" * 60000)
|
|
assert not result.is_valid
|
|
|
|
|
|
class TestOutputFormat:
|
|
"""Test output format detection and preservation."""
|
|
|
|
def test_png_stays_png(self):
|
|
fmt, ext = get_output_format('PNG')
|
|
assert fmt == 'PNG'
|
|
assert ext == 'png'
|
|
|
|
def test_bmp_stays_bmp(self):
|
|
fmt, ext = get_output_format('BMP')
|
|
assert fmt == 'BMP'
|
|
assert ext == 'bmp'
|
|
|
|
def test_jpeg_becomes_png(self):
|
|
fmt, ext = get_output_format('JPEG')
|
|
assert fmt == 'PNG'
|
|
assert ext == 'png'
|
|
|
|
def test_gif_becomes_png(self):
|
|
fmt, ext = get_output_format('GIF')
|
|
assert fmt == 'PNG'
|
|
assert ext == 'png'
|
|
|
|
def test_none_becomes_png(self):
|
|
fmt, ext = get_output_format(None)
|
|
assert fmt == 'PNG'
|
|
assert ext == 'png'
|
|
|
|
def test_unknown_becomes_png(self):
|
|
fmt, ext = get_output_format('WEBP')
|
|
assert fmt == 'PNG'
|
|
assert ext == 'png'
|
|
|
|
|
|
class TestEncodeDecode:
|
|
"""Test encoding and decoding (requires test images)."""
|
|
|
|
@pytest.fixture
|
|
def png_image(self):
|
|
"""Create a simple PNG test image."""
|
|
from PIL import Image
|
|
img = Image.new('RGB', (100, 100), color='red')
|
|
buf = io.BytesIO()
|
|
img.save(buf, format='PNG')
|
|
return buf.getvalue()
|
|
|
|
@pytest.fixture
|
|
def bmp_image(self):
|
|
"""Create a simple BMP test image."""
|
|
from PIL import Image
|
|
img = Image.new('RGB', (100, 100), color='blue')
|
|
buf = io.BytesIO()
|
|
img.save(buf, format='BMP')
|
|
return buf.getvalue()
|
|
|
|
@pytest.fixture
|
|
def jpeg_image(self):
|
|
"""Create a simple JPEG test image."""
|
|
from PIL import Image
|
|
img = Image.new('RGB', (100, 100), color='green')
|
|
buf = io.BytesIO()
|
|
img.save(buf, format='JPEG', quality=95)
|
|
return buf.getvalue()
|
|
|
|
def test_encode_decode_roundtrip(self, png_image):
|
|
"""Test full encode/decode cycle."""
|
|
message = "Secret message!"
|
|
phrase = "apple forest thunder"
|
|
pin = "123456"
|
|
|
|
result = encode(
|
|
message=message,
|
|
reference_photo=png_image,
|
|
carrier_image=png_image,
|
|
day_phrase=phrase,
|
|
pin=pin
|
|
)
|
|
|
|
assert result.stego_image is not None
|
|
assert len(result.stego_image) > 0
|
|
assert result.filename.endswith('.png')
|
|
|
|
decoded = decode(
|
|
stego_image=result.stego_image,
|
|
reference_photo=png_image,
|
|
day_phrase=phrase,
|
|
pin=pin
|
|
)
|
|
|
|
assert decoded == message
|
|
|
|
def test_png_carrier_produces_png(self, png_image):
|
|
"""Test that PNG carrier produces PNG output."""
|
|
result = encode(
|
|
message="Test",
|
|
reference_photo=png_image,
|
|
carrier_image=png_image,
|
|
day_phrase="test phrase here",
|
|
pin="123456"
|
|
)
|
|
|
|
assert result.filename.endswith('.png')
|
|
# Verify actual format
|
|
output_format = get_image_format(result.stego_image)
|
|
assert output_format == 'PNG'
|
|
|
|
def test_bmp_carrier_produces_bmp(self, bmp_image, png_image):
|
|
"""Test that BMP carrier produces BMP output."""
|
|
result = encode(
|
|
message="Test",
|
|
reference_photo=png_image,
|
|
carrier_image=bmp_image,
|
|
day_phrase="test phrase here",
|
|
pin="123456"
|
|
)
|
|
|
|
assert result.filename.endswith('.bmp')
|
|
# Verify actual format
|
|
output_format = get_image_format(result.stego_image)
|
|
assert output_format == 'BMP'
|
|
|
|
def test_jpeg_carrier_produces_png(self, jpeg_image, png_image):
|
|
"""Test that JPEG carrier produces PNG output (lossy -> lossless)."""
|
|
result = encode(
|
|
message="Test",
|
|
reference_photo=png_image,
|
|
carrier_image=jpeg_image,
|
|
day_phrase="test phrase here",
|
|
pin="123456"
|
|
)
|
|
|
|
assert result.filename.endswith('.png')
|
|
# Verify actual format
|
|
output_format = get_image_format(result.stego_image)
|
|
assert output_format == 'PNG'
|
|
|
|
def test_bmp_roundtrip(self, bmp_image, png_image):
|
|
"""Test full encode/decode cycle with BMP."""
|
|
message = "BMP test message!"
|
|
phrase = "test phrase words"
|
|
pin = "123456"
|
|
|
|
result = encode(
|
|
message=message,
|
|
reference_photo=png_image,
|
|
carrier_image=bmp_image,
|
|
day_phrase=phrase,
|
|
pin=pin
|
|
)
|
|
|
|
assert result.filename.endswith('.bmp')
|
|
|
|
decoded = decode(
|
|
stego_image=result.stego_image,
|
|
reference_photo=png_image,
|
|
day_phrase=phrase,
|
|
pin=pin
|
|
)
|
|
|
|
assert decoded == message
|
|
|
|
def test_wrong_pin_fails(self, png_image):
|
|
"""Test that wrong PIN fails to decode."""
|
|
result = encode(
|
|
message="Secret",
|
|
reference_photo=png_image,
|
|
carrier_image=png_image,
|
|
day_phrase="test phrase here",
|
|
pin="123456"
|
|
)
|
|
|
|
with pytest.raises(stegasoo.DecryptionError):
|
|
decode(
|
|
stego_image=result.stego_image,
|
|
reference_photo=png_image,
|
|
day_phrase="test phrase here",
|
|
pin="654321" # Wrong PIN
|
|
)
|
|
|
|
def test_wrong_phrase_fails(self, png_image):
|
|
"""Test that wrong phrase fails to decode."""
|
|
result = encode(
|
|
message="Secret",
|
|
reference_photo=png_image,
|
|
carrier_image=png_image,
|
|
day_phrase="correct phrase here",
|
|
pin="123456"
|
|
)
|
|
|
|
with pytest.raises(stegasoo.DecryptionError):
|
|
decode(
|
|
stego_image=result.stego_image,
|
|
reference_photo=png_image,
|
|
day_phrase="wrong phrase here",
|
|
pin="123456"
|
|
)
|
|
|
|
|
|
class TestVersion:
|
|
"""Test version information."""
|
|
|
|
def test_version_exists(self):
|
|
assert hasattr(stegasoo, '__version__')
|
|
assert stegasoo.__version__ == "2.0.1"
|
|
|
|
def test_day_names(self):
|
|
assert len(stegasoo.DAY_NAMES) == 7
|
|
assert stegasoo.DAY_NAMES[0] == 'Monday'
|
|
assert stegasoo.DAY_NAMES[6] == 'Sunday'
|
|
|
|
|
|
if __name__ == '__main__':
|
|
pytest.main([__file__, '-v'])
|