tests.rs

//! Unit tests for the gradually-update module.

#![cfg(test)]

use super::*;
use codec::Encode;
use frame_support::{assert_noop, assert_ok};
use mock::{Event, *};
use sp_runtime::{FixedPointNumber, FixedU128, Permill};
use sp_std::convert::TryInto;

fn storage_set(key: &Vec<u8>, value: &Vec<u8>) {
	// let bounded_key: StorageValueBytes<Runtime> =
	// key.to_vec().try_into().unwrap(); let bounded_value:
	// StorageValueBytes<Runtime> = key.to_vec().try_into().unwrap();
	frame_support::storage::unhashed::put(key, value);
}

fn storage_get(key: &Vec<u8>) -> StorageValueBytes<Runtime> {
	frame_support::storage::unhashed::get::<StorageValueBytes<Runtime>>(key).unwrap_or_default()
}

#[test]
fn gradually_update_should_work() {
	ExtBuilder::default().build().execute_with(|| {
		System::set_block_number(1);

		let update: GraduallyUpdate<StorageKeyBytes<Runtime>, StorageValueBytes<Runtime>> = GraduallyUpdate {
			key: vec![1].try_into().unwrap(),
			target_value: vec![9].try_into().unwrap(),
			per_block: vec![1].try_into().unwrap(),
		};
		assert_ok!(GraduallyUpdateModule::gradually_update(Origin::root(), update.clone()));

		let gradually_update_event = Event::gradually_update(crate::Event::GraduallyUpdateAdded(
			update.key,
			update.per_block,
			update.target_value,
		));
		assert!(System::events()
			.iter()
			.any(|record| record.event == gradually_update_event));
	});
}

#[test]
fn gradually_update_should_fail() {
	ExtBuilder::default().build().execute_with(|| {
		let update: GraduallyUpdate<StorageKeyBytes<Runtime>, StorageValueBytes<Runtime>> = GraduallyUpdate {
			key: vec![1].try_into().unwrap(),
			target_value: 9u32.encode().try_into().unwrap(),
			per_block: 1u64.encode().try_into().unwrap(),
		};
		assert_noop!(
			GraduallyUpdateModule::gradually_update(Origin::root(), update.clone()),
			Error::<Runtime>::InvalidPerBlockOrTargetValue
		);

		let update: GraduallyUpdate<StorageKeyBytes<Runtime>, StorageValueBytes<Runtime>> = GraduallyUpdate {
			key: vec![1].try_into().unwrap(),
			target_value: 90u32.encode().try_into().unwrap(),
			per_block: 1u32.encode().try_into().unwrap(),
		};
		assert_ok!(GraduallyUpdateModule::gradually_update(Origin::root(), update.clone()));

		GraduallyUpdateModule::on_finalize(20);

		let new_update = GraduallyUpdate {
			key: vec![1].try_into().unwrap(),
			target_value: 9u64.encode().try_into().unwrap(),
			per_block: 1u64.encode().try_into().unwrap(),
		};
		assert_noop!(
			GraduallyUpdateModule::gradually_update(Origin::root(), new_update.clone()),
			Error::<Runtime>::InvalidTargetValue
		);

		assert_noop!(
			GraduallyUpdateModule::gradually_update(Origin::root(), update.clone()),
			Error::<Runtime>::GraduallyUpdateHasExisted
		);
	});
}

#[test]
fn cancel_gradually_update_should_work() {
	ExtBuilder::default().build().execute_with(|| {
		System::set_block_number(1);

		let update: GraduallyUpdate<StorageKeyBytes<Runtime>, StorageValueBytes<Runtime>> = GraduallyUpdate {
			key: vec![1].try_into().unwrap(),
			target_value: vec![9].try_into().unwrap(),
			per_block: vec![1].try_into().unwrap(),
		};
		assert_ok!(GraduallyUpdateModule::gradually_update(Origin::root(), update.clone()));
		let gradually_update_event = Event::gradually_update(crate::Event::GraduallyUpdateAdded(
			update.key.clone(),
			update.per_block,
			update.target_value,
		));
		assert!(System::events()
			.iter()
			.any(|record| record.event == gradually_update_event));

		assert_ok!(GraduallyUpdateModule::cancel_gradually_update(
			Origin::root(),
			update.key.clone()
		));
		let cancel_gradually_update_event =
			Event::gradually_update(crate::Event::GraduallyUpdateCancelled(update.key.clone()));
		assert!(System::events()
			.iter()
			.any(|record| record.event == cancel_gradually_update_event));
	});
}

