ivoryos 1.2.5__py3-none-any.whl → 1.4.4__py3-none-any.whl

tests/conftest.py

@@ -0,0 +1,133 @@
+from enum import Enum
+
+import bcrypt
+import pytest
+from ivoryos.config import get_config
+
+from ivoryos import create_app, socketio, db as _db, utils, global_config
+from ivoryos.utils.db_models import User
+
+
+@pytest.fixture(scope='session')
+def app():
+    """Create a new app instance for the test session."""
+    _app = create_app(get_config('testing'))
+    return _app
+
+@pytest.fixture
+def client(app):
+    """A test client for the app."""
+    with app.test_client() as client:
+        with app.app_context():
+            _db.create_all()
+        yield client
+        with app.app_context():
+            _db.drop_all()
+
+# @pytest.fixture(scope='session')
+# def db(app):
+#     """Session-wide test database."""
+#     with app.app_context():
+#         _db.create_all()
+#         yield _db
+#         _db.drop_all()
+
+@pytest.fixture(scope='module')
+def init_database(app):
+    """
+    Creates the database tables and seeds it with a default test user.
+    This runs once per test module.
+    """
+    with app.app_context():
+        # Drop everything first to ensure a clean slate
+        _db.drop_all()
+        # Create the database tables
+        _db.create_all()
+
+        # Insert a default user for authentication tests
+        # Note: In a real app with password hashing, you'd call a hash function here.
+        password = 'password'
+        bcrypt_password = bcrypt.hashpw(password.encode('utf-8'), bcrypt.gensalt())
+        default_user = User(username='testuser', password=bcrypt_password)
+        _db.session.add(default_user)
+        _db.session.commit()
+
+        yield _db  # this is where the testing happens!
+
+        # Teardown: drop all tables after the tests in the module are done
+        _db.drop_all()
+
+
+# ---------------------
+# Authentication Fixture
+# ---------------------
+
+@pytest.fixture(scope='function')
+def auth(client, init_database):
+    """
+    Logs in the default user for a single test function.
+    Depends on `init_database` to ensure the user exists.
+    Handles logout as part of teardown.
+    """
+    # Log in the default user
+    client.post('/ivoryos/auth/login', data={
+        'username': 'testuser',
+        'password': 'password'
+    }, follow_redirects=True)
+
+    yield client  # this is where the testing happens!
+
+    # Log out the user after the test is done
+    client.get('/ivoryos/auth/logout', follow_redirects=True)
+
+
+@pytest.fixture
+def socketio_client(app):
+    """A test client for Socket.IO."""
+    return socketio.test_client(app)
+
+
+class TestEnum(Enum):
+    """An example Enum for testing type conversion."""
+    OPTION_A = 'A'
+    OPTION_B = 'B'
+
+class DummyModule:
+    """A more comprehensive dummy instrument for testing."""
+    def int_method(self, arg: int = 1):
+        return arg
+
+    def float_method(self, arg: float = 1.0):
+        return arg
+
+    def bool_method(self, arg: bool = False):
+        return arg
+
+    def list_method(self, arg: list = None):
+        return arg or []
+
+    def enum_method(self, arg: TestEnum = TestEnum.OPTION_A):
+        return arg
+
+    def str_method(self) -> dict:
+        return {'status': 'OK'}
+
+
+@pytest.fixture
+def test_deck(app):
+    """
+    A fixture that creates and loads a predictable 'deck' of dummy instruments
+    for testing the dynamic control routes.
+    """
+    dummy_module = DummyModule()
+    snapshot = utils.create_deck_snapshot(dummy_module)
+
+    with app.app_context():
+        global_config.deck_snapshot = snapshot
+        global_config.deck = dummy_module # instantiate the class
+
+    yield DummyModule
+
+    with app.app_context():
+        global_config.deck_snapshot = {}
+        global_config.deck = {}

tests/integration/test_route_auth.py

