bec-widgets 0.99.8__py3-none-any.whl → 0.99.9__py3-none-any.whl

tests/unit_tests/test_bec_motor_map.py

@@ -1,282 +0,0 @@
-import numpy as np
-import pytest
-from bec_lib.messages import DeviceMessage
-
-from bec_widgets.widgets.figure import BECFigure
-from bec_widgets.widgets.figure.plots.motor_map.motor_map import BECMotorMap, MotorMapConfig
-from bec_widgets.widgets.figure.plots.waveform.waveform_curve import SignalData
-
-from .client_mocks import mocked_client
-from .conftest import create_widget
-
-
-def test_motor_map_init(qtbot, mocked_client):
-    bec_figure = create_widget(qtbot, BECFigure, client=mocked_client)
-    default_config = MotorMapConfig(widget_class="BECMotorMap")
-
-    mm = bec_figure.motor_map(config=default_config.model_dump())
-    default_config.gui_id = mm.gui_id
-
-    assert mm.config == default_config
-
-
-def test_motor_map_change_motors(qtbot, mocked_client):
-    bec_figure = create_widget(qtbot, BECFigure, client=mocked_client)
-    mm = bec_figure.motor_map("samx", "samy")
-
-    assert mm.motor_x == "samx"
-    assert mm.motor_y == "samy"
-    assert mm.config.signals.x == SignalData(name="samx", entry="samx", limits=[-10, 10])
-    assert mm.config.signals.y == SignalData(name="samy", entry="samy", limits=[-5, 5])
-
-    mm.change_motors("samx", "samz")
-
-    assert mm.config.signals.x == SignalData(name="samx", entry="samx", limits=[-10, 10])
-    assert mm.config.signals.y == SignalData(name="samz", entry="samz", limits=[-8, 8])
-
-
-def test_motor_map_get_limits(qtbot, mocked_client):
-    bec_figure = create_widget(qtbot, BECFigure, client=mocked_client)
-    mm = bec_figure.motor_map("samx", "samy")
-    expected_limits = {"samx": [-10, 10], "samy": [-5, 5]}
-
-    for motor_name, expected_limit in expected_limits.items():
-        actual_limit = mm._get_motor_limit(motor_name)
-        assert actual_limit == expected_limit
-
-
-def test_motor_map_get_init_position(qtbot, mocked_client):
-    bec_figure = create_widget(qtbot, BECFigure, client=mocked_client)
-    mm = bec_figure.motor_map("samx", "samy")
-    mm.set_precision(2)
-
-    motor_map_dev = mm.client.device_manager.devices
-
-    expected_positions = {
-        ("samx", "samx"): motor_map_dev["samx"].read()["samx"]["value"],
-        ("samy", "samy"): motor_map_dev["samy"].read()["samy"]["value"],
-    }
-
-    for (motor_name, entry), expected_position in expected_positions.items():
-        actual_position = mm._get_motor_init_position(motor_name, entry, 2)
-        assert actual_position == expected_position
-
-
-def test_motor_movement_updates_position_and_database(qtbot, mocked_client):
-    bec_figure = create_widget(qtbot, BECFigure, client=mocked_client)
-    mm = bec_figure.motor_map("samx", "samy")
-    motor_map_dev = mm.client.device_manager.devices
-
-    init_positions = {
-        "samx": [motor_map_dev["samx"].read()["samx"]["value"]],
-        "samy": [motor_map_dev["samy"].read()["samy"]["value"]],
-    }
-
-    mm.change_motors("samx", "samy")
-
-    assert mm.database_buffer["x"] == init_positions["samx"]
-    assert mm.database_buffer["y"] == init_positions["samy"]
-
-    # Simulate motor movement for 'samx' only
-    new_position_samx = 4.0
-    msg = DeviceMessage(signals={"samx": {"value": new_position_samx}}, metadata={})
-    mm.on_device_readback(msg.content, msg.metadata)
-
-    init_positions["samx"].append(new_position_samx)
-    init_positions["samy"].append(init_positions["samy"][-1])
-    # Verify database update for 'samx'
-    assert mm.database_buffer["x"] == init_positions["samx"]
-
-    # Verify 'samy' retains its last known position
-    assert mm.database_buffer["y"] == init_positions["samy"]
-
-
-def test_scatter_plot_rendering(qtbot, mocked_client):
-    bec_figure = create_widget(qtbot, BECFigure, client=mocked_client)
-    mm = bec_figure.motor_map("samx", "samy")
-    motor_map_dev = mm.client.device_manager.devices
-
-    init_positions = {
-        "samx": [motor_map_dev["samx"].read()["samx"]["value"]],
-        "samy": [motor_map_dev["samy"].read()["samy"]["value"]],
-    }
-
-    mm.change_motors("samx", "samy")
-
-    # Simulate motor movement for 'samx' only
-    new_position_samx = 4.0
-    msg = DeviceMessage(signals={"samx": {"value": new_position_samx}}, metadata={})
-    mm.on_device_readback(msg.content, msg.metadata)
-    mm._update_plot()
-
-    # Get the scatter plot item
-    scatter_plot_item = mm.plot_components["scatter"]
-
-    # Check the scatter plot item properties
-    assert len(scatter_plot_item.data) > 0, "Scatter plot data is empty"
-    x_data = scatter_plot_item.data["x"]
-    y_data = scatter_plot_item.data["y"]
-    assert x_data[-1] == new_position_samx, "Scatter plot X data not updated correctly"
-    assert (
-        y_data[-1] == init_positions["samy"][-1]
-    ), "Scatter plot Y data should retain last known position"
-
-
-def test_plot_visualization_consistency(qtbot, mocked_client):
-    bec_figure = create_widget(qtbot, BECFigure, client=mocked_client)
-    mm = bec_figure.motor_map("samx", "samy")
-    mm.change_motors("samx", "samy")
-    # Simulate updating the plot with new data
-    msg = DeviceMessage(signals={"samx": {"value": 5}}, metadata={})
-    mm.on_device_readback(msg.content, msg.metadata)
-    msg = DeviceMessage(signals={"samy": {"value": 9}}, metadata={})
-    mm.on_device_readback(msg.content, msg.metadata)
-    mm._update_plot()
-
-    scatter_plot_item = mm.plot_components["scatter"]
-
-    # Check if the scatter plot reflects the new data correctly
-    assert (
-        scatter_plot_item.data["x"][-1] == 5 and scatter_plot_item.data["y"][-1] == 9
-    ), "Plot not updated correctly with new data"
-
-
-def test_change_background_value(qtbot, mocked_client):
-    bec_figure = create_widget(qtbot, BECFigure, client=mocked_client)
-    mm = bec_figure.motor_map("samx", "samy")
-
-    assert mm.config.background_value == 25
-    assert np.all(mm.plot_components["limit_map"].image == 25.0)
-
-    mm.set_background_value(50)
-    qtbot.wait(200)
-
-    assert mm.config.background_value == 50
-    assert np.all(mm.plot_components["limit_map"].image == 50.0)
-
-
-def test_motor_map_init_from_config(qtbot, mocked_client):
-    bec_figure = create_widget(qtbot, BECFigure, client=mocked_client)
-    config = {
-        "widget_class": "BECMotorMap",
-        "gui_id": "mm_id",
-        "parent_id": bec_figure.gui_id,
-        "row": 0,
-        "col": 0,
-        "axis": {
-            "title": "Motor position: (-0.0, 0.0)",
-            "title_size": None,
-            "x_label": "Motor X (samx)",
-            "x_label_size": None,
-            "y_label": "Motor Y (samy)",
-            "y_label_size": None,
-            "legend_label_size": None,
-            "x_scale": "linear",
-            "y_scale": "linear",
-            "x_lim": None,
-            "y_lim": None,
-            "x_grid": True,
-            "y_grid": True,
-        },
-        "signals": {
-            "source": "device_readback",
-            "x": {
-                "name": "samx",
-                "entry": "samx",
-                "unit": None,
-                "modifier": None,
-                "limits": [-10.0, 10.0],
-            },
-            "y": {
-                "name": "samy",
-                "entry": "samy",
-                "unit": None,
-                "modifier": None,
-                "limits": [-5.0, 5.0],
-            },
-            "z": None,
-            "dap": None,
-        },
-        "color": (255, 255, 255, 255),
-        "scatter_size": 5,
-        "max_points": 50,
-        "num_dim_points": 10,
-        "precision": 5,
-        "background_value": 50,
-    }
-    mm = bec_figure.motor_map(config=config)
-    config["gui_id"] = mm.gui_id
-
-    assert mm._config_dict == config
-
-
-def test_motor_map_set_scatter_size(qtbot, mocked_client):
-    bec_figure = create_widget(qtbot, BECFigure, client=mocked_client)
-    mm = bec_figure.motor_map("samx", "samy")
-
-    assert mm.config.scatter_size == 5
-    assert mm.plot_components["scatter"].opts["size"] == 5
-
-    mm.set_scatter_size(10)
-    qtbot.wait(200)
-
-    assert mm.config.scatter_size == 10
-    assert mm.plot_components["scatter"].opts["size"] == 10
-
-
-def test_motor_map_change_precision(qtbot, mocked_client):
-    bec_figure = create_widget(qtbot, BECFigure, client=mocked_client)
-    mm = bec_figure.motor_map("samx", "samy")
-
-    assert mm.config.precision == 2
-    mm.set_precision(10)
-    assert mm.config.precision == 10
-
-
-def test_motor_map_set_color(qtbot, mocked_client):
-    bec_figure = create_widget(qtbot, BECFigure, client=mocked_client)
-    mm = bec_figure.motor_map("samx", "samy")
-
-    assert mm.config.color == (255, 255, 255, 255)
-
-    mm.set_color((0, 0, 0, 255))
-    qtbot.wait(200)
-    assert mm.config.color == (0, 0, 0, 255)
-
-
-def test_motor_map_get_data_max_points(qtbot, mocked_client):
-    bec_figure = create_widget(qtbot, BECFigure, client=mocked_client)
-    mm = bec_figure.motor_map("samx", "samy")
-    motor_map_dev = mm.client.device_manager.devices
-
-    init_positions = {
-        "samx": [motor_map_dev["samx"].read()["samx"]["value"]],
-        "samy": [motor_map_dev["samy"].read()["samy"]["value"]],
-    }
-    msg = DeviceMessage(signals={"samx": {"value": 5.0}}, metadata={})
-    mm.on_device_readback(msg.content, msg.metadata)
-    msg = DeviceMessage(signals={"samy": {"value": 9.0}}, metadata={})
-    mm.on_device_readback(msg.content, msg.metadata)
-    msg = DeviceMessage(signals={"samx": {"value": 6.0}}, metadata={})
-    mm.on_device_readback(msg.content, msg.metadata)
-    msg = DeviceMessage(signals={"samy": {"value": 7.0}}, metadata={})
-    mm.on_device_readback(msg.content, msg.metadata)
-
-    expected_x = [init_positions["samx"][-1], 5.0, 5.0, 6.0, 6.0]
-    expected_y = [init_positions["samy"][-1], init_positions["samy"][-1], 9.0, 9.0, 7.0]
-    get_data = mm.get_data()
-
-    assert mm.database_buffer["x"] == expected_x
-    assert mm.database_buffer["y"] == expected_y
-    assert get_data["x"] == expected_x
-    assert get_data["y"] == expected_y
-
-    mm.set_max_points(3)
-    qtbot.wait(200)
-    get_data = mm.get_data()
-    assert len(get_data["x"]) == 3
-    assert len(get_data["y"]) == 3
-    assert get_data["x"] == expected_x[-3:]
-    assert get_data["y"] == expected_y[-3:]
-    assert mm.database_buffer["x"] == expected_x[-3:]
-    assert mm.database_buffer["y"] == expected_y[-3:]

