test: first steps with AppTest and a mock multi-file file_uploader

- a test fixture that generates the right interface but fake data inside
the file objects
- a demo script instantiating a few minimal components (the
file_uploader, a callback for the on_change handling, and some visual
elements that are dynamically created when files are uploaded)

- some work towards a second fixture that loads real data too, not
used in any tests yet

src/apptest/demo_multifile_upload.py

@@ -0,0 +1,65 @@
+# a minimal snippet for validating the upload sequence, for testing purposes (with AppTest)
+
+import streamlit as st
+
+# to run streamlit from this subdir, we need the the src dir on the path
+# NOTE: pytest doesn't need this to run the tests, but to develop the test
+# harness is hard without running streamlit 
+import sys
+from os import path
+# src (parent from here)
+src_dir = path.dirname( path.dirname( path.abspath(__file__) ) )
+sys.path.append(src_dir)
+
+# we aim to validate: 
+# - user uploads multple files via FileUploader (with key=file_uploader_data)
+# - they get buffered into session state
+# - some properties are extracted from the files, and are displayed in a visual
+#   element so we can validate them with apptest.
+
+
+from input.input_handling import (
+    spoof_metadata, is_valid_email,
+    get_image_datetime, get_image_latlon,
+    init_input_data_session_states
+)
+
+def buffer_uploaded_files():
+    st.write("buffering files! ")
+    uploaded_files = st.session_state.file_uploader_data
+    for ix, file in enumerate(uploaded_files):
+        image_datetime_raw = get_image_datetime(file)
+        latitude0, longitude0 = get_image_latlon(file)
+        #st.write(f"- file {ix}: {file.name}")
+        #st.write(f"  - datetime: {image_datetime_raw}")
+        #st.write(f"  - lat/lon: {latitude0}, {longitude0}")
+        s = f"index: {ix}, name: {file.name}, datetime: {image_datetime_raw}, lat: {latitude0}, lon:{longitude0}"
+        st.text_area(f"{file.name}", value=s, key=f"metadata_{ix}")
+        print(s)
+        
+init_input_data_session_states()
+
+with st.sidebar:
+    author_email = st.text_input("Author Email", spoof_metadata.get('author_email', ""),
+                                                key="input_author_email")
+    if author_email and not is_valid_email(author_email):   
+        st.error("Please enter a valid email address.")
+
+    st.file_uploader(
+        "Upload one or more images", type=["png", 'jpg', 'jpeg', 'webp'],
+        accept_multiple_files=True, 
+        key="file_uploader_data", 
+        on_change=buffer_uploaded_files
+        )
+
+# this is the callback that would be triggered by the FileUploader
+# - unfortunately, we get into a mess now
+#   - in real app, this runs twice and breaks (because of the duplicate keys)
+#   - in the test, if we don't run manually, we don't get the frontend elements to validate
+#   - if we remove the on_change, both run ok. but it deviates from the true app.
+# - possible ways forward?
+#   - could we patch the on_change, or substitute the buffer_uploaded_files?
+if (1 and "file_uploader_data" in st.session_state and 
+    len(st.session_state.file_uploader_data) ):
+    print(f"buffering files: {len(st.session_state.file_uploader_data)}")
+    buffer_uploaded_files()

tests/test_demo_multifile_upload.py

