From 9959a9679fd6483ec066b303355d3ae0b5ebe399 Mon Sep 17 00:00:00 2001
From: Ivan Dubrov <dubrov.ivan@gmail.com>
Date: Sat, 24 Aug 2019 17:58:59 -0700
Subject: [PATCH] =?UTF-8?q?=F0=9F=90=B9Adding=20test=20for=20patch=5Funsaf?=
 =?UTF-8?q?e?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .circleci/config.yml |  4 +++-
 src/tests/util.rs    | 47 ++++++++++++++++++++++++++++++++++----------
 2 files changed, 40 insertions(+), 11 deletions(-)

diff --git a/.circleci/config.yml b/.circleci/config.yml
index ef10e1b..f450423 100644
--- a/.circleci/config.yml
+++ b/.circleci/config.yml
@@ -6,9 +6,11 @@ jobs:
     steps:
       - checkout
       - run: rustup component add clippy
+      - run: rustup component add rustfmt
       - run: cargo build
       - run: cargo test --all-targets
-      - run: cargo clippy
+      - run: cargo clippy --all --all-targets
+      - run: cargo fmt -- --check
 #      - run: cargo tarpaulin --out Xml
 #      - run:
 #          name: Uploading code coverage
diff --git a/src/tests/util.rs b/src/tests/util.rs
index ec34371..bf4e753 100644
--- a/src/tests/util.rs
+++ b/src/tests/util.rs
@@ -1,4 +1,3 @@
-use crate::{merge, patch, Patch};
 use serde::Deserialize;
 use serde_json::Value;
 use std::fmt::Write;
@@ -17,18 +16,19 @@ struct TestCase {
     merge: bool,
 }
 
-fn run_case(doc: Value, patches: Value, merge_patch: bool) -> Result<Value, String> {
+fn run_case(doc: &Value, patches: &Value, merge_patch: bool) -> Result<Value, String> {
     let mut actual = doc.clone();
     if merge_patch {
-        merge(&mut actual, &patches);
+        crate::merge(&mut actual, &patches);
     } else {
-        let patches: Patch = serde_json::from_value(patches).map_err(|e| e.to_string())?;
+        let patches: crate::Patch =
+            serde_json::from_value(patches.clone()).map_err(|e| e.to_string())?;
 
         // Patch and verify that in case of error document wasn't changed
-        patch(&mut actual, &patches)
+        crate::patch(&mut actual, &patches)
             .map_err(|e| {
                 assert_eq!(
-                    doc, actual,
+                    *doc, actual,
                     "no changes should be made to the original document"
                 );
                 e
@@ -38,6 +38,14 @@ fn run_case(doc: Value, patches: Value, merge_patch: bool) -> Result<Value, Stri
     Ok(actual)
 }
 
+fn run_case_patch_unsafe(doc: &Value, patches: &Value) -> Result<Value, String> {
+    let mut actual = doc.clone();
+    let patches: crate::Patch =
+        serde_json::from_value(patches.clone()).map_err(|e| e.to_string())?;
+    crate::patch_unsafe(&mut actual, &patches).map_err(|e| e.to_string())?;
+    Ok(actual)
+}
+
 pub fn run_specs(path: &str) {
     let file = fs::File::open(path).unwrap();
     let buf = io::BufReader::new(file);
@@ -56,20 +64,39 @@ pub fn run_specs(path: &str) {
             continue;
         }
 
-        match run_case(tc.doc, tc.patch, tc.merge) {
+        match run_case(&tc.doc, &tc.patch, tc.merge) {
             Ok(actual) => {
                 if let Some(ref error) = tc.error {
                     println!("expected to fail with '{}'", error);
                     panic!("expected to fail, got document {:?}", actual);
                 }
                 println!();
-                if let Some(expected) = tc.expected {
-                    assert_eq!(expected, actual);
+                if let Some(ref expected) = tc.expected {
+                    assert_eq!(*expected, actual);
                 }
             }
             Err(err) => {
                 println!("failed with '{}'", err);
-                tc.error.expect("patch expected to succeed");
+                tc.error.as_ref().expect("patch expected to succeed");
+            }
+        }
+
+        if !tc.merge {
+            match run_case_patch_unsafe(&tc.doc, &tc.patch) {
+                Ok(actual) => {
+                    if let Some(ref error) = tc.error {
+                        println!("expected to fail with '{}'", error);
+                        panic!("expected to fail, got document {:?}", actual);
+                    }
+                    println!();
+                    if let Some(ref expected) = tc.expected {
+                        assert_eq!(*expected, actual);
+                    }
+                }
+                Err(err) => {
+                    println!("failed with '{}'", err);
+                    tc.error.as_ref().expect("patch expected to succeed");
+                }
             }
         }
     }