@@ -0,0 +1,80 @@
+from ivoryos.utils.db_models import User, db
+
+
+def test_get_signup(client):
+    """
+    GIVEN a client
+    WHEN a GET request is made to /ivoryos/auth/signup
+    THEN check that signup page loads with 200 status and contains "Signup" text
+    """
+    response = client.get("/ivoryos/auth/signup", follow_redirects=True)
+    assert response.status_code == 200
+    assert b"Signup" in response.data
+
+
+def test_route_auth_signup(client):
+    """
+    GIVEN a client
+    WHEN a POST request is made to /ivoryos/auth/signup with valid credentials
+    THEN check that signup succeeds with 200 status and the user is created in database
+    """
+    response = client.post("/ivoryos/auth/signup",
+                           data={
+                               "username": "second_testuser",
+                               "password": "password"
+                           },
+                           follow_redirects=True
+                           )
+    assert response.status_code == 200
+    assert b"Login" in response.data
+
+    # Verify user was created
+    with client.application.app_context():
+        user = db.session.query(User).filter(User.username == 'second_testuser').first()
+        assert user is not None
+
+
+def test_duplicate_user_signup(client, init_database):
+    """
+    GIVEN a client and init_database fixture
+    WHEN a POST request is made to signup with an existing username
+    THEN check that signup fails with 409 status and appropriate error message
+    """
+    client.post('/ivoryos/auth/signup', data={
+        'username': 'existinguser',
+        'password': 'anotherpass'
+    })
+    # Try to create duplicate
+    response = client.post('/ivoryos/auth/signup', data={
+        'username': 'existinguser',
+        'password': 'anotherpass'
+    })
+    assert response.status_code == 409
+    assert b"Signup" in response.data
+    assert b"User already exists" in response.data
+
+    # Verify user was created
+    users = db.session.query(User).filter(User.username == 'existinguser').all()
+    assert len(users) == 1
+
+
+def test_failed_login(client):
+    """
+    GIVEN a client and invalid login credentials
+    WHEN a POST request is made to /ivoryos/auth/login
+    THEN check that login fails with 401 status and the appropriate error message
+    """
+    response = client.post('/ivoryos/auth/login', data={
+        'username': 'nonexistent',
+        'password': 'wrongpass'
+    })
+    assert response.status_code == 401
+
+def test_logout(auth):
+    """
+    GIVEN an authenticated client
+    WHEN a GET request is made to /ivoryos/auth/logout
+    THEN check that logout succeeds with 302 status and redirects to login
+    """
+    response = auth.get('/ivoryos/auth/logout')
+    assert response.status_code == 302  # Redirect to login

tests/integration/test_route_control.py

