Merge pull request hyperledger-indy#929 from vimmerru/bugfixes/is-802

Bugfixes/is 802

Author: Vyacheslav

libindy/src/services/wallet/storage/default/mod.rs

@@ -857,6 +857,21 @@ mod tests {
         assert_match!(Err(WalletStorageError::NotFound), res);
     }
 
+    #[test]
+    fn sqlite_storage_add_works_for_is_802() {
+        _cleanup();
+
+        let storage = _storage();
+
+        storage.add(&_type1(), &_id1(), &_value1(), &_tags()).unwrap();
+
+        let res = storage.add(&_type1(), &_id1(), &_value1(), &_tags());
+        assert_match!(Err(WalletStorageError::ItemAlreadyExists), res);
+
+        let res = storage.add(&_type1(), &_id1(), &_value1(), &_tags());
+        assert_match!(Err(WalletStorageError::ItemAlreadyExists), res);
+    }
+
     #[test]
     fn sqlite_storage_set_get_works() {
         _cleanup();

libindy/src/services/wallet/storage/default/transaction.rs

@@ -25,6 +25,16 @@ impl<'conn> Transaction<'conn> {
             })
     }
 
+    /// Get the current setting for what happens to the transaction when it is dropped.
+    pub fn drop_behavior(&self) -> DropBehavior {
+        self.drop_behavior
+    }
+
+    /// Configure the transaction to perform the specified action when it is dropped.
+    pub fn set_drop_behavior(&mut self, drop_behavior: DropBehavior) {
+        self.drop_behavior = drop_behavior
+    }
+
     /// A convenience method which consumes and commits a transaction.
     pub fn commit(mut self) -> Result<()> {
         self.commit_()
@@ -34,6 +44,36 @@ impl<'conn> Transaction<'conn> {
         self.committed = true;
         self.conn.execute_batch("COMMIT")
     }
+
+    /// A convenience method which consumes and rolls back a transaction.
+    pub fn rollback(mut self) -> Result<()> {
+        self.rollback_()
+    }
+
+    fn rollback_(&mut self) -> Result<()> {
+        self.committed = true;
+        self.conn.execute_batch("ROLLBACK")
+    }
+
+    /// Consumes the transaction, committing or rolling back according to the current setting
+    /// (see `drop_behavior`).
+    ///
+    /// Functionally equivalent to the `Drop` implementation, but allows callers to see any
+    /// errors that occur.
+    pub fn finish(mut self) -> Result<()> {
+        self.finish_()
+    }
+
+    fn finish_(&mut self) -> Result<()> {
+        if self.committed {
+            return Ok(());
+        }
+        match self.drop_behavior() {
+            DropBehavior::Commit => self.commit_(),
+            DropBehavior::Rollback => self.rollback_(),
+            DropBehavior::Ignore => Ok(()),
+        }
+    }
 }
 
 impl<'conn> Deref for Transaction<'conn> {
@@ -42,4 +82,11 @@ impl<'conn> Deref for Transaction<'conn> {
     fn deref(&self) -> &Connection {
         self.conn
     }
-}
+}
+
+#[allow(unused_must_use)]
+impl<'conn> Drop for Transaction<'conn> {
+    fn drop(&mut self) {
+        self.finish_();
+    }
+}

libindy/tests/did.rs

@@ -1069,6 +1069,36 @@ mod high_cases {
 
             TestUtils::cleanup_storage();
         }
+
+        #[test]
+        fn indy_store_their_did_works_for_is_802() {
+            TestUtils::cleanup_storage();
+
+            let wallet_handle = WalletUtils::create_and_open_default_wallet().unwrap();
+
+            let identity_json = json!({
+                "did": DID,
+                "verkey": VERKEY,
+            }).to_string();
+
+            // 1. Try 'storeTheirDid' operation with say did1 and verkey1
+            DidUtils::store_their_did(wallet_handle, &identity_json).unwrap();
+
+            // 2. Repeat above operation (with same did and ver key used in #1)
+            // but this time catch and swallow the exception (it will throw the exception WalletItemAlreadyExistsException)
+            let res = DidUtils::store_their_did(wallet_handle, &identity_json);
+            assert_eq!(ErrorCode::WalletItemAlreadyExists, res.unwrap_err());
+
+            // 3. Then, now if you try 'storeTheirDid' operation
+            // (either with same did and verkey or you can choose different did and verkey),
+            // in IS-802 it fails with error 'Storage error occurred during wallet operation.'
+            let res = DidUtils::store_their_did(wallet_handle, &identity_json);
+            assert_eq!(ErrorCode::WalletItemAlreadyExists, res.unwrap_err());
+
+            WalletUtils::close_wallet(wallet_handle).unwrap();
+
+            TestUtils::cleanup_storage();
+        }
     }
 
     mod replace_keys {