[examples] Sync SDK examples from awsdocs/aws-doc-sdk-examples

Includes commit(s):
  02819aebf320f98f0ac7f508a1bb73c569b3d6fe
  2b96edaa6801292b9f0705b1f1e15ddd386ecf1b
  1d851c3ae9fec718b2c7959f36d1193b3f8261dc
  c6d523c62d721609172d38cc2609f03d9ddf9e5b
  af69b9adfa59bfcc3d243de4c66efe9023af3382
  7aa0394f9785da88c27b41c4895b972d5cc131d1
  dbfcb34ed041e059f49ce74186308232c102919a
  97a177aab8c3d2fef97416cb66e4b4d0da840138

Co-authored-by: David Souther <[email protected]>
Co-authored-by: Kasper Primdal Lauritzen <[email protected]>
Co-authored-by: ford prior <[email protected]>

Author: 4 people

examples/dynamodb/Cargo.toml

@@ -42,6 +42,10 @@ version = "0.54.1"
 path = "../../sdk/aws-smithy-types"
 version = "0.54.1"
 
+[dependencies.sdk-examples-test-utils]
+path = "../test-utils"
+version = "0.1.0"
+
 [dependencies.serde]
 version = "1.0"
 features = ["derive"]

examples/dynamodb/src/bin/list-more-tables.rs

@@ -21,5 +21,6 @@ async fn main() -> Result<(), Error> {
     let config = make_config(Opt::from_args()).await?;
     let client = Client::new(&config);
 
-    list_tables_iterative(&client).await
+    list_tables_iterative(&client).await?;
+    Ok(())
 }

examples/dynamodb/src/bin/list-tables-local.rs

@@ -20,6 +20,7 @@ async fn main() -> Result<(), Error> {
         .build();
 
     let client = Client::from_conf(dynamodb_local_config);
-    list_tables(&client).await
+    list_tables(&client).await?;
+    Ok(())
 }
 // snippet-end:[dynamodb.rust.list-tables-local]

examples/dynamodb/src/bin/list-tables.rs

@@ -20,5 +20,6 @@ async fn main() -> Result<(), Error> {
 
     let shared_config = make_config(Opt::from_args()).await?;
     let client = Client::new(&shared_config);
-    list_tables(&client).await
+    list_tables(&client).await?;
+    Ok(())
 }

examples/dynamodb/src/scenario/add.rs

@@ -14,9 +14,18 @@ pub struct Item {
     pub last: String,
 }
 
+#[derive(Debug, PartialEq)]
+pub struct ItemOut {
+    pub p_type: Option<AttributeValue>,
+    pub age: Option<AttributeValue>,
+    pub username: Option<AttributeValue>,
+    pub first_name: Option<AttributeValue>,
+    pub last_name: Option<AttributeValue>,
+}
+
 // Add an item to a table.
 // snippet-start:[dynamodb.rust.add-item]
-pub async fn add_item(client: &Client, item: Item, table: &String) -> Result<(), Error> {
+pub async fn add_item(client: &Client, item: Item, table: &String) -> Result<ItemOut, Error> {
     let user_av = AttributeValue::S(item.username);
     let type_av = AttributeValue::S(item.p_type);
     let age_av = AttributeValue::S(item.age);
@@ -38,15 +47,71 @@ pub async fn add_item(client: &Client, item: Item, table: &String) -> Result<(),
 
     let attributes = resp.attributes().unwrap();
 
+    let username = attributes.get("username").cloned();
+    let first_name = attributes.get("first_name").cloned();
+    let last_name = attributes.get("last_name").cloned();
+    let age = attributes.get("age").cloned();
+    let p_type = attributes.get("p_type").cloned();
+
     println!(
         "Added user {:?}, {:?} {:?}, age {:?} as {:?} user",
-        attributes.get("username"),
-        attributes.get("first_name"),
-        attributes.get("last_name"),
-        attributes.get("age"),
-        attributes.get("p_type")
+        username, first_name, last_name, age, p_type
     );
 
-    Ok(())
+    Ok(ItemOut {
+        p_type,
+        age,
+        username,
+        first_name,
+        last_name,
+    })
 }
 // snippet-end:[dynamodb.rust.add-item]
+
+// snippet-start:[dynamodb.rust.add-item.test]
+#[cfg(test)]
+mod test {
+    use aws_sdk_dynamodb::model::AttributeValue;
+    use sdk_examples_test_utils::single_shot_client;
+
+    use super::{add_item, Item, ItemOut};
+
+    #[tokio::test]
+    async fn test_add_item() {
+        let client = single_shot_client! {
+        sdk: aws_sdk_dynamodb,
+        status: 200,
+        response: r#"{"Attributes": {
+                "p_type": {"S": "Brown"},
+                "age": {"N": "27"},
+                "username": {"S": "testuser"},
+                "first_name": {"S": "Test"},
+                "last_name": {"S": "User"}
+            }}"#};
+
+        let item = Item {
+            username: "testuser".into(),
+            p_type: "Brown".into(),
+            age: "27".into(),
+            first: "Test".into(),
+            last: "User".into(),
+        };
+
+        let resp = add_item(&client, item, &"test_table".to_string()).await;
+
+        assert!(resp.is_ok(), "{:?}", resp);
+        let out = resp.unwrap();
+
+        assert_eq!(
+            out,
+            ItemOut {
+                p_type: Some(AttributeValue::S("Brown".to_string())),
+                age: Some(AttributeValue::N("27".to_string())),
+                username: Some(AttributeValue::S("testuser".to_string())),
+                first_name: Some(AttributeValue::S("Test".to_string())),
+                last_name: Some(AttributeValue::S("User".to_string()))
+            }
+        )
+    }
+}
+// snippet-end:[dynamodb.rust.add-item.test]

