mirror of
https://github.com/smittix/intercept.git
synced 2026-04-25 07:10:00 -07:00
e00fbfddc1
- Fix SSE fanout thread AttributeError when source queue is None during interpreter shutdown by snapshotting to local variable with null guard - Fix branded "i" logo rendering oversized on first page load (FOUC) by adding inline width/height to SVG elements across 10 templates - Bump version to 2.26.0 in config.py, pyproject.toml, and CHANGELOG.md Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
592 lines
23 KiB
Python
592 lines
23 KiB
Python
"""Tests for WeFax (Weather Fax) routes, decoder, and station loader."""
|
|
|
|
from __future__ import annotations
|
|
|
|
import json
|
|
import math
|
|
from pathlib import Path
|
|
from unittest.mock import MagicMock, patch
|
|
|
|
import numpy as np
|
|
|
|
|
|
def _login_session(client) -> None:
|
|
"""Mark the Flask test session as authenticated."""
|
|
with client.session_transaction() as sess:
|
|
sess['logged_in'] = True
|
|
sess['username'] = 'test'
|
|
sess['role'] = 'admin'
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Station database tests
|
|
# ---------------------------------------------------------------------------
|
|
|
|
class TestWeFaxStations:
|
|
"""WeFax station database tests."""
|
|
|
|
def test_load_stations_returns_list(self):
|
|
"""load_stations() should return a non-empty list."""
|
|
from utils.wefax_stations import load_stations
|
|
stations = load_stations()
|
|
assert isinstance(stations, list)
|
|
assert len(stations) >= 10
|
|
|
|
def test_station_has_required_fields(self):
|
|
"""Each station must have required fields."""
|
|
from utils.wefax_stations import load_stations
|
|
required = {'name', 'callsign', 'country', 'city', 'coordinates',
|
|
'frequencies', 'ioc', 'lpm', 'schedule'}
|
|
for station in load_stations():
|
|
missing = required - set(station.keys())
|
|
assert not missing, f"Station {station.get('callsign', '?')} missing: {missing}"
|
|
|
|
def test_get_station_by_callsign(self):
|
|
"""get_station() should return correct station."""
|
|
from utils.wefax_stations import get_station
|
|
station = get_station('NOJ')
|
|
assert station is not None
|
|
assert station['callsign'] == 'NOJ'
|
|
assert station['country'] == 'US'
|
|
|
|
def test_get_station_case_insensitive(self):
|
|
"""get_station() should be case-insensitive."""
|
|
from utils.wefax_stations import get_station
|
|
assert get_station('noj') is not None
|
|
|
|
def test_get_station_not_found(self):
|
|
"""get_station() should return None for unknown callsign."""
|
|
from utils.wefax_stations import get_station
|
|
assert get_station('XXXXX') is None
|
|
|
|
def test_resolve_tuning_frequency_auto_uses_carrier_for_known_station(self):
|
|
"""Known station frequencies default to carrier-list behavior in auto mode."""
|
|
from utils.wefax_stations import resolve_tuning_frequency_khz
|
|
|
|
tuned, reference, offset_applied = resolve_tuning_frequency_khz(
|
|
listed_frequency_khz=4298.0,
|
|
station_callsign='NOJ',
|
|
frequency_reference='auto',
|
|
)
|
|
|
|
assert math.isclose(tuned, 4296.1, abs_tol=1e-6)
|
|
assert reference == 'carrier'
|
|
assert offset_applied is True
|
|
|
|
def test_resolve_tuning_frequency_auto_preserves_unknown_station_input(self):
|
|
"""Ad-hoc frequencies (no station metadata) should be treated as dial."""
|
|
from utils.wefax_stations import resolve_tuning_frequency_khz
|
|
|
|
tuned, reference, offset_applied = resolve_tuning_frequency_khz(
|
|
listed_frequency_khz=4298.0,
|
|
station_callsign='',
|
|
frequency_reference='auto',
|
|
)
|
|
|
|
assert math.isclose(tuned, 4298.0, abs_tol=1e-6)
|
|
assert reference == 'dial'
|
|
assert offset_applied is False
|
|
|
|
def test_resolve_tuning_frequency_dial_override(self):
|
|
"""Explicit dial reference must bypass USB alignment."""
|
|
from utils.wefax_stations import resolve_tuning_frequency_khz
|
|
|
|
tuned, reference, offset_applied = resolve_tuning_frequency_khz(
|
|
listed_frequency_khz=4298.0,
|
|
station_callsign='NOJ',
|
|
frequency_reference='dial',
|
|
)
|
|
|
|
assert math.isclose(tuned, 4298.0, abs_tol=1e-6)
|
|
assert reference == 'dial'
|
|
assert offset_applied is False
|
|
|
|
def test_resolve_tuning_frequency_rejects_invalid_reference(self):
|
|
"""Invalid frequency reference values should raise a validation error."""
|
|
from utils.wefax_stations import resolve_tuning_frequency_khz
|
|
|
|
try:
|
|
resolve_tuning_frequency_khz(
|
|
listed_frequency_khz=4298.0,
|
|
station_callsign='NOJ',
|
|
frequency_reference='invalid',
|
|
)
|
|
raise AssertionError("Expected ValueError for invalid frequency_reference")
|
|
except ValueError as exc:
|
|
assert 'frequency_reference' in str(exc)
|
|
|
|
def test_station_frequencies_have_khz(self):
|
|
"""Each frequency entry must have 'khz' and 'description'."""
|
|
from utils.wefax_stations import load_stations
|
|
for station in load_stations():
|
|
for freq in station['frequencies']:
|
|
assert 'khz' in freq, f"{station['callsign']} missing khz"
|
|
assert 'description' in freq, f"{station['callsign']} missing description"
|
|
assert isinstance(freq['khz'], (int, float))
|
|
assert freq['khz'] > 0
|
|
|
|
def test_schedule_format(self):
|
|
"""Schedule entries must have utc, duration_min, content."""
|
|
from utils.wefax_stations import load_stations
|
|
for station in load_stations():
|
|
for entry in station['schedule']:
|
|
assert 'utc' in entry
|
|
assert 'duration_min' in entry
|
|
assert 'content' in entry
|
|
# UTC format: HH:MM
|
|
parts = entry['utc'].split(':')
|
|
assert len(parts) == 2
|
|
assert 0 <= int(parts[0]) <= 23
|
|
assert 0 <= int(parts[1]) <= 59
|
|
|
|
def test_get_current_broadcasts(self):
|
|
"""get_current_broadcasts() should return up to 3 entries."""
|
|
from utils.wefax_stations import get_current_broadcasts
|
|
broadcasts = get_current_broadcasts('NOJ')
|
|
assert isinstance(broadcasts, list)
|
|
assert len(broadcasts) <= 3
|
|
for b in broadcasts:
|
|
assert 'utc' in b
|
|
assert 'content' in b
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Decoder unit tests
|
|
# ---------------------------------------------------------------------------
|
|
|
|
class TestWeFaxDecoder:
|
|
"""WeFax decoder DSP and data class tests."""
|
|
|
|
def test_freq_to_pixel_black(self):
|
|
"""1500 Hz should map to 0 (black)."""
|
|
from utils.wefax import _freq_to_pixel
|
|
assert _freq_to_pixel(1500.0) == 0
|
|
|
|
def test_freq_to_pixel_white(self):
|
|
"""2300 Hz should map to 255 (white)."""
|
|
from utils.wefax import _freq_to_pixel
|
|
assert _freq_to_pixel(2300.0) == 255
|
|
|
|
def test_freq_to_pixel_mid(self):
|
|
"""1900 Hz (carrier) should map to ~128."""
|
|
from utils.wefax import _freq_to_pixel
|
|
val = _freq_to_pixel(1900.0)
|
|
assert 120 <= val <= 135
|
|
|
|
def test_freq_to_pixel_clamp_low(self):
|
|
"""Below 1500 Hz should clamp to 0."""
|
|
from utils.wefax import _freq_to_pixel
|
|
assert _freq_to_pixel(1000.0) == 0
|
|
|
|
def test_freq_to_pixel_clamp_high(self):
|
|
"""Above 2300 Hz should clamp to 255."""
|
|
from utils.wefax import _freq_to_pixel
|
|
assert _freq_to_pixel(3000.0) == 255
|
|
|
|
def test_ioc_576_pixel_count(self):
|
|
"""IOC 576 should give pi*576 ≈ 1809 pixels per line."""
|
|
pixels = int(math.pi * 576)
|
|
assert pixels == 1809
|
|
|
|
def test_ioc_288_pixel_count(self):
|
|
"""IOC 288 should give pi*288 ≈ 904 pixels per line."""
|
|
pixels = int(math.pi * 288)
|
|
assert pixels == 904
|
|
|
|
def test_goertzel_mag_detects_tone(self):
|
|
"""Goertzel should detect a pure tone."""
|
|
from utils.wefax import _goertzel_mag
|
|
sr = 22050
|
|
freq = 1900.0
|
|
t = np.arange(sr) / sr
|
|
samples = np.sin(2 * np.pi * freq * t)
|
|
mag = _goertzel_mag(samples[:2205], freq, sr)
|
|
# Should be significantly non-zero for a matching tone
|
|
assert mag > 1.0
|
|
|
|
def test_goertzel_mag_rejects_wrong_freq(self):
|
|
"""Goertzel should be much weaker for non-matching frequency."""
|
|
from utils.wefax import _goertzel_mag
|
|
sr = 22050
|
|
t = np.arange(sr) / sr
|
|
samples = np.sin(2 * np.pi * 1900.0 * t)
|
|
mag_match = _goertzel_mag(samples[:2205], 1900.0, sr)
|
|
mag_off = _goertzel_mag(samples[:2205], 300.0, sr)
|
|
assert mag_match > mag_off * 5
|
|
|
|
def test_detect_tone_start(self):
|
|
"""detect_tone should identify a 300 Hz start tone."""
|
|
from utils.wefax import _detect_tone
|
|
sr = 22050
|
|
t = np.arange(sr) / sr
|
|
samples = np.sin(2 * np.pi * 300.0 * t)
|
|
assert _detect_tone(samples[:2205], 300.0, sr, threshold=2.0)
|
|
|
|
def test_wefax_image_to_dict(self):
|
|
"""WeFaxImage.to_dict() should produce expected format."""
|
|
from datetime import datetime, timezone
|
|
|
|
from utils.wefax import WeFaxImage
|
|
img = WeFaxImage(
|
|
filename='test.png',
|
|
path=Path('/tmp/test.png'),
|
|
station='NOJ',
|
|
frequency_khz=4298,
|
|
timestamp=datetime(2026, 1, 1, tzinfo=timezone.utc),
|
|
ioc=576,
|
|
lpm=120,
|
|
size_bytes=1234,
|
|
)
|
|
d = img.to_dict()
|
|
assert d['filename'] == 'test.png'
|
|
assert d['station'] == 'NOJ'
|
|
assert d['frequency_khz'] == 4298
|
|
assert d['ioc'] == 576
|
|
assert d['url'] == '/wefax/images/test.png'
|
|
|
|
def test_wefax_progress_to_dict(self):
|
|
"""WeFaxProgress.to_dict() should produce expected format."""
|
|
from utils.wefax import WeFaxProgress
|
|
p = WeFaxProgress(
|
|
status='receiving',
|
|
station='NOJ',
|
|
message='Receiving: 100 lines',
|
|
progress_percent=50,
|
|
line_count=100,
|
|
)
|
|
d = p.to_dict()
|
|
assert d['type'] == 'wefax_progress'
|
|
assert d['status'] == 'receiving'
|
|
assert d['progress'] == 50
|
|
assert d['station'] == 'NOJ'
|
|
assert d['line_count'] == 100
|
|
|
|
def test_singleton_returns_same_instance(self, tmp_path):
|
|
"""get_wefax_decoder() should return a singleton."""
|
|
from utils.wefax import WeFaxDecoder
|
|
# Use __new__ to avoid __init__ creating dirs
|
|
d1 = WeFaxDecoder.__new__(WeFaxDecoder)
|
|
# Test the module-level singleton pattern
|
|
import utils.wefax as wefax_mod
|
|
original = wefax_mod._decoder
|
|
try:
|
|
wefax_mod._decoder = d1
|
|
assert wefax_mod.get_wefax_decoder() is d1
|
|
assert wefax_mod.get_wefax_decoder() is d1
|
|
finally:
|
|
wefax_mod._decoder = original
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Route tests
|
|
# ---------------------------------------------------------------------------
|
|
|
|
class TestWeFaxRoutes:
|
|
"""WeFax route endpoint tests."""
|
|
|
|
def test_status(self, client):
|
|
"""GET /wefax/status should return decoder status."""
|
|
_login_session(client)
|
|
mock_decoder = MagicMock()
|
|
mock_decoder.is_running = False
|
|
mock_decoder.get_images.return_value = []
|
|
|
|
with patch('routes.wefax.get_wefax_decoder', return_value=mock_decoder):
|
|
response = client.get('/wefax/status')
|
|
|
|
assert response.status_code == 200
|
|
data = response.get_json()
|
|
assert data['available'] is True
|
|
assert data['running'] is False
|
|
|
|
def test_stations_list(self, client):
|
|
"""GET /wefax/stations should return station list."""
|
|
_login_session(client)
|
|
response = client.get('/wefax/stations')
|
|
assert response.status_code == 200
|
|
data = response.get_json()
|
|
assert data['status'] == 'ok'
|
|
assert data['count'] >= 10
|
|
|
|
def test_station_detail(self, client):
|
|
"""GET /wefax/stations/NOJ should return station detail."""
|
|
_login_session(client)
|
|
response = client.get('/wefax/stations/NOJ')
|
|
assert response.status_code == 200
|
|
data = response.get_json()
|
|
assert data['status'] == 'ok'
|
|
assert data['station']['callsign'] == 'NOJ'
|
|
assert 'current_broadcasts' in data
|
|
|
|
def test_station_not_found(self, client):
|
|
"""GET /wefax/stations/XXXXX should return 404."""
|
|
_login_session(client)
|
|
response = client.get('/wefax/stations/XXXXX')
|
|
assert response.status_code == 404
|
|
|
|
def test_start_requires_frequency(self, client):
|
|
"""POST /wefax/start without frequency should fail."""
|
|
_login_session(client)
|
|
mock_decoder = MagicMock()
|
|
mock_decoder.is_running = False
|
|
|
|
with patch('routes.wefax.get_wefax_decoder', return_value=mock_decoder):
|
|
response = client.post(
|
|
'/wefax/start',
|
|
data=json.dumps({}),
|
|
content_type='application/json',
|
|
)
|
|
|
|
assert response.status_code == 400
|
|
data = response.get_json()
|
|
assert data['status'] == 'error'
|
|
|
|
def test_start_validates_frequency_range(self, client):
|
|
"""POST /wefax/start with out-of-range frequency should fail."""
|
|
_login_session(client)
|
|
mock_decoder = MagicMock()
|
|
mock_decoder.is_running = False
|
|
|
|
with patch('routes.wefax.get_wefax_decoder', return_value=mock_decoder):
|
|
response = client.post(
|
|
'/wefax/start',
|
|
data=json.dumps({'frequency_khz': 100}), # 0.1 MHz - too low
|
|
content_type='application/json',
|
|
)
|
|
|
|
assert response.status_code == 400
|
|
|
|
def test_start_validates_ioc(self, client):
|
|
"""POST /wefax/start with invalid IOC should fail."""
|
|
_login_session(client)
|
|
mock_decoder = MagicMock()
|
|
mock_decoder.is_running = False
|
|
|
|
with patch('routes.wefax.get_wefax_decoder', return_value=mock_decoder):
|
|
response = client.post(
|
|
'/wefax/start',
|
|
data=json.dumps({'frequency_khz': 4298, 'ioc': 999}),
|
|
content_type='application/json',
|
|
)
|
|
|
|
assert response.status_code == 400
|
|
data = response.get_json()
|
|
assert 'IOC' in data['message']
|
|
|
|
def test_start_validates_lpm(self, client):
|
|
"""POST /wefax/start with invalid LPM should fail."""
|
|
_login_session(client)
|
|
mock_decoder = MagicMock()
|
|
mock_decoder.is_running = False
|
|
|
|
with patch('routes.wefax.get_wefax_decoder', return_value=mock_decoder):
|
|
response = client.post(
|
|
'/wefax/start',
|
|
data=json.dumps({'frequency_khz': 4298, 'lpm': 999}),
|
|
content_type='application/json',
|
|
)
|
|
|
|
assert response.status_code == 400
|
|
data = response.get_json()
|
|
assert 'LPM' in data['message']
|
|
|
|
def test_start_success(self, client):
|
|
"""POST /wefax/start with valid params should succeed."""
|
|
_login_session(client)
|
|
mock_decoder = MagicMock()
|
|
mock_decoder.is_running = False
|
|
mock_decoder.start.return_value = True
|
|
|
|
with patch('routes.wefax.get_wefax_decoder', return_value=mock_decoder), \
|
|
patch('routes.wefax.app_module.claim_sdr_device', return_value=None):
|
|
response = client.post(
|
|
'/wefax/start',
|
|
data=json.dumps({
|
|
'frequency_khz': 4298,
|
|
'station': 'NOJ',
|
|
'device': 0,
|
|
'ioc': 576,
|
|
'lpm': 120,
|
|
}),
|
|
content_type='application/json',
|
|
)
|
|
|
|
assert response.status_code == 200
|
|
data = response.get_json()
|
|
assert data['status'] == 'started'
|
|
assert data['frequency_khz'] == 4298
|
|
assert data['usb_offset_applied'] is True
|
|
assert math.isclose(data['tuned_frequency_khz'], 4296.1, abs_tol=1e-6)
|
|
assert data['frequency_reference'] == 'carrier'
|
|
assert data['station'] == 'NOJ'
|
|
mock_decoder.start.assert_called_once()
|
|
start_kwargs = mock_decoder.start.call_args.kwargs
|
|
assert math.isclose(start_kwargs['frequency_khz'], 4296.1, abs_tol=1e-6)
|
|
|
|
def test_start_respects_dial_reference_override(self, client):
|
|
"""POST /wefax/start with dial reference should not apply USB offset."""
|
|
_login_session(client)
|
|
mock_decoder = MagicMock()
|
|
mock_decoder.is_running = False
|
|
mock_decoder.start.return_value = True
|
|
|
|
with patch('routes.wefax.get_wefax_decoder', return_value=mock_decoder), \
|
|
patch('routes.wefax.app_module.claim_sdr_device', return_value=None):
|
|
response = client.post(
|
|
'/wefax/start',
|
|
data=json.dumps({
|
|
'frequency_khz': 4298,
|
|
'station': 'NOJ',
|
|
'device': 0,
|
|
'frequency_reference': 'dial',
|
|
}),
|
|
content_type='application/json',
|
|
)
|
|
|
|
assert response.status_code == 200
|
|
data = response.get_json()
|
|
assert data['status'] == 'started'
|
|
assert data['usb_offset_applied'] is False
|
|
assert math.isclose(data['tuned_frequency_khz'], 4298.0, abs_tol=1e-6)
|
|
assert data['frequency_reference'] == 'dial'
|
|
start_kwargs = mock_decoder.start.call_args.kwargs
|
|
assert math.isclose(start_kwargs['frequency_khz'], 4298.0, abs_tol=1e-6)
|
|
|
|
def test_start_device_busy(self, client):
|
|
"""POST /wefax/start should return 409 when device is busy."""
|
|
_login_session(client)
|
|
mock_decoder = MagicMock()
|
|
mock_decoder.is_running = False
|
|
|
|
with patch('routes.wefax.get_wefax_decoder', return_value=mock_decoder), \
|
|
patch('routes.wefax.app_module.claim_sdr_device',
|
|
return_value='Device 0 in use by pager'):
|
|
response = client.post(
|
|
'/wefax/start',
|
|
data=json.dumps({'frequency_khz': 4298}),
|
|
content_type='application/json',
|
|
)
|
|
|
|
assert response.status_code == 409
|
|
data = response.get_json()
|
|
assert data['error_type'] == 'DEVICE_BUSY'
|
|
|
|
def test_stop(self, client):
|
|
"""POST /wefax/stop should stop the decoder."""
|
|
_login_session(client)
|
|
mock_decoder = MagicMock()
|
|
|
|
with patch('routes.wefax.get_wefax_decoder', return_value=mock_decoder):
|
|
response = client.post('/wefax/stop')
|
|
|
|
assert response.status_code == 200
|
|
data = response.get_json()
|
|
assert data['status'] == 'stopped'
|
|
mock_decoder.stop.assert_called_once()
|
|
|
|
def test_images_list(self, client):
|
|
"""GET /wefax/images should return image list."""
|
|
_login_session(client)
|
|
mock_decoder = MagicMock()
|
|
mock_decoder.get_images.return_value = []
|
|
|
|
with patch('routes.wefax.get_wefax_decoder', return_value=mock_decoder):
|
|
response = client.get('/wefax/images')
|
|
|
|
assert response.status_code == 200
|
|
data = response.get_json()
|
|
assert data['status'] == 'ok'
|
|
assert data['count'] == 0
|
|
|
|
def test_delete_image_invalid_filename(self, client):
|
|
"""DELETE /wefax/images/<filename> should reject invalid filenames."""
|
|
_login_session(client)
|
|
mock_decoder = MagicMock()
|
|
|
|
with patch('routes.wefax.get_wefax_decoder', return_value=mock_decoder):
|
|
# Use a filename with special chars that won't be split by Flask routing
|
|
response = client.delete('/wefax/images/te$t!file.png')
|
|
|
|
assert response.status_code == 400
|
|
|
|
def test_delete_image_wrong_extension(self, client):
|
|
"""DELETE /wefax/images/<filename> should reject non-PNG."""
|
|
_login_session(client)
|
|
mock_decoder = MagicMock()
|
|
|
|
with patch('routes.wefax.get_wefax_decoder', return_value=mock_decoder):
|
|
response = client.delete('/wefax/images/test.jpg')
|
|
|
|
assert response.status_code == 400
|
|
|
|
def test_schedule_enable_applies_usb_alignment(self, client):
|
|
"""Scheduler should receive tuned USB dial frequency in auto mode."""
|
|
_login_session(client)
|
|
mock_scheduler = MagicMock()
|
|
mock_scheduler.enable.return_value = {
|
|
'enabled': True,
|
|
'scheduled_count': 2,
|
|
'total_broadcasts': 2,
|
|
}
|
|
|
|
with patch('utils.wefax_scheduler.get_wefax_scheduler', return_value=mock_scheduler):
|
|
response = client.post(
|
|
'/wefax/schedule/enable',
|
|
data=json.dumps({
|
|
'station': 'NOJ',
|
|
'frequency_khz': 4298,
|
|
'device': 0,
|
|
}),
|
|
content_type='application/json',
|
|
)
|
|
|
|
assert response.status_code == 200
|
|
data = response.get_json()
|
|
assert data['status'] == 'ok'
|
|
assert data['usb_offset_applied'] is True
|
|
assert math.isclose(data['tuned_frequency_khz'], 4296.1, abs_tol=1e-6)
|
|
enable_kwargs = mock_scheduler.enable.call_args.kwargs
|
|
assert math.isclose(enable_kwargs['frequency_khz'], 4296.1, abs_tol=1e-6)
|
|
|
|
|
|
class TestWeFaxProgressCallback:
|
|
"""Regression tests for WeFax route-level progress callback behavior."""
|
|
|
|
def test_terminal_progress_releases_active_device(self):
|
|
"""Terminal decoder events must release any manually claimed SDR."""
|
|
import routes.wefax as wefax_routes
|
|
|
|
original_device = wefax_routes.wefax_active_device
|
|
try:
|
|
wefax_routes.wefax_active_device = 3
|
|
with patch('routes.wefax.app_module.release_sdr_device') as mock_release:
|
|
wefax_routes._progress_callback({
|
|
'type': 'wefax_progress',
|
|
'status': 'error',
|
|
'message': 'decode failed',
|
|
})
|
|
|
|
mock_release.assert_called_once_with(3, 'rtlsdr')
|
|
assert wefax_routes.wefax_active_device is None
|
|
finally:
|
|
wefax_routes.wefax_active_device = original_device
|
|
|
|
def test_non_terminal_progress_does_not_release_active_device(self):
|
|
"""Non-terminal progress updates must not release SDR ownership."""
|
|
import routes.wefax as wefax_routes
|
|
|
|
original_device = wefax_routes.wefax_active_device
|
|
try:
|
|
wefax_routes.wefax_active_device = 4
|
|
with patch('routes.wefax.app_module.release_sdr_device') as mock_release:
|
|
wefax_routes._progress_callback({
|
|
'type': 'wefax_progress',
|
|
'status': 'receiving',
|
|
'line_count': 120,
|
|
})
|
|
|
|
mock_release.assert_not_called()
|
|
assert wefax_routes.wefax_active_device == 4
|
|
finally:
|
|
wefax_routes.wefax_active_device = original_device
|