Engines now return FileMeta with correct millisecond timestamps

kernel/src/engine/default/filesystem.rs

@@ -68,7 +68,7 @@ impl<E: TaskExecutor> FileSystemClient for ObjectStoreFileSystemClient<E> {
                         sender
                             .send(Ok(FileMeta {
                                 location,
-                                last_modified: meta.last_modified.timestamp(),
+                                last_modified: meta.last_modified.timestamp_millis(),
                                 size: meta.size,
                             }))
                             .ok();
@@ -216,6 +216,36 @@ mod tests {
         assert_eq!(data[2], Bytes::from("el-da"));
     }
 
+    #[tokio::test]
+    async fn test_file_meta_is_correct() {
+        let tmp = tempfile::tempdir().unwrap();
+        let tmp_store = LocalFileSystem::new_with_prefix(tmp.path()).unwrap();
+
+        let data = Bytes::from("kernel-data");
+        let name = delta_path_for_version(1, "json");
+        tmp_store.put(&name, data.clone().into()).await.unwrap();
+
+        let url = Url::from_directory_path(tmp.path()).unwrap();
+        let prefix = Path::from_url_path(url.path()).expect("Couldn't get path");
+        let store = Arc::new(LocalFileSystem::new());
+        let engine = DefaultEngine::new(store, prefix, Arc::new(TokioBackgroundExecutor::new()));
+        let files: Vec<_> = engine
+            .get_file_system_client()
+            .list_from(&Url::parse("file://").unwrap())
+            .unwrap()
+            .try_collect()
+            .unwrap();
+
+        let object_meta = tmp_store.head(&name).await.unwrap();
+        let expected_location = url.join(name.as_ref()).unwrap();
+        let expected_file_meta = FileMeta {
+            location: expected_location,
+            // We assert that the timestamp is in milliseconds
+            last_modified: object_meta.last_modified.timestamp_millis(),
+            size: object_meta.size,
+        };
+        assert_eq!(files, vec![expected_file_meta]);
+    }
     #[tokio::test]
     async fn test_default_engine_listing() {
         let tmp = tempfile::tempdir().unwrap();

kernel/src/engine/sync/fs_client.rs

@@ -51,19 +51,19 @@ impl FileSystemClient for SyncFilesystemClient {
                 .sorted_by_key(|ent| ent.path())
                 .map(|ent| {
                     ent.metadata().map_err(Error::IOError).and_then(|metadata| {
-                        let last_modified: u64 = metadata
+                        let last_modified = metadata
                             .modified()
-                            .map(
-                                |modified| match modified.duration_since(SystemTime::UNIX_EPOCH) {
-                                    Ok(d) => d.as_secs(),
-                                    Err(_) => 0,
-                                },
-                            )
+                            .ok()
+                            .and_then(|modified| {
+                                modified.duration_since(SystemTime::UNIX_EPOCH).ok()
+                            })
+                            .and_then(|modified| modified.as_millis().try_into().ok())
                             .unwrap_or(0);
+
                         Url::from_file_path(ent.path())
                             .map(|location| FileMeta {
                                 location,
-                                last_modified: last_modified as i64,
+                                last_modified,
                                 size: metadata.len() as usize,
                             })
                             .map_err(|_| Error::Generic(format!("Invalid path: {:?}", ent.path())))
@@ -97,20 +97,53 @@ impl FileSystemClient for SyncFilesystemClient {
 
 #[cfg(test)]
 mod tests {
-    use std::fs::File;
     use std::io::Write;
+    use std::os::unix::fs::MetadataExt;
+    use std::{fs::File, time::UNIX_EPOCH};
 
     use bytes::{BufMut, BytesMut};
+    use itertools::Itertools;
     use url::Url;
 
     use super::SyncFilesystemClient;
-    use crate::FileSystemClient;
+    use crate::{FileMeta, FileSystemClient};
 
     /// generate json filenames that follow the spec (numbered padded to 20 chars)
     fn get_json_filename(index: usize) -> String {
         format!("{index:020}.json")
     }
 
+    #[test]
+    fn test_file_meta_is_correct() -> Result<(), Box<dyn std::error::Error>> {
+        let client = SyncFilesystemClient;
+        let tmp_dir = tempfile::tempdir().unwrap();
+
+        let path = tmp_dir.path().join(get_json_filename(1));
+        let mut f = File::create(path)?;
+        writeln!(f, "null")?;
+
+        let url_path = tmp_dir.path().join(get_json_filename(1));
+        let url = Url::from_file_path(url_path).unwrap();
+        let list: Vec<_> = client.list_from(&url)?.try_collect()?;
+
+        let metadata = f.metadata()?;
+        // We assert that the timestamp is in milliseconds
+        let expected_timestamp = metadata
+            .modified()?
+            .duration_since(UNIX_EPOCH)?
+            .as_millis()
+            .try_into()?;
+        let expected_size = metadata.size().try_into()?;
+        let expected_file_meta = FileMeta {
+            location: url,
+            last_modified: expected_timestamp,
+            size: expected_size,
+        };
+
+        assert_eq!(list, vec![expected_file_meta]);
+        Ok(())
+    }
+
     #[test]
     fn test_list_from() -> Result<(), Box<dyn std::error::Error>> {
         let client = SyncFilesystemClient;