@@ -0,0 +1,166 @@
+from typing import Protocol, runtime_checkable
+
+from pathlib import Path
+from io import BytesIO
+from PIL import Image
+
+import pytest
+from unittest.mock import MagicMock, patch
+from streamlit.testing.v1 import AppTest
+
+# - tests for apptest/demo_multifile_upload
+
+# zero test: no inputs -> empty session state 
+# (or maybe even non-existent session state; for file_uploader we are not allowed to initialise the keyed variable, st borks)
+
+# many test: list of 2 inputs -> session state with 2 files
+
+
+
+# for expectations
+from input.input_handling import spoof_metadata
+from input.input_validator import get_image_datetime, get_image_latlon
+
+
+@runtime_checkable
+class UploadedFile(Protocol):
+    name: str
+    size: int
+    type: str
+    #RANDO: str
+    _file_urls: list
+
+    def getvalue(self) -> bytes: ...
+    def read(self) -> bytes: ... 
+
+        
+class MockUploadedFile(BytesIO):
+    def __init__(self, 
+                 initial_bytes: bytes, 
+                 *, 
+                 name: str, 
+                 size: int, 
+                 type: str):
+        super().__init__(initial_bytes)
+        self.name = name  # Simulate a filename
+        self.size = size  # Simulate file size
+        self.type = type  # Simulate MIME type
+
+
+@pytest.fixture
+def mock_uploadedFile():
+    def _mock_uploadedFile(name: str, size: int, type: str):
+        test_data = b'test data'
+        # now load some real data, if fname exists
+        base = Path(__file__).parent.parent
+        fname = Path(base / f"tests/data/{name}")
+        
+        if fname.exists():
+            with open(fname, 'rb') as f:
+                #test_data = BytesIO(f.read()) 
+                test_data = f.read()
+        else:
+            #print(f"[DDDD] {name}, {size}, {type} not found")
+            raise FileNotFoundError(f"file {fname} not found ({name}, {size}, {type})")
+    
+        return MockUploadedFile(
+                test_data, name=name, size=size, type=type,)
+    
+    return _mock_uploadedFile
+
+    
+@pytest.fixture
+def mock_uploadedFileNoRealData():
+    class MockGUIClassFakeData(MagicMock):
+        def __init__(self, *args, **kwargs):
+            super().__init__(*args, **kwargs)
+            name = kwargs.get('fname', 'image2.jpg')
+            size = kwargs.get('size', 123456)
+            type = kwargs.get('type', 'image/jpeg')
+            self.bytes_io = MockUploadedFile(
+                b"test data", name=name, size=size, type=type)
+            self.get_data = MagicMock(return_value=self.bytes_io)
+            # it seems unclear to me which member attributes get set by the MockUploadedFile constructor
+            # - for some reason, size and type get set, but name does not, and results in 
+            #   <MockGUIClass name='mock.name' id='<12345>'>.
+            #   so let's sjust explicitly set all the relevant attributes here.
+            self.name = name
+            self.size = size
+            self.type = type
+            
+    return MockGUIClassFakeData
+
+@pytest.fixture
+def mock_uploadedFile_List(mock_uploadedFileNoRealData):
+    def create_list_of_mocks(num_files=3, **kwargs):
+        return [mock_uploadedFileNoRealData(**kwargs) for _ in range(num_files)]
+    return create_list_of_mocks
+
+@pytest.fixture
+def mock_uploadedFile_List_ImageData(mock_uploadedFile):
+    def create_list_of_mocks_realdata(num_files=3, **kwargs):
+        print(f"[D] [mock_uploadedFile_List_Img-internal] num_files: {num_files}")
+        data = [
+            {"name": "cakes.jpg", "size": 1234, "type": "image/jpeg"},
+            {"name": "cakes_no_exif_datetime.jpg", "size": 12345, "type": "image/jpeg"},
+            {"name": "cakes_no_exif_gps.jpg", "size": 123456, "type": "image/jpeg"},
+        ]
+        
+        _the_files = []
+        for i in range(num_files):
+            _the_files.append( mock_uploadedFile(**data[i]))
+        
+        print(f"========== finished init of {num_files} mock_uploaded files | {len(_the_files)} ==========")
+        return _the_files
+            
+        #return [mock_uploadedFile(**kwargs) for _ in range(num_files)]
+    return create_list_of_mocks_realdata
+
+    
+    
+def test_no_input_no_interaction():
+    at = AppTest.from_file("src/apptest/demo_multifile_upload.py").run()
+    
+    assert at.session_state.observations == {}
+    assert at.session_state.input_author_email == spoof_metadata.get("author_email")
+
+
+
+@patch("streamlit.file_uploader")
+def test_mockupload_list(mock_file_uploader_rtn: MagicMock, mock_uploadedFile_List):
+    # Create a list of 2 mock files
+    mock_files = mock_uploadedFile_List(num_files=2, fname="test.jpg", size=100, type="image/jpeg")
+    
+    # Set the return value of the mocked file_uploader to the list of mock files
+    mock_file_uploader_rtn.return_value = mock_files
+
+    # Run the Streamlit app
+    at = AppTest.from_file("src/apptest/demo_multifile_upload.py").run()
+
+    # put the mocked file_upload into session state, as if it were the result of a file upload, with the key 'file_uploader_data'
+    at.session_state["file_uploader_data"] = mock_files
+
+    #print(f"[I] session state: {at.session_state}")
+    #print(f"[I] uploaded files: {at.session_state.file_uploader_data}")
+
+    if 1:
+        print(f"[I] uploaded files: {at.session_state.file_uploader_data}")
+        for _f in at.session_state.file_uploader_data:
+            print(f"[I]  props: {dir(_f)}")
+            print(f"[I]  name: {_f.name}")
+            print(f"[I]  size: {_f.size}")
+            print(f"[I]  type: {_f.type}")
+            print(f"[I] data : {type(_f)} | {type(_f.return_value)} | {_f}")
+            # lets make an image from it.
+            #im = Image.open(_f)
+            
+
+            
+
+
+        # Verify behavior in the app
+        assert len(at.session_state.file_uploader_data) == 2
+        
+        assert at.session_state.file_uploader_data[0].size == 100  # Check properties of the first file
+        assert at.session_state.file_uploader_data[1].name == "test.jpg"  # Check properties of the second file
+