Move test crates into a "testing" folder and add a ui (trybuild) test and ui-test helpers (#567)

* move test crates into a testing folder and add a ui test and helpers * undo wee mixup with another PR * cargo fmt * clippy * tidy ui-tests a little * test different DispatchError types * refactor dispatch error stuff * name ui tests * duff => useless * align versions and cargo fmt
2026-04-24 07:48:00 +00:00 · 2022-06-17 14:33:58 +01:00
parent 7621d71892
commit 9cf63bafac
31 changed files with 1005 additions and 4 deletions
@@ -0,0 +1,139 @@
+// Copyright 2019-2022 Parity Technologies (UK) Ltd.
+// This file is part of subxt.
+//
+// subxt 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.
+//
+// subxt 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 subxt.  If not, see <http://www.gnu.org/licenses/>.
+
+use crate::{
+    node_runtime::{
+        self,
+        DispatchError,
+    },
+    pair_signer,
+    test_context,
+};
+use sp_keyring::AccountKeyring;
+
+#[tokio::test]
+async fn storage_plain_lookup() -> Result<(), subxt::Error<DispatchError>> {
+    let ctx = test_context().await;
+
+    // Look up a plain value. Wait long enough that we don't get the genesis block data,
+    // because it may have no storage associated with it.
+    tokio::time::sleep(std::time::Duration::from_secs(6)).await;
+    let entry = ctx.api.storage().timestamp().now(None).await?;
+    assert!(entry > 0);
+
+    Ok(())
+}
+
+#[tokio::test]
+async fn storage_map_lookup() -> Result<(), subxt::Error<DispatchError>> {
+    let ctx = test_context().await;
+
+    let signer = pair_signer(AccountKeyring::Alice.pair());
+    let alice = AccountKeyring::Alice.to_account_id();
+
+    // Do some transaction to bump the Alice nonce to 1:
+    ctx.api
+        .tx()
+        .system()
+        .remark(vec![1, 2, 3, 4, 5])?
+        .sign_and_submit_then_watch_default(&signer)
+        .await?
+        .wait_for_finalized_success()
+        .await?;
+
+    // Look up the nonce for the user (we expect it to be 1).
+    let entry = ctx.api.storage().system().account(&alice, None).await?;
+    assert_eq!(entry.nonce, 1);
+
+    Ok(())
+}
+
+// This fails until the fix in https://github.com/paritytech/subxt/pull/458 is introduced.
+// Here we create a key that looks a bit like a StorageNMap key, but should in fact be
+// treated as a StorageKey (ie we should hash both values together with one hasher, rather
+// than hash both values separately, or ignore the second value).
+#[tokio::test]
+async fn storage_n_mapish_key_is_properly_created(
+) -> Result<(), subxt::Error<DispatchError>> {
+    use codec::Encode;
+    use node_runtime::{
+        runtime_types::sp_core::crypto::KeyTypeId,
+        session::storage::KeyOwner,
+    };
+    use subxt::{
+        storage::StorageKeyPrefix,
+        StorageEntry,
+    };
+
+    // This is what the generated code hashes a `session().key_owner(..)` key into:
+    let actual_key_bytes = KeyOwner(&KeyTypeId([1, 2, 3, 4]), &[5u8, 6, 7, 8])
+        .key()
+        .final_key(StorageKeyPrefix::new::<KeyOwner>())
+        .0;
+
+    // Let's manually hash to what we assume it should be and compare:
+    let expected_key_bytes = {
+        // Hash the prefix to the storage entry:
+        let mut bytes = sp_core::twox_128("Session".as_bytes()).to_vec();
+        bytes.extend(&sp_core::twox_128("KeyOwner".as_bytes())[..]);
+        // twox64_concat a *tuple* of the args expected:
+        let suffix = (KeyTypeId([1, 2, 3, 4]), vec![5u8, 6, 7, 8]).encode();
+        bytes.extend(&sp_core::twox_64(&suffix));
+        bytes.extend(&suffix);
+        bytes
+    };
+
+    assert_eq!(actual_key_bytes, expected_key_bytes);
+    Ok(())
+}
+
+#[tokio::test]
+async fn storage_n_map_storage_lookup() -> Result<(), subxt::Error<DispatchError>> {
+    let ctx = test_context().await;
+
+    // Boilerplate; we create a new asset class with ID 99, and then
+    // we "approveTransfer" of some of this asset class. This gives us an
+    // entry in the `Approvals` StorageNMap that we can try to look up.
+    let signer = pair_signer(AccountKeyring::Alice.pair());
+    let alice = AccountKeyring::Alice.to_account_id();
+    let bob = AccountKeyring::Bob.to_account_id();
+    ctx.api
+        .tx()
+        .assets()
+        .create(99, alice.clone().into(), 1)?
+        .sign_and_submit_then_watch_default(&signer)
+        .await?
+        .wait_for_finalized_success()
+        .await?;
+    ctx.api
+        .tx()
+        .assets()
+        .approve_transfer(99, bob.clone().into(), 123)?
+        .sign_and_submit_then_watch_default(&signer)
+        .await?
+        .wait_for_finalized_success()
+        .await?;
+
+    // The actual test; look up this approval in storage:
+    let entry = ctx
+        .api
+        .storage()
+        .assets()
+        .approvals(&99, &alice, &bob, None)
+        .await?;
+    assert_eq!(entry.map(|a| a.amount), Some(123));
+    Ok(())
+}