Be consistent about comparison order in asserts

Author: PGijsbers

tests/config_test.py

@@ -9,21 +9,21 @@ def test_apply_defaults_to_siblings_applies_defaults() -> None:
     input_ = {"defaults": {1: 1}, "other": {}}
     expected = {"other": {1: 1}}
     output = _apply_defaults_to_siblings(input_)
-    assert expected == output
+    assert output == expected
 
 
 def test_apply_defaults_to_siblings_does_not_override() -> None:
     input_ = {"defaults": {1: 1}, "other": {1: 2}}
     expected = {"other": {1: 2}}
     output = _apply_defaults_to_siblings(input_)
-    assert expected == output
+    assert output == expected
 
 
 def test_apply_defaults_to_siblings_ignores_nontables() -> None:
     input_ = {"defaults": {1: 1}, "other": {1: 2}, "not-a-table": 3}
     expected = {"other": {1: 2}, "not-a-table": 3}
     output = _apply_defaults_to_siblings(input_)
-    assert expected == output
+    assert output == expected
 
 
 def test_load_configuration_adds_environment_variables(default_configuration_file: Path) -> None:

tests/dependencies/fetch_user_test.py

@@ -21,8 +21,8 @@ async def test_fetch_user(api_key: str, user: User, user_test: AsyncConnection)
     async with aclosing(fetch_user(api_key, user_data=user_test)) as agen:
         db_user = await anext(agen)
     assert isinstance(db_user, User)
-    assert user.user_id == db_user.user_id
-    assert set(await user.get_groups()) == set(await db_user.get_groups())
+    assert db_user.user_id == user.user_id
+    assert set(await db_user.get_groups()) == set(await user.get_groups())
 
 
 async def test_fetch_user_no_key_no_user() -> None:

tests/routers/openml/datasets_list_datasets_test.py

@@ -105,8 +105,8 @@ async def test_list_data_identical(
 
     # PHP API has a double nested dictionary that never has other entries
     php_json = original.json()["data"]["dataset"]
-    assert len(php_json) == len(new_json)
-    assert php_json == new_json
+    assert len(new_json) == len(php_json)
+    assert new_json == php_json
     return None
 
 
@@ -341,6 +341,6 @@ async def test_list_data_quality(
         status=DatasetStatusFilter.ALL,
         user=None,
         expdb_db=expdb_test,
-        **{quality: range_},  # type: ignore[arg-type]
+        **{quality: range_},
     )
     assert len(result) == count

tests/routers/openml/datasets_qualities_test.py

@@ -119,7 +119,7 @@ async def test_get_quality(py_api: httpx.AsyncClient) -> None:
         {"name": "kNN1NErrRate", "value": 0.06347438752783964},
         {"name": "kNN1NKappa", "value": 0.8261102938928316},
     ]
-    difference = deepdiff.DeepDiff(expected, response.json(), ignore_order=True)
+    difference = deepdiff.DeepDiff(response.json(), expected, ignore_order=True)
     assert not difference
 
 
