refactor(tests): split integration tests into separate files

- Move from single 700-line file to modular structure
- Create tests/integration/ directory with 8 separate files:
  - test_state_integration.py (3 tests)
  - test_sslcert_integration.py (3 tests)
  - test_ntp_integration.py (2 tests)
  - test_license_integration.py (1 test)
  - test_threshold_integration.py (6 tests - above/below)
  - test_nsconfig_integration.py (1 test)
  - test_hwinfo_integration.py (1 test)
  - test_debug_integration.py (1 test)
- Remove old test_integration_with_mock_api.py

Total: 18 integration tests, all passing.

Benefits:
- Better organization (one file per command group)
- Easier to navigate and maintain
- Follows pytest best practices

Author: slauger

tests/integration/__init__.py

@@ -0,0 +1 @@
+"""Integration tests using Mock NITRO API Server"""

tests/integration/test_debug_integration.py

@@ -0,0 +1,33 @@
+"""Integration tests for Debug Command"""
+
+from argparse import Namespace
+
+from check_netscaler.client import NITROClient
+from check_netscaler.commands.debug import DebugCommand
+from check_netscaler.constants import STATE_OK
+
+
+class TestDebugCommandIntegration:
+    """Test debug command against mock API"""
+
+    def test_debug_raw_response(self, mock_nitro_server):
+        """Test debug shows raw API response"""
+        with NITROClient(
+            hostname=mock_nitro_server.host,
+            port=mock_nitro_server.port,
+            username="nsroot",
+            password="nsroot",
+            ssl=False,
+        ) as client:
+            args = Namespace(
+                command="debug",
+                objecttype="lbvserver",
+                objectname="lb_web",
+                endpoint="config",
+            )
+
+            command = DebugCommand(client, args)
+            result = command.execute()
+
+            assert result.status == STATE_OK
+            assert "lbvserver" in result.message or "lb_web" in result.message

tests/integration/test_hwinfo_integration.py

@@ -0,0 +1,28 @@
+"""Integration tests for HWInfo Command"""
+
+from argparse import Namespace
+
+from check_netscaler.client import NITROClient
+from check_netscaler.commands.hwinfo import HWInfoCommand
+from check_netscaler.constants import STATE_OK
+
+
+class TestHWInfoCommandIntegration:
+    """Test hwinfo command against mock API"""
+
+    def test_hwinfo_display(self, mock_nitro_server):
+        """Test hwinfo displays hardware information"""
+        with NITROClient(
+            hostname=mock_nitro_server.host,
+            port=mock_nitro_server.port,
+            username="nsroot",
+            password="nsroot",
+            ssl=False,
+        ) as client:
+            args = Namespace(command="hwinfo")
+
+            command = HWInfoCommand(client, args)
+            result = command.execute()
+
+            assert result.status == STATE_OK
+            assert "Platform" in result.message or "CPU" in result.message

tests/integration/test_license_integration.py

@@ -0,0 +1,37 @@
+"""Integration tests for License Command"""
+
+from argparse import Namespace
+
+from check_netscaler.client import NITROClient
+from check_netscaler.commands.license import LicenseCommand
+from check_netscaler.constants import STATE_OK
+
+
+class TestLicenseCommandIntegration:
+    """Test license command against mock API"""
+
+    def test_license_check_ok(self, mock_nitro_server):
+        """Test license check with valid license"""
+        with NITROClient(
+            hostname=mock_nitro_server.host,
+            port=mock_nitro_server.port,
+            username="nsroot",
+            password="nsroot",
+            ssl=False,
+        ) as client:
+            args = Namespace(
+                command="license",
+                objectname=None,
+                warning="30",
+                critical="10",
+                endpoint="config",
+            )
+
+            command = LicenseCommand(client, args)
+            result = command.execute()
+
+            assert result.status == STATE_OK
+            assert "CNS_V3000_SERVER_PLT" in result.message
+            assert "CNS_WEBLOGGING" in result.message
+            assert "CNS_SSL" in result.message
+            assert "never expires" in result.message

tests/integration/test_nsconfig_integration.py