tests/unit_tests/test_bec_queue.py

@@ -1,111 +0,0 @@
-import pytest
-from bec_lib import messages
-
-from bec_widgets.widgets.bec_queue.bec_queue import BECQueue
-
-from .client_mocks import mocked_client
-
-
-@pytest.fixture
-def bec_queue_msg_full():
-    content = {
-        "primary": {
-            "info": [
-                {
-                    "active_request_block": None,
-                    "is_scan": [True],
-                    "queue_id": "600163fc-5e56-4901-af25-14e9ee76817c",
-                    "request_blocks": [
-                        {
-                            "RID": "89a76021-28c0-4297-828e-74ae40b941e5",
-                            "content": {
-                                "parameter": {
-                                    "args": {"samx": [-0.1, 0.1]},
-                                    "kwargs": {
-                                        "exp_time": 0.5,
-                                        "relative": True,
-                                        "steps": 20,
-                                        "system_config": {
-                                            "file_directory": None,
-                                            "file_suffix": None,
-                                        },
-                                    },
-                                },
-                                "queue": "primary",
-                                "scan_type": "line_scan",
-                            },
-                            "is_scan": True,
-                            "metadata": {
-                                "RID": "89a76021-28c0-4297-828e-74ae40b941e5",
-                                "file_directory": None,
-                                "file_suffix": None,
-                                "user_metadata": {"sample_name": "testA"},
-                            },
-                            "msg": messages.ScanQueueMessage(
-                                metadata={
-                                    "file_suffix": None,
-                                    "file_directory": None,
-                                    "user_metadata": {"sample_name": "testA"},
-                                    "RID": "89a76021-28c0-4297-828e-74ae40b941e5",
-                                },
-                                scan_type="line_scan",
-                                parameter={
-                                    "args": {"samx": [-0.1, 0.1]},
-                                    "kwargs": {
-                                        "steps": 20,
-                                        "exp_time": 0.5,
-                                        "relative": True,
-                                        "system_config": {
-                                            "file_suffix": None,
-                                            "file_directory": None,
-                                        },
-                                    },
-                                },
-                                queue="primary",
-                            ),
-                            "readout_priority": {
-                                "async": [],
-                                "baseline": [],
-                                "monitored": ["samx"],
-                                "on_request": [],
-                            },
-                            "report_instructions": [{"scan_progress": 20}],
-                            "scan_id": "2d704cc3-c172-404c-866d-608ce09fce40",
-                            "scan_motors": ["samx"],
-                            "scan_number": 1289,
-                        }
-                    ],
-                    "scan_id": ["2d704cc3-c172-404c-866d-608ce09fce40"],
-                    "scan_number": [1289],
-                    "status": "COMPLETED",
-                }
-            ],
-            "status": "RUNNING",
-        }
-    }
-    msg = messages.ScanQueueStatusMessage(metadata={}, queue=content)
-    return msg
-
-
-@pytest.fixture
-def bec_queue(qtbot, mocked_client):
-    widget = BECQueue(client=mocked_client)
-    qtbot.addWidget(widget)
-    qtbot.waitExposed(widget)
-    yield widget
-
-
-def test_bec_queue(bec_queue, bec_queue_msg_full):
-    bec_queue.update_queue(bec_queue_msg_full.content, {})
-    assert bec_queue.table.rowCount() == 1
-    assert bec_queue.table.item(0, 0).text() == "1289"
-    assert bec_queue.table.item(0, 1).text() == "line_scan"
-    assert bec_queue.table.item(0, 2).text() == "COMPLETED"
-
-
-def test_bec_queue_empty(bec_queue):
-    bec_queue.update_queue({}, {})
-    assert bec_queue.table.rowCount() == 1
-    assert bec_queue.table.item(0, 0).text() == ""
-    assert bec_queue.table.item(0, 1).text() == ""
-    assert bec_queue.table.item(0, 2).text() == ""

