RSCBC-252: Treat unknown scope errors the same as unknown collection

Author: chvck

sdk/couchbase-core/src/collectionresolver.rs

@@ -82,6 +82,7 @@ where
     if let Some(memdx_err) = err.is_memdx_error() {
         if memdx_err.is_server_error_kind(ServerErrorKind::UnknownCollectionID)
             || memdx_err.is_server_error_kind(ServerErrorKind::UnknownCollectionName)
+            || memdx_err.is_server_error_kind(ServerErrorKind::UnknownScopeName)
         {
             resolver
                 .invalidate_collection_id(scope_name, collection_name)

sdk/couchbase-core/src/crudcomponent.rs

@@ -954,7 +954,9 @@ impl<
             };
 
             if let Some(memdx_err) = err.is_memdx_error() {
-                if memdx_err.is_server_error_kind(ServerErrorKind::UnknownCollectionName) {
+                if memdx_err.is_server_error_kind(ServerErrorKind::UnknownCollectionName)
+                    || memdx_err.is_server_error_kind(ServerErrorKind::UnknownScopeName)
+                {
                     return Err(err);
                 }
             }

sdk/couchbase-core/src/retry.rs

@@ -354,6 +354,9 @@ fn server_error_to_retry_reason(rs: &Arc<RetryManager>, e: &ServerError) -> Opti
         ServerErrorKind::UnknownCollectionName => {
             return Some(RetryReason::KvCollectionOutdated);
         }
+        ServerErrorKind::UnknownScopeName => {
+            return Some(RetryReason::KvCollectionOutdated);
+        }
         ServerErrorKind::Locked => {
             return Some(RetryReason::KvLocked);
         }

sdk/couchbase-core/tests/agent_ops.rs

@@ -22,7 +22,7 @@ use crate::common::default_agent_options::{create_default_options, create_option
 use crate::common::helpers::try_until;
 use crate::common::helpers::{
     create_collection_and_wait_for_kv, delete_collection_and_wait_for_kv, generate_bytes_value,
-    generate_key, is_memdx_error,
+    generate_key, generate_string_key, is_memdx_error,
 };
 use crate::common::test_config::{run_test, setup_test};
 use couchbase_core::agent::Agent;
@@ -778,3 +778,46 @@ fn test_changed_collection_id() {
         assert!(upsert_result.mutation_token.is_some());
     });
 }
+
+#[test]
+fn test_unknown_scope() {
+    setup_test(async |config| {
+        let agent_opts = create_default_options(config.clone()).await;
+        let scope_name = generate_string_key();
+        let collection_name = generate_string_key();
+
+        let mut agent = Agent::new(agent_opts).await.unwrap();
+
+        let strat = Arc::new(BestEffortRetryStrategy::default());
+
+        let key = generate_key();
+        let value = generate_bytes_value(32);
+
+        let upsert_opts = UpsertOptions::new(
+            key.as_slice(),
+            &scope_name,
+            &collection_name,
+            value.as_slice(),
+        )
+        .retry_strategy(strat);
+
+        try_until(
+            Instant::now().add(Duration::from_secs(30)),
+            Duration::from_millis(100),
+            "upsert didn't fail with timeout in allowed time",
+            || async {
+                let upsert_result = timeout_at(
+                    Instant::now().add(Duration::from_millis(2500)),
+                    agent.upsert(upsert_opts.clone()),
+                )
+                .await;
+
+                match upsert_result {
+                    Ok(_) => Ok(None),
+                    Err(_e) => Ok(Some(())),
+                }
+            },
+        )
+        .await;
+    });
+}

sdk/couchbase-core/tests/common/helpers.rs

@@ -148,6 +148,39 @@ pub async fn delete_collection_and_wait_for_kv(
     timeout_at(deadline, fut()).await.unwrap();
 }
 
+pub async fn delete_scope_and_wait_for_kv(
+    agent: &Agent,
+    bucket_name: &str,
+    scope_name: &str,
+    collection_name: &str,
+    deadline: Instant,
+) {
+    agent
+        .delete_scope(&DeleteScopeOptions::new(bucket_name, scope_name))
+        .await
+        .unwrap();
+
+    let fut = || async {
+        loop {
+            let resp = agent
+                .get_collection_id(GetCollectionIdOptions::new(scope_name, collection_name))
+                .await;
+            if let Some(e) = resp.err() {
+                if is_memdx_error(&e)
+                    .unwrap()
+                    .is_server_error_kind(ServerErrorKind::UnknownScopeName)
+                {
+                    break;
+                }
+            }
+
+            tokio::time::sleep(Duration::from_millis(100)).await;
+        }
+    };
+
+    timeout_at(deadline, fut()).await.unwrap();
+}
+
 pub fn is_memdx_error(e: &Error) -> Option<&memdx::error::Error> {
     match e.kind() {
         ErrorKind::Memdx(err, ..) => Some(err),