adding some test

Author: aramikm

common/primitives/src/offchain.rs

@@ -1,7 +1,6 @@
 use crate::msa::MessageSourceId;
 use numtoa::NumToA;
-use parity_scale_codec::{Decode, Encode};
-use sp_io::offchain_index;
+use parity_scale_codec::Decode;
 use sp_runtime::offchain::storage::{StorageRetrievalError, StorageValueRef};
 use sp_std::{fmt::Debug, vec, vec::Vec};
 
@@ -36,25 +35,6 @@ pub fn get_index_value<V: Decode + Debug>(key: &[u8]) -> Result<Option<V>, Stora
 	get_impl::<V>(key)
 }
 
-/// Wrapper for offchain_index remove operations
-pub fn remove_offchain_index_value(key: &[u8]) {
-	offchain_index::clear(key);
-}
-
-/// Wrapper for offchain_index set operations
-pub fn set_offchain_index_value(key: &[u8], value: &[u8]) {
-	offchain_index::set(key, value);
-}
-
-/// Sets a value by the key to offchain index
-pub fn set_index_value<V>(key: &[u8], value: V)
-where
-	V: Encode + Debug,
-{
-	let oci_mem = StorageValueRef::persistent(key);
-	oci_mem.set(&value);
-}
-
 /// Gets a value by the key from persistent storage
 fn get_impl<V: Decode + Debug>(key: &[u8]) -> Result<Option<V>, StorageRetrievalError> {
 	let oci_mem = StorageValueRef::persistent(key);
@@ -64,3 +44,89 @@ fn get_impl<V: Decode + Debug>(key: &[u8]) -> Result<Option<V>, StorageRetrieval
 		Err(_) => Err(StorageRetrievalError::Undecodable),
 	}
 }
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use sp_core::offchain::{testing, OffchainDbExt, OffchainWorkerExt};
+	use sp_io::TestExternalities;
+
+	#[test]
+	fn get_msa_account_lock_name_should_return_expected_value() {
+		let msa_id: MessageSourceId = 2_000_000;
+		let result = get_msa_account_lock_name(msa_id);
+		assert_eq!(result, b"Msa::ofw::lock::2000000".to_vec());
+	}
+
+	#[test]
+	fn get_msa_account_storage_name_should_return_expected_value() {
+		let msa_id: MessageSourceId = 2_000_000;
+		let result = get_msa_account_storage_key_name(msa_id);
+		assert_eq!(result, b"Msa::ofw::keys::2000000".to_vec());
+	}
+
+	#[test]
+	fn get_index_for_not_set_should_return_none() {
+		let (offchain, _state) = testing::TestOffchainExt::new();
+		let mut t = TestExternalities::default();
+		t.register_extension(OffchainDbExt::new(offchain.clone()));
+		t.register_extension(OffchainWorkerExt::new(offchain));
+
+		t.execute_with(|| {
+			let key = b"my_key";
+			let result = get_index_value::<MessageSourceId>(key);
+			assert_eq!(result, Ok(None));
+		});
+	}
+
+	#[test]
+	fn get_index_for_set_should_return_expected() {
+		// arrange
+		let (offchain, _state) = testing::TestOffchainExt::new();
+		let mut t = TestExternalities::default();
+		t.register_extension(OffchainDbExt::new(offchain.clone()));
+		t.register_extension(OffchainWorkerExt::new(offchain));
+
+		t.execute_with(|| {
+			let key = b"my_key1";
+			let msa_id: MessageSourceId = 1000000;
+			let oci_mem = StorageValueRef::persistent(key);
+			oci_mem.set(&msa_id);
+
+			// act
+			let result = get_index_value::<MessageSourceId>(key);
+
+			// assert
+			assert_eq!(result, Ok(Some(msa_id)));
+		});
+	}
+
+	#[test]
+	fn get_index_for_not_decodable_should_return_error() {
+		let (offchain, _state) = testing::TestOffchainExt::new();
+		let mut t = TestExternalities::default();
+		t.register_extension(OffchainDbExt::new(offchain.clone()));
+		t.register_extension(OffchainWorkerExt::new(offchain));
+
+		#[derive(Debug, Decode, PartialEq)]
+		struct Testing {
+			pub a: u64,
+			pub b: u32,
+			pub c: u16,
+		}
+
+		t.execute_with(|| {
+			// arrange
+			let key = b"my_key2";
+			let msa_id: MessageSourceId = 1000000;
+			let oci_mem = StorageValueRef::persistent(key);
+			oci_mem.set(&msa_id);
+
+			// act
+			let result = get_index_value::<Testing>(key);
+
+			// assert
+			assert_eq!(result, Err(StorageRetrievalError::Undecodable));
+		});
+	}
+}