tests/unit_tests/test_bec_status_box.py

@@ -1,123 +0,0 @@
-# pylint: skip-file
-from unittest import mock
-
-import pytest
-from bec_lib.messages import BECStatus, ServiceMetricMessage, StatusMessage
-
-from bec_widgets.widgets.bec_status_box.bec_status_box import BECServiceInfoContainer, BECStatusBox
-
-from .client_mocks import mocked_client
-
-
-@pytest.fixture
-def service_status_fixture():
-    yield mock.MagicMock()
-
-
-@pytest.fixture
-def status_box(qtbot, mocked_client, service_status_fixture):
-    widget = BECStatusBox(client=mocked_client, bec_service_status_mixin=service_status_fixture)
-    qtbot.addWidget(widget)
-    qtbot.waitExposed(widget)
-    yield widget
-
-
-def test_update_top_item(status_box):
-    assert status_box.tree.children()[0].children()[0].config.status == "IDLE"
-    name = status_box.box_name
-    status_box.update_top_item_status(status="RUNNING")
-    assert status_box.status_container[name]["info"].status == "RUNNING"
-    assert status_box.tree.children()[0].children()[0].config.status == "RUNNING"
-
-
-def test_create_status_widget(status_box):
-    name = "test_service"
-    status = BECStatus.IDLE
-    info = {"test": "test"}
-    metrics = {"metric": "test_metric"}
-    item = status_box._create_status_widget(name, status, info, metrics)
-    assert item.config.service_name == name
-    assert item.config.status == status.name
-    assert item.config.info == info
-    assert item.config.metrics == metrics
-
-
-def test_bec_service_container(status_box):
-    name = "test_service"
-    status = BECStatus.IDLE
-    info = {"test": "test"}
-    metrics = {"metric": "test_metric"}
-    expected_return = BECServiceInfoContainer(
-        service_name=name, status=status.name, info=info, metrics=metrics
-    )
-    assert status_box.box_name in status_box.status_container
-    assert len(status_box.status_container) == 1
-    status_box._update_status_container(name, status, info, metrics)
-    assert len(status_box.status_container) == 2
-    assert status_box.status_container[name]["info"] == expected_return
-
-
-def test_add_tree_item(status_box):
-    name = "test_service"
-    status = BECStatus.IDLE
-    info = {"test": "test"}
-    metrics = {"metric": "test_metric"}
-    assert len(status_box.tree.children()[0].children()) == 1
-    status_box.add_tree_item(name, status, info, metrics)
-    assert len(status_box.tree.children()[0].children()) == 2
-    assert name in status_box.status_container
-
-
-def test_update_service_status(status_box):
-    """Also checks check redundant tree items"""
-    name = "test_service"
-    status = BECStatus.IDLE
-    info = {"test": "test"}
-    metrics = {"metric": "test_metric"}
-    status_box.add_tree_item(name, status, info, {})
-    not_connected_name = "invalid_service"
-    status_box.add_tree_item(not_connected_name, status, info, metrics)
-
-    services_status = {name: StatusMessage(name=name, status=status, info=info)}
-    services_metrics = {name: ServiceMetricMessage(name=name, metrics=metrics)}
-
-    with mock.patch.object(status_box, "update_core_services", return_value=services_status):
-        assert not_connected_name in status_box.status_container
-        status_box.update_service_status(services_status, services_metrics)
-        assert status_box.status_container[name]["widget"].config.metrics == metrics
-        assert not_connected_name not in status_box.status_container
-
-
-def test_update_core_services(status_box):
-    status_box.CORE_SERVICES = ["test_service"]
-    name = "test_service"
-    status = BECStatus.RUNNING
-    info = {"test": "test"}
-    metrics = {"metric": "test_metric"}
-    services_status = {name: StatusMessage(name=name, status=status, info=info)}
-    services_metrics = {name: ServiceMetricMessage(name=name, metrics=metrics)}
-
-    status_box.update_core_services(services_status, services_metrics)
-    assert status_box.tree.children()[0].children()[0].config.status == "RUNNING"
-    assert status_box.status_container[name]["widget"].config.metrics == metrics
-
-    status = BECStatus.IDLE
-    services_status = {name: StatusMessage(name=name, status=status, info=info)}
-    services_metrics = {name: ServiceMetricMessage(name=name, metrics=metrics)}
-    status_box.update_core_services(services_status, services_metrics)
-    assert status_box.tree.children()[0].children()[0].config.status == status.name
-    assert status_box.status_container[name]["widget"].config.metrics == metrics
-
-
-def test_double_click_item(status_box):
-    name = "test_service"
-    status = BECStatus.IDLE
-    info = {"test": "test"}
-    metrics = {"MyData": "This should be shown nicely"}
-    status_box.add_tree_item(name, status, info, metrics)
-    container = status_box.status_container[name]
-    item = container["item"]
-    status_item = container["widget"]
-    with mock.patch.object(status_item, "show_popup") as mock_show_popup:
-        status_box.tree.itemDoubleClicked.emit(item, 0)
-        assert mock_show_popup.call_count == 1

