make ability to have multiple default endpoints for the network

Signed-off-by: Uncle Stretch <uncle.stretch@ghostchain.io>

pallets/networks/src/tests.rs

@@ -12,7 +12,10 @@ fn prepare_network_data() -> (u32, NetworkData) {
         1u32,
         NetworkData {
             chain_name: "Ethereum".into(),
-            default_endpoint: "https:://some-endpoint.my-server.com/v1/my-super-secret-key".into(),
+            default_endpoints: vec![
+                "https:://some-endpoint.my-server.com/v1/my-super-secret-key".into(),
+                "https:://another-endpoint.my-server.com/v1/my-super-secret-key".into(),
+            ],
             finality_delay: 69,
             rate_limit_delay: 69,
             block_distance: 69,
@@ -113,26 +116,117 @@ fn could_update_network_name_from_authority_account() {
 }
 
 #[test]
-fn could_update_network_endpoint_from_authority_account() {
+fn could_add_network_endpoint_from_authority_account() {
     ExtBuilder::build().execute_with(|| {
-        let new_endpoint = b"https:://google.com".to_vec();
+        let raw_endpoint: Vec<u8> =
+            "https:://new-endpoint.my-server.com/v1/my-super-secret-key".into();
         let (chain_id, network) = prepare_network_data();
         register_and_check_network(chain_id, network.clone());
         assert_ok!(GhostNetworks::update_network_endpoint(
             RuntimeOrigin::signed(UpdaterAccount::get()),
             chain_id,
-            new_endpoint.clone()
+            None,
+            Some(raw_endpoint.clone()),
+        ));
+        System::assert_last_event(RuntimeEvent::GhostNetworks(
+            crate::Event::NetworkEndpointAdded {
+                chain_id,
+                endpoint: raw_endpoint.clone(),
+            },
+        ));
+        let current_network = Networks::<Test>::get(chain_id).unwrap();
+        assert_eq!(
+            current_network.default_endpoints.len(),
+            network.default_endpoints.len() + 1
+        );
+        assert_eq!(
+            current_network
+                .default_endpoints
+                .last()
+                .cloned()
+                .unwrap_or_default(),
+            raw_endpoint
+        );
+        assert_ne!(&network, &current_network);
+    });
+}
+
+#[test]
+fn could_remove_network_endpoint_from_authority_account() {
+    ExtBuilder::build().execute_with(|| {
+        let index_to_remove = 0u32;
+        let (chain_id, network) = prepare_network_data();
+        register_and_check_network(chain_id, network.clone());
+        assert_ok!(GhostNetworks::update_network_endpoint(
+            RuntimeOrigin::signed(UpdaterAccount::get()),
+            chain_id,
+            Some(index_to_remove),
+            None,
+        ));
+        System::assert_last_event(RuntimeEvent::GhostNetworks(
+            crate::Event::NetworkEndpointRemoved {
+                chain_id,
+                index: index_to_remove,
+            },
+        ));
+        let current_network = Networks::<Test>::get(chain_id).unwrap();
+        assert_eq!(
+            current_network.default_endpoints.len(),
+            network.default_endpoints.len() - 1
+        );
+        assert_ne!(
+            current_network
+                .default_endpoints
+                .get(index_to_remove as usize),
+            network.default_endpoints.get(index_to_remove as usize)
+        );
+        assert_ne!(&network, &current_network);
+    });
+}
+
+#[test]
+fn could_update_network_endpoint_from_authority_account() {
+    ExtBuilder::build().execute_with(|| {
+        let index_to_update = 0u32;
+        let raw_endpoint: Vec<u8> =
+            "https:://new-endpoint.my-server.com/v1/my-super-secret-key".into();
+        let (chain_id, network) = prepare_network_data();
+        register_and_check_network(chain_id, network.clone());
+        assert_ok!(GhostNetworks::update_network_endpoint(
+            RuntimeOrigin::signed(UpdaterAccount::get()),
+            chain_id,
+            Some(index_to_update),
+            Some(raw_endpoint.clone()),
         ));
         System::assert_last_event(RuntimeEvent::GhostNetworks(
             crate::Event::NetworkEndpointUpdated {
                 chain_id,
-                default_endpoint: new_endpoint.clone(),
+                index: index_to_update,
+                endpoint: raw_endpoint.clone(),
             },
         ));
+        let previous_endpoints_len = network.default_endpoints.len();
         let mut final_network = network.clone();
-        final_network.default_endpoint = new_endpoint;
-        assert_eq!(Networks::<Test>::get(chain_id), Some(final_network.clone()));
-        assert_ne!(network, final_network);
+        if let Some(endpoint_by_index) = final_network
+            .default_endpoints
+            .get_mut(index_to_update as usize)
+        {
+            *endpoint_by_index = raw_endpoint.clone();
+        }
+        let current_network = Networks::<Test>::get(chain_id).unwrap();
+        assert_eq!(
+            current_network.default_endpoints.len(),
+            previous_endpoints_len
+        );
+        assert_eq!(
+            current_network
+                .default_endpoints
+                .get(index_to_update as usize)
+                .cloned()
+                .unwrap_or_default(),
+            raw_endpoint
+        );
+        assert_ne!(&network, &final_network);
     });
 }
 
@@ -365,13 +459,17 @@ fn could_not_update_network_name_from_random_account() {
 #[test]
 fn could_not_update_network_endpoint_from_random_account() {
     ExtBuilder::build().execute_with(|| {
+        let index_to_update = 0u32;
+        let raw_endpoint: Vec<u8> =
+            "https:://new-endpoint.my-server.com/v1/my-super-secret-key".into();
         let (chain_id, network) = prepare_network_data();
         register_and_check_network(chain_id, network.clone());
         assert_err!(
             GhostNetworks::update_network_endpoint(
                 RuntimeOrigin::signed(RegistererAccount::get()),
                 chain_id,
-                "https:://google.com".into()
+                Some(index_to_update),
+                Some(raw_endpoint.clone()),
             ),
             DispatchError::BadOrigin
         );
@@ -379,7 +477,8 @@ fn could_not_update_network_endpoint_from_random_account() {
             GhostNetworks::update_network_endpoint(
                 RuntimeOrigin::signed(RemoverAccount::get()),
                 chain_id,
-                "https:://google.com".into()
+                Some(index_to_update),
+                Some(raw_endpoint.clone()),
             ),
             DispatchError::BadOrigin
         );
@@ -387,7 +486,83 @@ fn could_not_update_network_endpoint_from_random_account() {
             GhostNetworks::update_network_endpoint(
                 RuntimeOrigin::signed(RandomAccount::get()),
                 chain_id,
-                "https:://google.com".into()
+                Some(index_to_update),
+                Some(raw_endpoint.clone()),
+            ),
+            DispatchError::BadOrigin
+        );
+        assert_eq!(Networks::<Test>::get(chain_id), Some(network));
+    });
+}
+
+#[test]
+fn could_not_add_network_endpoint_from_random_account() {
+    ExtBuilder::build().execute_with(|| {
+        let raw_endpoint: Vec<u8> =
+            "https:://new-endpoint.my-server.com/v1/my-super-secret-key".into();
+        let (chain_id, network) = prepare_network_data();
+        register_and_check_network(chain_id, network.clone());
+        assert_err!(
+            GhostNetworks::update_network_endpoint(
+                RuntimeOrigin::signed(RegistererAccount::get()),
+                chain_id,
+                None,
+                Some(raw_endpoint.clone()),
+            ),
+            DispatchError::BadOrigin
+        );
+        assert_err!(
+            GhostNetworks::update_network_endpoint(
+                RuntimeOrigin::signed(RemoverAccount::get()),
+                chain_id,
+                None,
+                Some(raw_endpoint.clone()),
+            ),
+            DispatchError::BadOrigin
+        );
+        assert_err!(
+            GhostNetworks::update_network_endpoint(
+                RuntimeOrigin::signed(RandomAccount::get()),
+                chain_id,
+                None,
+                Some(raw_endpoint.clone()),
+            ),
+            DispatchError::BadOrigin
+        );
+        assert_eq!(Networks::<Test>::get(chain_id), Some(network));
+    });
+}
+
+#[test]
+fn could_not_remove_network_endpoint_from_random_account() {
+    ExtBuilder::build().execute_with(|| {
+        let index_to_remove = 0u32;
+        let (chain_id, network) = prepare_network_data();
+        register_and_check_network(chain_id, network.clone());
+        assert_err!(
+            GhostNetworks::update_network_endpoint(
+                RuntimeOrigin::signed(RegistererAccount::get()),
+                chain_id,
+                Some(index_to_remove),
+                None,
+            ),
+            DispatchError::BadOrigin
+        );
+        assert_err!(
+            GhostNetworks::update_network_endpoint(
+                RuntimeOrigin::signed(RemoverAccount::get()),
+                chain_id,
+                Some(index_to_remove),
+                None,
+            ),
+            DispatchError::BadOrigin
+        );
+        assert_err!(
+            GhostNetworks::update_network_endpoint(
+                RuntimeOrigin::signed(RandomAccount::get()),
+                chain_id,
+                Some(index_to_remove),
+                None,
             ),
             DispatchError::BadOrigin
         );
@@ -688,7 +863,44 @@ fn could_not_update_endpoint_for_non_existent_network() {
             GhostNetworks::update_network_endpoint(
                 RuntimeOrigin::signed(UpdaterAccount::get()),
                 chain_id,
-                "https:://google.com".into()
+                Some(0u32),
+                Some("https:://new-endpoint.my-server.com/v1/my-super-secret-key".into()),
+            ),
+            crate::Error::<Test>::NetworkDoesNotExist
+        );
+        assert_eq!(Networks::<Test>::get(chain_id), None);
+    });
+}
+
+#[test]
+fn could_not_add_endpoint_for_non_existent_network() {
+    ExtBuilder::build().execute_with(|| {
+        let chain_id: u32 = 1;
+        assert_eq!(Networks::<Test>::get(chain_id), None);
+        assert_err!(
+            GhostNetworks::update_network_endpoint(
+                RuntimeOrigin::signed(UpdaterAccount::get()),
+                chain_id,
+                None,
+                Some("https:://new-endpoint.my-server.com/v1/my-super-secret-key".into()),
+            ),
+            crate::Error::<Test>::NetworkDoesNotExist
+        );
+        assert_eq!(Networks::<Test>::get(chain_id), None);
+    });
+}
+
+#[test]
+fn could_not_remove_endpoint_for_non_existent_network() {
+    ExtBuilder::build().execute_with(|| {
+        let chain_id: u32 = 1;
+        assert_eq!(Networks::<Test>::get(chain_id), None);
+        assert_err!(
+            GhostNetworks::update_network_endpoint(
+                RuntimeOrigin::signed(UpdaterAccount::get()),
+                chain_id,
+                Some(0u32),
+                None,
             ),
             crate::Error::<Test>::NetworkDoesNotExist
         );