updating tests

Author: pmajali

tests/integration/monitor/test_plugin_get_metrics.py

@@ -1,7 +1,3 @@
-"""
-Integration tests for the get_metrics plugin
-"""
-
 import json
 import os
 
@@ -129,184 +125,59 @@ def test_conflicting_time_params():
     )
 
 
-@pytest.mark.skipif(
-    not os.getenv('JWE_TOKEN'),
-    reason="JWE_TOKEN environment variable required for monitoring tests"
-)
 @pytest.mark.smoke
-def test_nodebalancer_metrics_basic():
-    """Test get_metrics with nodebalancer service (with authentication)"""
-    # Use a non-existent entity ID to avoid side effects
-    # This will test the complete command flow but fail gracefully
-    try:
-        output = exec_test_command(BASE_CMD + [
-            "nodebalancer",
-            "--entity-ids", "999999",
-            "--metrics", "nb_ingress_traffic_rate:sum",
-            "--duration", "15",
-            "--duration-unit", "min"
-        ])
+def test_objstorage_metrics_basic():
+    """Test get_metrics with objectstorage service (with authentication)"""
+    # Use objectstorage service which doesn't require entity-ids
+    output = exec_test_command(BASE_CMD + [
+        "objectstorage",
+        "--metrics", "obj_requests_num:sum",
+        "--duration", "15",
+        "--duration-unit", "min",
+        "--entity-region", "us-east"
+    ])
 
-        # If it succeeds, check for expected output structure
-        assert "Fetching metrics" in output or "data" in output.lower()
+    print(f"SUCCESS: {output}")
+    assert "Fetching metrics" in output or "data" in output.lower()
 
-    except RuntimeError as e:
-        # Expected to fail with entity not found or similar API error
-        # Ensure it's not a command structure error
-        error_output = str(e)
-        assert "API request failed" in error_output or "entity" in error_output.lower()
-        # Should not be argument parsing errors
-        assert "unrecognized arguments" not in error_output
-        assert "invalid choice" not in error_output
 
+def test_obj_metrics_with_filters():
+    """Test get_metrics with objectstorage service and filters"""
+    output = exec_test_command(BASE_CMD + [
+        "objectstorage",
+        "--metrics", "obj_requests_num:sum",
+        "--duration", "30",
+        "--duration-unit", "min",
+        "--entity-region", "us-west",
+        "--filters", "request_type:eq:get"
+    ])
 
-@pytest.mark.skipif(
-    not os.getenv('JWE_TOKEN'),
-    reason="JWE_TOKEN environment variable required for monitoring tests"
-)
-def test_dbaas_metrics_with_filters():
-    """Test get_metrics with dbaas service and filters"""
-    try:
-        output = exec_test_command(BASE_CMD + [
-            "dbaas",
-            "--entity-ids", "999999",
-            "--metrics", "cpu_usage:avg,memory_usage:max",
-            "--duration", "30",
-            "--duration-unit", "min",
-            "--filters", "node_type:in:primary,secondary",
-            "--group-by", "entity_id,node_type"
-        ])
-
-        assert "Fetching metrics" in output or "data" in output.lower()
+    assert "Fetching metrics" in output or "data" in output.lower()
 
-    except RuntimeError as e:
-        error_output = str(e)
-        assert "API request failed" in error_output or "entity" in error_output.lower()
-        assert "unrecognized arguments" not in error_output
 
 
-@pytest.mark.skipif(
-    not os.getenv('JWE_TOKEN'),
-    reason="JWE_TOKEN environment variable required for monitoring tests"
-)
 def test_absolute_time_metrics():