tests/unit_tests/test_client_utils.py

@@ -1,76 +0,0 @@
-from unittest import mock
-
-import pytest
-
-from bec_widgets.cli.client import BECFigure
-from bec_widgets.cli.client_utils import BECGuiClientMixin, _start_plot_process
-
-from .client_mocks import FakeDevice
-
-
-@pytest.fixture
-def cli_figure():
-    fig = BECFigure(gui_id="test")
-    with mock.patch.object(fig, "_run_rpc") as mock_rpc_call:
-        with mock.patch.object(fig, "gui_is_alive", return_value=True):
-            yield fig, mock_rpc_call
-
-
-def test_rpc_call_plot(cli_figure):
-    fig, mock_rpc_call = cli_figure
-    fig.plot(x_name="samx", y_name="bpm4i")
-    mock_rpc_call.assert_called_with("plot", x_name="samx", y_name="bpm4i")
-
-
-def test_rpc_call_accepts_device_as_input(cli_figure):
-    dev1 = FakeDevice("samx")
-    dev2 = FakeDevice("bpm4i")
-    fig, mock_rpc_call = cli_figure
-    fig.plot(x_name=dev1, y_name=dev2)
-    mock_rpc_call.assert_called_with("plot", x_name="samx", y_name="bpm4i")
-
-
-@pytest.mark.parametrize(
-    "config, call_config",
-    [
-        (None, None),
-        ("/path/to/config.yml", "/path/to/config.yml"),
-        ({"key": "value"}, '{"key": "value"}'),
-    ],
-)
-def test_client_utils_start_plot_process(config, call_config):
-    with mock.patch("bec_widgets.cli.client_utils.subprocess.Popen") as mock_popen:
-        _start_plot_process("gui_id", BECFigure, config)
-        command = ["bec-gui-server", "--id", "gui_id", "--gui_class", "BECFigure"]
-        if call_config:
-            command.extend(["--config", call_config])
-        mock_popen.assert_called_once_with(
-            command,
-            text=True,
-            start_new_session=True,
-            stdout=mock.ANY,
-            stderr=mock.ANY,
-            env=mock.ANY,
-        )
-
-
-def test_client_utils_passes_client_config_to_server(bec_dispatcher):
-    """
-    Test that the client config is passed to the server. This ensures that
-    changes to the client config (either through config files or plugins) are
-    reflected in the server.
-    """
-    mixin = BECGuiClientMixin()
-    mixin._client = bec_dispatcher.client
-    mixin._gui_id = "gui_id"
-    mixin.gui_is_alive = mock.MagicMock()
-    mixin.gui_is_alive.side_effect = [True]
-
-    with mock.patch("bec_widgets.cli.client_utils._start_plot_process") as mock_start_plot:
-        with mock.patch.object(mixin, "_start_update_script") as mock_start_update:
-            mock_start_plot.return_value = [mock.MagicMock(), mock.MagicMock()]
-            mixin.show()
-            mock_start_plot.assert_called_once_with(
-                "gui_id", BECGuiClientMixin, mixin._client._service_config.config
-            )
-            mock_start_update.assert_called_once()

