remove dedupe lookup logic

Signed-off-by: Alina Buzachis <[email protected]>

Author: alinabuzachis

core/tests/test_controller_client.py

@@ -28,128 +28,33 @@ def _fake_response(status_code: int, payload: dict | list) -> requests.Response:
     return resp
 
 
-@patch("core.utils.controller.client.get_http_session")
-def test_post_success(mock_get_http_session):
-    session = MagicMock()
-    session.post.return_value = _fake_response(201, {"id": 99})
-    mock_get_http_session.return_value = session
-
-    assert cc.post(session, "/labels/", {"name": "foo"}) == {"id": 99}
-    session.post.assert_called_once()
-
-
-@patch("core.utils.controller.client.get_http_session")
-def test_post_duplicate_name(mock_get_http_session):
-    session = MagicMock()
-    session.post.return_value = _fake_response(400, {"error": "duplicate"})
-    session.get.return_value = _fake_response(
-        200, {"results": [{"id": 42, "name": "foo"}]}
-    )
-    mock_get_http_session.return_value = session
-
-    out = cc.post(session, "/labels/", {"name": "foo"})
-    assert out == {"id": 42, "name": "foo"}
-
-    session.get.assert_called_once()
-    session.post.assert_called_once()
-
-
 @patch("core.utils.controller.client.get_http_session")
 def test_post_non_400_error_is_propagated(mock_get_http_session):
+    """
+    Test that a non-400 error is also immediately propagated.
+    """
     session = MagicMock()
     session.post.return_value = _fake_response(500, {"error": "server"})
     mock_get_http_session.return_value = session
 
     with pytest.raises(requests.HTTPError):
         cc.post(session, "/labels/", {"name": "foo"})
 
-    # Ensure we don't try to deduplicate
     session.get.assert_not_called()
+    session.post.assert_called_once()
 
 
 @patch("core.utils.controller.client.get_http_session")
-def test_post_400_dedupe_no_results_raises(mock_get_http_session):
-    session = MagicMock()
-    post_resp = _fake_response(400, {"detail": "duplicate"})
-    session.post.return_value = post_resp
-    session.get.return_value = _fake_response(200, {"results": []})
-    mock_get_http_session.return_value = session
-
-    with pytest.raises(requests.HTTPError) as exc:
-        cc.post(session, "/labels/", {"name": "foo", "organization": 1})
-
-    assert isinstance(exc.value, requests.HTTPError)
-    assert exc.value.response.status_code == 400
-    session.get.assert_called_once()
-    # Ensure params include both default dedupe keys
-    _, kwargs = session.get.call_args
-    assert kwargs["params"] == {"name": "foo", "organization": 1}
-
-
-@patch("core.utils.controller.client.get_http_session")
-def test_post_400_dedupe_lookup_http_error_still_raises(mock_get_http_session):
-    session = MagicMock()
-    session.post.return_value = _fake_response(400, {"detail": "duplicate"})
-    # Lookup GET itself errors (e.g., 404)
-    session.get.return_value = _fake_response(404, {"detail": "not found"})
-    mock_get_http_session.return_value = session
-
-    with pytest.raises(requests.HTTPError):
-        cc.post(session, "/labels/", {"name": "foo"})
-
-    session.get.assert_called_once()
-
-
-@patch("core.utils.controller.client.get_http_session")
-def test_post_400_dedupe_params_subset_when_missing_org(mock_get_http_session):
-    session = MagicMock()
-    session.post.return_value = _fake_response(400, {"detail": "duplicate"})
-    session.get.return_value = _fake_response(200, {"results": []})
-    mock_get_http_session.return_value = session
-
-    with pytest.raises(requests.HTTPError):
-        cc.post(session, "/labels/", {"name": "foo"})
-
-    # Only 'name' present in params, no 'organization' since it wasn’t provided
-    _, kwargs = session.get.call_args
-    assert kwargs["params"] == {"name": "foo"}
-
-
-@patch("core.utils.controller.client.get_http_session")
-def test_post_400_with_custom_dedupe_keys(mock_get_http_session):
-    session = MagicMock()
-    session.post.return_value = _fake_response(400, {"detail": "duplicate"})
-    session.get.return_value = _fake_response(200, {"results": []})
-    mock_get_http_session.return_value = session
-
-    with pytest.raises(requests.HTTPError):
-        cc.post(
-            session,
-            "/labels/",
-            {"name": "foo", "organization": 1, "extra": "x"},
-            dedupe_keys=("name", "extra"),
-        )
-
-    # Only custom keys should be used
-    _, kwargs = session.get.call_args
-    assert kwargs["params"] == {"name": "foo", "extra": "x"}
-
-
-@patch("core.utils.controller.client.get_http_session")
-def test_post_400_error_json_fallback_to_text(mock_get_http_session):
+def test_post_success(mock_get_http_session):
+    """
+    Test that a successful POST request returns the JSON response.
+    """
     session = MagicMock()
