Reorganising the repository - external renames and moves (#4074)

* Adding first rough ouline of the repository structure * Remove old CI stuff * add title * formatting fixes * move node-exits job's script to scripts dir * Move docs into subdir * move to bin * move maintainence scripts, configs and helpers into its own dir * add .local to ignore * move core->client * start up 'test' area * move test client * move test runtime * make test move compile * Add dependencies rule enforcement. * Fix indexing. * Update docs to reflect latest changes * Moving /srml->/paint * update docs * move client/sr-* -> primitives/ * clean old readme * remove old broken code in rhd * update lock * Step 1. * starting to untangle client * Fix after merge. * start splitting out client interfaces * move children and blockchain interfaces * Move trie and state-machine to primitives. * Fix WASM builds. * fixing broken imports * more interface moves * move backend and light to interfaces * move CallExecutor * move cli off client * moving around more interfaces * re-add consensus crates into the mix * fix subkey path * relieve client from executor * starting to pull out client from grandpa * move is_decendent_of out of client * grandpa still depends on client directly * lemme tests pass * rename srml->paint * Make it compile. * rename interfaces->client-api * Move keyring to primitives. * fixup libp2p dep * fix broken use * allow dependency enforcement to fail * move fork-tree * Moving wasm-builder * make env * move build-script-utils * fixup broken crate depdencies and names * fix imports for authority discovery * fix typo * update cargo.lock * fixing imports * Fix paths and add missing crates * re-add missing crates
2026-04-26 21:37:56 +00:00 · 2019-11-14 21:51:17 +01:00
parent becc3b0a4f
commit 60e5011c72
809 changed files with 7801 additions and 6464 deletions
@@ -0,0 +1,200 @@
+// Copyright 2017-2019 Parity Technologies (UK) Ltd.
+// This file is part of Substrate.
+
+// Substrate is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Substrate is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Substrate.  If not, see <http://www.gnu.org/licenses/>.
+
+//! Test implementation for Externalities.
+
+use std::{collections::HashMap, any::{Any, TypeId}};
+use hash_db::Hasher;
+use crate::{
+	backend::{InMemory, Backend}, OverlayedChanges,
+	changes_trie::{
+		InMemoryStorage as ChangesTrieInMemoryStorage,
+		BlockNumber as ChangesTrieBlockNumber,
+	},
+	ext::Ext,
+};
+use primitives::{
+	storage::{
+		well_known_keys::{CHANGES_TRIE_CONFIG, CODE, HEAP_PAGES, is_child_storage_key}
+	},
+	hash::H256, Blake2Hasher,
+};
+use codec::Encode;
+use externalities::{Extensions, Extension};
+
+type StorageTuple = (HashMap<Vec<u8>, Vec<u8>>, HashMap<Vec<u8>, HashMap<Vec<u8>, Vec<u8>>>);
+
+/// Simple HashMap-based Externalities impl.
+pub struct TestExternalities<H: Hasher<Out=H256>=Blake2Hasher, N: ChangesTrieBlockNumber=u64> {
+	overlay: OverlayedChanges,
+	backend: InMemory<H>,
+	changes_trie_storage: ChangesTrieInMemoryStorage<H, N>,
+	extensions: Extensions,
+}
+
+impl<H: Hasher<Out=H256>, N: ChangesTrieBlockNumber> TestExternalities<H, N> {
+	/// Get externalities implementation.
+	pub fn ext(&mut self) -> Ext<H, N, InMemory<H>, ChangesTrieInMemoryStorage<H, N>> {
+		Ext::new(
+			&mut self.overlay,
+			&self.backend,
+			Some(&self.changes_trie_storage),
+			Some(&mut self.extensions),
+		)
+	}
+
+	/// Create a new instance of `TestExternalities` with storage.
+	pub fn new(storage: StorageTuple) -> Self {
+		Self::new_with_code(&[], storage)
+	}
+
+	/// Create a new instance of `TestExternalities` with code and storage.
+	pub fn new_with_code(code: &[u8], mut storage: StorageTuple) -> Self {
+		let mut overlay = OverlayedChanges::default();
+
+		assert!(storage.0.keys().all(|key| !is_child_storage_key(key)));
+		assert!(storage.1.keys().all(|key| is_child_storage_key(key)));
+
+		super::set_changes_trie_config(
+			&mut overlay,
+			storage.0.get(&CHANGES_TRIE_CONFIG.to_vec()).cloned(),
+			false,
+		).expect("changes trie configuration is correct in test env; qed");
+
+		storage.0.insert(HEAP_PAGES.to_vec(), 8u64.encode());
+		storage.0.insert(CODE.to_vec(), code.to_vec());
+
+		let backend: HashMap<_, _> = storage.1.into_iter()
+			.map(|(keyspace, map)| (Some(keyspace), map))
+			.chain(Some((None, storage.0)).into_iter())
+			.collect();
+
+		TestExternalities {
+			overlay,
+			changes_trie_storage: ChangesTrieInMemoryStorage::new(),
+			backend: backend.into(),
+			extensions: Default::default(),
+		}
+	}
+
+	/// Insert key/value into backend
+	pub fn insert(&mut self, k: Vec<u8>, v: Vec<u8>) {
+		self.backend = self.backend.update(vec![(None, k, Some(v))]);
+	}
+
+	/// Registers the given extension for this instance.
+	pub fn register_extension<E: Any + Extension>(&mut self, ext: E) {
+		self.extensions.register(ext);
+	}
+
+	/// Get mutable reference to changes trie storage.
+	pub fn changes_trie_storage(&mut self) -> &mut ChangesTrieInMemoryStorage<H, N> {
+		&mut self.changes_trie_storage
+	}
+
+	/// Return a new backend with all pending value.
+	pub fn commit_all(&self) -> InMemory<H> {
+		let top = self.overlay.committed.top.clone().into_iter()
+			.chain(self.overlay.prospective.top.clone().into_iter())
+			.map(|(k, v)| (None, k, v.value));
+
+		let children = self.overlay.committed.children.clone().into_iter()
+			.chain(self.overlay.prospective.children.clone().into_iter())
+			.flat_map(|(keyspace, map)| {
+				map.into_iter()
+					.map(|(k, v)| (Some(keyspace.clone()), k, v.value))
+					.collect::<Vec<_>>()
+			});
+
+		self.backend.update(top.chain(children).collect())
+	}
+
+	/// Execute the given closure while `self` is set as externalities.
+	///
+	/// Returns the result of the given closure.
+	pub fn execute_with<R>(&mut self, execute: impl FnOnce() -> R) -> R {
+		let mut ext = self.ext();
+		externalities::set_and_run_with_externalities(&mut ext, execute)
+	}
+}
+
+impl<H: Hasher<Out=H256>, N: ChangesTrieBlockNumber> std::fmt::Debug for TestExternalities<H, N> {
+	fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+		write!(f, "overlay: {:?}\nbackend: {:?}", self.overlay, self.backend.pairs())
+	}
+}
+
+impl<H: Hasher<Out=H256>, N: ChangesTrieBlockNumber> PartialEq for TestExternalities<H, N> {
+	/// This doesn't test if they are in the same state, only if they contains the
+	/// same data at this state
+	fn eq(&self, other: &TestExternalities<H, N>) -> bool {
+		self.commit_all().eq(&other.commit_all())
+	}
+}
+
+impl<H: Hasher<Out=H256>, N: ChangesTrieBlockNumber> Default for TestExternalities<H, N> {
+	fn default() -> Self { Self::new(Default::default()) }
+}
+
+impl<H: Hasher<Out=H256>, N: ChangesTrieBlockNumber> From<StorageTuple> for TestExternalities<H, N> {
+	fn from(storage: StorageTuple) -> Self {
+		Self::new(storage)
+	}
+}
+
+impl<H, N> externalities::ExtensionStore for TestExternalities<H, N> where
+	H: Hasher<Out=H256>,
+	N: ChangesTrieBlockNumber,
+{
+	fn extension_by_type_id(&mut self, type_id: TypeId) -> Option<&mut dyn Any> {
+		self.extensions.get_mut(type_id)
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use primitives::traits::Externalities;
+	use hex_literal::hex;
+
+	#[test]
+	fn commit_should_work() {
+		let mut ext = TestExternalities::<Blake2Hasher, u64>::default();
+		let mut ext = ext.ext();
+		ext.set_storage(b"doe".to_vec(), b"reindeer".to_vec());
+		ext.set_storage(b"dog".to_vec(), b"puppy".to_vec());
+		ext.set_storage(b"dogglesworth".to_vec(), b"cat".to_vec());
+		const ROOT: [u8; 32] = hex!("2a340d3dfd52f5992c6b117e9e45f479e6da5afffafeb26ab619cf137a95aeb8");
+		assert_eq!(ext.storage_root(), H256::from(ROOT));
+	}
+
+	#[test]
+	fn set_and_retrieve_code() {
+		let mut ext = TestExternalities::<Blake2Hasher, u64>::default();
+		let mut ext = ext.ext();
+
+		let code = vec![1, 2, 3];
+		ext.set_storage(CODE.to_vec(), code.clone());
+
+		assert_eq!(&ext.storage(CODE).unwrap(), &code);
+	}
+
+	#[test]
+	fn check_send() {
+		fn assert_send<T: Send>() {}
+		assert_send::<TestExternalities::<Blake2Hasher, u64>>();
+	}
+}