examples/dynamodb/src/scenario/create.rs

@@ -7,11 +7,16 @@ use crate::scenario::error::Error;
 use aws_sdk_dynamodb::model::{
     AttributeDefinition, KeySchemaElement, KeyType, ProvisionedThroughput, ScalarAttributeType,
 };
+use aws_sdk_dynamodb::output::CreateTableOutput;
 use aws_sdk_dynamodb::Client;
 
 // Create a table.
 // snippet-start:[dynamodb.rust.create-table]
-pub async fn create_table(client: &Client, table: &str, key: &str) -> Result<(), Error> {
+pub async fn create_table(
+    client: &Client,
+    table: &str,
+    key: &str,
+) -> Result<CreateTableOutput, Error> {
     let a_name: String = key.into();
     let table_name: String = table.into();
 
@@ -40,9 +45,9 @@ pub async fn create_table(client: &Client, table: &str, key: &str) -> Result<(),
         .await;
 
     match create_table_response {
-        Ok(_) => {
+        Ok(out) => {
             println!("Added table {} with key {}", table, key);
-            Ok(())
+            Ok(out)
         }
         Err(e) => {
             eprintln!("Got an error creating table:");
@@ -52,3 +57,40 @@ pub async fn create_table(client: &Client, table: &str, key: &str) -> Result<(),
     }
 }
 // snippet-end:[dynamodb.rust.create-table]
+
+#[cfg(test)]
+mod test {
+    use sdk_examples_test_utils::single_shot_client;
+
+    use super::create_table;
+
+    // snippet-start:[dynamodb.rust.create-table.test]
+    #[tokio::test]
+    async fn test_create_table() {
+        let client = single_shot_client! {
+            sdk: aws_sdk_dynamodb,
+            status: 200,
+            response: r#""#
+        };
+
+        let resp = create_table(&client, "test_table", "test_key").await;
+
+        assert!(resp.is_ok(), "{resp:?}");
+    }
+    // snippet-end:[dynamodb.rust.create-table.test]
+
+    // snippet-start:[dynamodb.rust.create-table.test_err]
+    #[tokio::test]
+    async fn test_create_table_err() {
+        let client = single_shot_client! {
+            sdk: aws_sdk_dynamodb,
+            status: 400,
+            response: r#""#
+        };
+
+        let resp = create_table(&client, "test_table", "test_key").await;
+
+        assert!(resp.is_err(), "{resp:?}");
+    }
+    // snippet-end:[dynamodb.rust.create-table.test_err]
+}

examples/dynamodb/src/scenario/delete.rs

@@ -4,7 +4,11 @@
  */
 
 use crate::scenario::error::Error;
-use aws_sdk_dynamodb::{model::AttributeValue, Client};
+use aws_sdk_dynamodb::{
+    model::AttributeValue,
+    output::{DeleteItemOutput, DeleteTableOutput},
+    Client,
+};
 
 // Deletes an item from the table.
 // snippet-start:[dynamodb.rust.delete-item]
@@ -13,17 +17,17 @@ pub async fn delete_item(
     table: &str,
     key: &str,
     value: &str,
-) -> Result<(), Error> {
+) -> Result<DeleteItemOutput, Error> {
     match client
         .delete_item()
         .table_name(table)
         .key(key, AttributeValue::S(value.into()))
         .send()
         .await
     {
-        Ok(_) => {
+        Ok(out) => {
             println!("Deleted item from table");
-            Ok(())
+            Ok(out)
         }
         Err(e) => Err(Error::unhandled(e)),
     }
@@ -32,11 +36,36 @@ pub async fn delete_item(
 
 // Delete a table.
 // snippet-start:[dynamodb.rust.delete-table]
-pub async fn delete_table(client: &Client, table: &str) -> Result<(), Error> {
-    client.delete_table().table_name(table).send().await?;
+pub async fn delete_table(client: &Client, table: &str) -> Result<DeleteTableOutput, Error> {
+    let resp = client.delete_table().table_name(table).send().await;
 
-    println!("Deleted table");
-
-    Ok(())
+    match resp {
+        Ok(out) => {
+            println!("Deleted table");
+            Ok(out)
+        }
+        Err(e) => Err(Error::Unhandled(e.into())),
+    }
 }
 // snippet-end:[dynamodb.rust.delete-table]
+
+#[cfg(test)]
+mod test {
+    use super::delete_item;
+    use sdk_examples_test_utils::single_shot_client;
+
+    // snippet-start:[dynamodb.rust.delete-item.test_err]
+    #[tokio::test]
+    async fn test_delete_item_err() {
+        let client = single_shot_client! {
+            sdk: aws_sdk_dynamodb,
+            status: 500,
+            response: r#""#
+        };
+
+        let resp = delete_item(&client, "test_table", "id", "test").await;
+
+        assert!(resp.is_err(), "{resp:?}");
+    }
+    // snippet-end:[dynamodb.rust.delete-item.test_err]
+}