Struct sp_state_machine::TestExternalities
source · pub struct TestExternalities<H>where
H: Hasher + 'static,
H::Out: Codec + Ord,{
pub backend: InMemoryBackend<H>,
pub extensions: Extensions,
pub state_version: StateVersion,
/* private fields */
}
Expand description
Simple HashMap-based Externalities impl.
Fields§
§backend: InMemoryBackend<H>
Storage backend.
extensions: Extensions
Extensions.
state_version: StateVersion
State version to use during tests.
Implementations§
source§impl<H> TestExternalities<H>where
H: Hasher + 'static,
H::Out: Ord + 'static + Codec,
impl<H> TestExternalities<H>where
H: Hasher + 'static,
H::Out: Ord + 'static + Codec,
sourcepub fn ext(&mut self) -> Ext<'_, H, InMemoryBackend<H>>
pub fn ext(&mut self) -> Ext<'_, H, InMemoryBackend<H>>
Get externalities implementation.
Examples found in repository?
196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236
pub fn execute_with<R>(&mut self, execute: impl FnOnce() -> R) -> R {
let mut ext = self.ext();
sp_externalities::set_and_run_with_externalities(&mut ext, execute)
}
/// Execute the given closure while `self`, with `proving_backend` as backend, is set as
/// externalities.
///
/// This implementation will wipe the proof recorded in between calls. Consecutive calls will
/// get their own proof from scratch.
pub fn execute_and_prove<R>(&mut self, execute: impl FnOnce() -> R) -> (R, StorageProof) {
let proving_backend = TrieBackendBuilder::wrap(&self.backend)
.with_recorder(Default::default())
.build();
let mut proving_ext = Ext::new(
&mut self.overlay,
&mut self.storage_transaction_cache,
&proving_backend,
Some(&mut self.extensions),
);
let outcome = sp_externalities::set_and_run_with_externalities(&mut proving_ext, execute);
let proof = proving_backend.extract_proof().expect("Failed to extract storage proof");
(outcome, proof)
}
/// Execute the given closure while `self` is set as externalities.
///
/// Returns the result of the given closure, if no panics occurred.
/// Otherwise, returns `Err`.
pub fn execute_with_safe<R>(
&mut self,
f: impl FnOnce() -> R + UnwindSafe,
) -> Result<R, String> {
let mut ext = AssertUnwindSafe(self.ext());
std::panic::catch_unwind(move || {
sp_externalities::set_and_run_with_externalities(&mut *ext, f)
})
.map_err(|e| format!("Closure panicked: {:?}", e))
}
sourcepub fn new_with_state_version(
storage: Storage,
state_version: StateVersion
) -> Self
pub fn new_with_state_version(
storage: Storage,
state_version: StateVersion
) -> Self
Create a new instance of TestExternalities
with storage for a given state version.
Examples found in repository?
263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284
fn default() -> Self {
// default to default version.
Self::new_with_state_version(Storage::default(), Default::default())
}
}
impl<H: Hasher> From<Storage> for TestExternalities<H>
where
H::Out: Ord + 'static + codec::Codec,
{
fn from(storage: Storage) -> Self {
Self::new_with_state_version(storage, Default::default())
}
}
impl<H: Hasher> From<(Storage, StateVersion)> for TestExternalities<H>
where
H::Out: Ord + 'static + codec::Codec,
{
fn from((storage, state_version): (Storage, StateVersion)) -> Self {
Self::new_with_state_version(storage, state_version)
}
sourcepub fn new_with_code(code: &[u8], storage: Storage) -> Self
pub fn new_with_code(code: &[u8], storage: Storage) -> Self
Create a new instance of TestExternalities
with code and storage.
sourcepub fn new_with_code_and_state(
code: &[u8],
storage: Storage,
state_version: StateVersion
) -> Self
pub fn new_with_code_and_state(
code: &[u8],
storage: Storage,
state_version: StateVersion
) -> Self
Create a new instance of TestExternalities
with code and storage for a given state
version.
Examples found in repository?
78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95
pub fn new(storage: Storage) -> Self {
Self::new_with_code_and_state(&[], storage, Default::default())
}
/// Create a new instance of `TestExternalities` with storage for a given state version.
pub fn new_with_state_version(storage: Storage, state_version: StateVersion) -> Self {
Self::new_with_code_and_state(&[], storage, state_version)
}
/// New empty test externalities.
pub fn new_empty() -> Self {
Self::new_with_code_and_state(&[], Storage::default(), Default::default())
}
/// Create a new instance of `TestExternalities` with code and storage.
pub fn new_with_code(code: &[u8], storage: Storage) -> Self {
Self::new_with_code_and_state(code, storage, Default::default())
}
sourcepub fn overlayed_changes(&self) -> &OverlayedChanges
pub fn overlayed_changes(&self) -> &OverlayedChanges
Returns the overlayed changes.
sourcepub fn persist_offchain_overlay(&mut self)
pub fn persist_offchain_overlay(&mut self)
Move offchain changes from overlay to the persistent store.
sourcepub fn offchain_db(&self) -> TestPersistentOffchainDB
pub fn offchain_db(&self) -> TestPersistentOffchainDB
A shared reference type around the offchain worker storage.
sourcepub fn insert(&mut self, k: StorageKey, v: StorageValue)
pub fn insert(&mut self, k: StorageKey, v: StorageValue)
Insert key/value into backend
sourcepub fn insert_child(&mut self, c: ChildInfo, k: StorageKey, v: StorageValue)
pub fn insert_child(&mut self, c: ChildInfo, k: StorageKey, v: StorageValue)
Insert key/value into backend.
This only supports inserting keys in child tries.
sourcepub fn register_extension<E: Any + Extension>(&mut self, ext: E)
pub fn register_extension<E: Any + Extension>(&mut self, ext: E)
Registers the given extension for this instance.
sourcepub fn as_backend(&self) -> InMemoryBackend<H>
pub fn as_backend(&self) -> InMemoryBackend<H>
Return a new backend with all pending changes.
In contrast to commit_all
this will not panic if there are open
transactions.
sourcepub fn commit_all(&mut self) -> Result<(), String>
pub fn commit_all(&mut self) -> Result<(), String>
Commit all pending changes to the underlying backend.
Panic
This will panic if there are still open transactions.
sourcepub fn execute_with<R>(&mut self, execute: impl FnOnce() -> R) -> R
pub fn execute_with<R>(&mut self, execute: impl FnOnce() -> R) -> R
Execute the given closure while self
is set as externalities.
Returns the result of the given closure.
sourcepub fn execute_and_prove<R>(
&mut self,
execute: impl FnOnce() -> R
) -> (R, StorageProof)
pub fn execute_and_prove<R>(
&mut self,
execute: impl FnOnce() -> R
) -> (R, StorageProof)
Execute the given closure while self
, with proving_backend
as backend, is set as
externalities.
This implementation will wipe the proof recorded in between calls. Consecutive calls will get their own proof from scratch.
sourcepub fn execute_with_safe<R>(
&mut self,
f: impl FnOnce() -> R + UnwindSafe
) -> Result<R, String>
pub fn execute_with_safe<R>(
&mut self,
f: impl FnOnce() -> R + UnwindSafe
) -> Result<R, String>
Execute the given closure while self
is set as externalities.
Returns the result of the given closure, if no panics occurred.
Otherwise, returns Err
.
Trait Implementations§
source§impl<H> ExtensionStore for TestExternalities<H>where
H: Hasher,
H::Out: Ord + Codec,
impl<H> ExtensionStore for TestExternalities<H>where
H: Hasher,
H::Out: Ord + Codec,
source§fn extension_by_type_id(&mut self, type_id: TypeId) -> Option<&mut dyn Any>
fn extension_by_type_id(&mut self, type_id: TypeId) -> Option<&mut dyn Any>
type_id
and returns it as a &mut dyn Any
. Read moresource§impl<H> ExternalitiesExt for TestExternalities<H>where
H: Hasher,
H::Out: Ord + Codec,
impl<H> ExternalitiesExt for TestExternalities<H>where
H: Hasher,
H::Out: Ord + Codec,
source§impl<H: Hasher> From<(Storage, StateVersion)> for TestExternalities<H>where
H::Out: Ord + 'static + Codec,
impl<H: Hasher> From<(Storage, StateVersion)> for TestExternalities<H>where
H::Out: Ord + 'static + Codec,
source§impl<H: Hasher> PartialEq<TestExternalities<H>> for TestExternalities<H>where
H::Out: Ord + 'static + Codec,
impl<H: Hasher> PartialEq<TestExternalities<H>> for TestExternalities<H>where
H::Out: Ord + 'static + Codec,
source§fn eq(&self, other: &TestExternalities<H>) -> bool
fn eq(&self, other: &TestExternalities<H>) -> bool
This doesn’t test if they are in the same state, only if they contains the same data at this state
Auto Trait Implementations§
impl<H> !RefUnwindSafe for TestExternalities<H>
impl<H> Send for TestExternalities<H>
impl<H> !Sync for TestExternalities<H>
impl<H> Unpin for TestExternalities<H>where
H: Unpin,
<H as Hasher>::Out: Unpin,
impl<H> !UnwindSafe for TestExternalities<H>
Blanket Implementations§
§impl<T> Downcast for Twhere
T: Any,
impl<T> Downcast for Twhere
T: Any,
§fn into_any(self: Box<T, Global>) -> Box<dyn Any + 'static, Global>
fn into_any(self: Box<T, Global>) -> Box<dyn Any + 'static, Global>
Box<dyn Trait>
(where Trait: Downcast
) to Box<dyn Any>
. Box<dyn Any>
can
then be further downcast
into Box<ConcreteType>
where ConcreteType
implements Trait
.§fn into_any_rc(self: Rc<T>) -> Rc<dyn Any + 'static>
fn into_any_rc(self: Rc<T>) -> Rc<dyn Any + 'static>
Rc<Trait>
(where Trait: Downcast
) to Rc<Any>
. Rc<Any>
can then be
further downcast
into Rc<ConcreteType>
where ConcreteType
implements Trait
.§fn as_any(&self) -> &(dyn Any + 'static)
fn as_any(&self) -> &(dyn Any + 'static)
&Trait
(where Trait: Downcast
) to &Any
. This is needed since Rust cannot
generate &Any
’s vtable from &Trait
’s.§fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)
fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)
&mut Trait
(where Trait: Downcast
) to &Any
. This is needed since Rust cannot
generate &mut Any
’s vtable from &mut Trait
’s.source§impl<T> Instrument for T
impl<T> Instrument for T
source§fn instrument(self, span: Span) -> Instrumented<Self>
fn instrument(self, span: Span) -> Instrumented<Self>
source§fn in_current_span(self) -> Instrumented<Self>
fn in_current_span(self) -> Instrumented<Self>
source§impl<T, Outer> IsWrappedBy<Outer> for Twhere
Outer: AsRef<T> + AsMut<T> + From<T>,
T: From<Outer>,
impl<T, Outer> IsWrappedBy<Outer> for Twhere
Outer: AsRef<T> + AsMut<T> + From<T>,
T: From<Outer>,
source§impl<S, T> UncheckedInto<T> for Swhere
T: UncheckedFrom<S>,
impl<S, T> UncheckedInto<T> for Swhere
T: UncheckedFrom<S>,
source§fn unchecked_into(self) -> T
fn unchecked_into(self) -> T
unchecked_from
.