change(pass-webauthn): tests

pass-webauthn/Cargo.toml

@@ -9,26 +9,25 @@ version = "0.1.0"
 [dependencies]
 codec.workspace = true
 frame-support.workspace = true
-frame-system.workspace = true
+frame-support.optional = true
 scale-info.workspace = true
 traits-authn.workspace = true
 verifier.workspace = true
 
 [dev-dependencies]
+frame-system.workspace = true
 pallet-balances.workspace = true
 pallet-pass.workspace = true
 sp-io.workspace = true
-sp-runtime.workspace = true
 
 [features]
 default = ["std", "runtime"]
-runtime = []
+runtime = ["frame-support"]
 runtime-benchmarks = [
   "frame-support/runtime-benchmarks",
   "frame-system/runtime-benchmarks",
   "pallet-balances/runtime-benchmarks",
   "pallet-pass/runtime-benchmarks",
-  "sp-runtime/runtime-benchmarks",
 ]
 std = [
   "codec/std",
@@ -38,7 +37,6 @@ std = [
   "pallet-pass/std",
   "scale-info/std",
   "sp-io/std",
-  "sp-runtime/std",
   "traits-authn/std",
   "verifier/std",
 ]
@@ -47,5 +45,4 @@ try-runtime = [
   "frame-system/try-runtime",
   "pallet-balances/try-runtime",
   "pallet-pass/try-runtime",
-  "sp-runtime/try-runtime",
 ]

pass-webauthn/src/impls.rs

@@ -2,11 +2,12 @@ use core::marker::PhantomData;
 
 use frame_support::Parameter;
 use traits_authn::{
-    AuthorityId, Challenge, DeviceChallengeResponse, DeviceId, HashedUserId, UserChallengeResponse,
+    AuthorityId, Challenge, Challenger, DeviceChallengeResponse, DeviceId, HashedUserId,
+    UserChallengeResponse,
 };
 use verifier::webauthn_verify;
 
-use crate::{Attestation, Credential};
+use crate::{Attestation, Credential, CxOf, Device, DeviceInfo};
 
 impl<Cx> Attestation<Cx>
 where
@@ -64,6 +65,24 @@ where
     }
 }
 
+#[cfg(any(feature = "runtime", test))]
+impl<Ch, A> From<Attestation<CxOf<Ch>>> for Device<Ch, A>
+where
+    Ch: Challenger,
+    CxOf<Ch>: Parameter + Copy + 'static,
+{
+    fn from(value: Attestation<CxOf<Ch>>) -> Self {
+        Device::new(DeviceInfo(value.device_id().clone()))
+    }
+}
+
+#[cfg(any(feature = "runtime", test))]
+impl AsRef<DeviceId> for DeviceInfo {
+    fn as_ref(&self) -> &DeviceId {
+        &self.0
+    }
+}
+
 impl<Cx> Credential<Cx>
 where
     Cx: Parameter,

pass-webauthn/src/lib.rs

@@ -2,12 +2,11 @@
 
 use core::marker::PhantomData;
 
-use codec::{Decode, Encode};
-use frame_support::Parameter;
+use codec::{Decode, Encode, MaxEncodedLen};
 use scale_info::TypeInfo;
 use traits_authn::{
     util::{Auth, Dev},
-    Challenger,
+    Challenger, DeviceId,
 };
 
 type CxOf<Ch> = <Ch as Challenger>::Context;
@@ -20,7 +19,11 @@ mod impls;
 #[cfg(any(feature = "runtime", test))]
 pub type Authenticator<Ch, A> = Auth<Device<Ch, A>, Attestation<CxOf<Ch>>>;
 #[cfg(any(feature = "runtime", test))]