#[test]
fn cancel_gradually_update_should_fail() {
	ExtBuilder::default().build().execute_with(|| {
		let update: GraduallyUpdate<StorageKeyBytes<Runtime>, StorageValueBytes<Runtime>> = GraduallyUpdate {
			key: vec![1].try_into().unwrap(),
			target_value: 9u32.encode().try_into().unwrap(),
			per_block: 1u32.encode().try_into().unwrap(),
		};
		assert_noop!(
			GraduallyUpdateModule::cancel_gradually_update(Origin::root(), update.key.clone()),
			Error::<Runtime>::GraduallyUpdateNotFound
		);

		assert_ok!(GraduallyUpdateModule::gradually_update(Origin::root(), update.clone()));

		assert_ok!(GraduallyUpdateModule::cancel_gradually_update(
			Origin::root(),
			update.key.clone()
		));
	});
}

#[test]
fn add_on_finalize_should_work() {
	ExtBuilder::default().build().execute_with(|| {
		System::set_block_number(1);

		let update: GraduallyUpdate<StorageKeyBytes<Runtime>, StorageValueBytes<Runtime>> = GraduallyUpdate {
			key: vec![1].try_into().unwrap(),
			target_value: vec![30].try_into().unwrap(),
			per_block: vec![1].try_into().unwrap(),
		};
		assert_ok!(GraduallyUpdateModule::gradually_update(Origin::root(), update.clone()));
		assert_eq!(storage_get(&update.key), Vec::<u8>::new());

		GraduallyUpdateModule::on_finalize(10);
		assert_eq!(storage_get(&update.key), vec![10]);
		let gradually_update_blocknumber_event = Event::gradually_update(crate::Event::Updated(
			10,
			update.key.clone(),
			vec![10].try_into().unwrap(),
		));
		println!("Length {}", System::events().len());
		assert!(System::events().iter().any(|record| {
			println!("{:?}", record.event);
			record.event == gradually_update_blocknumber_event
		}));
		assert_eq!(System::events().len(), 2);

		GraduallyUpdateModule::on_finalize(15);
		assert_eq!(storage_get(&update.key), vec![10]);
		assert_eq!(System::events().len(), 2);

		GraduallyUpdateModule::on_finalize(20);
		assert_eq!(storage_get(&update.key), vec![20]);
		let gradually_update_blocknumber_event = Event::gradually_update(crate::Event::Updated(
			20,
			update.key.clone(),
			vec![20].try_into().unwrap(),
		));
		assert!(System::events()
			.iter()
			.any(|record| record.event == gradually_update_blocknumber_event));
		assert_eq!(System::events().len(), 3);

		GraduallyUpdateModule::on_finalize(40);
		assert_eq!(storage_get(&update.key), vec![30]);
		let gradually_update_blocknumber_event = Event::gradually_update(crate::Event::Updated(
			40,
			update.key.clone(),
			vec![30].try_into().unwrap(),
		));
		assert!(System::events()
			.iter()
			.any(|record| record.event == gradually_update_blocknumber_event));
	});
}