@@ -171,22 +171,22 @@ def _assert_get_quality_error_dataset_not_found(
     php_error = php_response.json()["error"]
     py_error = python_response.json()
 
-    assert php_error["code"] == py_error["code"]
+    assert py_error["code"] == php_error["code"]
     assert php_error["message"] == "Unknown dataset"
     assert re.match(r"Dataset with id \d+ not found.", py_error["detail"])
 
 
 def _assert_get_quality_error_dataset_process_error(
     python_response: httpx.Response, php_response: httpx.Response
 ) -> None:
-    assert php_response.status_code == python_response.status_code
+    assert python_response.status_code == php_response.status_code
 
     php_error = php_response.json()["error"]
     py_error = python_response.json()
 
-    assert php_error["code"] == py_error["code"]
+    assert py_error["code"] == php_error["code"]
     assert php_error["message"] == "Dataset processed with error"
     assert py_error["title"] == "Dataset Processing Error"
     # The PHP can add some additional unnecessary escapes.
-    assert php_error["additional_information"][:30] == py_error["detail"][:30]
-    assert php_error["additional_information"][-30:] == py_error["detail"][-30:]
+    assert py_error["detail"][:30] == php_error["additional_information"][:30]
+    assert py_error["detail"][-30:] == php_error["additional_information"][-30:]

tests/routers/openml/migration/datasets_migration_test.py

@@ -28,13 +28,13 @@ async def test_dataset_response_is_identical(  # noqa: C901, PLR0912
     if new.status_code == HTTPStatus.FORBIDDEN:
         assert original.status_code == HTTPStatus.PRECONDITION_FAILED
     else:
-        assert original.status_code == new.status_code
+        assert new.status_code == original.status_code
 
     if new.status_code != HTTPStatus.OK:
         # RFC 9457: Python API now returns problem+json format
         assert new.headers["content-type"] == "application/problem+json"
         # Both APIs should return error responses in the same cases
-        assert original.json()["error"]["code"] == new.json()["code"]
+        assert new.json()["code"] == original.json()["error"]["code"]
         old_error_message = original.json()["error"]["message"]
         assert new.json()["detail"].startswith(old_error_message)
         return
@@ -95,7 +95,7 @@ async def test_dataset_response_is_identical(  # noqa: C901, PLR0912
     if "description" not in new_body:
         new_body["description"] = []
 
-    assert original_json == new_body
+    assert new_body == original_json
 
 
 @pytest.mark.parametrize(
@@ -146,7 +146,7 @@ async def test_private_dataset_owner_access(
         php_api.get(f"/data/{private_dataset}?api_key={api_key}"),
     )
     assert old_response.status_code == HTTPStatus.OK
-    assert old_response.status_code == new_response.status_code
+    assert new_response.status_code == old_response.status_code
     assert new_response.json()["id"] == private_dataset
 
 
@@ -201,24 +201,24 @@ async def test_dataset_tag_response_is_identical(
     # RFC 9457: Tag conflict now returns 409 instead of 500
     if original.status_code == HTTPStatus.INTERNAL_SERVER_ERROR and already_tagged:
         assert new.status_code == HTTPStatus.CONFLICT
-        assert original.json()["error"]["code"] == new.json()["code"]
+        assert new.json()["code"] == original.json()["error"]["code"]
         assert original.json()["error"]["message"] == "Entity already tagged by this tag."
         assert re.match(
             pattern=r"Dataset \d+ already tagged with " + f"'{tag}'.",
             string=new.json()["detail"],
         )
         return
 
-    assert original.status_code == new.status_code, original.json()
+    assert new.status_code == original.status_code, original.json()
     if new.status_code != HTTPStatus.OK:
-        assert original.json()["error"]["code"] == new.json()["code"]
-        assert original.json()["error"]["message"] == new.json()["detail"]
+        assert new.json()["code"] == original.json()["error"]["code"]
+        assert new.json()["detail"] == original.json()["error"]["message"]
         return
 
     original = original.json()
     new = new.json()
     new = nested_remove_single_element_list(new)
-    assert original == new
+    assert new == original
 
 
 @pytest.mark.parametrize(
@@ -238,12 +238,12 @@ async def test_datasets_feature_is_identical(
 
     if new.status_code != HTTPStatus.OK:
         error = original.json()["error"]
-        assert error["code"] == new.json()["code"]
+        assert new.json()["code"] == error["code"]
         if error["message"] == "No features found. Additionally, dataset processed with error":
             pattern = r"No features found. Additionally, dataset \d+ processed with error\."
             assert re.match(pattern, new.json()["detail"])
         else:
-            assert error["message"] == new.json()["detail"]
+            assert new.json()["detail"] == error["message"]
         return
 
     python_body = new.json()

tests/routers/openml/migration/flows_migration_test.py

@@ -94,8 +94,8 @@ def convert_flow_naming_and_defaults(flow: dict[str, Any]) -> dict[str, Any]:
     # differences (e.g., '1.0' vs '1')
     expected = nested_str_to_num(expected)
     difference = deepdiff.diff.DeepDiff(
-        expected,
         new,
+        expected,
         ignore_order=True,
         ignore_numeric_type_changes=True,
     )

tests/routers/openml/migration/runs_migration_test.py

@@ -33,7 +33,7 @@ async def test_get_run_trace_equal(
 
     php_error = php_response.json()["error"]
     py_error = py_response.json()
-    assert php_error["code"] == py_error["code"]
+    assert py_error["code"] == php_error["code"]
     if php_error["code"] == "571":
         assert php_error["message"] == "Run not found."
         assert py_error["detail"] == f"Run {run_id} not found."

tests/routers/openml/migration/setups_migration_test.py

@@ -85,23 +85,23 @@ async def test_setup_untag_response_is_identical_when_tag_exists(
         )
 
     if new.status_code == HTTPStatus.OK:
-        assert original.status_code == new.status_code
+        assert new.status_code == original.status_code
         original_untag = original.json()["setup_untag"]
         new_untag = new.json()["setup_untag"]
-        assert original_untag["id"] == new_untag["id"]
+        assert new_untag["id"] == original_untag["id"]
         if tags := original_untag.get("tag"):
             if isinstance(tags, str):
-                assert tags == new_untag["tag"][0]
+                assert new_untag["tag"][0] == tags
             else:
-                assert tags == new_untag["tag"]
+                assert new_untag["tag"] == tags
         else:
             assert new_untag["tag"] == []
         return
 
     code, message = original.json()["error"].values()
     assert original.status_code == HTTPStatus.PRECONDITION_FAILED
     assert new.status_code == HTTPStatus.FORBIDDEN
-    assert code == new.json()["code"]
+    assert new.json()["code"] == code
     assert message == "Tag is not owned by you"
     assert re.match(
         r"You may not remove tag \S+ of setup \d+ because it was not created by you.",
@@ -131,7 +131,7 @@ async def test_setup_untag_response_is_identical_setup_doesnt_exist(
     assert original.status_code == HTTPStatus.PRECONDITION_FAILED
     assert new.status_code == HTTPStatus.NOT_FOUND
     assert original.json()["error"]["message"] == "Entity not found."
-    assert original.json()["error"]["code"] == new.json()["code"]
+    assert new.json()["code"] == original.json()["error"]["code"]
     assert re.match(
         r"Setup \d+ not found.",
         new.json()["detail"],
@@ -159,7 +159,7 @@ async def test_setup_untag_response_is_identical_tag_doesnt_exist(
 
     assert original.status_code == HTTPStatus.PRECONDITION_FAILED
     assert new.status_code == HTTPStatus.NOT_FOUND
-    assert original.json()["error"]["code"] == new.json()["code"]
+    assert new.json()["code"] == original.json()["error"]["code"]
     assert original.json()["error"]["message"] == "Tag not found."
     assert re.match(
         r"Setup \d+ does not have tag '\S+'.",
@@ -208,15 +208,15 @@ async def test_setup_tag_response_is_identical_when_tag_doesnt_exist(  # noqa: P
         )
 
     assert new.status_code == HTTPStatus.OK
-    assert original.status_code == new.status_code
+    assert new.status_code == original.status_code
     original_tag = original.json()["setup_tag"]
     new_tag = new.json()["setup_tag"]
-    assert original_tag["id"] == new_tag["id"]
+    assert new_tag["id"] == original_tag["id"]
     if tags := original_tag.get("tag"):
         if isinstance(tags, str):
-            assert tags == new_tag["tag"][0]
+            assert new_tag["tag"][0] == tags
         else:
-            assert set(tags) == set(new_tag["tag"])
+            assert set(new_tag["tag"]) == set(tags)
     else:
         assert new_tag["tag"] == []
 
@@ -243,7 +243,7 @@ async def test_setup_tag_response_is_identical_setup_doesnt_exist(
     assert original.status_code == HTTPStatus.PRECONDITION_FAILED
     assert new.status_code == HTTPStatus.NOT_FOUND
     assert original.json()["error"]["message"] == "Entity not found."
-    assert original.json()["error"]["code"] == new.json()["code"]
+    assert new.json()["code"] == original.json()["error"]["code"]
     assert re.match(
         r"Setup \d+ not found.",
         new.json()["detail"],
@@ -293,7 +293,7 @@ async def test_get_setup_response_is_identical_setup_doesnt_exist(
     assert original.status_code == HTTPStatus.PRECONDITION_FAILED
     assert new.status_code == HTTPStatus.NOT_FOUND
     assert original.json()["error"]["message"] == "Unknown setup"
-    assert original.json()["error"]["code"] == new.json()["code"]
+    assert new.json()["code"] == original.json()["error"]["code"]
     assert new.json()["detail"] == f"Setup {setup_id} not found."
 
 
@@ -326,4 +326,4 @@ async def test_get_setup_response_is_identical(
     new_json = nested_str_to_num(new.json())
     new_json = nested_remove_values(new_json, values=[[], None])
 
-    assert original_json == new_json
+    assert new_json == original_json

tests/routers/openml/migration/tasks_migration_test.py

@@ -168,7 +168,7 @@ async def test_list_tasks_equal(
     php_ids = {int(t["task_id"]) for t in php_tasks}
     py_ids = {int(t["task_id"]) for t in py_tasks}
 
-    assert php_ids == py_ids, (
+    assert py_ids == php_ids, (
         f"PHP and Python must return the exact same task IDs: {php_ids ^ py_ids}"
     )
 

tests/routers/openml/qualities_list_test.py

@@ -35,8 +35,8 @@ async def test_list_qualities_identical(
         py_api.get("/datasets/qualities/list"),
         php_api.get("/data/qualities/list"),
     )
-    assert original.status_code == new.status_code
-    assert original.json() == new.json()
+    assert new.status_code == original.status_code
+    assert new.json() == original.json()
     # To keep the test idempotent, we cannot test if reaction to database changes is identical
 
 
@@ -157,11 +157,11 @@ async def test_list_qualities(py_api: httpx.AsyncClient, expdb_test: AsyncConnec
             ],
         },
     }
-    assert expected == response.json()
+    assert response.json() == expected
 
     deleted = expected["data_qualities_list"]["quality"].pop()
     await _remove_quality_from_database(quality_name=deleted, expdb_test=expdb_test)
 
     response = await py_api.get("/datasets/qualities/list")
     assert response.status_code == HTTPStatus.OK
-    assert expected == response.json()
+    assert response.json() == expected