git.delta.rocks / unique-network / refs/commits / 29e7096ea1cc

--- a/pallets/nft/src/lib.rs
+++ b/pallets/nft/src/lib.rs
@@ -40,6 +40,9 @@
 #[cfg(test)]
 mod tests;
 
+// Structs
+// #region
+
 #[derive(Encode, Decode, Eq, Debug, Clone, PartialEq)]
 #[cfg_attr(feature = "std", derive(Serialize, Deserialize))]
 pub enum CollectionMode {
@@ -158,6 +161,8 @@
     type Event: From<Event<Self>> + Into<<Self as system::Trait>::Event>;
 }
 
+// #endregion
+
 decl_storage! {
     trait Store for Module<T: Trait> as Nft {
 
@@ -1287,6 +1292,7 @@
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 // Economic models
+// #region
 
 /// Fee multiplier.
 pub type Multiplier = FixedU128;
@@ -1481,3 +1487,4 @@
         Ok(())
     }
 }
+// #endregion
\ No newline at end of file

3use crate::{ApprovePermissions, CollectionMode, AccessMode, Ownership};3use crate::{ApprovePermissions, CollectionMode, AccessMode, Ownership};
4use frame_support::{assert_noop, assert_ok};4use frame_support::{assert_noop, assert_ok};
55
6// Use cases tests region
7// #region
6#[test]8#[test]
7fn create_nft_item() {9fn create_nft_item() {
8    new_test_ext().execute_with(|| {10    new_test_ext().execute_with(|| {
956    });958    });
957}959}
958960
961// #endregion
962
963// Coverage tests region
964// #region
965
966#[test]
967fn owner_can_add_address_to_white_list() {
968    new_test_ext().execute_with(|| {
969        let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();
970        let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();
971        let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
972        let mode: CollectionMode = CollectionMode::NFT(2000);
973        let origin1 = Origin::signed(1);
974
975        assert_ok!(TemplateModule::create_collection(
976            origin1.clone(),
977            col_name1.clone(),
978            col_desc1.clone(),
979            token_prefix1.clone(),
980            mode
981        ));
982
983        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 2));
984        assert_eq!(TemplateModule::white_list(1)[0], 2);
985    });
986}
987
988#[test]
989fn admin_can_add_address_to_white_list() {
990    new_test_ext().execute_with(|| {
991        let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();
992        let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();
993        let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
994        let mode: CollectionMode = CollectionMode::NFT(2000);
995        let origin1 = Origin::signed(1);
996        let origin2 = Origin::signed(2);
997
998        assert_ok!(TemplateModule::create_collection(
999            origin1.clone(),
1000            col_name1.clone(),
1001            col_desc1.clone(),
1002            token_prefix1.clone(),
1003            mode
1004        ));
1005
1006        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), 1, 2));
1007        assert_ok!(TemplateModule::add_to_white_list(origin2.clone(), 1, 3));
1008        assert_eq!(TemplateModule::white_list(1)[0], 3);
1009    });
1010}
1011
1012#[test]
1013fn nonprivileged_user_cannot_add_address_to_white_list() {
1014    new_test_ext().execute_with(|| {
1015        let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();
1016        let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();
1017        let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
1018        let mode: CollectionMode = CollectionMode::NFT(2000);
1019        let origin1 = Origin::signed(1);
1020        let origin2 = Origin::signed(2);
1021
1022        assert_ok!(TemplateModule::create_collection(
1023            origin1.clone(),
1024            col_name1.clone(),
1025            col_desc1.clone(),
1026            token_prefix1.clone(),
1027            mode
1028        ));
1029
1030        assert_noop!(TemplateModule::add_to_white_list(origin2.clone(), 1, 3), "You do not have permissions to modify this collection");
1031    });
1032}
1033
1034#[test]
1035fn nobody_can_add_address_to_white_list_of_nonexisting_collection() {
1036    new_test_ext().execute_with(|| {
1037
1038        let origin1 = Origin::signed(1);
1039        assert_noop!(TemplateModule::add_to_white_list(origin1.clone(), 1, 2), "This collection does not exist");
1040    });
1041}
1042
1043#[test]
1044fn nobody_can_add_address_to_white_list_of_deleted_collection() {
1045    new_test_ext().execute_with(|| {
1046        let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();
1047        let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();
1048        let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
1049        let mode: CollectionMode = CollectionMode::NFT(2000);
1050        let origin1 = Origin::signed(1);
1051
1052        assert_ok!(TemplateModule::create_collection(
1053            origin1.clone(),
1054            col_name1.clone(),
1055            col_desc1.clone(),
1056            token_prefix1.clone(),
1057            mode
1058        ));
1059
1060        assert_ok!(TemplateModule::destroy_collection(origin1.clone(), 1));
1061        assert_noop!(TemplateModule::add_to_white_list(origin1.clone(), 1, 2), "This collection does not exist");
1062    });
1063}
1064
1065// If address is already added to white list, nothing happens
1066#[test]
1067fn address_is_already_added_to_white_list() {
1068    new_test_ext().execute_with(|| {
1069
1070        let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();
1071        let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();
1072        let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
1073        let mode: CollectionMode = CollectionMode::NFT(2000);
1074        let origin1 = Origin::signed(1);
1075
1076        assert_ok!(TemplateModule::create_collection(
1077            origin1.clone(),
1078            col_name1.clone(),
1079            col_desc1.clone(),
1080            token_prefix1.clone(),
1081            mode
1082        ));
1083
1084        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 2));
1085        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 2));
1086        assert_eq!(TemplateModule::white_list(1)[0], 2);
1087        assert_eq!(TemplateModule::white_list(1).len(), 1);
1088    });
1089}
1090
1091#[test]
1092fn owner_can_remove_address_from_white_list() {
1093    new_test_ext().execute_with(|| {
1094        
1095        let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();
1096        let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();
1097        let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
1098        let mode: CollectionMode = CollectionMode::NFT(2000);
1099        let origin1 = Origin::signed(1);
1100
1101        assert_ok!(TemplateModule::create_collection(
1102            origin1.clone(),
1103            col_name1.clone(),
1104            col_desc1.clone(),
1105            token_prefix1.clone(),
1106            mode
1107        ));
1108
1109        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 2));
1110        assert_ok!(TemplateModule::remove_from_white_list(origin1.clone(), 1, 2));
1111        assert_eq!(TemplateModule::white_list(1).len(), 0);
1112    });
1113}
1114
1115#[test]
1116fn admin_can_remove_address_from_white_list() {
1117    new_test_ext().execute_with(|| {
1118
1119        let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();
1120        let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();
1121        let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
1122        let mode: CollectionMode = CollectionMode::NFT(2000);
1123        let origin1 = Origin::signed(1);
1124        let origin2 = Origin::signed(2);
1125
1126        assert_ok!(TemplateModule::create_collection(
1127            origin1.clone(),
1128            col_name1.clone(),
1129            col_desc1.clone(),
1130            token_prefix1.clone(),
1131            mode
1132        ));
1133
1134        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), 1, 2));
1135
1136        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 3));
1137        assert_ok!(TemplateModule::remove_from_white_list(origin2.clone(), 1, 3));
1138        assert_eq!(TemplateModule::white_list(1).len(), 0);
1139    });
1140}
1141
1142#[test]
1143fn nonprivileged_user_cannot_remove_address_from_white_list() {
1144    new_test_ext().execute_with(|| {
1145
1146        let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();
1147        let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();
1148        let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
1149        let mode: CollectionMode = CollectionMode::NFT(2000);
1150        let origin1 = Origin::signed(1);
1151        let origin2 = Origin::signed(2);
1152
1153        assert_ok!(TemplateModule::create_collection(
1154            origin1.clone(),
1155            col_name1.clone(),
1156            col_desc1.clone(),
1157            token_prefix1.clone(),
1158            mode
1159        ));
1160
1161        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 2));
1162        assert_noop!(TemplateModule::remove_from_white_list(origin2.clone(), 1, 2), "You do not have permissions to modify this collection");
1163        assert_eq!(TemplateModule::white_list(1)[0], 2);
1164    });
1165}
1166
1167#[test]
1168fn nobody_can_remove_address_from_white_list_of_nonexisting_collection() {
1169    new_test_ext().execute_with(|| {
1170
1171        let origin1 = Origin::signed(1);
1172        assert_noop!(TemplateModule::remove_from_white_list(origin1.clone(), 1, 2), "This collection does not exist");
1173    });
1174}
1175
1176#[test]
1177fn nobody_can_remove_address_from_white_list_of_deleted_collection() {
1178    new_test_ext().execute_with(|| {
1179
1180        let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();
1181        let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();
1182        let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
1183        let mode: CollectionMode = CollectionMode::NFT(2000);
1184        let origin1 = Origin::signed(1);
1185        let origin2 = Origin::signed(2);
1186
1187        assert_ok!(TemplateModule::create_collection(
1188            origin1.clone(),
1189            col_name1.clone(),
1190            col_desc1.clone(),
1191            token_prefix1.clone(),
1192            mode
1193        ));
1194
1195        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 2));
1196        assert_ok!(TemplateModule::destroy_collection(origin1.clone(), 1));
1197        assert_noop!(TemplateModule::remove_from_white_list(origin2.clone(), 1, 2), "This collection does not exist");
1198        assert_eq!(TemplateModule::white_list(1).len(), 0);
1199    });
1200}
1201
1202// If address is already removed from white list, nothing happens
1203#[test]
1204fn address_is_already_removed_from_white_list() {
1205    new_test_ext().execute_with(|| {
1206        let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();
1207        let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();
1208        let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
1209        let mode: CollectionMode = CollectionMode::NFT(2000);
1210        let origin1 = Origin::signed(1);
1211
1212        assert_ok!(TemplateModule::create_collection(
1213            origin1.clone(),
1214            col_name1.clone(),
1215            col_desc1.clone(),
1216            token_prefix1.clone(),
1217            mode
1218        ));
1219
1220        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 2));
1221        assert_ok!(TemplateModule::remove_from_white_list(origin1.clone(), 1, 2));
1222        assert_ok!(TemplateModule::remove_from_white_list(origin1.clone(), 1, 2));
1223        assert_eq!(TemplateModule::white_list(1).len(), 0);
1224    });
1225}
1226
1227// If Public Access mode is set to WhiteList, tokens can’t be transferred from a non-whitelisted address with transfer or transferFrom (2 tests)
1228#[test]
1229fn white_list_test_1() {
1230    new_test_ext().execute_with(|| {
1231        let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();
1232        let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();
1233        let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
1234        let mode: CollectionMode = CollectionMode::NFT(2000);
1235
1236        let origin1 = Origin::signed(1);
1237        assert_ok!(TemplateModule::create_collection(
1238            origin1.clone(),
1239            col_name1.clone(),
1240            col_desc1.clone(),
1241            token_prefix1.clone(),
1242            mode
1243        ));
1244        assert_eq!(TemplateModule::collection(1).owner, 1);
1245
1246        assert_ok!(TemplateModule::create_item(
1247            origin1.clone(),
1248            1,
1249            [1, 2, 3].to_vec(),
1250            1
1251        ));
1252
1253        assert_ok!(TemplateModule::set_public_access_mode(origin1.clone(), 1, AccessMode::WhiteList));
1254        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 2));
1255
1256        assert_noop!(TemplateModule::transfer(
1257            origin1.clone(),
1258            3,
1259            1,
1260            1,
1261            1
1262        ), "Address is not in white list");
1263    });
1264}
1265
1266#[test]
1267fn white_list_test_2() {
1268    new_test_ext().execute_with(|| {
1269        let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();
1270        let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();
1271        let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
1272        let mode: CollectionMode = CollectionMode::NFT(2000);
1273
1274        let origin1 = Origin::signed(1);
1275        assert_ok!(TemplateModule::create_collection(
1276            origin1.clone(),
1277            col_name1.clone(),
1278            col_desc1.clone(),
1279            token_prefix1.clone(),
1280            mode
1281        ));
1282        assert_eq!(TemplateModule::collection(1).owner, 1);
1283
1284        assert_ok!(TemplateModule::create_item(
1285            origin1.clone(),
1286            1,
1287            [1, 2, 3].to_vec(),
1288            1
1289        ));
1290
1291        assert_ok!(TemplateModule::set_public_access_mode(origin1.clone(), 1, AccessMode::WhiteList));
1292        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 1));
1293        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 2));
1294
1295        // do approve
1296        assert_ok!(TemplateModule::approve(origin1.clone(), 1, 1, 1));
1297        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 1);
1298
1299        assert_ok!(TemplateModule::remove_from_white_list(origin1.clone(), 1, 1));
1300
1301        assert_noop!(TemplateModule::transfer_from(
1302            origin1.clone(),
1303            1,
1304            3,
1305            1,
1306            1,
1307            1
1308        ), "Address is not in white list");
1309    });
1310}
1311
1312// If Public Access mode is set to WhiteList, tokens can’t be transferred to a non-whitelisted address with transfer or transferFrom (2 tests)
1313#[test]
1314fn white_list_test_3() {
1315    new_test_ext().execute_with(|| {
1316        let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();
1317        let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();
1318        let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
1319        let mode: CollectionMode = CollectionMode::NFT(2000);
1320
1321        let origin1 = Origin::signed(1);
1322        assert_ok!(TemplateModule::create_collection(
1323            origin1.clone(),
1324            col_name1.clone(),
1325            col_desc1.clone(),
1326            token_prefix1.clone(),
1327            mode
1328        ));
1329        assert_eq!(TemplateModule::collection(1).owner, 1);
1330
1331        assert_ok!(TemplateModule::create_item(
1332            origin1.clone(),
1333            1,
1334            [1, 2, 3].to_vec(),
1335            1
1336        ));
1337
1338        assert_ok!(TemplateModule::set_public_access_mode(origin1.clone(), 1, AccessMode::WhiteList));
1339        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 1));
1340
1341        assert_noop!(TemplateModule::transfer(
1342            origin1.clone(),
1343            3,
1344            1,
1345            1,
1346            1
1347        ), "Address is not in white list");
1348    });
1349}
1350
1351#[test]
1352fn white_list_test_4() {
1353    new_test_ext().execute_with(|| {
1354        let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();
1355        let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();
1356        let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
1357        let mode: CollectionMode = CollectionMode::NFT(2000);
1358
1359        let origin1 = Origin::signed(1);
1360        assert_ok!(TemplateModule::create_collection(
1361            origin1.clone(),
1362            col_name1.clone(),
1363            col_desc1.clone(),
1364            token_prefix1.clone(),
1365            mode
1366        ));
1367        assert_eq!(TemplateModule::collection(1).owner, 1);
1368
1369        assert_ok!(TemplateModule::create_item(
1370            origin1.clone(),
1371            1,
1372            [1, 2, 3].to_vec(),
1373            1
1374        ));
1375
1376        assert_ok!(TemplateModule::set_public_access_mode(origin1.clone(), 1, AccessMode::WhiteList));
1377        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 1));
1378        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 2));
1379
1380        // do approve
1381        assert_ok!(TemplateModule::approve(origin1.clone(), 1, 1, 1));
1382        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 1);
1383
1384        assert_ok!(TemplateModule::remove_from_white_list(origin1.clone(), 1, 2));
1385
1386        assert_noop!(TemplateModule::transfer_from(
1387            origin1.clone(),
1388            1,
1389            3,
1390            1,
1391            1,
1392            1
1393        ), "Address is not in white list");
1394    });
1395}
1396
1397// If Public Access mode is set to WhiteList, tokens can’t be destroyed by a non-whitelisted address (even if it owned them before enabling WhiteList mode)
1398#[test]
1399fn white_list_test_5() {
1400    new_test_ext().execute_with(|| {
1401        let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();
1402        let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();
1403        let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
1404        let mode: CollectionMode = CollectionMode::NFT(2000);
1405
1406        let origin1 = Origin::signed(1);
1407        assert_ok!(TemplateModule::create_collection(
1408            origin1.clone(),
1409            col_name1.clone(),
1410            col_desc1.clone(),
1411            token_prefix1.clone(),
1412            mode
1413        ));
1414        assert_eq!(TemplateModule::collection(1).owner, 1);
1415
1416        assert_ok!(TemplateModule::create_item(
1417            origin1.clone(),
1418            1,
1419            [1, 2, 3].to_vec(),
1420            1
1421        ));
1422
1423        assert_ok!(TemplateModule::set_public_access_mode(origin1.clone(), 1, AccessMode::WhiteList));
1424        assert_noop!(TemplateModule::burn_item(origin1.clone(), 1, 1), "Address is not in white list");
1425    });
1426}
1427
1428// If Public Access mode is set to WhiteList, oken transfers can’t be Approved by a non-whitelisted address (see Approve method).
1429#[test]
1430fn white_list_test_6() {
1431    new_test_ext().execute_with(|| {
1432        let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();
1433        let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();
1434        let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
1435        let mode: CollectionMode = CollectionMode::NFT(2000);
1436
1437        let origin1 = Origin::signed(1);
1438        assert_ok!(TemplateModule::create_collection(
1439            origin1.clone(),
1440            col_name1.clone(),
1441            col_desc1.clone(),
1442            token_prefix1.clone(),
1443            mode
1444        ));
1445        assert_ok!(TemplateModule::set_public_access_mode(origin1.clone(), 1, AccessMode::WhiteList));
1446
1447        // do approve
1448        assert_noop!(TemplateModule::approve(origin1.clone(), 1, 1, 1), "Address is not in white list");
1449    });
1450}
1451
1452// If Public Access mode is set to WhiteList, tokens can be transferred from a whitelisted address with transfer or transferFrom (2 tests) and
1453//          tokens can be transferred from a whitelisted address with transfer or transferFrom (2 tests)
1454#[test]
1455fn white_list_test_7() {
1456    new_test_ext().execute_with(|| {
1457        let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();
1458        let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();
1459        let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
1460        let mode: CollectionMode = CollectionMode::NFT(2000);
1461
1462        let origin1 = Origin::signed(1);
1463        assert_ok!(TemplateModule::create_collection(
1464            origin1.clone(),
1465            col_name1.clone(),
1466            col_desc1.clone(),
1467            token_prefix1.clone(),
1468            mode
1469        ));
1470        assert_eq!(TemplateModule::collection(1).owner, 1);
1471
1472        assert_ok!(TemplateModule::create_item(
1473            origin1.clone(),
1474            1,
1475            [1, 2, 3].to_vec(),
1476            1
1477        ));
1478
1479        assert_ok!(TemplateModule::set_public_access_mode(origin1.clone(), 1, AccessMode::WhiteList));
1480        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 1));
1481        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 2));
1482
1483        assert_ok!(TemplateModule::transfer(
1484            origin1.clone(),
1485            2,
1486            1,
1487            1,
1488            1
1489        ));
1490    });
1491}
1492
1493#[test]
1494fn white_list_test_8() {
1495    new_test_ext().execute_with(|| {
1496        let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();
1497        let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();
1498        let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
1499        let mode: CollectionMode = CollectionMode::NFT(2000);
1500
1501        let origin1 = Origin::signed(1);
1502        assert_ok!(TemplateModule::create_collection(
1503            origin1.clone(),
1504            col_name1.clone(),
1505            col_desc1.clone(),
1506            token_prefix1.clone(),
1507            mode
1508        ));
1509        assert_eq!(TemplateModule::collection(1).owner, 1);
1510
1511        assert_ok!(TemplateModule::create_item(
1512            origin1.clone(),
1513            1,
1514            [1, 2, 3].to_vec(),
1515            1
1516        ));
1517
1518        assert_ok!(TemplateModule::set_public_access_mode(origin1.clone(), 1, AccessMode::WhiteList));
1519        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 1));
1520        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 2));
1521
1522        // do approve
1523        assert_ok!(TemplateModule::approve(origin1.clone(), 1, 1, 1));
1524        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 1);
1525
1526        assert_ok!(TemplateModule::transfer_from(
1527            origin1.clone(),
1528            1,
1529            2,
1530            1,
1531            1,
1532            1
1533        ));
1534    });
1535}
1536
1537// If Public Access mode is set to WhiteList, and Mint Permission is set to false, tokens can be created by owner.
1538#[test]
1539fn white_list_test_9() {
1540    new_test_ext().execute_with(|| {
1541        let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();
1542        let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();
1543        let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
1544        let mode: CollectionMode = CollectionMode::NFT(2000);
1545
1546        let origin1 = Origin::signed(1);
1547        assert_ok!(TemplateModule::create_collection(
1548            origin1.clone(),
1549            col_name1.clone(),
1550            col_desc1.clone(),
1551            token_prefix1.clone(),
1552            mode
1553        ));
1554
1555        assert_ok!(TemplateModule::set_public_access_mode(origin1.clone(), 1, AccessMode::WhiteList));
1556        assert_ok!(TemplateModule::set_mint_permission(origin1.clone(), 1, false));
1557
1558        assert_ok!(TemplateModule::create_item(
1559            origin1.clone(),
1560            1,
1561            [1, 2, 3].to_vec(),
1562            1
1563        ));
1564    });
1565}
1566
1567// If Public Access mode is set to WhiteList, and Mint Permission is set to false, tokens can be created by admin.
1568#[test]
1569fn white_list_test_10() {
1570    new_test_ext().execute_with(|| {
1571        let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();
1572        let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();
1573        let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
1574        let mode: CollectionMode = CollectionMode::NFT(2000);
1575
1576        let origin1 = Origin::signed(1);
1577        let origin2 = Origin::signed(2);
1578        assert_ok!(TemplateModule::create_collection(
1579            origin1.clone(),
1580            col_name1.clone(),
1581            col_desc1.clone(),
1582            token_prefix1.clone(),
1583            mode
1584        ));
1585
1586        assert_ok!(TemplateModule::set_public_access_mode(origin1.clone(), 1, AccessMode::WhiteList));
1587        assert_ok!(TemplateModule::set_mint_permission(origin1.clone(), 1, false));
1588
1589        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), 1, 2));
1590
1591        assert_ok!(TemplateModule::create_item(
1592            origin2.clone(),
1593            1,
1594            [1, 2, 3].to_vec(),
1595            2
1596        ));
1597    });
1598}
1599
1600// If Public Access mode is set to WhiteList, and Mint Permission is set to false, tokens cannot be created by non-privileged and white listed address.
1601#[test]
1602fn white_list_test_11() {
1603    new_test_ext().execute_with(|| {
1604        let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();
1605        let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();
1606        let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
1607        let mode: CollectionMode = CollectionMode::NFT(2000);
1608
1609        let origin1 = Origin::signed(1);
1610        let origin2 = Origin::signed(2);
1611        assert_ok!(TemplateModule::create_collection(
1612            origin1.clone(),
1613            col_name1.clone(),
1614            col_desc1.clone(),
1615            token_prefix1.clone(),
1616            mode
1617        ));
1618
1619        assert_ok!(TemplateModule::set_public_access_mode(origin1.clone(), 1, AccessMode::WhiteList));
1620        assert_ok!(TemplateModule::set_mint_permission(origin1.clone(), 1, false));
1621        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 2));
1622
1623        assert_noop!(TemplateModule::create_item(
1624            origin2.clone(),
1625            1,
1626            [1, 2, 3].to_vec(),
1627            2
1628        ), "Collection is not in mint mode");
1629    });
1630}
1631
1632// If Public Access mode is set to WhiteList, and Mint Permission is set to false, tokens cannot be created by non-privileged and non-white listed address.
1633#[test]
1634fn white_list_test_12() {
1635    new_test_ext().execute_with(|| {
1636        let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();
1637        let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();
1638        let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
1639        let mode: CollectionMode = CollectionMode::NFT(2000);
1640
1641        let origin1 = Origin::signed(1);
1642        let origin2 = Origin::signed(2);
1643        assert_ok!(TemplateModule::create_collection(
1644            origin1.clone(),
1645            col_name1.clone(),
1646            col_desc1.clone(),
1647            token_prefix1.clone(),
1648            mode
1649        ));
1650
1651        assert_ok!(TemplateModule::set_public_access_mode(origin1.clone(), 1, AccessMode::WhiteList));
1652        assert_ok!(TemplateModule::set_mint_permission(origin1.clone(), 1, false));
1653
1654        assert_noop!(TemplateModule::create_item(
1655            origin2.clone(),
1656            1,
1657            [1, 2, 3].to_vec(),
1658            2
1659        ), "Collection is not in mint mode");
1660    });
1661}
1662
1663// If Public Access mode is set to WhiteList, and Mint Permission is set to true, tokens can be created by owner.
1664#[test]
1665fn white_list_test_13() {
1666    new_test_ext().execute_with(|| {
1667        let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();
1668        let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();
1669        let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
1670        let mode: CollectionMode = CollectionMode::NFT(2000);
1671
1672        let origin1 = Origin::signed(1);
1673        assert_ok!(TemplateModule::create_collection(
1674            origin1.clone(),
1675            col_name1.clone(),
1676            col_desc1.clone(),
1677            token_prefix1.clone(),
1678            mode
1679        ));
1680
1681        assert_ok!(TemplateModule::set_public_access_mode(origin1.clone(), 1, AccessMode::WhiteList));
1682        assert_ok!(TemplateModule::set_mint_permission(origin1.clone(), 1, true));
1683
1684        assert_ok!(TemplateModule::create_item(
1685            origin1.clone(),
1686            1,
1687            [1, 2, 3].to_vec(),
1688            1
1689        ));
1690    });
1691}
1692
1693// If Public Access mode is set to WhiteList, and Mint Permission is set to true, tokens can be created by admin.
1694#[test]
1695fn white_list_test_14() {
1696    new_test_ext().execute_with(|| {
1697        let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();
1698        let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();
1699        let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
1700        let mode: CollectionMode = CollectionMode::NFT(2000);
1701
1702        let origin1 = Origin::signed(1);
1703        let origin2 = Origin::signed(2);
1704        assert_ok!(TemplateModule::create_collection(
1705            origin1.clone(),
1706            col_name1.clone(),
1707            col_desc1.clone(),
1708            token_prefix1.clone(),
1709            mode
1710        ));
1711
1712        assert_ok!(TemplateModule::set_public_access_mode(origin1.clone(), 1, AccessMode::WhiteList));
1713        assert_ok!(TemplateModule::set_mint_permission(origin1.clone(), 1, true));
1714
1715        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), 1, 2));
1716
1717        assert_ok!(TemplateModule::create_item(
1718            origin2.clone(),
1719            1,
1720            [1, 2, 3].to_vec(),
1721            2
1722        ));
1723    });
1724}
1725
1726// If Public Access mode is set to WhiteList, and Mint Permission is set to true, tokens cannot be created by non-privileged and non-white listed address.
1727#[test]
1728fn white_list_test_15() {
1729    new_test_ext().execute_with(|| {
1730        let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();
1731        let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();
1732        let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
1733        let mode: CollectionMode = CollectionMode::NFT(2000);
1734
1735        let origin1 = Origin::signed(1);
1736        let origin2 = Origin::signed(2);
1737        assert_ok!(TemplateModule::create_collection(
1738            origin1.clone(),
1739            col_name1.clone(),
1740            col_desc1.clone(),
1741            token_prefix1.clone(),
1742            mode
1743        ));
1744
1745        assert_ok!(TemplateModule::set_public_access_mode(origin1.clone(), 1, AccessMode::WhiteList));
1746        assert_ok!(TemplateModule::set_mint_permission(origin1.clone(), 1, true));
1747
1748        assert_noop!(TemplateModule::create_item(
1749            origin2.clone(),
1750            1,
1751            [1, 2, 3].to_vec(),
1752            2
1753        ), "Address is not in white list");
1754    });
1755}
1756
1757// If Public Access mode is set to WhiteList, and Mint Permission is set to true, tokens can be created by non-privileged and white listed address.
1758#[test]
1759fn white_list_test_16() {
1760    new_test_ext().execute_with(|| {
1761        let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();
1762        let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();
1763        let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
1764        let mode: CollectionMode = CollectionMode::NFT(2000);
1765
1766        let origin1 = Origin::signed(1);
1767        let origin2 = Origin::signed(2);
1768        assert_ok!(TemplateModule::create_collection(
1769            origin1.clone(),
1770            col_name1.clone(),
1771            col_desc1.clone(),
1772            token_prefix1.clone(),
1773            mode
1774        ));
1775
1776        assert_ok!(TemplateModule::set_public_access_mode(origin1.clone(), 1, AccessMode::WhiteList));
1777        assert_ok!(TemplateModule::set_mint_permission(origin1.clone(), 1, true));
1778        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 2));
1779
1780        assert_ok!(TemplateModule::create_item(
1781            origin2.clone(),
1782            1,
1783            [1, 2, 3].to_vec(),
1784            2
1785        ));
1786    });
1787}
1788
1789// #endregion