Merge pull request #5 from mocks-rs/0.3.5

0.3.5

Author: codemountains

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "mocks"
-version = "0.3.4"
+version = "0.3.5"
 edition = "2021"
 authors = ["codemountains <codemountains@gmail.com>"]
 description = "Get a mock REST APIs with zero coding within seconds."

Cargo.toml

@@ -1,6 +1,6 @@
 # mocks docs
 
-## Build
+## Build for Homebrew
 
 ```shell
 cargo build --release

docs/DOCUMENT.md

@@ -14,10 +14,7 @@ pub async fn get_all(
         .lock()
         .map_err(|e| MocksError::Exception(e.to_string()))?;
 
-    let value = state
-        .storage
-        .get_all(&resource)
-        .ok_or(MocksError::ResourceNotFound)?;
+    let value = state.storage.get_all(&resource)?;
     let response = json!({
         resource: value
     });
@@ -33,9 +30,6 @@ pub async fn get_one(
         .lock()
         .map_err(|e| MocksError::Exception(e.to_string()))?;
 
-    let value = state
-        .storage
-        .get_one(&resource, &id)
-        .ok_or(MocksError::ObjectNotFound)?;
+    let value = state.storage.get_one(&resource, &id)?;
     Ok((StatusCode::OK, Json(value)))
 }

src/server/handler/get.rs

@@ -42,14 +42,14 @@ impl Storage {
 
     /// **GET**
     /// Retrieve all items for a given resource
-    pub fn get_all(&self, resource_key: &str) -> Option<Value> {
-        select_all(&self.data, resource_key).ok()
+    pub fn get_all(&self, resource_key: &str) -> Result<Value, MocksError> {
+        self.fetch(|data| select_all(data, resource_key))
     }
 
     /// **GET**
     /// Retrieve a specific item from a resource
-    pub fn get_one(&self, resource_key: &str, item_key: &str) -> Option<Value> {
-        select_one(&self.data, resource_key, item_key).ok()
+    pub fn get_one(&self, resource_key: &str, item_key: &str) -> Result<Value, MocksError> {
+        self.fetch(|data| select_one(data, resource_key, item_key))
     }
 
     /// **POST**
@@ -98,6 +98,18 @@ impl Storage {
         self.operate(|data| remove(data, resource_key, item_key))
     }
 
+    /// Fetches data from the storage using the provided operation
+    ///
+    /// This method abstracts the common pattern of performing a fetch operation,
+    /// and returning the result.
+    fn fetch<F>(&self, operation: F) -> Result<Value, MocksError>
+    where
+        F: FnOnce(&StorageData) -> Result<Value, MocksError>,
+    {
+        let result = operation(&self.data)?;
+        Ok(result)
+    }
+
     /// Perform an operation on the storage data and write changes if successful
     ///
     /// This method abstracts the common pattern of performing an operation,

src/storage.rs

@@ -1,3 +1,7 @@
+use crate::error::MocksError;
+use crate::storage::{Input, StorageData};
+use serde_json::Value;
+
 pub mod insert;
 pub mod remove;
 pub mod replace;
@@ -6,3 +10,36 @@ pub mod select_all;
 pub mod select_one;
 pub mod update;
 pub mod update_one;
+
+pub fn extract_id_in_input(input: &Input) -> Result<String, MocksError> {
+    input
+        .get("id")
+        .and_then(|v| match v {
+            Value::Number(id) => Some(id.to_string()),
+            Value::String(id) => Some(id.to_string()),
+            _ => None,
+        })
+        .ok_or(MocksError::InvalidRequest)
+}
+
+pub fn check_duplicate_id(
+    data: &StorageData,
+    resource_key: &str,
+    id: &str,
+) -> Result<(), MocksError> {
+    if select_one::select_one(data, resource_key, id).is_ok() {
+        Err(MocksError::DuplicateId)
+    } else {
+        Ok(())
+    }
+}
+
+pub fn extract_array_resource(
+    data: &StorageData,
+    resource_key: &str,
+) -> Result<Vec<Value>, MocksError> {
+    data.get(resource_key)
+        .and_then(Value::as_array)
+        .ok_or(MocksError::ResourceNotFound)
+        .cloned()
+}

src/storage/operation.rs

@@ -1,5 +1,5 @@
 use crate::error::MocksError;
-use crate::storage::operation::select_one::select_one;
+use crate::storage::operation::{check_duplicate_id, extract_id_in_input};
 use crate::storage::{Input, StorageData};
 use serde_json::Value;
 
@@ -9,18 +9,16 @@ pub fn insert(
     input: &Input,
 ) -> Result<Value, MocksError> {
     // Validation to check duplicate IDs
-    let id = input
-        .get("id")
-        .and_then(|v| match v {
-            Value::Number(id) => Some(id.to_string()),
-            Value::String(id) => Some(id.to_string()),
-            _ => None,
-        })
-        .ok_or(MocksError::InvalidRequest)?;
-    if select_one(data, resource_key, &id).is_ok() {
-        return Err(MocksError::DuplicateId);
-    }
+    let id = extract_id_in_input(input)?;
+    check_duplicate_id(data, resource_key, &id)?;
+    insert_input(data, resource_key, input)
+}
 
+fn insert_input(
+    data: &mut StorageData,
+    resource_key: &str,
+    input: &Input,
+) -> Result<Value, MocksError> {
     data.get_mut(resource_key)
         .and_then(Value::as_array_mut)
         .map(|values| {

src/storage/operation/insert.rs

@@ -1,4 +1,5 @@
 use crate::error::MocksError;
+use crate::storage::operation::extract_array_resource;
 use crate::storage::operation::select_one::select_one;
 use crate::storage::StorageData;
 use serde_json::Value;
@@ -8,31 +9,30 @@ pub fn remove(
     resource_key: &str,
     search_key: &str,
 ) -> Result<Value, MocksError> {
-    let values = data
-        .get(resource_key)
-        .and_then(Value::as_array)
-        .ok_or(MocksError::ResourceNotFound)?;
+    let values = extract_array_resource(data, resource_key)?;
 
     // Get the target to be removed
-    let removed = select_one(data, resource_key, search_key)?;
+    let remove_one = select_one(data, resource_key, search_key)?;
+    let removed_resource = remove_target(values, search_key);
+    data[resource_key] = Value::Array(removed_resource);
+    Ok(remove_one)
+}
 
-    let filtered: Vec<Value> = values
+fn remove_target(values: Vec<Value>, key: &str) -> Vec<Value> {
+    values
         .iter()
         .filter(|&value| {
             value
                 .get("id")
                 .and_then(|id| match id {
-                    Value::Number(n) => Some(n.to_string() != search_key),
-                    Value::String(s) => Some(s != search_key),
+                    Value::Number(n) => Some(n.to_string() != key),
+                    Value::String(s) => Some(s != key),
                     _ => None,
                 })
                 .unwrap_or(true)
         })
         .cloned()
-        .collect();
-
-    data[resource_key] = Value::Array(filtered);
-    Ok(removed)
+        .collect()
 }
 
 #[cfg(test)]

src/storage/operation/remove.rs

@@ -1,4 +1,5 @@
 use crate::error::MocksError;
+use crate::storage::operation::extract_array_resource;
 use crate::storage::operation::select_one::select_one;
 use crate::storage::{Input, StorageData};
 use serde_json::Value;
@@ -9,30 +10,29 @@ pub fn replace(
     search_key: &str,
     input: &Input,
 ) -> Result<Value, MocksError> {
-    let values = data
-        .get(resource_key)
-        .and_then(Value::as_array)
-        .ok_or(MocksError::ResourceNotFound)?;
+    let values = extract_array_resource(data, resource_key)?;
 
     // Validation to confirm the existence
     select_one(data, resource_key, search_key)?;
+    let replaced_resource = replace_target_with_input(values, search_key, input);
+    data[resource_key] = Value::Array(replaced_resource);
+    Ok(input.clone())
+}
 
-    let replaced: Vec<Value> = values
+fn replace_target_with_input(values: Vec<Value>, key: &str, input: &Input) -> Vec<Value> {
+    values
         .iter()
         .map(|value| {
             let id = value.get("id");
-            if matches!(id, Some(Value::Number(n)) if n.to_string() == search_key)
-                || matches!(id, Some(Value::String(s)) if s == search_key)
+            if matches!(id, Some(Value::Number(n)) if n.to_string() == key)
+                || matches!(id, Some(Value::String(s)) if s == key)
             {
                 input.clone()
             } else {
                 value.clone()
             }
         })
-        .collect();
-
-    data[resource_key] = Value::Array(replaced);
-    Ok(input.clone())
+        .collect()
 }
 
 #[cfg(test)]

src/storage/operation/replace.rs

@@ -1,19 +1,28 @@
 use crate::error::MocksError;
+use crate::storage::operation::extract_id_in_input;
 use crate::storage::{Input, StorageData};
-use serde_json::Value;
+use serde_json::{Map, Value};
 
 pub fn replace_one(
     data: &mut StorageData,
     resource_key: &str,
     input: &Input,
 ) -> Result<Value, MocksError> {
+    extract_id_in_input(input)?;
     let valid_input = input.as_object().ok_or(MocksError::InvalidRequest)?;
+    replace_target_with_map_input(data, resource_key, valid_input.clone())
+}
 
+fn replace_target_with_map_input(
+    data: &mut StorageData,
+    resource_key: &str,
+    map_input: Map<String, Value>,
+) -> Result<Value, MocksError> {
     data.get_mut(resource_key)
         .and_then(Value::as_object_mut)
         .map(|v| {
-            *v = valid_input.clone();
-            input.clone()
+            *v = map_input.clone();
+            Value::Object(map_input)
         })
         .ok_or(MocksError::ObjectNotFound)
 }

src/storage/operation/replace_one.rs

@@ -12,8 +12,18 @@ pub fn update(
         .get_mut(resource_key)
         .and_then(Value::as_array_mut)
         .ok_or(MocksError::ResourceNotFound)?;
+    match update_resource_with_input(values, search_key, input) {
+        Some(value) => Ok(value),
+        None => Err(MocksError::ObjectNotFound),
+    }
+}
 
-    let updated = values.iter_mut().find_map(|value| {
+fn update_resource_with_input(
+    values: &mut [Value],
+    search_key: &str,
+    input: &Input,
+) -> Option<Value> {
+    values.iter_mut().find_map(|value| {
         let obj = value.as_object_mut()?;
         let id = obj.get("id")?;
 
@@ -31,12 +41,7 @@ pub fn update(
         } else {
             None
         }
-    });
-
-    match updated {
-        Some(value) => Ok(value),
-        None => Err(MocksError::ObjectNotFound),
-    }
+    })
 }
 
 #[cfg(test)]

src/storage/operation/update.rs

@@ -10,8 +10,11 @@ pub fn update_one(
     let resource = data
         .get_mut(resource_key)
         .ok_or(MocksError::ObjectNotFound)?;
+    update_target_with_input(resource, input)
+}
 
-    match resource {
+fn update_target_with_input(value: &mut Value, input: &Input) -> Result<Value, MocksError> {
+    match value {
         Value::Object(map) => {
             if let Value::Object(input_map) = input {
                 map.extend(input_map.iter().map(|(k, v)| (k.clone(), v.clone())));
@@ -20,7 +23,7 @@ pub fn update_one(
                 return Err(MocksError::Exception(EXCEPTION_ERROR_MESSAGE.to_string()));
             }
 
-            Ok(resource.clone())
+            Ok(value.clone())
         }
         _ => Err(MocksError::ObjectNotFound),
     }

src/storage/operation/update_one.rs

@@ -1,12 +1,31 @@
 {
   "posts": [
-    { "id": "01J7BAKH37HPG116ZRRFKHBDGB", "title": "first post", "views": 100 },
-    { "id": "01J7BAKH37GE8B688PT4RC7TP4", "title": "second post", "views": 10 }
+    {
+      "id": "01J7BAKH37HPG116ZRRFKHBDGB",
+      "title": "first post",
+      "views": 100
+    },
+    {
+      "id": "01J7BAKH37GE8B688PT4RC7TP4",
+      "title": "second post",
+      "views": 10
+    }
   ],
   "comments": [
-    { "id": 1, "text": "a comment", "post_id": "01J7BAKH37HPG116ZRRFKHBDGB" },
-    { "id": 2, "text": "another comment", "post_id": "01J7BAKH37HPG116ZRRFKHBDGB" }
+    {
+      "id": 1,
+      "text": "a comment",
+      "post_id": "01J7BAKH37HPG116ZRRFKHBDGB"
+    },
+    {
+      "id": 2,
+      "text": "another comment",
+      "post_id": "01J7BAKH37HPG116ZRRFKHBDGB"
+    }
   ],
-  "profile": { "id": "01J7BAQE1GMD78FN3J0FJCNS8T", "name": "mocks" },
+  "profile": {
+    "id": "01J7BAQE1GMD78FN3J0FJCNS8T",
+    "name": "mocks"
+  },
   "friends": []
 }