secret store separated from util (#1304)

* bump rust-crypto

* initial version of account provider utilizing secret store

* update lazy_static to latest version

* AccountProvider accounts method

* new AccountProvider tests in progress

* basic tests for new AccountProvider

* ethcore compiles with new account provider and secret store

* ethcore-rpc build now compiling with new AccountProvider

* most rpc tests passing with new accounts_provider

* fixed basic_authority tests

* fixed eth_transaction_count rpc test

* fixed mocked/eth.rs tests

* fixed personal tests

* fixed personal signer rpc tests

* removed warnings

* parity compiling fine with new sstore

* fixed import direction

* do not unlock temporarily when we have the password

* removed TODO in account import

* display warning on auto account import failure

* fixed compiling of ethstore on windows

* ethstore as a part of parity repo

* added ethkey

ethstore/tests/api.rs

@@ -0,0 +1,72 @@
+extern crate rand;
+extern crate ethstore;
+
+mod util;
+
+use ethstore::{SecretStore, EthStore};
+use ethstore::ethkey::{Random, Generator, Secret};
+use util::TransientDir;
+
+#[test]
+fn secret_store_create() {
+	let dir = TransientDir::create().unwrap();
+	let _ = EthStore::open(Box::new(dir)).unwrap();
+}
+
+#[test]
+#[should_panic]
+fn secret_store_open_not_existing() {
+	let dir = TransientDir::open();
+	let _ = EthStore::open(Box::new(dir)).unwrap();
+}
+
+fn random_secret() -> Secret {
+	Random.generate().unwrap().secret().clone()
+}
+
+#[test]
+fn secret_store_create_account() {
+	let dir = TransientDir::create().unwrap();
+	let store = EthStore::open(Box::new(dir)).unwrap();
+	assert_eq!(store.accounts().len(), 0);
+	assert!(store.insert_account(random_secret(), "").is_ok());
+	assert_eq!(store.accounts().len(), 1);
+	assert!(store.insert_account(random_secret(), "").is_ok());
+	assert_eq!(store.accounts().len(), 2);
+}
+
+#[test]
+fn secret_store_sign() {
+	let dir = TransientDir::create().unwrap();
+	let store = EthStore::open(Box::new(dir)).unwrap();
+	assert!(store.insert_account(random_secret(), "").is_ok());
+	let accounts = store.accounts();
+	assert_eq!(accounts.len(), 1);
+	assert!(store.sign(&accounts[0], "", &Default::default()).is_ok());
+	assert!(store.sign(&accounts[0], "1", &Default::default()).is_err());
+}
+
+#[test]
+fn secret_store_change_password() {
+	let dir = TransientDir::create().unwrap();
+	let store = EthStore::open(Box::new(dir)).unwrap();
+	assert!(store.insert_account(random_secret(), "").is_ok());
+	let accounts = store.accounts();
+	assert_eq!(accounts.len(), 1);
+	assert!(store.sign(&accounts[0], "", &Default::default()).is_ok());
+	assert!(store.change_password(&accounts[0], "", "1").is_ok());
+	assert!(store.sign(&accounts[0], "", &Default::default()).is_err());
+	assert!(store.sign(&accounts[0], "1", &Default::default()).is_ok());
+}
+
+#[test]
+fn secret_store_remove_account() {
+	let dir = TransientDir::create().unwrap();
+	let store = EthStore::open(Box::new(dir)).unwrap();
+	assert!(store.insert_account(random_secret(), "").is_ok());
+	let accounts = store.accounts();
+	assert_eq!(accounts.len(), 1);
+	assert!(store.remove_account(&accounts[0], "").is_ok());
+	assert_eq!(store.accounts().len(), 0);
+	assert!(store.remove_account(&accounts[0], "").is_err());
+}

ethstore/tests/util/mod.rs

@@ -0,0 +1,3 @@
+mod transient_dir;
+
+pub use self::transient_dir::TransientDir;

ethstore/tests/util/transient_dir.rs

@@ -0,0 +1,58 @@
+use std::path::PathBuf;
+use std::{env, fs};
+use rand::{Rng, OsRng};
+use ethstore::dir::{KeyDirectory, DiskDirectory};
+use ethstore::ethkey::Address;
+use ethstore::{Error, SafeAccount};
+
+pub fn random_dir() -> PathBuf {
+	let mut rng = OsRng::new().unwrap();
+	let mut dir = env::temp_dir();
+	dir.push(format!("{:x}-{:x}", rng.next_u64(), rng.next_u64()));
+	dir
+}
+
+pub struct TransientDir {
+	dir: DiskDirectory,
+	path: PathBuf,
+}
+
+impl TransientDir {
+	pub fn create() -> Result<Self, Error> {
+		let path = random_dir();
+		let result = TransientDir {
+			dir: try!(DiskDirectory::create(&path)),
+			path: path,
+		};
+
+		Ok(result)
+	}
+
+	pub fn open() -> Self {
+		let path = random_dir();
+		TransientDir {
+			dir: DiskDirectory::at(&path),
+			path: path,
+		}
+	}
+}
+
+impl Drop for TransientDir {
+	fn drop(&mut self) {
+		fs::remove_dir_all(&self.path).expect("Expected to remove temp dir");
+	}
+}
+
+impl KeyDirectory for TransientDir {
+	fn load(&self) -> Result<Vec<SafeAccount>, Error> {
+		self.dir.load()
+	}
+
+	fn insert(&self, account: SafeAccount) -> Result<(), Error> {
+		self.dir.insert(account)
+	}
+
+	fn remove(&self, address: &Address) -> Result<(), Error> {
+		self.dir.remove(address)
+	}
+}