@@ -0,0 +1,94 @@
+from unittest.mock import patch, Mock
+
+from ivoryos.utils.db_models import Script
+from ivoryos import db
+
+def test_control_panel_redirects_anonymous(client):
+    """
+    GIVEN an anonymous user
+    WHEN the control panel is accessed
+    THEN they should be redirected to the login page
+    """
+    response = client.get('/ivoryos/control/home/deck', follow_redirects=True)
+    assert response.status_code == 200
+    assert b'Login' in response.data
+
+def test_deck_control_for_auth_user(auth):
+    """
+    GIVEN an authenticated user
+    WHEN the control panel is accessed
+    THEN the page should load successfully
+    """
+    response = auth.get('/ivoryos/control/home/deck', follow_redirects=True)
+    assert response.status_code == 200
+    assert b'<title>IvoryOS | Devices</title>' in response.data # Assuming this text exists on the page
+
+def test_temp_control_for_auth_user(auth):
+    """
+    GIVEN an authenticated user
+    WHEN the control panel is accessed
+    THEN the page should load successfully
+    """
+    response = auth.get('/ivoryos/control/home/temp', follow_redirects=True)
+    assert response.status_code == 200
+    # assert b'<title>IvoryOS | Devices</title>' in response.data # Assuming this text exists on the page
+
+def test_new_controller_page(auth):
+    """Test new controller page loads"""
+    response = auth.get('/ivoryos/control/new/')
+    assert response.status_code == 200
+
+def test_download_proxy(self, auth_headers):
+    """Test proxy download functionality"""
+    with patch('ivoryos.routes.control.control.global_config') as mock_config:
+        mock_config.deck_snapshot = {'test_instrument': {'test_method': {'signature': 'test()'}}}
+        response = auth_headers.get('/ivoryos/control/download')
+        assert response.status_code == 200
+        assert response.headers['Content-Disposition'].startswith('attachment')
+
+def test_backend_control_get(self, auth_headers):
+    """Test backend control GET endpoint"""
+    with patch('ivoryos.routes.control.control.global_config') as mock_config:
+        mock_config.deck_snapshot = {'test_instrument': {'test_method': {'signature': 'test()'}}}
+        response = auth_headers.get('/ivoryos/api/control/')
+        assert response.status_code == 200
+        assert response.is_json
+
+@patch('ivoryos.routes.control.control.runner')
+@patch('ivoryos.routes.control.control.find_instrument_by_name')
+@patch('ivoryos.routes.control.control.create_form_from_module')
+def test_backend_control_post(self, mock_form, mock_find, mock_runner, auth_headers):
+    """Test backend control POST endpoint"""
+    # Setup mocks
+    mock_instrument = Mock()
+    mock_find.return_value = mock_instrument
+    mock_field = Mock()
+    mock_field.name = 'test_param'
+    mock_field.data = 'test_value'
+    mock_form_instance = Mock()
+    mock_form_instance.__iter__ = Mock(return_value=iter([mock_field]))
+    mock_form.return_value = {'test_method': mock_form_instance}
+    mock_runner.run_single_step.return_value = 'success'
+    response = auth_headers.post('/ivoryos/api/control/test_instrument', data={
+        'hidden_name': 'test_method',
+        'hidden_wait': 'true'
+    })
+    assert response.status_code == 200
+
+# def test_control(auth, app):
+#     """
+#     GIVEN an authenticated user and an existing script
+#     WHEN a POST request is made to run the script
+#     THEN the user should be redirected and a success message shown
+#     """
+#     # We need to create a script in the database first
+#     with app.app_context():
+#         script = Script(name='My Test Script', author='testuser', content='print("hello")')
+#         db.session.add(script)
+#         db.session.commit()
+#         script_id = script.id
+#
+#     # Simulate running the script
+#     response = auth.post(f'/ivoryos/control/run/{script_id}', follow_redirects=True)
+#     assert response.status_code == 200
+#     assert b'has been initiated' in response.data # Check for a flash message

tests/integration/test_route_database.py

@@ -0,0 +1,61 @@
+from datetime import datetime
+
+from ivoryos.utils.db_models import Script, WorkflowRun, WorkflowStep
+from ivoryos import db
+
+def test_database_scripts_page(auth):
+    """
+    GIVEN an authenticated user
+    WHEN they access the script database page
+    THEN the page should load and show their scripts
+    """
+    # First, create a script so the page has something to render
+    with auth.application.app_context():
+        script = Script(name='test_script', author='testuser')
+        db.session.add(script)
+        db.session.commit()
+
+    response = auth.get('/ivoryos/database/scripts/', follow_redirects=True)
+    assert response.status_code == 200
+    # assert b'Scripts Database' in response.data
+    assert b'<title>IvoryOS | Design Database</title>' in response.data
+
+def test_database_workflows_page(auth):
+    """
+    GIVEN an authenticated user
+    WHEN they access the workflow database page
+    THEN the page should load and show past workflow runs
+    """
+    # Create a workflow run to display
+    with auth.application.app_context():
+        run = WorkflowRun(name="untitled", platform="deck",start_time=datetime.now())
+        db.session.add(run)
+        db.session.commit()
+        run_id = run.id
+
+    response = auth.get('/ivoryos/database/workflows/', follow_redirects=True)
+    assert response.status_code == 200
+    assert b'Workflow ID' in response.data
+    # assert b'run_id' in response.data
+
+def test_view_specific_workflow(auth):
+    """
+    GIVEN an authenticated user and an existing workflow run
+    WHEN they access the specific URL for that workflow
+    THEN the detailed view for that run should be displayed
+    """
+    with auth.application.app_context():
+        run = WorkflowRun(name='test_workflow', platform='test_platform', start_time=datetime.now())
+        db.session.add(run)
+        db.session.commit()
+        run_id = run.id
+
+        step = WorkflowStep(method_name='test_step', workflow_id=run_id, phase="main", run_error=False, start_time=datetime.now())
+        db.session.add(step)
+        db.session.commit()
+        # run_id = run.id
+
+    response = auth.get(f'/ivoryos/database/workflows/{run_id}', follow_redirects=True)
+    assert response.status_code == 200
+    # assert b'test_step' in response.data # Check for a title on the view page
+    assert b'test_workflow' in response.data