-    """Test get_metrics with absolute time range"""
-    try:
-        output = exec_test_command(BASE_CMD + [
-            "linodes",
-            "--entity-ids", "999999",
-            "--metrics", "cpu_percent:avg",
-            "--start-time", "2025-12-22T00:00:00Z",
-            "--end-time", "2025-12-22T12:00:00Z",
-            "--granularity", "5",
-            "--granularity-unit", "min"
-        ])
-
-        assert "Fetching metrics" in output or "data" in output.lower()
-
-    except RuntimeError as e:
-        error_output = str(e)
-        assert "API request failed" in error_output or "entity" in error_output.lower()
-        assert "unrecognized arguments" not in error_output
-
-
-@pytest.mark.skipif(
-    not os.getenv('JWE_TOKEN'),
-    reason="JWE_TOKEN environment variable required for monitoring tests"
-)
-def test_multiple_entity_ids():
-    """Test get_metrics with multiple entity IDs"""
-    try:
-        output = exec_test_command(BASE_CMD + [
-            "nodebalancer",
-            "--entity-ids", "999999,888888,777777",
-            "--metrics", "nb_ingress_traffic_rate:sum,nb_egress_traffic_rate:avg",
-            "--duration", "1",
-            "--duration-unit", "hr",
-            "--granularity", "15",
-            "--granularity-unit", "min"
-        ])
+    """Test get_metrics with objectstorage service and absolute time range"""
+    output = exec_test_command(BASE_CMD + [
+        "objectstorage",
+        "--metrics", "obj_requests_num:sum",
+        "--start-time", "2025-12-22T00:00:00Z",
+        "--end-time", "2025-12-22T12:00:00Z",
+        "--entity-region", "us-southeast",
+        "--granularity", "5",
+        "--granularity-unit", "min"
+    ])
 
-        assert "Fetching metrics" in output or "data" in output.lower()
+    assert "Fetching metrics" in output or "data" in output.lower()
 
