fix: real AP id tests, exact poster key check, exists port, list_movies fake

crates/domain/src/testing/fakes/noops.rs

@@ -61,6 +61,10 @@ impl ObjectStorage for NoopObjectStorage {
     async fn delete(&self, _key: &str) -> Result<(), DomainError> {
         Ok(())
     }
+
+    async fn exists(&self, _key: &str) -> Result<bool, DomainError> {
+        Ok(true)
+    }
 }
 
 // Re-export production noop types so test code that imports from

crates/domain/src/testing/fakes/panics.rs

@@ -609,6 +609,9 @@ impl ObjectStorage for PanicObjectStorage {
     async fn delete(&self, _: &str) -> Result<(), DomainError> {
         panic!("PanicObjectStorage called")
     }
+    async fn exists(&self, _: &str) -> Result<bool, DomainError> {
+        panic!("PanicObjectStorage called")
+    }
 }
 
 pub struct PanicAuthService;

crates/domain/src/testing/fakes/store_movie.rs

@@ -152,14 +152,53 @@ impl MovieQuery for InMemoryStore {
 
     async fn list_movies(
         &self,
-        _page: &PageParams,
-        _filter: &MovieFilter,
+        page: &PageParams,
+        filter: &MovieFilter,
     ) -> Result<Paginated<MovieSummary>, DomainError> {
+        // Mirrors the sqlite adapter: filter, ORDER BY title ASC, then page.
+        let movies = self.movies.read().unwrap();
+        let profiles = self.movie_profiles.read().unwrap();
+        let search = filter.search.as_deref().map(str::to_lowercase);
+        let mut rows: Vec<MovieSummary> = movies
+            .values()
+            .filter_map(|m| {
+                let profile = profiles.get(&m.id().value());
+                let genres: Vec<String> = profile
+                    .map(|p| p.genres.iter().map(|g| g.name.clone()).collect())
+                    .unwrap_or_default();
+                let language = profile.and_then(|p| p.original_language.clone());
+                let keep = search
+                    .as_ref()
+                    .is_none_or(|q| m.title().value().to_lowercase().contains(q))
+                    && filter
+                        .language
+                        .as_ref()
+                        .is_none_or(|l| language.as_ref() == Some(l))
+                    && filter.genre.as_ref().is_none_or(|g| {
+                        genres.iter().any(|n| n.to_lowercase() == g.to_lowercase())
+                    });
+                keep.then(|| MovieSummary {
+                    movie: m.clone(),
+                    genres,
+                    runtime_minutes: profile.and_then(|p| p.runtime_minutes),
+                    original_language: language,
+                    overview: profile.and_then(|p| p.overview.clone()),
+                    collection_name: profile.and_then(|p| p.collection_name.clone()),
+                })
+            })
+            .collect();
+        rows.sort_by(|a, b| a.movie.title().value().cmp(b.movie.title().value()));
+        let total_count = rows.len() as u64;
+        let items = rows
+            .into_iter()
+            .skip(page.offset as usize)
+            .take(page.limit as usize)
+            .collect();
         Ok(Paginated {
-            items: vec![],
-            total_count: 0,
-            limit: 10,
-            offset: 0,
+            items,
+            total_count,
+            limit: page.limit,
+            offset: page.offset,
         })
     }