Add tests for EyesBase.close()

Author: eirenik0

eyes_core/applitools/core/eyes_base.py

@@ -307,7 +307,7 @@ def close(self, raise_ex=True):
         try:
             logger.debug("close({})".format(raise_ex))
             if not self._is_opened:
-                raise ValueError("Eyes not open")
+                raise EyesError("Eyes not open")
 
             self._is_opened = False
 

tests/unit/conftest.py

@@ -11,6 +11,11 @@
     Configuration,
     ImageMatchSettings,
     RunningSession,
+    SessionStartInfo,
+    SessionType,
+    BatchInfo,
+    AppEnvironment,
+    MatchLevel,
 )
 from applitools.common.utils.json_utils import attr_from_json
 from applitools.core import EyesBase, ServerConnector
@@ -73,6 +78,7 @@ def started_connector(configured_connector):
         timeout_sec=configured_connector.timeout_sec,
     )
     configured_connector._is_session_started = True
+
     return configured_connector
 
 
@@ -93,7 +99,7 @@ def app_output_with_screenshot(app_output, screenshot):
     return AppOutputWithScreenshot(app_output, screenshot)
 
 
-@pytest.fixture
+@pytest.fixture(scope="function")
 def image_match_settings():
     return ImageMatchSettings()
 
@@ -106,7 +112,7 @@ def app_output_provider(image, app_output_with_screenshot):
     return apo
 
 
-@pytest.fixture
+@pytest.fixture(scope="function")
 def running_session():
     RUNNING_SESSION_DATA = """{
         "id": "some id",
@@ -117,3 +123,27 @@ def running_session():
     }"""
     RUNNING_SESSION_OBJ = attr_from_json(RUNNING_SESSION_DATA, RunningSession)
     return RUNNING_SESSION_OBJ
+
+
+@pytest.fixture(scope="function")
+def session_start_info():
+    return SessionStartInfo(
+        agent_id="eyes.core.python/3.15.4",
+        session_type=SessionType.SEQUENTIAL,
+        app_id_or_name="TestApp",
+        ver_id=None,
+        scenario_id_or_name="TestName",
+        batch_info=BatchInfo(),
+        baseline_env_name="Baseline env name",
+        environment_name="Env name",
+        environment=AppEnvironment(),
+        default_match_settings=ImageMatchSettings(match_level=MatchLevel.STRICT),
+        branch_name="branch Name",
+        parent_branch_name="parentBranchName",
+        baseline_branch_name="baselineBranchName",
+        compare_with_parent_branch=False,
+        ignore_baseline=False,
+        save_diffs=True,
+        render=False,
+        properties=[],
+    )

tests/unit/eyes_selenium/test_eyes.py

@@ -141,10 +141,10 @@ def test_get_set_cut_provider(eyes):
         assert isinstance(eyes.cut_provider, UnscaledFixedCutProvider)
 
 
-def test_eyes_abort(eyes):
-    eyes.abort()
-
-
 def test_check_without_open_call(eyes):
     with pytest.raises(EyesError):
         eyes.check("Test", Target.window())
+
+
+def test_eyes_base_abort(eyes):
+    eyes.abort()

tests/unit/eyes_selenium/test_eyes_close.py

@@ -0,0 +1,112 @@
+import os
+
+import pytest
+from mock import MagicMock
+
+from applitools.common import (
+    EyesError,
+    TestResults,
+    DiffsFoundError,
+    NewTestError,
+    TestFailedError,
+)
+from applitools.selenium import Eyes
+
+
+@pytest.fixture(scope="function")
+def eyes():
+    return Eyes()
+
+
+@pytest.fixture(scope="function")
+def eyes_opened(eyes, running_session, session_start_info):
+    os.environ["APPLITOOLS_API_KEY"] = "SOME KEY"
+    eyes._current_eyes._is_opened = True
+    eyes._current_eyes._running_session = running_session
+    eyes._current_eyes._session_start_info = session_start_info
+    eyes._current_eyes._server_connector.stop_session = MagicMock(
+        side_effect=lambda *args, **kwargs: TestResults(
+            1, 2, 3, 4, 3, 4, 5, 6, 2, status="unresolved"
+        )
+    )
+    return eyes
+
+
+@pytest.fixture(scope="function")
+def eyes_opened_unresolved_new(eyes_opened, started_connector, running_session):
+    started_connector.stop_session = MagicMock(
+        side_effect=lambda *args, **kwargs: TestResults(
+            1, 2, 3, 4, 3, 4, 5, 6, 2, status="unresolved"
+        )
+    )
+    eyes_opened._current_eyes._server_connector = started_connector
+    running_session.is_new_session = True
+    eyes_opened._current_eyes._running_session = running_session
+    return eyes_opened
+
+
+@pytest.fixture(scope="function")
+def eyes_opened_unresolved_old(eyes_opened, started_connector):
+    started_connector.stop_session = MagicMock(
+        side_effect=lambda *args, **kwargs: TestResults(
+            1, 2, 3, 4, 3, 4, 5, 6, 2, status="unresolved"
+        )
+    )
+    eyes_opened._current_eyes._server_connector = started_connector
+    return eyes_opened
+
+
+@pytest.fixture(scope="function")
+def eyes_opened_failed(eyes_opened, started_connector):
+    started_connector.stop_session = MagicMock(
+        side_effect=lambda *args, **kwargs: TestResults(
+            1, 2, 3, 4, 3, 4, 5, 6, 2, status="failed"
+        )
+    )
+    eyes_opened._current_eyes._server_connector = started_connector
+    return eyes_opened
+
+
+def test_eyes_close_not_opened(eyes):
+    with pytest.raises(EyesError):
+        eyes.close()
+
+
+def test_eyes_close_opened_but_not_session_running(eyes_opened):
+    eyes_opened._current_eyes._running_session = None
+    test_results = eyes_opened.close()
+    assert test_results == TestResults()
+
+
+def test_eyes_close_old_test_unresolved(eyes_opened_unresolved_old):
+    with pytest.raises(DiffsFoundError):
+        eyes_opened_unresolved_old.close()
+
+
+def test_eyes_close_old_test_unresolved_silent(eyes_opened_unresolved_old):
+    eyes_opened_unresolved_old.close(False)
+
+
+def test_eyes_close_new_test_unresolved_should_fail(eyes_opened_unresolved_new):
+    eyes_opened_unresolved_new.fail_on_new_test = True
+
+    with pytest.raises(NewTestError):
+        eyes_opened_unresolved_new.close(False)
+
+
+def test_eyes_close_new_test_unresolved(eyes_opened_unresolved_new):
+    with pytest.raises(NewTestError):
+        eyes_opened_unresolved_new.close()
+
+
+def test_eyes_close_new_test_unresolved_silent(eyes_opened_unresolved_new):
+    eyes_opened_unresolved_new.close(False)
+
+
+def test_eyes_close_old_test_failed(eyes_opened_failed):
+    with pytest.raises(TestFailedError):
+        eyes_opened_failed.close()
+
+
+def test_eyes_close_old_test_failed_silent(eyes_opened_failed):
+    eyes_opened_failed.close(False)