#[test]
fn sub_on_finalize_should_work() {
	ExtBuilder::default().build().execute_with(|| {
		System::set_block_number(1);

		let update: GraduallyUpdate<StorageKeyBytes<Runtime>, StorageValueBytes<Runtime>> = GraduallyUpdate {
			key: vec![1].try_into().unwrap(),
			target_value: vec![5].try_into().unwrap(),
			per_block: vec![1].try_into().unwrap(),
		};

		storage_set(&update.key, &vec![30]);
		assert_ok!(GraduallyUpdateModule::gradually_update(Origin::root(), update.clone()));
		assert_eq!(storage_get(&update.key), vec![30]);

		GraduallyUpdateModule::on_finalize(10);
		assert_eq!(storage_get(&update.key), vec![20]);
		let gradually_update_blocknumber_event = Event::gradually_update(crate::Event::Updated(
			10,
			update.key.clone(),
			vec![20].try_into().unwrap(),
		));
		assert!(System::events()
			.iter()
			.any(|record| record.event == gradually_update_blocknumber_event));
		assert_eq!(System::events().len(), 2);

		GraduallyUpdateModule::on_finalize(15);
		assert_eq!(storage_get(&update.key), vec![20]);
		assert_eq!(System::events().len(), 2);

		GraduallyUpdateModule::on_finalize(20);
		assert_eq!(storage_get(&update.key), vec![10]);
		let gradually_update_blocknumber_event = Event::gradually_update(crate::Event::Updated(
			20,
			update.key.clone(),
			vec![10].try_into().unwrap(),
		));
		assert!(System::events()
			.iter()
			.any(|record| record.event == gradually_update_blocknumber_event));
		assert_eq!(System::events().len(), 3);

		GraduallyUpdateModule::on_finalize(40);
		assert_eq!(storage_get(&update.key), vec![5]);
		let gradually_update_blocknumber_event = Event::gradually_update(crate::Event::Updated(
			40,
			update.key.clone(),
			vec![5].try_into().unwrap(),
		));
		assert!(System::events()
			.iter()
			.any(|record| record.event == gradually_update_blocknumber_event));
	});
}

#[test]
fn u32_should_work() {
	ExtBuilder::default().build().execute_with(|| {
		let update: GraduallyUpdate<StorageKeyBytes<Runtime>, StorageValueBytes<Runtime>> = GraduallyUpdate {
			key: vec![1].try_into().unwrap(),
			target_value: 30u32.encode().try_into().unwrap(),
			per_block: 1u32.encode().try_into().unwrap(),
		};
		assert_ok!(GraduallyUpdateModule::gradually_update(Origin::root(), update.clone()));
		assert_eq!(storage_get(&update.key), Vec::<u8>::new());
		GraduallyUpdateModule::on_finalize(10);
		assert_eq!(storage_get(&update.key), vec![10, 0, 0, 0]);
		GraduallyUpdateModule::on_finalize(15);
		assert_eq!(storage_get(&update.key), vec![10, 0, 0, 0]);
		GraduallyUpdateModule::on_finalize(20);
		assert_eq!(storage_get(&update.key), vec![20, 0, 0, 0]);
		GraduallyUpdateModule::on_finalize(40);
		assert_eq!(storage_get(&update.key), vec![30, 0, 0, 0]);
	});
}