tests/integration/test_route_design.py

@@ -0,0 +1,36 @@
+def test_design_page_loads_for_auth_user(auth):
+    """
+    GIVEN an authenticated user
+    WHEN the design page is accessed
+    THEN the page should load successfully
+    """
+    response = auth.get('/ivoryos/design/script/', follow_redirects=True)
+    assert response.status_code == 200
+    assert b'<title>IvoryOS | Design</title>' in response.data # Assuming this text exists
+
+
+def test_clear_canvas(auth):
+    """
+    Tests clearing the design canvas.
+    """
+    response = auth.get('/ivoryos/design/clear', follow_redirects=True)
+    assert response.status_code == 200
+    # assert b'Operations' in response.data
+
+# def test_add_action(auth, test_deck):
+#     """
+#     Tests adding an action to the design canvas.
+#     """
+#     response = auth.post('/ivoryos/design/script/deck.dummy/', data={
+#         'hidden_name': 'int_method',
+#         'arg': '10'
+#     }, follow_redirects=True)
+#     assert response.status_code == 200
+
+def test_experiment_run_page(auth):
+    """
+    Tests the experiment run page.
+    """
+    response = auth.get('/ivoryos/design/campaign')
+    assert response.status_code == 200
+    assert b'Run Panel' in response.data

tests/integration/test_route_main.py

@@ -0,0 +1,35 @@
+from flask_login import current_user
+
+
+def test_home_page_authenticated(auth, app):
+    """
+    GIVEN an authenticated user (using the 'auth' fixture)
+    WHEN the home page is accessed
+    THEN check that they see the main application page
+    """
+    with auth.application.test_request_context('/ivoryos/'):
+        # Manually trigger the before_request functions that Flask-Login uses
+        app.preprocess_request()
+
+        # Assert that the `current_user` proxy is now populated and authenticated
+        assert current_user.is_authenticated
+        assert current_user.username == 'testuser'
+
+def test_help_page(client):
+    """
+    GIVEN an unauthenticated user
+    WHEN they access the help page
+    THEN check that the page loads successfully and contains documentation content
+    """
+    response = client.get('/ivoryos/help')
+    assert response.status_code == 200
+    assert b'Documentations' in response.data
+
+def test_prefix_redirect(auth):
+    """
+    GIVEN an authenticated user (using the 'auth' fixture)
+    WHEN the home page is accessed without prefix
+    THEN check that they see the main application page
+    """
+    response = auth.get('/', follow_redirects=True)
+    assert response.status_code == 200

tests/integration/test_sockets.py

@@ -0,0 +1,26 @@
+def test_socket_connection(socketio_client):
+    """
+    Test that a client can successfully connect to the Socket.IO server.
+    """
+    assert socketio_client.is_connected()
+    socketio_client.disconnect()
+    assert not socketio_client.is_connected()
+
+
+# def test_logger_socket_event(socketio_client):
+#     """
+#     Test the custom logging event handler.
+#     (This assumes you have a handler like `@socketio.on('start_log')`)
+#     """
+#     # Connect the client
+#     socketio_client.connect()
+#
+#     # Emit an event from the client to the server
+#     socketio_client.emit('start_log', {'logger_name': 'my_test_logger'})
+#
+#     # Check what the server sent back to the client
+#     received = socketio_client.get_received()
+#
+#     assert len(received) > 0
+#     assert received[0]['name'] == 'log_message'  # Check for the event name
+#     assert 'Logger my_test_logger started' in received[0]['args'][0]['data']

tests/unit/test_type_conversion.py