@@ -0,0 +1,28 @@
+"""Integration tests for NSConfig Command"""
+
+from argparse import Namespace
+
+from check_netscaler.client import NITROClient
+from check_netscaler.commands.nsconfig import NSConfigCommand
+from check_netscaler.constants import STATE_OK
+
+
+class TestNSConfigCommandIntegration:
+    """Test nsconfig command against mock API"""
+
+    def test_nsconfig_no_changes(self, mock_nitro_server):
+        """Test nsconfig when no unsaved changes"""
+        with NITROClient(
+            hostname=mock_nitro_server.host,
+            port=mock_nitro_server.port,
+            username="nsroot",
+            password="nsroot",
+            ssl=False,
+        ) as client:
+            args = Namespace(command="nsconfig")
+
+            command = NSConfigCommand(client, args)
+            result = command.execute()
+
+            assert result.status == STATE_OK
+            assert "No unsaved configuration changes" in result.message

tests/integration/test_ntp_integration.py

@@ -0,0 +1,60 @@
+"""Integration tests for NTP Command"""
+
+from argparse import Namespace
+
+from check_netscaler.client import NITROClient
+from check_netscaler.commands.ntp import NTPCommand
+from check_netscaler.constants import STATE_OK, STATE_WARNING
+
+
+class TestNTPCommandIntegration:
+    """Test NTP command against mock API"""
+
+    def test_ntp_check_ok(self, mock_nitro_server):
+        """Test NTP check with synchronized state"""
+        with NITROClient(
+            hostname=mock_nitro_server.host,
+            port=mock_nitro_server.port,
+            username="nsroot",
+            password="nsroot",
+            ssl=False,
+        ) as client:
+            args = Namespace(
+                command="ntp",
+                warning=None,
+                critical=None,
+            )
+
+            command = NTPCommand(client, args)
+            result = command.execute()
+
+            assert result.status == STATE_OK
+            assert "Offset" in result.message
+            assert "jitter" in result.message
+            assert "stratum" in result.message
+            assert "truechimers=3" in result.message
+            assert "offset" in result.perfdata
+            assert "jitter" in result.perfdata
+            assert result.perfdata["truechimers"] == 3.0
+
+    def test_ntp_check_with_thresholds(self, mock_nitro_server):
+        """Test NTP check with warning thresholds"""
+        with NITROClient(
+            hostname=mock_nitro_server.host,
+            port=mock_nitro_server.port,
+            username="nsroot",
+            password="nsroot",
+            ssl=False,
+        ) as client:
+            # Set warning at 0.003s (3ms) - our fixture has 5ms offset
+            args = Namespace(
+                command="ntp",
+                warning="o=0.003",
+                critical="o=0.010",
+            )
+
+            command = NTPCommand(client, args)
+            result = command.execute()
+
+            assert result.status == STATE_WARNING
+            assert "WARNING" in result.message

tests/integration/test_sslcert_integration.py