-pub type Device<Ch, A> = Dev<Vec<u8>, A, Ch, Credential<CxOf<Ch>>>;
+pub type Device<Ch, A> = Dev<DeviceInfo, A, Ch, Credential<CxOf<Ch>>>;
+
+#[cfg(any(feature = "runtime", test))]
+#[derive(MaxEncodedLen, TypeInfo, Decode, Encode)]
+pub struct DeviceInfo(DeviceId);
 
 #[derive(Encode, Decode, TypeInfo, Debug, PartialEq, Eq, Clone)]
 pub struct Attestation<Cx> {
@@ -31,17 +34,6 @@ pub struct Attestation<Cx> {
     pub(crate) signature: Vec<u8>,
 }
 
-#[cfg(any(feature = "runtime", test))]
-impl<Ch, A> From<Attestation<CxOf<Ch>>> for Device<Ch, A>
-where
-    Ch: Challenger,
-    CxOf<Ch>: Parameter,
-{
-    fn from(value: Attestation<CxOf<Ch>>) -> Self {
-        Device::new(value.public_key)
-    }
-}
-
 #[derive(Encode, Decode, TypeInfo, Debug, PartialEq, Eq, Clone)]
 pub struct Credential<Cx> {
     __phantom: PhantomData<Cx>,

pass-webauthn/src/tests.rs

@@ -0,0 +1,114 @@
+//! Test environment for pass webauthn.
+
+use frame_support::{
+    assert_noop, assert_ok, derive_impl, parameter_types,
+    sp_runtime::{str_array as s, traits::Hash},
+    traits::ConstU64,
+    PalletId,
+};
+use frame_system::{pallet_prelude::BlockNumberFor, Config, EnsureRootWithSuccess};
+use traits_authn::{util::AuthorityFromPalletId, Challenger, HashedUserId};
+
+use crate::{Attestation, Authenticator};
+
+#[frame_support::runtime]
+pub mod runtime {
+    #[runtime::runtime]
+    #[runtime::derive(
+        RuntimeCall,
+        RuntimeEvent,
+        RuntimeError,
+        RuntimeOrigin,
+        RuntimeTask,
+        RuntimeHoldReason,
+        RuntimeFreezeReason
+    )]
+    pub struct Test;
+
+    #[runtime::pallet_index(0)]
+    pub type System = frame_system;
+    #[runtime::pallet_index(1)]
+    pub type Pass = pallet_pass;
+
+    #[runtime::pallet_index(10)]
+    pub type Balances = pallet_balances;
+}
+
+pub type Block = frame_system::mocking::MockBlock<Test>;
+pub type AccountId = <Test as frame_system::Config>::AccountId;
+
+#[derive_impl(frame_system::config_preludes::TestDefaultConfig as frame_system::DefaultConfig)]
+impl frame_system::Config for Test {
+    type BaseCallFilter = frame_support::traits::Everything;
+    type Block = Block;
+    type AccountData = pallet_balances::AccountData<AccountId>;
+}
+
+#[derive_impl(pallet_balances::config_preludes::TestDefaultConfig as pallet_balances::DefaultConfig)]
+impl pallet_balances::Config for Test {
+    type AccountStore = System;
+}
+
+parameter_types! {
+  pub PassPalletId: PalletId = PalletId(*b"pass/web");
+  pub NeverPays: Option<pallet_pass::DepositInformation<Test>> = None;
+}
+
+pub struct BlockChallenger;
+
+impl Challenger for BlockChallenger {
+    type Context = BlockNumberFor<Test>;
+
+    fn generate(_: &Self::Context) -> traits_authn::Challenge {
+        <Test as Config>::Hashing::hash(&System::block_number().to_le_bytes()).0
+    }
+}
+
+impl pallet_pass::Config for Test {
+    type RuntimeEvent = RuntimeEvent;
+    type RuntimeCall = RuntimeCall;
+    type Currency = Balances;
+    type Authenticator = Authenticator<BlockChallenger, AuthorityFromPalletId<PassPalletId>>;
+    type PalletsOrigin = OriginCaller;
+    type PalletId = PassPalletId;
+    type MaxSessionDuration = ConstU64<10>;
+    type RegisterOrigin = EnsureRootWithSuccess<Self::AccountId, NeverPays>;
+    type WeightInfo = ();
+}
+
+fn new_test_ext() -> sp_io::TestExternalities {
+    let mut t = sp_io::TestExternalities::default();
+    t.execute_with(|| {
+        System::set_block_number(1);
+    });
+    t
+}
+
+const USER: HashedUserId = s("the_user");
+
+#[test]
+fn registration_fails_if_attestation_is_invalid() {
+    new_test_ext().execute_with(|| {
+        // TODO: Fill with garbage data or incorrect signature (whatever works best)
+        assert_noop!(
+            Pass::register(
+                RuntimeOrigin::root(),
+                USER,
+                Attestation::new(b"".to_vec(), b"".to_vec(), b"".to_vec(), b"".to_vec())
+            ),
+            pallet_pass::Error::<Test>::DeviceAttestationInvalid,
+        );
+    })
+}
+
+#[test]
+fn registration_works_if_attestation_is_valid() {
+    new_test_ext().execute_with(|| {
+        // TODO: Fill with valid data and signature
+        assert_ok!(Pass::register(
+            RuntimeOrigin::root(),
+            USER,
+            Attestation::new(b"".to_vec(), b"".to_vec(), b"".to_vec(), b"".to_vec())
+        ));
+    })
+}