ivoryos 1.2.0b1__py3-none-any.whl → 1.2.2__py3-none-any.whl

tests/integration/test_route_auth.py

@@ -1,80 +0,0 @@
-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

@@ -1,94 +0,0 @@
-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

@@ -1,61 +0,0 @@
-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

@@ -1,36 +0,0 @@
-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

@@ -1,35 +0,0 @@
-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

@@ -1,26 +0,0 @@
-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']