node/service/src/block_sealing.rs

@@ -181,7 +181,10 @@ pub fn frequency_dev_sealing(
 	let rpc_extensions_builder = {
 		let client = client.clone();
 		let transaction_pool = transaction_pool.clone();
-		let backend = backend.offchain_storage();
+		let backend = match config.offchain_worker.enabled {
+			true => backend.offchain_storage(),
+			false => None,
+		};
 
 		move |deny_unsafe, _| {
 			let deps = crate::rpc::FullDeps {

node/service/src/service.rs

@@ -295,7 +295,10 @@ async fn start_node_impl(
 	let rpc_builder = {
 		let client = client.clone();
 		let transaction_pool = transaction_pool.clone();
-		let backend = backend.offchain_storage();
+		let backend = match parachain_config.offchain_worker.enabled {
+			true => backend.offchain_storage(),
+			false => None,
+		};
 
 		Box::new(move |deny_unsafe, _| {
 			let deps = crate::rpc::FullDeps {

pallets/msa/src/lib.rs

@@ -263,8 +263,8 @@ pub mod pallet {
 	/// At the start of the next block this storage is set to 0
 	#[pallet::storage]
 	#[pallet::whitelist_storage]
-	#[pallet::getter(fn get_msa_event_count)]
-	pub(super) type MSAEventCount<T: Config> = StorageValue<_, u16, ValueQuery>;
+	#[pallet::getter(fn get_offchain_index_event_count)]
+	pub(super) type OffchainIndexEventCount<T: Config> = StorageValue<_, u16, ValueQuery>;
 
 	#[pallet::event]
 	#[pallet::generate_deposit(pub (super) fn deposit_event)]
@@ -427,7 +427,7 @@ pub mod pallet {
 	#[pallet::hooks]
 	impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {
 		fn on_initialize(_block_number: BlockNumberFor<T>) -> Weight {
-			<MSAEventCount<T>>::set(0u16);
+			<OffchainIndexEventCount<T>>::set(0u16);
 			// allocates 1 read and 1 write for any access of `MSAEventCount` in every block
 			T::DbWeight::get().reads_writes(1u64, 1u64)
 		}

pallets/msa/src/offchain_storage.rs

@@ -1,4 +1,4 @@
-use crate::{pallet::MSAEventCount, Config, Event, Pallet, PublicKeyToMsaId};
+use crate::{pallet::OffchainIndexEventCount, Config, Event, Pallet, PublicKeyToMsaId};
 pub use common_primitives::msa::MessageSourceId;
 /// Offchain Storage for MSA
 use common_primitives::offchain::{
@@ -8,9 +8,10 @@ use common_primitives::offchain::{
 use frame_support::RuntimeDebugNoBound;
 use frame_system::pallet_prelude::BlockNumberFor;
 use parity_scale_codec::{Decode, Encode};
-use sp_core::serde::Deserialize;
+use sp_core::serde::{Deserialize, Serialize};
 extern crate alloc;
 use alloc::string::String;
+use sp_io::offchain_index;
 use sp_runtime::{
 	offchain::{
 		storage::StorageValueRef,
@@ -59,19 +60,21 @@ const NUMBER_OF_PREVIOUS_BLOCKS_TO_CHECK: u32 = 5u32;
 const NUMBER_OF_BLOCKS_TO_EXPLORE: u32 = 1000;
 
 /// HTTP request deadline in milliseconds
-const HTTP_REQUEST_DEADLINE_MILLISECONDS: u64 = 2000;
+pub const HTTP_REQUEST_DEADLINE_MILLISECONDS: u64 = 2000;
 
 /// LOCAL RPC URL and port
 /// warning: this should be updated if rpc port is set to anything different from 9944
-const RPC_REQUEST_URL: &'static str = "http://localhost:9944";
+pub const RPC_FINALIZED_BLOCK_REQUEST_URL: &'static str = "http://localhost:9944";
+/// request body for getting last finalized block from rpc
+pub const RPC_FINALIZED_BLOCK_REQUEST_BODY: &[u8; 78] = b"{\"id\": 10, \"jsonrpc\": \"2.0\", \"method\": \"chain_getFinalizedHead\", \"params\": []}";
 
 /// stores the event into offchain DB using offchain indexing
 pub fn offchain_index_event<T: Config>(event: &Event<T>, msa_id: MessageSourceId) {
 	if let Some(event) = IndexedEvent::map(event, msa_id) {
 		let block_number: u32 =
 			<frame_system::Pallet<T>>::block_number().try_into().unwrap_or_default();
-		let current_event_count: u16 = <MSAEventCount<T>>::get().saturating_add(1);
-		<MSAEventCount<T>>::put(current_event_count);
+		let current_event_count: u16 = <OffchainIndexEventCount<T>>::get().saturating_add(1);
+		<OffchainIndexEventCount<T>>::put(current_event_count);
 		let event_key = [
 			BLOCK_EVENT_KEY,
 			block_number.encode().as_slice(),
@@ -173,7 +176,7 @@ fn set_offchain_index<V>(key: &[u8], value: V)
 where
 	V: Encode + Clone + Decode + Eq + Debug,
 {
-	offchain_common::set_offchain_index_value(key, value.encode().as_slice());
+	offchain_index::set(key, value.encode().as_slice());
 }
 
 /// Get offchain index value, used to store MSA Events to be process by offchain worker
@@ -302,9 +305,9 @@ fn clean_offchain_events<T: Config>(block_number: BlockNumberFor<T>) {
 		let key =
 			[BLOCK_EVENT_KEY, block_number.encode().as_slice(), i.encode().as_slice()].concat();
 
-		offchain_common::remove_offchain_index_value(key.encode().as_slice());
+		offchain_index::clear(key.encode().as_slice());
 	}
-	offchain_common::remove_offchain_index_value(count_key.encode().as_slice());
+	offchain_index::clear(count_key.encode().as_slice());
 }
 
 /// offchain worker callback for indexing msa keys
@@ -385,9 +388,9 @@ fn process_offchain_events<T: Config>(msa_id: MessageSourceId, events: Vec<Index
 	msa_storage.set(&msa_keys);
 }
 
-#[derive(Deserialize, Encode, Decode, Default, Debug)]
-struct FinalizedResult {
-	result: String,
+#[derive(Serialize, Deserialize, Encode, Decode, Default, Debug)]
+pub struct FinalizedBlockResponse {
+	pub result: String,
 }
 
 /// get finalized
@@ -398,8 +401,8 @@ pub fn fetch_finalized<T: Config>() -> Result<T::Hash, sp_runtime::offchain::htt
 	// coming from the host machine.
 	let deadline =
 		sp_io::offchain::timestamp().add(Duration::from_millis(HTTP_REQUEST_DEADLINE_MILLISECONDS));
-	let body = vec![b"{\"id\": 10, \"jsonrpc\": \"2.0\", \"method\": \"chain_getFinalizedHead\", \"params\": []}"];
-	let request = sp_runtime::offchain::http::Request::post(RPC_REQUEST_URL, body);
+	let body = vec![RPC_FINALIZED_BLOCK_REQUEST_BODY];
+	let request = sp_runtime::offchain::http::Request::post(RPC_FINALIZED_BLOCK_REQUEST_URL, body);
 	let pending = request
 		.add_header("Content-Type", "application/json")
 		.deadline(deadline)
@@ -427,7 +430,7 @@ pub fn fetch_finalized<T: Config>() -> Result<T::Hash, sp_runtime::offchain::htt
 	})?;
 
 	log::debug!("{}", body_str);
-	let gh_info: FinalizedResult =
+	let gh_info: FinalizedBlockResponse =
 		serde_json::from_str(body_str).map_err(|_| sp_runtime::offchain::http::Error::Unknown)?;
 
 	let decoded_from_hex = hex::decode(&gh_info.result[2..])

pallets/msa/src/rpc/src/lib.rs

@@ -88,6 +88,8 @@ pub enum MsaOffchainRpcError {
 	ErrorAcquiringLLock,
 	/// Error decoding data
 	ErrorDecodingData,
+	/// Offchain indexing is not enabled
+	OffchainIndexingNotEnabled,
 }
 
 impl From<MsaOffchainRpcError> for JsonRpseeError {
@@ -161,7 +163,7 @@ where
 		let reader = self.offchain.try_read().ok_or(MsaOffchainRpcError::ErrorAcquiringLLock)?;
 		let raw: Option<Bytes> = reader
 			.as_ref()
-			.ok_or(MsaOffchainRpcError::ErrorAcquiringLLock)?
+			.ok_or(MsaOffchainRpcError::OffchainIndexingNotEnabled)?
 			.get(sp_offchain::STORAGE_PREFIX, &msa_key)
 			.map(Into::into);
 		if let Some(rr) = raw {
@@ -173,8 +175,8 @@ where
 				.map(|account_id| KeyInfoResponse { msa_id, key: account_id })
 				.collect();
 
-			return RpcResult::Ok(Some(res))
+			return Ok(Some(res))
 		}
-		RpcResult::Ok(None)
+		Ok(None)
 	}
 }

pallets/msa/src/rpc/src/tests/mod.rs

@@ -5,7 +5,9 @@ use rpc_mock::*;
 
 use common_primitives::node::BlockNumber;
 use pallet_msa_runtime_api::MsaRuntimeApi;
+use parity_scale_codec::Encode;
 use sp_api::offchain::testing::TestPersistentOffchainDB;
+use sp_core::{offchain::OffchainStorage, sr25519::Public};
 use sp_runtime::traits::Zero;
 use std::{sync::Arc, vec};
 use substrate_test_runtime_client::runtime::{AccountId, Block};
@@ -184,3 +186,50 @@ async fn get_granted_schemas_by_msa_id_with_bad_provider_id() {
 	let response = result.unwrap();
 	assert!(response.is_none());
 }
+
+#[tokio::test]
+async fn get_keys_by_msa_id_with_disabled_offchain_should_fail() {
+	let client = Arc::new(TestApi {});
+	let api = MsaHandler::<TestApi, Block, TestPersistentOffchainDB>::new(client, None);
+
+	let result = api.get_keys_by_msa_id(NOT_EXIST_MSA);
+
+	assert_eq!(true, result.is_err());
+	assert_eq!("Custom error: OffchainIndexingNotEnabled", result.unwrap_err().to_string());
+}
+
+#[tokio::test]
+async fn get_keys_by_msa_id_with_empty_value_should_work() {
+	let client = Arc::new(TestApi {});
+	let api = MsaHandler::<TestApi, Block, TestPersistentOffchainDB>::new(
+		client,
+		Some(TestPersistentOffchainDB::new()),
+	);
+
+	let result = api.get_keys_by_msa_id(NOT_EXIST_MSA);
+
+	assert_eq!(true, result.is_ok());
+	let response = result.unwrap();
+	assert_eq!(None, response);
+}
+
+#[tokio::test]
+async fn get_keys_by_msa_id_with_value_should_work() {
+	let msa_id: MessageSourceId = 10;
+	let accounts = vec![Public([1u8; 32])];
+	let client = Arc::new(TestApi {});
+	let mut db = TestPersistentOffchainDB::new();
+	db.set(
+		sp_offchain::STORAGE_PREFIX,
+		&get_msa_account_storage_key_name(msa_id),
+		&accounts.encode(),
+	);
+	let api = MsaHandler::<TestApi, Block, TestPersistentOffchainDB>::new(client, Some(db));
+
+	let result = api.get_keys_by_msa_id(msa_id);
+
+	assert_eq!(true, result.is_ok());
+	let response = result.unwrap();
+	assert_eq!(true, response.is_some());
+	assert_eq!(vec![KeyInfoResponse { msa_id, key: accounts[0] }], response.unwrap());
+}

pallets/msa/src/tests/mock.rs

@@ -12,6 +12,8 @@ use frame_system::EnsureRoot;
 use pallet_collective;
 use parity_scale_codec::MaxEncodedLen;
 use sp_core::{sr25519, sr25519::Public, Encode, Pair, H256};
+use sp_core::offchain::{OffchainDbExt, OffchainWorkerExt, testing};
+use sp_io::TestExternalities;
 use sp_runtime::{
 	traits::{BlakeTwo256, ConvertInto, IdentityLookup},
 	AccountId32, BuildStorage, DispatchError, MultiSignature,
@@ -213,6 +215,18 @@ pub fn new_test_ext() -> sp_io::TestExternalities {
 	ext
 }
 
+pub fn new_test_with_offchain_ext() -> sp_io::TestExternalities {
+	set_max_signature_stored(8000);
+	set_max_public_keys_per_msa(255);
+	let t = frame_system::GenesisConfig::<Test>::default().build_storage().unwrap();
+	let mut ext = sp_io::TestExternalities::new(t);
+	let (offchain, _state) = testing::TestOffchainExt::new();
+	ext.register_extension(OffchainDbExt::new(offchain.clone()));
+	ext.register_extension(OffchainWorkerExt::new(offchain));
+	ext.execute_with(|| System::set_block_number(1));
+	ext
+}
+
 pub fn run_to_block(n: u32) {
 	while System::block_number() < n {
 		if System::block_number() > 1 {

pallets/msa/src/tests/mod.rs

@@ -10,3 +10,4 @@ mod retirement_tests;
 mod schema_permission_tests;
 mod signature_registry_tests;
 mod signed_extension_tests;
+mod offchain_tests;