@@ -0,0 +1,90 @@
+"""Integration tests for SSL Certificate Command"""
+
+from argparse import Namespace
+
+from check_netscaler.client import NITROClient
+from check_netscaler.commands.sslcert import SSLCertCommand
+from check_netscaler.constants import STATE_CRITICAL, STATE_OK, STATE_WARNING
+
+
+class TestSSLCertCommandIntegration:
+    """Test SSL certificate command against mock API"""
+
+    def test_sslcert_check_ok(self, mock_nitro_server):
+        """Test SSL cert check with OK cert (60 days)"""
+        with NITROClient(
+            hostname=mock_nitro_server.host,
+            port=mock_nitro_server.port,
+            username="nsroot",
+            password="nsroot",
+            ssl=False,
+        ) as client:
+            args = Namespace(
+                command="sslcert",
+                objecttype="sslcertkey",
+                objectname="cert_web",
+                warning="30",
+                critical="10",
+                filter=None,
+                limit=None,
+            )
+
+            command = SSLCertCommand(client, args)
+            result = command.execute()
+
+            assert result.status == STATE_OK
+            assert "1 certificate(s) OK" in result.message
+            assert "warn=30d" in result.message
+            assert "crit=10d" in result.message
+
+    def test_sslcert_check_warning(self, mock_nitro_server):
+        """Test SSL cert check with warning cert (20 days)"""
+        with NITROClient(
+            hostname=mock_nitro_server.host,
+            port=mock_nitro_server.port,
+            username="nsroot",
+            password="nsroot",
+            ssl=False,
+        ) as client:
+            args = Namespace(
+                command="sslcert",
+                objecttype="sslcertkey",
+                objectname="cert_warning",
+                warning="30",
+                critical="10",
+                filter=None,
+                limit=None,
+            )
+
+            command = SSLCertCommand(client, args)
+            result = command.execute()
+
+            assert result.status == STATE_WARNING
+            assert "WARNING:" in result.message
+            assert "cert_warning expires in 20 days" in result.message
+
+    def test_sslcert_check_critical(self, mock_nitro_server):
+        """Test SSL cert check with critical cert (5 days)"""
+        with NITROClient(
+            hostname=mock_nitro_server.host,
+            port=mock_nitro_server.port,
+            username="nsroot",
+            password="nsroot",
+            ssl=False,
+        ) as client:
+            args = Namespace(
+                command="sslcert",
+                objecttype="sslcertkey",
+                objectname="cert_critical",
+                warning="30",
+                critical="10",
+                filter=None,
+                limit=None,
+            )
+
+            command = SSLCertCommand(client, args)
+            result = command.execute()
+
+            assert result.status == STATE_CRITICAL
+            assert "CRITICAL:" in result.message
+            assert "cert_critical expires in 5 days" in result.message

tests/integration/test_state_integration.py

@@ -0,0 +1,84 @@
+"""Integration tests for State Command"""
+
+from argparse import Namespace
+
+from check_netscaler.client import NITROClient
+from check_netscaler.commands.state import StateCommand
+from check_netscaler.constants import STATE_CRITICAL, STATE_OK
+
+
+class TestStateCommandIntegration:
+    """Test state command against mock API"""
+
+    def test_state_check_lbvserver_up(self, mock_nitro_server):
+        """Test checking state of UP load balancer"""
+        with NITROClient(
+            hostname=mock_nitro_server.host,
+            port=mock_nitro_server.port,
+            username="nsroot",
+            password="nsroot",
+            ssl=False,
+        ) as client:
+            args = Namespace(
+                command="state",
+                objecttype="lbvserver",
+                objectname="lb_web",
+                filter=None,
+                limit=None,
+            )
+
+            command = StateCommand(client, args)
+            result = command.execute()
+
+            assert result.status == STATE_OK
+            assert result.message == "lbvserver is UP"
+
+    def test_state_check_lbvserver_down(self, mock_nitro_server):
+        """Test checking state of DOWN load balancer"""
+        with NITROClient(
+            hostname=mock_nitro_server.host,
+            port=mock_nitro_server.port,
+            username="nsroot",
+            password="nsroot",
+            ssl=False,
+        ) as client:
+            args = Namespace(
+                command="state",
+                objecttype="lbvserver",
+                objectname="lb_down",
+                filter=None,
+                limit=None,
+            )
+
+            command = StateCommand(client, args)
+            result = command.execute()
+
+            assert result.status == STATE_CRITICAL
+            assert "CRITICAL" in result.message
+            assert "lb_down" in result.message
+            assert "1/1" in result.message
+
+    def test_state_check_all_lbvservers(self, mock_nitro_server):
+        """Test checking all load balancers"""
+        with NITROClient(
+            hostname=mock_nitro_server.host,
+            port=mock_nitro_server.port,
+            username="nsroot",
+            password="nsroot",
+            ssl=False,
+        ) as client:
+            args = Namespace(
+                command="state",
+                objecttype="lbvserver",
+                objectname=None,
+                filter=None,
+                limit=None,
+            )
+
+            command = StateCommand(client, args)
+            result = command.execute()
+
+            assert result.status == STATE_CRITICAL
+            assert "CRITICAL" in result.message
+            assert "lb_down" in result.message
+            assert "1/3" in result.message