-    except RuntimeError as e:
-        error_output = str(e)
-        assert "API request failed" in error_output or "entity" in error_output.lower()
-        assert "unrecognized arguments" not in error_output
-
-
-@pytest.mark.skipif(
-    not os.getenv('JWE_TOKEN'),
-    reason="JWE_TOKEN environment variable required for monitoring tests"
-)
-def test_complex_filters():
-    """Test get_metrics with complex filter combinations"""
-    try:
-        output = exec_test_command(BASE_CMD + [
-            "dbaas",
-            "--entity-ids", "999999",
-            "--metrics", "cpu_usage:avg,memory_usage:avg,connections:count",
-            "--duration", "2",
-            "--duration-unit", "hr",
-            "--filters", "node_type:in:primary,secondary;status:eq:active;environment:ne:test",
-            "--group-by", "entity_id,node_type,environment",
-            "--granularity", "30",
-            "--granularity-unit", "min"
-        ])
-
-        assert "Fetching metrics" in output or "data" in output.lower()
-
-    except RuntimeError as e:
-        error_output = str(e)
-        assert "API request failed" in error_output or "entity" in error_output.lower()
-        assert "unrecognized arguments" not in error_output
-
-
-def test_missing_token_error():
-    """Test error handling when JWE_TOKEN is missing"""
-    # Temporarily remove token
-    original_token = os.getenv('JWE_TOKEN')
-    if 'JWE_TOKEN' in os.environ:
-        del os.environ['JWE_TOKEN']
-
-    try:
-        exec_failing_test_command(
-            BASE_CMD + [
-                "nodebalancer",
-                "--entity-ids", "123",
-                "--metrics", "cpu_usage:avg",
-                "--duration", "15",
-                "--duration-unit", "min"
-            ],
-            expected_code=ExitCodes.REQUEST_FAILED
-        )
-    finally:
-        # Restore token
-        if original_token:
-            os.environ['JWE_TOKEN'] = original_token
-
-
-def test_empty_entity_ids():
-    """Test handling of empty entity IDs"""
-    exec_failing_test_command(
-        BASE_CMD + [
-            "nodebalancer",
-            "--entity-ids", "",
-            "--metrics", "cpu_usage:avg",
-            "--duration", "15",
-            "--duration-unit", "min"
-        ],
-        expected_code=ExitCodes.REQUEST_FAILED
-    )
 
 
 def test_malformed_filters():
     """Test handling of malformed filter syntax"""
     exec_failing_test_command(
         BASE_CMD + [
-            "dbaas",
-            "--entity-ids", "123",
-            "--metrics", "cpu_usage:avg",
+            "objectstorage",
+            "--metrics", "obj_requests_num:sum",
             "--duration", "15",
             "--duration-unit", "min",
             "--filters", "invalid_filter_format"
@@ -315,25 +186,4 @@ def test_malformed_filters():
     )
 
 
-def test_service_validation():
-    """Test that valid services are recognized correctly"""
-    valid_services = ["nodebalancer", "netloadbalancer", "linodes", "dbaas"]
-
-    for service in valid_services:
-        # This should fail due to missing authentication, not service validation
-        try:
-            exec_failing_test_command(
-                BASE_CMD + [
-                    service,
-                    "--entity-ids", "123",
-                    "--metrics", "cpu_usage:avg",
-                    "--duration", "15",
-                    "--duration-unit", "min"
-                ],
-                expected_code=ExitCodes.REQUEST_FAILED
-            )
-        except AssertionError as e:
-            # If it fails with wrong exit code, check it's not service validation error
-            error_msg = str(e).lower()
-            assert "invalid choice" not in error_msg
-            assert f"invalid choice: '{service}'" not in error_msg
+

tests/unit/test_plugin_get_metrics.py

@@ -1,7 +1,3 @@
-"""
-Unit tests for the get_metrics plugin
-"""
-
 import json
 import os
 from unittest.mock import MagicMock, Mock, patch
@@ -11,33 +7,13 @@
 
 from linodecli.plugins.get_metrics import (
     call,
-    get_auth_token,
     get_metrics,
     get_metrics_parser,
     make_api_request,
     print_metrics_response,
 )
 
 
-class TestAuthToken:
-    """Test authentication token handling"""
-
-    def test_get_auth_token_success(self):
-        """Test successful token retrieval from environment"""
-        with patch.dict(os.environ, {"JWE_TOKEN": "test_token"}):
-            token = get_auth_token()
-            assert token == "test_token"
-
-    def test_get_auth_token_missing(self):
-        """Test error when token is missing"""
-        with patch.dict(os.environ, {}, clear=True):
-            with pytest.raises(ValueError) as excinfo:
-                get_auth_token()
-            assert "JWE_TOKEN environment variable is required" in str(
-                excinfo.value
-            )
-
-
 class TestAPIRequest:
     """Test API request functionality"""
 
@@ -68,7 +44,7 @@ def test_make_api_request_http_error(self, mock_post):
         mock_response.json.return_value = {"error": "Unauthorized"}
         mock_post.return_value = mock_response
 
-        status_code, result = make_api_request(
+        status_code, _ = make_api_request(
             "nodebalancer", "metrics", "POST", {}, "test_token"
         )
         assert status_code == 401
@@ -83,7 +59,6 @@ def test_get_metrics_relative_time(self, mock_api_request, mock_print):
         """Test get_metrics with relative time duration"""
         mock_api_request.return_value = (200, {"data": {"test": "data"}})
 
-        # get_metrics doesn't return data, it calls print_metrics_response
         get_metrics(
             service_name="nodebalancer",
             entity_ids=[123, 456],
@@ -97,7 +72,6 @@ def test_get_metrics_relative_time(self, mock_api_request, mock_print):
             token="test_token",
         )
 
-        # Verify that print_metrics_response was called with the response
         mock_print.assert_called_once_with({"data": {"test": "data"}})
         mock_api_request.assert_called_once()
 
@@ -120,7 +94,6 @@ def test_get_metrics_absolute_time(self, mock_api_request, mock_print):
             token="test_token",
         )
 
-        # Verify print_metrics_response was called
         mock_print.assert_called_once_with({"data": {"test": "data"}})
 
     @patch("linodecli.plugins.get_metrics.print_metrics_response")
@@ -146,7 +119,6 @@ def test_get_metrics_with_filters_and_groupby(
             token="test_token",
         )
 
-        # Verify print_metrics_response was called
         mock_print.assert_called_once_with({"data": {"test": "data"}})
 
     @patch("linodecli.plugins.get_metrics.make_api_request")
@@ -171,7 +143,6 @@ def test_get_metrics_api_error(
             token="test_token",
         )
 
-        # Verify that sys.exit was called due to API error
         mock_exit.assert_called_with(2)  # ExitCodes.REQUEST_FAILED
 
 
@@ -182,7 +153,6 @@ def test_get_metrics_parser(self):
         """Test parser creation"""
         parser = get_metrics_parser()
 
-        # Test that parser has all expected arguments
         args = parser.parse_args(
             [
                 "nodebalancer",
@@ -228,8 +198,7 @@ def test_print_metrics_response_success(self, capsys: CaptureFixture):
         captured = capsys.readouterr()
 
         # Verify success output
-        assert "✓ Success" in captured.out
-        assert "150ms" in captured.out
+        assert "Series fetched: 1" in captured.out
         assert "Metrics Data:" in captured.out
 
     def test_print_metrics_response_error(self, capsys: CaptureFixture):