Merge pull request #1209 from rainlanguage/2025-01-22-gui-parse-metho…

…ds-error-cases

Adding error cases for non-hash values on gui parse methods

crates/settings/src/deployer.rs

@@ -59,6 +59,10 @@ impl Deployer {
                     return require_string(deployer_yaml, Some("network"), None)
                         .or_else(|_| Ok(deployer_key.to_string()));
                 }
+            } else {
+                return Err(YamlError::ParseError(
+                    "deployers field must be a map".to_string(),
+                ));
             }
         }
         Err(YamlError::ParseError(format!(
@@ -333,4 +337,60 @@ deployers:
         let network_key = Deployer::parse_network_key(documents, "mainnet").unwrap();
         assert_eq!(network_key, "mainnet");
     }
+
+    #[test]
+    fn test_parse_network_key() {
+        let yaml = r#"
+networks:
+    mainnet:
+        rpc: https://rpc.com
+        chain-id: 1
+deployers: test
+"#;
+        let error = Deployer::parse_network_key(vec![get_document(yaml)], "mainnet").unwrap_err();
+        assert_eq!(
+            error,
+            YamlError::ParseError("deployers field must be a map".to_string())
+        );
+
+        let yaml = r#"
+networks:
+    mainnet:
+        rpc: https://rpc.com
+        chain-id: 1
+deployers:
+  - test
+"#;
+        let error = Deployer::parse_network_key(vec![get_document(yaml)], "mainnet").unwrap_err();
+        assert_eq!(
+            error,
+            YamlError::ParseError("deployers field must be a map".to_string())
+        );
+
+        let yaml = r#"
+networks:
+    mainnet:
+        rpc: https://rpc.com
+        chain-id: 1
+deployers:
+  - test: test
+"#;
+        let error = Deployer::parse_network_key(vec![get_document(yaml)], "mainnet").unwrap_err();
+        assert_eq!(
+            error,
+            YamlError::ParseError("deployers field must be a map".to_string())
+        );
+
+        let yaml = r#"
+networks:
+    mainnet:
+        rpc: https://rpc.com
+        chain-id: 1
+deployers:
+  mainnet:
+    address: 0x1234567890123456789012345678901234567890
+"#;
+        let res = Deployer::parse_network_key(vec![get_document(yaml)], "mainnet").unwrap();
+        assert_eq!(res, "mainnet");
+    }
 }

crates/settings/src/deployment.rs

@@ -45,6 +45,10 @@ impl Deployment {
                 {
                     return require_string(deployment_yaml, Some("order"), None);
                 }
+            } else {
+                return Err(YamlError::ParseError(
+                    "deployments field must be a map".to_string(),
+                ));
             }
         }
         Err(YamlError::ParseError(format!(
@@ -520,4 +524,48 @@ deployments:
             YamlError::KeyShadowing("DuplicateDeployment".to_string())
         );
     }
+
+    #[test]
+    fn test_parse_order_key() {
+        let yaml = r#"
+deployments: test
+"#;
+        let error =
+            Deployment::parse_order_key(vec![get_document(yaml)], "deployment1").unwrap_err();
+        assert_eq!(
+            error,
+            YamlError::ParseError("deployments field must be a map".to_string())
+        );
+
+        let yaml = r#"
+deployments:
+  - test
+"#;
+        let error =
+            Deployment::parse_order_key(vec![get_document(yaml)], "deployment1").unwrap_err();
+        assert_eq!(
+            error,
+            YamlError::ParseError("deployments field must be a map".to_string())
+        );
+
+        let yaml = r#"
+deployments:
+  - test: test
+"#;
+        let error =
+            Deployment::parse_order_key(vec![get_document(yaml)], "deployment1").unwrap_err();
+        assert_eq!(
+            error,
+            YamlError::ParseError("deployments field must be a map".to_string())
+        );
+
+        let yaml = r#"
+deployments:
+  deployment1:
+    order: order1
+    scenario: scenario1
+"#;
+        let res = Deployment::parse_order_key(vec![get_document(yaml)], "deployment1").unwrap();
+        assert_eq!(res, "order1");
+    }
 }

crates/settings/src/gui.rs

@@ -280,6 +280,10 @@ impl Gui {
                             deployment_keys.push(key.clone());
                         }
                     }
+                } else {
+                    return Err(YamlError::ParseError(
+                        "deployments field must be a map in gui".to_string(),
+                    ));
                 }
             }
         }
@@ -1517,4 +1521,127 @@ gui:
 
         assert_eq!(error, YamlError::KeyShadowing("deployment1".to_string()));
     }