@@ -0,0 +1,42 @@
+from unittest.mock import patch
+
+from tests.conftest import TestEnum
+
+
+def test_int_conversion(auth, test_deck):
+    """Tests that a string from a form is converted to an integer."""
+    with patch('ivoryos.control.routes.global_config.deck_instance.deck_dummy.int_method') as mock_method:
+        auth.post('/ivoryos/control/deck.dummy/call/int_method', data={'arg': '123'})
+        # Check that the mock was called with an integer
+        mock_method.assert_called_with(arg=123)
+
+def test_float_conversion(auth, test_deck):
+    """Tests that a string from a form is converted to a float."""
+    with patch('ivoryos.control.routes.global_config.deck_instance.deck_dummy.float_method') as mock_method:
+        auth.post('/ivoryos/control/deck.dummy/call/float_method', data={'arg': '123.45'})
+        # Check that the mock was called with a float
+        mock_method.assert_called_with(arg=123.45)
+
+def test_bool_conversion(auth, test_deck):
+    """Tests that a string from a form is converted to a boolean."""
+    with patch('ivoryos.control.routes.global_config.deck_instance.deck_dummy.bool_method') as mock_method:
+        # Test with 'true'
+        auth.post('/ivoryos/control/deck.dummy/call/bool_method', data={'arg': 'true'})
+        mock_method.assert_called_with(arg=True)
+        # Test with 'false'
+        auth.post('/ivoryos/control/deck.dummy/call/bool_method', data={'arg': 'false'})
+        mock_method.assert_called_with(arg=False)
+
+def test_list_conversion(auth, test_deck):
+    """Tests that a comma-separated string from a form is converted to a list."""
+    with patch('ivoryos.control.routes.global_config.deck_instance.deck_dummy.list_method') as mock_method:
+        auth.post('/ivoryos/control/deck.dummy/call/list_method', data={'arg': 'a,b,c'})
+        # Check that the mock was called with a list of strings
+        mock_method.assert_called_with(arg=['a', 'b', 'c'])
+
+def test_enum_conversion(auth, test_deck):
+    """Tests that a string from a form is converted to an Enum member."""
+    with patch('ivoryos.control.routes.global_config.deck_instance.deck_dummy.enum_method') as mock_method:
+        auth.post('/ivoryos/control/deck.dummy/call/enum_method', data={'arg': 'OPTION_B'})
+        # Check that the mock was called with the correct Enum member
+        mock_method.assert_called_with(arg=TestEnum.OPTION_B)

tests/unit/test_util.py

@@ -0,0 +1,3 @@
+from ivoryos.utils import utils
+from ivoryos.utils.db_models import Script
+

ivoryos/routes/api/api.py

@@ -1,56 +0,0 @@
-import os
-from flask import Blueprint, jsonify, request, current_app
-
-from ivoryos.routes.control.control import find_instrument_by_name
-from ivoryos.utils.form import create_form_from_module
-from ivoryos.utils.global_config import GlobalConfig
-from ivoryos.utils.db_models import Script, WorkflowRun, SingleStep, WorkflowStep
-
-from ivoryos.socket_handlers import abort_pending, abort_current, pause, retry, runner
-from ivoryos.utils.task_runner import TaskRunner
-
-api = Blueprint('api', __name__)
-global_config = GlobalConfig()
-task_runner = TaskRunner()
-
-#TODO: add authentication and authorization to the API endpoints
-
-
-@api.route("/control/", strict_slashes=False, methods=['GET'])
-@api.route("/control/<string:instrument>", methods=['POST'])
-def backend_control(instrument: str=None):
-    """
-    .. :quickref: Backend Control; backend control
-
-    backend control through http requests
-
-    .. http:get:: /api/control/
-
-    :param instrument: instrument name
-    :type instrument: str
-
-    .. http:post:: /api/control/
-
-    """
-    if instrument:
-        inst_object = find_instrument_by_name(instrument)
-        forms = create_form_from_module(sdl_module=inst_object, autofill=False, design=False)
-
-    if request.method == 'POST':
-        method_name = request.form.get("hidden_name", None)
-        form = forms.get(method_name, None)
-        if form:
-            kwargs = {field.name: field.data for field in form if field.name not in ['csrf_token', 'hidden_name']}
-            wait = request.form.get("hidden_wait", "true") == "true"
-            output = task_runner.run_single_step(component=instrument, method=method_name, kwargs=kwargs, wait=wait,
-                                            current_app=current_app._get_current_object())
-            return jsonify(output), 200
-
-    snapshot = global_config.deck_snapshot.copy()
-    # Iterate through each instrument in the snapshot
-    for instrument_key, instrument_data in snapshot.items():
-        # Iterate through each function associated with the current instrument
-        for function_key, function_data in instrument_data.items():
-            # Convert the function signature to a string representation
-            function_data['signature'] = str(function_data['signature'])
-    return jsonify(snapshot), 200