#[test]
fn u128_should_work() {
	ExtBuilder::default().build().execute_with(|| {
		let update: GraduallyUpdate<StorageKeyBytes<Runtime>, StorageValueBytes<Runtime>> = GraduallyUpdate {
			key: vec![1].try_into().unwrap(),
			target_value: 30u128.encode().try_into().unwrap(),
			per_block: 1u128.encode().try_into().unwrap(),
		};
		assert_ok!(GraduallyUpdateModule::gradually_update(Origin::root(), update.clone()));
		assert_eq!(storage_get(&update.key), Vec::<u8>::new());
		GraduallyUpdateModule::on_finalize(10);
		assert_eq!(
			storage_get(&update.key),
			vec![10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
		);
		GraduallyUpdateModule::on_finalize(15);
		assert_eq!(
			storage_get(&update.key),
			vec![10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
		);
		GraduallyUpdateModule::on_finalize(20);
		assert_eq!(
			storage_get(&update.key),
			vec![20, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
		);
		GraduallyUpdateModule::on_finalize(40);
		assert_eq!(
			storage_get(&update.key),
			vec![30, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
		);
	});
}

#[test]
fn permill_should_work() {
	ExtBuilder::default().build().execute_with(|| {
		let update: GraduallyUpdate<StorageKeyBytes<Runtime>, StorageValueBytes<Runtime>> = GraduallyUpdate {
			key: vec![1].try_into().unwrap(),
			target_value: Permill::from_percent(30).encode().try_into().unwrap(),
			per_block: Permill::from_percent(1).encode().try_into().unwrap(),
		};
		assert_ok!(GraduallyUpdateModule::gradually_update(Origin::root(), update.clone()));
		assert_eq!(storage_get(&update.key), Vec::<u8>::new());
		GraduallyUpdateModule::on_finalize(10);
		assert_eq!(storage_get(&update.key), vec![160, 134, 1, 0]);
		GraduallyUpdateModule::on_finalize(15);
		assert_eq!(storage_get(&update.key), vec![160, 134, 1, 0]);
		GraduallyUpdateModule::on_finalize(20);
		assert_eq!(storage_get(&update.key), vec![64, 13, 3, 0]);
		GraduallyUpdateModule::on_finalize(40);
		assert_eq!(storage_get(&update.key), vec![224, 147, 4, 0]);
	});
}

#[test]
fn fixedu128_should_work() {
	ExtBuilder::default().build().execute_with(|| {
		let update: GraduallyUpdate<StorageKeyBytes<Runtime>, StorageValueBytes<Runtime>> = GraduallyUpdate {
			key: vec![1].try_into().unwrap(),
			target_value: FixedU128::saturating_from_rational(30, 1).encode().try_into().unwrap(),
			per_block: FixedU128::saturating_from_rational(1, 1).encode().try_into().unwrap(),
		};
		assert_ok!(GraduallyUpdateModule::gradually_update(Origin::root(), update.clone()));
		assert_eq!(storage_get(&update.key), Vec::<u8>::new());
		GraduallyUpdateModule::on_finalize(10);
		assert_eq!(
			storage_get(&update.key),
			vec![0, 0, 232, 137, 4, 35, 199, 138, 0, 0, 0, 0, 0, 0, 0, 0]
		);
		GraduallyUpdateModule::on_finalize(15);
		assert_eq!(
			storage_get(&update.key),
			vec![0, 0, 232, 137, 4, 35, 199, 138, 0, 0, 0, 0, 0, 0, 0, 0]
		);
		GraduallyUpdateModule::on_finalize(20);
		assert_eq!(
			storage_get(&update.key),
			vec![0, 0, 208, 19, 9, 70, 142, 21, 1, 0, 0, 0, 0, 0, 0, 0]
		);
		GraduallyUpdateModule::on_finalize(40);
		assert_eq!(
			storage_get(&update.key),
			vec![0, 0, 184, 157, 13, 105, 85, 160, 1, 0, 0, 0, 0, 0, 0, 0]
		);
	});
}

#[test]
fn finish_multiple_on_finalize_should_work() {
	ExtBuilder::default().build().execute_with(|| {
		System::set_block_number(1);

		let update: GraduallyUpdate<StorageKeyBytes<Runtime>, StorageValueBytes<Runtime>> = GraduallyUpdate {
			key: vec![10].try_into().unwrap(),
			target_value: vec![30].try_into().unwrap(),
			per_block: vec![1].try_into().unwrap(),
		};
		let update2: GraduallyUpdate<StorageKeyBytes<Runtime>, StorageValueBytes<Runtime>> = GraduallyUpdate {
			key: vec![20].try_into().unwrap(),
			target_value: vec![60].try_into().unwrap(),
			per_block: vec![2].try_into().unwrap(),
		};
		let update3: GraduallyUpdate<StorageKeyBytes<Runtime>, StorageValueBytes<Runtime>> = GraduallyUpdate {
			key: vec![30].try_into().unwrap(),
			target_value: vec![100].try_into().unwrap(),
			per_block: vec![3].try_into().unwrap(),
		};
		assert_ok!(GraduallyUpdateModule::gradually_update(Origin::root(), update.clone()));
		assert_ok!(GraduallyUpdateModule::gradually_update(Origin::root(), update2.clone()));
		assert_ok!(GraduallyUpdateModule::gradually_update(Origin::root(), update3.clone()));

		GraduallyUpdateModule::on_finalize(10);
		assert_eq!(storage_get(&update.key), vec![10]);
		assert_eq!(storage_get(&update2.key), vec![20]);
		assert_eq!(storage_get(&update3.key), vec![30]);

		GraduallyUpdateModule::on_finalize(15);
		assert_eq!(storage_get(&update.key), vec![10]);
		assert_eq!(storage_get(&update2.key), vec![20]);
		assert_eq!(storage_get(&update3.key), vec![30]);

		GraduallyUpdateModule::on_finalize(20);
		assert_eq!(storage_get(&update.key), vec![20]);
		assert_eq!(storage_get(&update2.key), vec![40]);
		assert_eq!(storage_get(&update3.key), vec![60]);

		GraduallyUpdateModule::on_finalize(40);
		assert_eq!(storage_get(&update.key), vec![30]);
		assert_eq!(storage_get(&update2.key), vec![60]);
		assert_eq!(storage_get(&update3.key), vec![90]);

		GraduallyUpdateModule::on_finalize(50);
		assert_eq!(storage_get(&update.key), vec![30]);
		assert_eq!(storage_get(&update2.key), vec![60]);
		assert_eq!(storage_get(&update3.key), vec![100]);
	});
}

#[test]
fn exceeding_max_gradually_updates_should_fail() {
	ExtBuilder::default().build().execute_with(|| {
		System::set_block_number(1);

		let update: GraduallyUpdate<StorageKeyBytes<Runtime>, StorageValueBytes<Runtime>> = GraduallyUpdate {
			key: vec![10].try_into().unwrap(),
			target_value: vec![30].try_into().unwrap(),
			per_block: vec![1].try_into().unwrap(),
		};
		let update2: GraduallyUpdate<StorageKeyBytes<Runtime>, StorageValueBytes<Runtime>> = GraduallyUpdate {
			key: vec![20].try_into().unwrap(),
			target_value: vec![60].try_into().unwrap(),
			per_block: vec![2].try_into().unwrap(),
		};
		let update3: GraduallyUpdate<StorageKeyBytes<Runtime>, StorageValueBytes<Runtime>> = GraduallyUpdate {
			key: vec![30].try_into().unwrap(),
			target_value: vec![100].try_into().unwrap(),
			per_block: vec![3].try_into().unwrap(),
		};
		let update4: GraduallyUpdate<StorageKeyBytes<Runtime>, StorageValueBytes<Runtime>> = GraduallyUpdate {
			key: vec![40].try_into().unwrap(),
			target_value: vec![120].try_into().unwrap(),
			per_block: vec![4].try_into().unwrap(),
		};
		assert_ok!(GraduallyUpdateModule::gradually_update(Origin::root(), update.clone()));
		assert_ok!(GraduallyUpdateModule::gradually_update(Origin::root(), update2.clone()));
		assert_ok!(GraduallyUpdateModule::gradually_update(Origin::root(), update3.clone()));
		assert_noop!(
			GraduallyUpdateModule::gradually_update(Origin::root(), update4.clone()),
			Error::<Runtime>::MaxGraduallyUpdateExceeded
		);

		GraduallyUpdateModule::on_finalize(10);
		GraduallyUpdateModule::on_finalize(20);
		GraduallyUpdateModule::on_finalize(30);
		assert_ok!(GraduallyUpdateModule::gradually_update(Origin::root(), update4.clone()));
		GraduallyUpdateModule::on_finalize(40);
		GraduallyUpdateModule::on_finalize(50);
		GraduallyUpdateModule::on_finalize(60);
		assert_eq!(storage_get(&update.key), vec![30]);
		assert_eq!(storage_get(&update2.key), vec![60]);
		assert_eq!(storage_get(&update3.key), vec![100]);
		assert_eq!(storage_get(&update4.key), vec![120]);
	});
}