Sync result (#547)

* Remove sync_account() returns MergeOutcome.

* Remove execute_sync() returns Option<MergeOutcome>.

* Split sync traits for single remote and multiple remotes.

* Use enum for remote sync result.

* Use RemoteResult in listen channel.

* Bump sos-net version, prepare for next release.

* Use type def for RemoteResult.

* Include Origin in RemoteResult.

* Prefer named fields for RemoteResult.

* Define SyncResult.

* Update sdk crate types to NetworkResult.

* Update net crate to use SyncResult type.

* Update sos cli for new SyncResult type.

* Update test specs.

* Bump minor version, prepare for next release.

* Remove obsolete into_option() function.

* Remove SyncError type.

* Add has_errors() and first_error_ref().

* Rename to has_error().

* Update dependencies.

Author: tmpfs

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "sos-account-extras"
-version = "0.14.5"
+version = "0.15.0"
 edition = "2021"
 description = "Extra features for Save Our Secrets local accounts."
 homepage = "https://saveoursecrets.com"
@@ -21,7 +21,7 @@ tokio.workspace = true
 once_cell.workspace = true
 
 [dependencies.sos-sdk]
-version = "0.14.5"
+version = "0.15"
 path = "../sdk"
 
 [build-dependencies]

crates/account_extras/Cargo.toml

@@ -38,7 +38,6 @@ pretty_assertions = "1.4"
 anticipate-runner = { version = "0.5.1" }
 
 [dev-dependencies.sos-net]
-version = "0.14.0" 
 features = ["full"]
 path = "../net"
 

crates/integration_tests/Cargo.toml

@@ -6,8 +6,7 @@ use crate::test_utils::{
 };
 use http::StatusCode;
 use sos_net::{
-    protocol::SyncError, sdk::prelude::*, Error as ClientError,
-    NetworkAccount, RemoteSync,
+    sdk::prelude::*, AccountSync, Error as ClientError, NetworkAccount,
 };
 
 use sos_server::AccessControlConfig;
@@ -52,10 +51,9 @@ async fn access_control_allow() -> Result<()> {
     allowed.owner.add_server(origin.clone()).await?;
     denied.add_server(origin.clone()).await?;
 
-    assert!(allowed.owner.sync().await.is_none());
+    assert!(allowed.owner.sync().await.first_error().is_none());
     let sync_error = denied.sync().await;
-    if let Some(SyncError { mut errors }) = sync_error {
-        let (_, err) = errors.remove(0);
+    if let Some(err) = sync_error.first_error() {
         assert!(matches!(
             err,
             ClientError::ResponseCode(StatusCode::FORBIDDEN)

crates/integration_tests/tests/access_control/allow.rs

@@ -6,8 +6,7 @@ use crate::test_utils::{
 };
 use http::StatusCode;
 use sos_net::{
-    protocol::SyncError, sdk::prelude::*, Error as ClientError,
-    NetworkAccount, RemoteSync,
+    sdk::prelude::*, AccountSync, Error as ClientError, NetworkAccount,
 };
 
 use sos_server::AccessControlConfig;
@@ -51,10 +50,9 @@ async fn access_control_deny() -> Result<()> {
 
     allowed.owner.add_server(origin.clone()).await?;
     denied.add_server(origin.clone()).await?;
-    assert!(allowed.owner.sync().await.is_none());
+    assert!(allowed.owner.sync().await.first_error().is_none());
     let sync_error = denied.sync().await;
-    if let Some(SyncError { mut errors }) = sync_error {
-        let (_, err) = errors.remove(0);
+    if let Some(err) = sync_error.first_error() {
         assert!(matches!(
             err,
             ClientError::ResponseCode(StatusCode::FORBIDDEN)

crates/integration_tests/tests/access_control/deny.rs

@@ -3,7 +3,7 @@ use crate::test_utils::{
     teardown,
 };
 use anyhow::Result;
-use sos_net::{sdk::prelude::*, RemoteSync};
+use sos_net::{sdk::prelude::*, AccountSync};
 
 /// Tests making conflicting changes to a folder whilst
 /// a server is offline and resolving the conflicts with
@@ -35,15 +35,15 @@ async fn auto_merge_create_secrets() -> Result<()> {
         .owner
         .create_secret(meta, secret, Default::default())
         .await?;
-    assert!(result1.sync_error.is_some());
+    assert!(result1.sync_result.first_error().is_some());
 
     // Create a secret on second device and fail to sync
     let (meta, secret) = mock::note("note_2", "offline_secret_2");
     let result2 = device2
         .owner
         .create_secret(meta, secret, Default::default())
         .await?;
-    assert!(result2.sync_error.is_some());
+    assert!(result2.sync_result.first_error().is_some());
 
     let device1_folder_state =
         device1.owner.commit_state(&default_folder).await?;
@@ -59,12 +59,12 @@ async fn auto_merge_create_secrets() -> Result<()> {
     let _server = spawn(TEST_ID, Some(addr), None).await?;
 
     // Sync the first device
-    assert!(device1.owner.sync().await.is_none());
+    assert!(device1.owner.sync().await.first_error().is_none());
 
     // Sync the second device which will auto merge local
     // changes with the remote so it has both secrets
-    let sync_error = device2.owner.sync().await;
-    assert!(sync_error.is_none());
+    let sync_result = device2.owner.sync().await;
+    assert!(sync_result.first_error().is_none());
 
     // Second device now has both secrets
     let (s1, _) = device2
@@ -94,7 +94,7 @@ async fn auto_merge_create_secrets() -> Result<()> {
 
     // Sync the first device again to fetch the remote commits
     // that were changed when the auto merge executed
-    assert!(device1.owner.sync().await.is_none());
+    assert!(device1.owner.sync().await.first_error().is_none());
 
     // First device now has both secrets
     let (s1, _) = device1

crates/integration_tests/tests/auto_merge/create_secrets.rs

@@ -3,7 +3,7 @@ use crate::test_utils::{
     teardown,
 };
 use anyhow::Result;
-use sos_net::{sdk::prelude::*, RemoteSync};
+use sos_net::{sdk::prelude::*, AccountSync};
 
 /// Tests making deletes to a folder whilst
 /// a server is offline and resolving the conflicts with
@@ -30,7 +30,7 @@ async fn auto_merge_delete_secrets() -> Result<()> {
         .owner
         .create_secret(meta, secret, Default::default())
         .await?;
-    assert!(result1.sync_error.is_none());
+    assert!(result1.sync_result.first_error().is_none());
 
     // Create a secret (device2) which will auto merge
     //
@@ -43,8 +43,7 @@ async fn auto_merge_delete_secrets() -> Result<()> {
         .owner
         .create_secret(meta, secret, Default::default())
         .await?;
-    println!("{:#?}", result2.sync_error);
-    assert!(result2.sync_error.is_none());
+    assert!(result2.sync_result.first_error().is_none());
 
     // Oh no, the server has gone offline!
     drop(server);
@@ -56,14 +55,14 @@ async fn auto_merge_delete_secrets() -> Result<()> {
         .owner
         .delete_secret(&result1.id, Default::default())
         .await?;
-    assert!(result.sync_error.is_some());
+    assert!(result.sync_result.first_error().is_some());
 
     // Second device deletes it's secret
     let result = device2
         .owner
         .delete_secret(&result2.id, Default::default())
         .await?;
-    assert!(result.sync_error.is_some());
+    assert!(result.sync_result.first_error().is_some());
 
     let device1_folder_state =
         device1.owner.commit_state(&default_folder).await?;
@@ -83,13 +82,13 @@ async fn auto_merge_delete_secrets() -> Result<()> {
     // This brings the first client and server into sync
     // with both create secrets and the deletion on the
     // first client but the second client is out of sync.
-    assert!(device1.owner.sync().await.is_none());
+    assert!(device1.owner.sync().await.first_error().is_none());
 
     // Sync second device to auto merge and push their offline changes
-    assert!(device2.owner.sync().await.is_none());
+    assert!(device2.owner.sync().await.first_error().is_none());
 
     // Sync first device again to fetch the pushed changes
-    assert!(device1.owner.sync().await.is_none());
+    assert!(device1.owner.sync().await.first_error().is_none());
 
     // Folder commits are back in sync
     let device1_folder_state =

crates/integration_tests/tests/auto_merge/delete_secrets.rs

@@ -3,7 +3,7 @@ use crate::test_utils::{
     teardown,
 };
 use anyhow::Result;
-use sos_net::{sdk::prelude::*, RemoteSync};
+use sos_net::{sdk::prelude::*, AccountSync};
 
 /// Tests making conflicting edits to a folder whilst
 /// a server is offline and resolving the conflicts with
@@ -30,10 +30,10 @@ async fn auto_merge_edit_secrets() -> Result<()> {
         .owner
         .create_secret(meta, secret, Default::default())
         .await?;
-    assert!(result.sync_error.is_none());
+    assert!(result.sync_result.first_error().is_none());
 
     // Sync to fetch the new secret on the second device
-    assert!(device2.owner.sync().await.is_none());
+    assert!(device2.owner.sync().await.first_error().is_none());
 
     // Oh no, the server has gone offline!
     drop(server);
@@ -42,7 +42,7 @@ async fn auto_merge_edit_secrets() -> Result<()> {
 
     // Update the secret whilst offline on first device
     let (meta, secret) = mock::note("edit_1", TEST_ID);
-    let SecretChange { sync_error, .. } = device1
+    let SecretChange { sync_result, .. } = device1
         .owner
         .update_secret(
             &result.id,
@@ -52,11 +52,11 @@ async fn auto_merge_edit_secrets() -> Result<()> {
             None,
         )
         .await?;
-    assert!(sync_error.is_some());
+    assert!(sync_result.first_error().is_some());
 
     // Update the secret whilst offline on second device
     let (meta, secret) = mock::note("edit_2", TEST_ID);
-    let SecretChange { sync_error, .. } = device2
+    let SecretChange { sync_result, .. } = device2
         .owner
         .update_secret(
             &result.id,
@@ -66,7 +66,7 @@ async fn auto_merge_edit_secrets() -> Result<()> {
             None,
         )
         .await?;
-    assert!(sync_error.is_some());
+    assert!(sync_result.first_error().is_some());
 
     let device1_folder_state =
         device1.owner.commit_state(&default_folder).await?;
@@ -82,13 +82,13 @@ async fn auto_merge_edit_secrets() -> Result<()> {
     let _server = spawn(TEST_ID, Some(addr), None).await?;
 
     // Sync first device to push changes
-    assert!(device1.owner.sync().await.is_none());
+    assert!(device1.owner.sync().await.first_error().is_none());
 
     // Sync second device to auto merge
-    assert!(device2.owner.sync().await.is_none());
+    assert!(device2.owner.sync().await.first_error().is_none());
 
     // Sync first device again to fetch auto merged changes
-    assert!(device1.owner.sync().await.is_none());
+    assert!(device1.owner.sync().await.first_error().is_none());
 
     let device1_folder_state =
         device1.owner.commit_state(&default_folder).await?;

crates/integration_tests/tests/auto_merge/edit_secrets.rs

@@ -32,7 +32,7 @@ async fn auto_merge_scan_commits() -> Result<()> {
         .owner
         .create_secret(meta, secret, Default::default())
         .await?;
-    assert!(result.sync_error.is_none());
+    assert!(result.sync_result.first_error().is_none());
     let (meta, secret) = mock::note("note_edited", TEST_ID);
     device
         .owner

crates/integration_tests/tests/auto_merge/scan_commits.rs

@@ -7,7 +7,7 @@ use crate::test_utils::{
     mock::files::{create_file_secret, update_file_secret},
     simulate_device, spawn, teardown, wait_for_num_transfers,
 };
-use sos_net::{sdk::prelude::*, RemoteSync};
+use sos_net::{sdk::prelude::*, AccountSync};
 
 /// Tests uploading an external file to multiple servers.
 #[tokio::test]
@@ -295,7 +295,7 @@ async fn file_transfers_multi_download() -> Result<()> {
     {
         // Sync pulls down the file event logs and
         // creates the pending download transfer operation
-        assert!(downloader.owner.sync().await.is_none());
+        assert!(downloader.owner.sync().await.first_error().is_none());
         wait_for_num_transfers(&downloader.owner, 1).await?;
 
         let server1_path = downloader.server_path;