Pallet-name-service tests

frame/name-service/src/tests.rs

@@ -24,9 +24,9 @@ use super::mock::*;
 use sp_core::blake2_256;
 use frame_support::{
 	assert_ok, assert_noop,
-	traits::{OnInitialize, OnFinalize}
+	traits::{OnInitialize, OnFinalize},
+	error::BadOrigin
 };
-use pallet_balances::Error as BalancesError;
 
 fn run_to_block(n: u64) {
 	while System::block_number() < n {
@@ -92,3 +92,262 @@ fn end_to_end_should_work() {
 		assert_ok!(NameService::bid(Origin::signed(1), name_hash, 5));
 	});
 }
+
+#[test]
+fn set_name_works(){
+	new_test_ext().execute_with(|| {
+		// Test data
+		let name = b"shawntabrizi";
+		let name_hash = blake2_256(name);
+
+		// name setting by manager works correctly
+		let status = NameStatus::Owned{ who: 1, expiration: None };
+		assert_ok!(NameService::set_name(Origin::signed(100), name_hash.clone(), status.clone()));
+
+		let stored_data = Registration::<Test>::get(&name_hash);
+		assert_eq!(stored_data, status);
+
+		// non manager call should fail
+		assert_noop!(NameService::set_name(Origin::signed(1), name_hash, status), BadOrigin);
+	})
+}
+
+#[test]
+fn bid_works(){
+	new_test_ext().execute_with(|| {
+		// Test data
+		let name = b"shawntabrizi";
+		let name_hash = blake2_256(name);
+
+		// call with less than MinBid should fail
+		assert_noop!(
+			NameService::bid(Origin::signed(1), name_hash, <mock::Test as Trait>::MinBid::get().saturating_sub(1)),
+			Error::<Test>::InvalidBid
+		);
+
+		// create bid works correctly
+		assert_ok!(NameService::bid(Origin::signed(1), name_hash, 5));
+		let stored_data = Registration::<Test>::get(&name_hash);
+		assert_eq!(stored_data, NameStatus::Bidding {
+			who: 1,
+			bid_end: <mock::Test as Trait>::BiddingPeriod::get(),
+			amount: 5
+		});
+		assert_eq!(Balances::free_balance(&1), 95);
+
+		// another bid at same price should fail
+		assert_noop!(NameService::bid(Origin::signed(2), name_hash, 5), Error::<Test>::InvalidBid);
+
+		// previous bidder should be able to raise bid
+		run_to_block(2);
+		assert_ok!(NameService::bid(Origin::signed(1), name_hash, 10));
+		let stored_data = Registration::<Test>::get(&name_hash);
+		assert_eq!(stored_data, NameStatus::Bidding {
+			who: 1,
+			bid_end: <mock::Test as Trait>::BiddingPeriod::get().saturating_add(2),
+			amount: 10
+		});
+		assert_eq!(Balances::free_balance(&1), 90);
+
+		// another user can outbid current bidder
+		assert_ok!(NameService::bid(Origin::signed(2), name_hash, 20));
+		let stored_data = Registration::<Test>::get(&name_hash);
+		assert_eq!(stored_data, NameStatus::Bidding {
+			who: 2,
+			bid_end: <mock::Test as Trait>::BiddingPeriod::get().saturating_add(2),
+			amount: 20
+		});
+		assert_eq!(Balances::free_balance(&1), 100);
+		assert_eq!(Balances::free_balance(&2), 180);
+
+		// cannot bid on expired item
+		run_to_block(12);
+		assert_noop!(NameService::bid(Origin::signed(2), name_hash, 25), Error::<Test>::InvalidBid);
+	})
+}
+
+#[test]
+fn claim_works(){
+	new_test_ext().execute_with(|| {
+		// Test data
+		let name = b"shawntabrizi";
+		let name_hash = blake2_256(name);
+
+		// claim to non existent name should fail
+		assert_noop!(NameService::claim(Origin::signed(1), name_hash, 1), Error::<Test>::InvalidClaim);
+
+		// setup a bid to claim
+		assert_ok!(NameService::bid(Origin::signed(1), name_hash, 10));
+
+		// claim before bid expiry should fail
+		assert_noop!(NameService::claim(Origin::signed(1), name_hash, 1), Error::<Test>::NotExpired);
+
+		run_to_block(<mock::Test as Trait>::BiddingPeriod::get());
+
+		// cannot invoke with less than one period
+		assert_noop!(NameService::claim(Origin::signed(1), name_hash, 0), Error::<Test>::InvalidClaim);
+
+		// call by not current bidder should fail
+		assert_noop!(NameService::claim(Origin::signed(2), name_hash, 1), Error::<Test>::NotBidder);
+
+		// claim by successful bidder should pass
+		assert_ok!(NameService::claim(Origin::signed(1), name_hash, 2));
+		assert_eq!(Balances::free_balance(&1), 60);
+		// ensure reserves have been slashed
+		assert_eq!(Balances::total_balance(&1), 60);
+
+		let stored_data = Registration::<Test>::get(&name_hash);
+		assert_eq!(stored_data, NameStatus::Owned {
+			who: 1,
+			expiration: Some(<mock::Test as Trait>::OwnershipPeriod::get()
+				.saturating_mul(2)
+				.saturating_add(<mock::Test as Trait>::BiddingPeriod::get())),
+		});
+
+		// call to previously claimed name should fail
+		assert_noop!(NameService::claim(Origin::signed(1), name_hash, 1), Error::<Test>::InvalidClaim);
+	});
+}
+
+#[test]
+fn free_works(){
+	new_test_ext().execute_with(|| {
+		// Test data
+		let name = b"shawntabrizi";
+		let name_hash = blake2_256(name);
+
+		// free non existent name should fail
+		assert_noop!(NameService::free(Origin::signed(1), name_hash), Error::<Test>::AlreadyAvailable);
+
+		// setup a bid to free
+		assert_ok!(NameService::bid(Origin::signed(1), name_hash, 10));
+
+		// free a name in bidding period should fail
+		assert_noop!(NameService::free(Origin::signed(2), name_hash), Error::<Test>::NotExpired);
+
+		// free should wait for claim period
+		run_to_block(<mock::Test as Trait>::BiddingPeriod::get());
+		assert_noop!(NameService::free(Origin::signed(2), name_hash), Error::<Test>::NotExpired);
+
+		// call after (bid_end+bidding+claim+1) period should pass
+		let ideal_block = <mock::Test as Trait>::BiddingPeriod::get().saturating_add(<mock::Test as Trait>::ClaimPeriod::get());
+		run_to_block(ideal_block.saturating_add(11));
+		assert_ok!(NameService::free(Origin::signed(1), name_hash));
+
+		let stored_data = Registration::<Test>::get(&name_hash);
+		assert_eq!(stored_data, NameStatus::default());
+
+		// original bidder reserve balance is slashed
+		assert_eq!(Balances::free_balance(&1), 90);
+		assert_eq!(Balances::reserved_balance(&1), 0);
+
+		// setup a claimed name to free
+		assert_ok!(NameService::bid(Origin::signed(2), name_hash, 10));
+		run_to_block(100);
+		assert_ok!(NameService::claim(Origin::signed(2), name_hash, 1));
+
+		// only current owner should be able to free non expired name
+		assert_noop!(NameService::free(Origin::signed(1), name_hash), Error::<Test>::NotExpired);
+		assert_ok!(NameService::free(Origin::signed(2), name_hash));
+		let stored_data = Registration::<Test>::get(&name_hash);
+		assert_eq!(stored_data, NameStatus::default());
+	});
+
+}
+
+#[test]
+fn assign_works(){
+	new_test_ext().execute_with(|| {
+		// Test data
+		let name = b"shawntabrizi";
+		let name_hash = blake2_256(name);
+
+		// setup a claimed name to assign
+		assert_ok!(NameService::bid(Origin::signed(1), name_hash, 10));
+		run_to_block(<mock::Test as Trait>::BiddingPeriod::get());
+		assert_ok!(NameService::claim(Origin::signed(1), name_hash, 1));
+
+		// non owner calls should fail
+		assert_noop!(NameService::assign(Origin::signed(2), name_hash, Some(4)), Error::<Test>::NotOwner);
+
+		// owner can assign accountID
+		assert_ok!(NameService::assign(Origin::signed(1), name_hash, Some(4)));
+		assert_eq!(Lookup::<Test>::get(&name_hash), Some(4));
+
+		// owner can unassign accountId
+		assert_ok!(NameService::assign(Origin::signed(1), name_hash, None));
+		assert_eq!(Lookup::<Test>::get(&name_hash), None);
+	});
+}
+
+#[test]
+fn unassign_works(){
+	new_test_ext().execute_with(|| {
+		// Test data
+		let name_hash = blake2_256(b"shawntabrizi");
+
+		// setup an assigned name to test
+		assert_ok!(NameService::bid(Origin::signed(1), name_hash, 10));
+		run_to_block(<mock::Test as Trait>::BiddingPeriod::get());
+		assert_ok!(NameService::claim(Origin::signed(1), name_hash, 1));
+		assert_ok!(NameService::assign(Origin::signed(1), name_hash, Some(1)));
+
+		// non assigned account call should fail
+		assert_noop!(NameService::unassign(Origin::signed(2), name_hash), Error::<Test>::NotAssigned);
+
+		// assigned account call should pass
+		assert_ok!(NameService::unassign(Origin::signed(1), name_hash));
+		assert_eq!(Lookup::<Test>::get(&name_hash), None);
+	});
+}
+
+#[test]
+fn make_permanent_works(){
+	new_test_ext().execute_with(|| {
+		// Test data
+		let name_hash = blake2_256(b"shawntabrizi");
+
+		// setup an assigned name to test
+		assert_ok!(NameService::bid(Origin::signed(1), name_hash, 10));
+		run_to_block(<mock::Test as Trait>::BiddingPeriod::get());
+		assert_ok!(NameService::claim(Origin::signed(1), name_hash, 1));
+
+		// call from non permeance account should fail
+		assert_noop!(NameService::make_permanent(Origin::signed(1), name_hash), BadOrigin);
+
+		// call from permeance accout should pass
+		assert_ok!(NameService::make_permanent(Origin::signed(200), name_hash));
+		let stored_data = Registration::<Test>::get(&name_hash);
+		assert_eq!(stored_data, NameStatus::Owned {
+				who: 1,
+				expiration: None,
+		});
+	});
+}
+
+#[test]
+fn extend_ownership_works(){
+	new_test_ext().execute_with(|| {
+		// Test data
+		let name_hash = blake2_256(b"shawntabrizi");
+
+		// call with non claimed name should fail
+		assert_noop!(NameService::extend_ownership(Origin::signed(1), name_hash), Error::<Test>::UnexpectedState);
+
+		// setup an assigned name to test
+		assert_ok!(NameService::bid(Origin::signed(1), name_hash, 10));
+		run_to_block(<mock::Test as Trait>::BiddingPeriod::get());
+		assert_ok!(NameService::claim(Origin::signed(1), name_hash, 1));
+
+		// call to extend ownership should pass
+		assert_ok!(NameService::extend_ownership(Origin::signed(2), name_hash));
+		// balance of caller should reduce by the extension fee
+		assert_eq!(Balances::free_balance(&2), 200.saturating_sub(5));
+
+		let stored_data = Registration::<Test>::get(&name_hash);
+		assert_eq!(stored_data, NameStatus::Owned {
+			who: 1,
+			expiration: Some(210)
+		});
+	});
+}