+
+    #[test]
+    fn test_parse_deployment_keys() {
+        let yaml = r#"
+networks:
+    network1:
+        rpc: https://eth.llamarpc.com
+        chain-id: 1
+tokens:
+    token1:
+        address: 0x0000000000000000000000000000000000000001
+        network: network1
+    token2:
+        address: 0x0000000000000000000000000000000000000002
+        network: network1
+gui:
+    name: test
+    description: test
+"#;
+
+        let error = Gui::parse_deployment_keys(vec![get_document(yaml)]).unwrap_err();
+        assert_eq!(
+            error,
+            YamlError::ParseError("deployments field missing in gui".to_string())
+        );
+
+        let yaml = r#"
+networks:
+    network1:
+        rpc: https://eth.llamarpc.com
+        chain-id: 1
+tokens:
+    token1:
+        address: 0x0000000000000000000000000000000000000001
+        network: network1
+    token2:
+        address: 0x0000000000000000000000000000000000000002
+        network: network1
+gui:
+    name: test
+    description: test
+    deployments: test
+"#;
+
+        let error = Gui::parse_deployment_keys(vec![get_document(yaml)]).unwrap_err();
+        assert_eq!(
+            error,
+            YamlError::ParseError("deployments field must be a map in gui".to_string())
+        );
+
+        let yaml = r#"
+networks:
+    network1:
+        rpc: https://eth.llamarpc.com
+        chain-id: 1
+tokens:
+    token1:
+        address: 0x0000000000000000000000000000000000000001
+        network: network1
+    token2:
+        address: 0x0000000000000000000000000000000000000002
+        network: network1
+gui:
+    name: test
+    description: test
+    deployments:
+      - test
+"#;
+
+        let error = Gui::parse_deployment_keys(vec![get_document(yaml)]).unwrap_err();
+        assert_eq!(
+            error,
+            YamlError::ParseError("deployments field must be a map in gui".to_string())
+        );
+
+        let yaml = r#"
+networks:
+    network1:
+        rpc: https://eth.llamarpc.com
+        chain-id: 1
+tokens:
+    token1:
+        address: 0x0000000000000000000000000000000000000001
+        network: network1
+    token2:
+        address: 0x0000000000000000000000000000000000000002
+        network: network1
+gui:
+    name: test
+    description: test
+    deployments:
+      - test: test
+"#;
+
+        let error = Gui::parse_deployment_keys(vec![get_document(yaml)]).unwrap_err();
+        assert_eq!(
+            error,
+            YamlError::ParseError("deployments field must be a map in gui".to_string())
+        );
+
+        let yaml = r#"
+networks:
+    network1:
+        rpc: https://eth.llamarpc.com
+        chain-id: 1
+tokens:
+    token1:
+        address: 0x0000000000000000000000000000000000000001
+        network: network1
+    token2:
+        address: 0x0000000000000000000000000000000000000002
+        network: network1
+gui:
+    name: test
+    description: test
+    deployments:
+      test: test
+      test2: test2
+"#;
+
+        let keys = Gui::parse_deployment_keys(vec![get_document(yaml)]).unwrap();
+        assert_eq!(keys, vec!["test".to_string(), "test2".to_string()]);
+    }
 }

crates/settings/src/network.rs

@@ -113,6 +113,10 @@ impl Network {
                         None,
                     )?)?);
                 }
+            } else {
+                return Err(YamlError::ParseError(
+                    "networks field must be a map".to_string(),
+                ));
             }
         }
         Err(YamlError::ParseError(format!(
@@ -357,4 +361,45 @@ networks:
         .unwrap_err();
         assert_eq!(error, YamlError::KeyShadowing("mainnet".to_string()));
     }
+
+    #[test]
+    fn test_parse_network_key() {
+        let yaml = r#"
+networks: test
+"#;
+        let error = Network::parse_rpc(vec![get_document(yaml)], "mainnet").unwrap_err();
+        assert_eq!(
+            error,
+            YamlError::ParseError("networks field must be a map".to_string())
+        );
+
+        let yaml = r#"
+networks:
+  - test
+"#;
+        let error = Network::parse_rpc(vec![get_document(yaml)], "mainnet").unwrap_err();
+        assert_eq!(
+            error,
+            YamlError::ParseError("networks field must be a map".to_string())
+        );
+
+        let yaml = r#"
+networks:
+  - test: test
+"#;
+        let error = Network::parse_rpc(vec![get_document(yaml)], "mainnet").unwrap_err();
+        assert_eq!(
+            error,
+            YamlError::ParseError("networks field must be a map".to_string())
+        );
+
+        let yaml = r#"
+networks:
+  mainnet:
+    rpc: https://rpc.com
+    chain-id: 1
+"#;
+        let res = Network::parse_rpc(vec![get_document(yaml)], "mainnet").unwrap();
+        assert_eq!(res, Url::parse("https://rpc.com").unwrap());
+    }
 }

crates/settings/src/order.rs

@@ -295,6 +295,10 @@ impl Order {
                         }
                     }
                 }
+            } else {
+                return Err(YamlError::ParseError(
+                    "orders field must be a map".to_string(),
+                ));
             }
         }
 
@@ -1014,4 +1018,36 @@ orders:
 
         assert_eq!(error, YamlError::KeyShadowing("DuplicateOrder".to_string()));
     }
+
+    #[test]
+    fn parse_network_key() {
+        let yaml = r#"
+orders: test
+"#;
+        let error = Order::parse_network_key(vec![get_document(yaml)], "order1").unwrap_err();
+        assert_eq!(
+            error,
+            YamlError::ParseError("orders field must be a map".to_string())
+        );
+
+        let yaml = r#"
+orders:
+  - test
+"#;
+        let error = Order::parse_network_key(vec![get_document(yaml)], "order1").unwrap_err();
+        assert_eq!(
+            error,
+            YamlError::ParseError("orders field must be a map".to_string())
+        );
+
+        let yaml = r#"
+orders:
+  - test: test
+"#;
+        let error = Order::parse_network_key(vec![get_document(yaml)], "order1").unwrap_err();
+        assert_eq!(
+            error,
+            YamlError::ParseError("orders field must be a map".to_string())
+        );
+    }
 }