tests/unit_tests/test_color_map_selector.py

@@ -1,42 +0,0 @@
-import pyqtgraph as pg
-import pytest
-
-from bec_widgets.widgets.colormap_selector.colormap_selector import ColormapSelector
-
-
-@pytest.fixture
-def color_map_selector(qtbot):
-    widget = ColormapSelector()
-    qtbot.addWidget(widget)
-    qtbot.waitExposed(widget)
-    yield widget
-
-
-def test_color_map_selector_init(color_map_selector):
-    assert color_map_selector is not None
-    assert isinstance(color_map_selector, ColormapSelector)
-
-    all_maps = pg.colormap.listMaps()
-    loaded_maps = [
-        color_map_selector.combo.itemText(i) for i in range(color_map_selector.combo.count())
-    ]
-    assert len(loaded_maps) > 0
-    assert all_maps == loaded_maps
-
-
-def test_color_map_selector_add_color_maps(color_map_selector):
-    color_map_selector.add_color_maps(["cividis", "viridis"])
-    assert color_map_selector.combo.count() == 2
-    assert color_map_selector.combo.itemText(0) == "cividis"
-    assert color_map_selector.combo.itemText(1) == "viridis"
-    assert color_map_selector.combo.itemText(2) != "cividis"
-    assert color_map_selector.combo.itemText(2) != "viridis"
-
-
-def test_colormap_add_maps_by_property(color_map_selector):
-    color_map_selector.colormaps = ["cividis", "viridis"]
-    assert color_map_selector.combo.count() == 2
-    assert color_map_selector.combo.itemText(0) == "cividis"
-    assert color_map_selector.combo.itemText(1) == "viridis"
-    assert color_map_selector.combo.itemText(2) != "cividis"
-    assert color_map_selector.combo.itemText(2) != "viridis"