fix(ci): Apply formatting and fix WebSocket test decorator (#27)

Changes:
- Applied Black and isort to all Python files (16 files reformatted)
- Fixed WebSocket test skip decorator (was misplaced, now uses pytestmark)
- Ensures all Code Quality checks pass

This resolves the remaining CI failures.

Co-authored-by: Brian Rodriguez | BRControls <b.rodriguez@brcontrols.com>

Author: CervezaStallone

modbus_webserver/test_settings.py

@@ -13,33 +13,33 @@
 
 # Disable static files storage issues in tests
 STORAGES = {
-    'default': {
-        'BACKEND': 'django.core.files.storage.FileSystemStorage',
+    "default": {
+        "BACKEND": "django.core.files.storage.FileSystemStorage",
     },
-    'staticfiles': {
-        'BACKEND': 'django.contrib.staticfiles.storage.StaticFilesStorage',
+    "staticfiles": {
+        "BACKEND": "django.contrib.staticfiles.storage.StaticFilesStorage",
     },
 }
 
 # Use faster database for tests (not in-memory to allow migrations)
 DATABASES = {
-    'default': {
-        'ENGINE': 'django.db.backends.sqlite3',
-        'NAME': BASE_DIR / 'test_db.sqlite3',
+    "default": {
+        "ENGINE": "django.db.backends.sqlite3",
+        "NAME": BASE_DIR / "test_db.sqlite3",
     }
 }
 
 # Disable caching in tests
 CACHES = {
-    'default': {
-        'BACKEND': 'django.core.cache.backends.dummy.DummyCache',
+    "default": {
+        "BACKEND": "django.core.cache.backends.dummy.DummyCache",
     }
 }
 
 # Disable Redis channel layer in tests
 CHANNEL_LAYERS = {
-    'default': {
-        'BACKEND': 'channels.layers.InMemoryChannelLayer',
+    "default": {
+        "BACKEND": "channels.layers.InMemoryChannelLayer",
     },
 }
 
@@ -49,20 +49,20 @@
 
 # Faster password hashing
 PASSWORD_HASHERS = [
-    'django.contrib.auth.hashers.MD5PasswordHasher',
+    "django.contrib.auth.hashers.MD5PasswordHasher",
 ]
 
 # Disable logging in tests
 LOGGING = {
-    'version': 1,
-    'disable_existing_loggers': True,
-    'handlers': {
-        'null': {
-            'class': 'logging.NullHandler',
+    "version": 1,
+    "disable_existing_loggers": True,
+    "handlers": {
+        "null": {
+            "class": "logging.NullHandler",
         },
     },
-    'root': {
-        'handlers': ['null'],
-        'level': 'DEBUG',
+    "root": {
+        "handlers": ["null"],
+        "level": "DEBUG",
     },
 }

tests/conftest.py

@@ -9,89 +9,92 @@
 def api_client():
     """DRF API client."""
     from rest_framework.test import APIClient
+
     return APIClient()
 
 
 @pytest.fixture
 def modbus_interface_rtu(db):
     """Create a test RTU interface."""
     from modbus_app.models import ModbusInterface
+
     return ModbusInterface.objects.create(
-        name='Test RTU',
-        protocol='RTU',
-        port='COM1',
+        name="Test RTU",
+        protocol="RTU",
+        port="COM1",
         baudrate=9600,
-        parity='N',
+        parity="N",
         stopbits=1,
         bytesize=8,
         timeout=3.0,
-        enabled=True
+        enabled=True,
     )
 
 
 @pytest.fixture
 def modbus_interface_tcp(db):
     """Create a test TCP interface."""
     from modbus_app.models import ModbusInterface
+
     return ModbusInterface.objects.create(
-        name='Test TCP',
-        protocol='TCP',
-        host='192.168.1.100',
+        name="Test TCP",
+        protocol="TCP",
+        host="192.168.1.100",
         tcp_port=502,
         timeout=3.0,
-        enabled=True
+        enabled=True,
     )
 
 
 @pytest.fixture
 def device(db, modbus_interface_rtu):
     """Create a test device."""
     from modbus_app.models import Device
+
     return Device.objects.create(
-        name='Test Device',
+        name="Test Device",
         interface=modbus_interface_rtu,
         slave_id=1,
         polling_interval=5,
-        enabled=True
+        enabled=True,
     )
 
 
 @pytest.fixture
 def register(db, device):
     """Create a test register."""
     from modbus_app.models import Register
+
     return Register.objects.create(
         device=device,
-        name='Test Register',
+        name="Test Register",
         function_code=3,
         address=100,
-        data_type='UINT16',
+        data_type="UINT16",
         conversion_factor=1.0,
         conversion_offset=0.0,
-        unit='°C',
-        enabled=True
+        unit="°C",
+        enabled=True,
     )
 
 
 @pytest.fixture
 def test_user(db, django_user_model):
     """Create a test user for each test."""
     import uuid
-    username = f'testuser_{uuid.uuid4().hex[:8]}'
+
+    username = f"testuser_{uuid.uuid4().hex[:8]}"
     return django_user_model.objects.create_user(
-        username=username,
-        password='testpass123',
-        email=f'{username}@example.com'
+        username=username, password="testpass123", email=f"{username}@example.com"
     )
 
 
 @pytest.fixture
 def admin_user(db, django_user_model):
     """Create an admin user for each test."""
     import uuid
-    username = f'admin_{uuid.uuid4().hex[:8]}'
+
+    username = f"admin_{uuid.uuid4().hex[:8]}"
     return django_user_model.objects.create_superuser(
-        username=username,
-        password='admin123',
-        email=f'{username}@example.com'
+        username=username, password="admin123", email=f"{username}@example.com"
     )

tests/factories.py

@@ -4,23 +4,22 @@
 
 import factory
 from factory.django import DjangoModelFactory
-from modbus_app.models import (
-    ModbusInterface, Device, Register, TrendData,
-    DashboardGroup, DashboardWidget, Alarm
-)
+
+from modbus_app.models import (Alarm, DashboardGroup, DashboardWidget, Device,
+                               ModbusInterface, Register, TrendData)
 
 
 class ModbusInterfaceFactory(DjangoModelFactory):
     """Factory for ModbusInterface model."""
-    
+
     class Meta:
         model = ModbusInterface
-    
-    name = factory.Sequence(lambda n: f'Interface {n}')
-    protocol = 'RTU'
-    port = 'COM1'
+
+    name = factory.Sequence(lambda n: f"Interface {n}")
+    protocol = "RTU"
+    port = "COM1"
     baudrate = 9600
-    parity = 'N'
+    parity = "N"
     stopbits = 1
     bytesize = 8
     timeout = 3.0
@@ -29,20 +28,20 @@ class Meta:
 
 class TCPInterfaceFactory(ModbusInterfaceFactory):
     """Factory for TCP ModbusInterface."""
-    
-    protocol = 'TCP'
-    host = '192.168.1.100'
+
+    protocol = "TCP"
+    host = "192.168.1.100"
     tcp_port = 502
-    port = ''
+    port = ""
 
 
 class DeviceFactory(DjangoModelFactory):
     """Factory for Device model."""
-    
+
     class Meta:
         model = Device
-    
-    name = factory.Sequence(lambda n: f'Device {n}')
+
+    name = factory.Sequence(lambda n: f"Device {n}")
     interface = factory.SubFactory(ModbusInterfaceFactory)
     slave_id = factory.Sequence(lambda n: n + 1)
     polling_interval = 5
@@ -51,54 +50,54 @@ class Meta:
 
 class RegisterFactory(DjangoModelFactory):
     """Factory for Register model."""
-    
+
     class Meta:
         model = Register
-    
+
     device = factory.SubFactory(DeviceFactory)
-    name = factory.Sequence(lambda n: f'Register {n}')
+    name = factory.Sequence(lambda n: f"Register {n}")
     function_code = 3
     address = factory.Sequence(lambda n: n)
-    data_type = 'UINT16'
+    data_type = "UINT16"
     conversion_factor = 1.0
     conversion_offset = 0.0
-    unit = '°C'
+    unit = "°C"
     enabled = True
 
 
 class TrendDataFactory(DjangoModelFactory):
     """Factory for TrendData model."""
-    
+
     class Meta:
         model = TrendData
-    
+
     register = factory.SubFactory(RegisterFactory)
-    raw_value = factory.Faker('pyfloat', min_value=0, max_value=100)
+    raw_value = factory.Faker("pyfloat", min_value=0, max_value=100)
     converted_value = factory.LazyAttribute(lambda obj: obj.raw_value * 0.1)
-    quality = 'good'
+    quality = "good"
 
 
 class DashboardGroupFactory(DjangoModelFactory):
     """Factory for DashboardGroup model."""
-    
+
     class Meta:
         model = DashboardGroup
-    
-    name = factory.Sequence(lambda n: f'Group {n}')
+
+    name = factory.Sequence(lambda n: f"Group {n}")
     row_order = factory.Sequence(lambda n: n)
     collapsed = False
 
 
 class DashboardWidgetFactory(DjangoModelFactory):
     """Factory for DashboardWidget model."""
-    
+
     class Meta:
         model = DashboardWidget
-    
+
     group = factory.SubFactory(DashboardGroupFactory)
     register = factory.SubFactory(RegisterFactory)
-    title = factory.Sequence(lambda n: f'Widget {n}')
-    widget_type = 'line_chart'
+    title = factory.Sequence(lambda n: f"Widget {n}")
+    widget_type = "line_chart"
     column_position = 0
     row_position = 0
     width = 6
@@ -107,14 +106,14 @@ class Meta:
 
 class AlarmFactory(DjangoModelFactory):
     """Factory for Alarm model."""
-    
+
     class Meta:
         model = Alarm
-    
+
     register = factory.SubFactory(RegisterFactory)
-    name = factory.Sequence(lambda n: f'Alarm {n}')
-    condition = 'greater_than'
+    name = factory.Sequence(lambda n: f"Alarm {n}")
+    condition = "greater_than"
     threshold_high = 80.0
-    severity = 'warning'
-    message = 'Threshold exceeded'
+    severity = "warning"
+    message = "Threshold exceeded"
     enabled = True