-    # Create a response whose .json() raises, forcing fallback to .text
-    resp = MagicMock(spec=requests.Response)
-    resp.status_code = 400
-    resp.text = "not json"
-    resp.json.side_effect = Exception("bad json")
-    resp.raise_for_status.side_effect = requests.HTTPError(response=resp)
-    session.post.return_value = resp
-    session.get.return_value = _fake_response(200, {"results": []})
+    session.post.return_value = _fake_response(201, {"id": 123, "name": "foo"})
     mock_get_http_session.return_value = session
 
-    with pytest.raises(requests.HTTPError) as exc:
-        cc.post(session, "/labels/", {"name": "foo"})
+    out = cc.post(session, "/labels/", {"name": "foo"})
+    assert out == {"id": 123, "name": "foo"}
 
-    # Error message should include the fallback text
-    assert "not json" in str(exc.value)
+    session.get.assert_not_called()
+    session.post.assert_called_once()

core/utils/controller/client.py

@@ -1,10 +1,8 @@
-import json
 import logging
 import urllib.parse
 from typing import Any
 from typing import Dict
 from typing import Optional
-from typing import Sequence
 
 import requests
 from django.conf import settings
@@ -32,30 +30,17 @@ def get(url: str, *, params: Optional[Dict] = None) -> requests.Response:
         return response
 
 
-def post(
-    session: requests.Session,
-    path: str,
-    data: Dict,
-    *,
-    dedupe_keys: Sequence[str] = ("name", "organization"),
-) -> Dict[str, Any]:
+def post(session: requests.Session, path: str, data: Dict) -> Dict[str, Any]:
     """
     Create a resource on the AAP controller.
-    If the POST fails with 400 because the object already exists,
-    perform a GET lookup using *dedupe_keys* taken from *data* and
-    return the existing object instead.
     Args:
         session: Pre-existing session.
         path: Controller endpoint, e.g. "/projects/" (must include trailing slash).
         data: JSON payload to send.
-        dedupe_keys: Keys from *data* to copy into the lookup query string when handling
-            a duplicate‑name error.
     Returns:
         JSON for the created or pre‑existing object.
     Raises:
         requests.HTTPError
-            Propagated if the status code is not a handled 400 or if the lookup
-            returns no result.
     """
     url = urllib.parse.urljoin(settings.AAP_URL, path)
 
@@ -64,40 +49,5 @@ def post(
         response.raise_for_status()
         return safe_json(lambda: response)()
 
-    except requests.exceptions.HTTPError as exc:
-        response = exc.response
-        if response.status_code != 400:
-            raise
-
-        try:
-            error_json = safe_json(lambda: response)()
-        except Exception:
-            error_json = {"detail": response.text}
-
-        logger.warning(f"AAP POST {url} failed with 400. Error response: {error_json}")
-        logger.debug(f"Payload sent: {json.dumps(data, indent=2)}")
-        logger.debug(f"AAP POST {url} 400; dedup lookup keys: {dedupe_keys}")
-
-        params = {k: data[k] for k in dedupe_keys if k in data}
-        try:
-            lookup_resp = session.get(url, params=params)
-            lookup_resp.raise_for_status()
-            results = safe_json(lambda: lookup_resp)().get("results", [])
-
-            if results:
-                logger.debug(
-                    f"""Resource already exists. Returning
-                    existing resource: {results[0]}"""
-                )
-                return results[0]  # type: ignore[no-any-return]
-        except Exception as e:
-            logger.debug(
-                f"Deduplication GET failed for {url} with params {params}: {e}"
-            )
-
-        raise requests.HTTPError(
-            f"400 Bad Request for {url}.\n"
-            f"Payload: {json.dumps(data, indent=2)}\n"
-            f"Response: {json.dumps(error_json, indent=2)}",
-            response=response,
-        )
+    except requests.exceptions.HTTPError:
+        raise