chore: renamed and reorganized tests of shared node, resources and types

crates/configuration/src/shared/node.rs

@@ -525,7 +525,7 @@ mod tests {
         assert_eq!(node_name, "node");
         assert_eq!(errors.len(), 1);
         assert_eq!(
-            errors.first().unwrap().to_string(),
+            errors.get(0).unwrap().to_string(),
             "command: 'invalid command' shouldn't contains whitespace"
         );
     }
@@ -541,7 +541,7 @@ mod tests {
         assert_eq!(node_name, "node");
         assert_eq!(errors.len(), 1);
         assert_eq!(
-            errors.first().unwrap().to_string(),
+            errors.get(0).unwrap().to_string(),
             "image: 'myinvalid.image' doesn't match regex '^([ip]|[hostname]/)?[tag_name]:[tag_version]?$'"
         );
     }
@@ -558,13 +558,13 @@ mod tests {
         assert_eq!(node_name, "node");
         assert_eq!(errors.len(), 1);
         assert_eq!(
-            errors.first().unwrap().to_string(),
+            errors.get(0).unwrap().to_string(),
             "bootnodes_addresses[0]: '/ip4//tcp/45421' failed to parse: invalid IPv4 address syntax"
         );
     }
 
     #[test]
-    fn node_config_builder_should_returns_errors_and_node_name_if_multiple_bootnode_address_are_invalid(
+    fn node_config_builder_should_returns_mulitle_errors_and_node_name_if_multiple_bootnode_address_are_invalid(
     ) {
         let (node_name, errors) = NodeConfigBuilder::new(None)
             .with_name("node")
@@ -574,14 +574,12 @@ mod tests {
 
         assert_eq!(node_name, "node");
         assert_eq!(errors.len(), 2);
-        // first error
         assert_eq!(
-            errors.first().unwrap().to_string(),
+            errors.get(0).unwrap().to_string(),
             "bootnodes_addresses[0]: '/ip4//tcp/45421' failed to parse: invalid IPv4 address syntax"
         );
-        // second error
         assert_eq!(
-            errors.last().unwrap().to_string(),
+            errors.get(1).unwrap().to_string(),
             "bootnodes_addresses[1]: '//10.42.153.10/tcp/43111' unknown protocol string: "
         );
     }
@@ -597,13 +595,14 @@ mod tests {
         assert_eq!(node_name, "node");
         assert_eq!(errors.len(), 1);
         assert_eq!(
-            errors.first().unwrap().to_string(),
+            errors.get(0).unwrap().to_string(),
             r"resources.limit_cpu: 'invalid' doesn't match regex '^\d+(.\d+)?(m|K|M|G|T|P|E|Ki|Mi|Gi|Ti|Pi|Ei)?$'"
         );
     }
 
     #[test]
-    fn node_config_builder_should_returns_errors_and_node_name_if_resources_has_multiple_errors() {
+    fn node_config_builder_should_returns_multiple_errors_and_node_name_if_resources_has_multiple_errors(
+    ) {
         let (node_name, errors) = NodeConfigBuilder::new(None)
             .with_name("node")
             .with_resources(|resources| {
@@ -617,11 +616,46 @@ mod tests {
         assert_eq!(node_name, "node");
         assert_eq!(errors.len(), 2);
         assert_eq!(
-            errors.first().unwrap().to_string(),
+            errors.get(0).unwrap().to_string(),
+            r"resources.limit_cpu: 'invalid' doesn't match regex '^\d+(.\d+)?(m|K|M|G|T|P|E|Ki|Mi|Gi|Ti|Pi|Ei)?$'"
+        );
+        assert_eq!(
+            errors.get(1).unwrap().to_string(),
+            r"resources.request_memory: 'invalid' doesn't match regex '^\d+(.\d+)?(m|K|M|G|T|P|E|Ki|Mi|Gi|Ti|Pi|Ei)?$'"
+        );
+    }
+
+    #[test]
+    fn node_config_builder_should_returns_multiple_errors_and_node_name_if_multiple_fields_have_errors(
+    ) {
+        let (node_name, errors) = NodeConfigBuilder::new(None)
+            .with_name("node")
+            .with_command("invalid command")
+            .with_image("myinvalid.image")
+            .with_resources(|resources| {
+                resources
+                    .with_limit_cpu("invalid")
+                    .with_request_memory("invalid")
+            })
+            .build()
+            .unwrap_err();
+
+        assert_eq!(node_name, "node");
+        assert_eq!(errors.len(), 4);
+        assert_eq!(
+            errors.get(0).unwrap().to_string(),
+            "command: 'invalid command' shouldn't contains whitespace"
+        );
+        assert_eq!(
+            errors.get(1).unwrap().to_string(),
+            "image: 'myinvalid.image' doesn't match regex '^([ip]|[hostname]/)?[tag_name]:[tag_version]?$'"
+        );
+        assert_eq!(
+            errors.get(2).unwrap().to_string(),
             r"resources.limit_cpu: 'invalid' doesn't match regex '^\d+(.\d+)?(m|K|M|G|T|P|E|Ki|Mi|Gi|Ti|Pi|Ei)?$'"
         );
         assert_eq!(
-            errors.last().unwrap().to_string(),
+            errors.get(3).unwrap().to_string(),
             r"resources.request_memory: 'invalid' doesn't match regex '^\d+(.\d+)?(m|K|M|G|T|P|E|Ki|Mi|Gi|Ti|Pi|Ei)?$'"
         );
     }

crates/configuration/src/shared/resources.rs

@@ -178,7 +178,7 @@ impl ResourcesBuilder {
 mod tests {
     use super::*;
 
-    macro_rules! resources_quantity_unit_test_impl {
+    macro_rules! impl_resources_quantity_unit_test {
         ($val:literal) => {{
             let resources = ResourcesBuilder::new()
                 .with_request_memory($val)
@@ -193,77 +193,77 @@ mod tests {
     }
 
     #[test]
-    fn we_should_be_able_to_convert_a_string_a_resource_quantity_without_unit() {
-        resources_quantity_unit_test_impl!("1000");
+    fn converting_a_string_a_resource_quantity_without_unit_should_succeeds() {
+        impl_resources_quantity_unit_test!("1000");
     }
 
     #[test]
-    fn we_should_be_able_to_convert_a_str_with_m_unit_into_a_resource_quantity() {
-        resources_quantity_unit_test_impl!("100m");
+    fn converting_a_str_with_m_unit_into_a_resource_quantity_should_succeeds() {
+        impl_resources_quantity_unit_test!("100m");
     }
 
     #[test]
-    fn we_should_be_able_to_convert_a_str_with_K_unit_into_a_resource_quantity() {
-        resources_quantity_unit_test_impl!("50K");
+    fn converting_a_str_with_K_unit_into_a_resource_quantity_should_succeeds() {
+        impl_resources_quantity_unit_test!("50K");
     }
 
     #[test]
-    fn we_should_be_able_to_convert_a_str_with_M_unit_into_a_resource_quantity() {
-        resources_quantity_unit_test_impl!("100M");
+    fn converting_a_str_with_M_unit_into_a_resource_quantity_should_succeeds() {
+        impl_resources_quantity_unit_test!("100M");
     }
 
     #[test]
-    fn we_should_be_able_to_convert_a_str_with_G_unit_into_a_resource_quantity() {
-        resources_quantity_unit_test_impl!("1G");
+    fn converting_a_str_with_G_unit_into_a_resource_quantity_should_succeeds() {
+        impl_resources_quantity_unit_test!("1G");
     }
 
     #[test]
-    fn we_should_be_able_to_convert_a_str_with_T_unit_into_a_resource_quantity() {
-        resources_quantity_unit_test_impl!("0.01T");
+    fn converting_a_str_with_T_unit_into_a_resource_quantity_should_succeeds() {
+        impl_resources_quantity_unit_test!("0.01T");
     }
 
     #[test]
-    fn we_should_be_able_to_convert_a_str_with_P_unit_into_a_resource_quantity() {
-        resources_quantity_unit_test_impl!("0.00001P");
+    fn converting_a_str_with_P_unit_into_a_resource_quantity_should_succeeds() {
+        impl_resources_quantity_unit_test!("0.00001P");
     }
 
     #[test]
-    fn we_should_be_able_to_convert_a_str_with_E_unit_into_a_resource_quantity() {
-        resources_quantity_unit_test_impl!("0.000000001E");
+    fn converting_a_str_with_E_unit_into_a_resource_quantity_should_succeeds() {
+        impl_resources_quantity_unit_test!("0.000000001E");
     }
 
     #[test]
-    fn we_should_be_able_to_convert_a_str_with_Ki_unit_into_a_resource_quantity() {
-        resources_quantity_unit_test_impl!("50Ki");
+    fn converting_a_str_with_Ki_unit_into_a_resource_quantity_should_succeeds() {
+        impl_resources_quantity_unit_test!("50Ki");
     }
 
     #[test]
-    fn we_should_be_able_to_convert_a_str_with_Mi_unit_into_a_resource_quantity() {
-        resources_quantity_unit_test_impl!("100Mi");
+    fn converting_a_str_with_Mi_unit_into_a_resource_quantity_should_succeeds() {
+        impl_resources_quantity_unit_test!("100Mi");
     }
 
     #[test]
-    fn we_should_be_able_to_convert_a_str_with_Gi_unit_into_a_resource_quantity() {
-        resources_quantity_unit_test_impl!("1Gi");
+    fn converting_a_str_with_Gi_unit_into_a_resource_quantity_should_succeeds() {
+        impl_resources_quantity_unit_test!("1Gi");
     }
 
     #[test]
-    fn we_should_be_able_to_convert_a_str_with_Ti_unit_into_a_resource_quantity() {
-        resources_quantity_unit_test_impl!("0.01Ti");
+    fn converting_a_str_with_Ti_unit_into_a_resource_quantity_should_succeeds() {
+        impl_resources_quantity_unit_test!("0.01Ti");
     }
 
     #[test]
-    fn we_should_be_able_to_convert_a_str_with_Pi_unit_into_a_resource_quantity() {
-        resources_quantity_unit_test_impl!("0.00001Pi");
+    fn converting_a_str_with_Pi_unit_into_a_resource_quantity_should_succeeds() {
+        impl_resources_quantity_unit_test!("0.00001Pi");
     }
 
     #[test]
-    fn we_should_be_able_to_convert_a_str_with_Ei_unit_into_a_resource_quantity() {
-        resources_quantity_unit_test_impl!("0.000000001Ei");
+    fn converting_a_str_with_Ei_unit_into_a_resource_quantity_should_succeeds() {
+        impl_resources_quantity_unit_test!("0.000000001Ei");
     }
 
     #[test]
-    fn resources_config_builder_should_returns_a_resources_config_correctly() {
+    fn resources_config_builder_should_succeeds_and_returns_a_resources_config() {
         let resources = ResourcesBuilder::new()
             .with_request_memory("200M")
             .with_request_cpu("1G")
@@ -279,54 +279,73 @@ mod tests {
     }
 
     #[test]
-    fn resources_config_builder_should_returns_an_error_if_couldnt_parse_request_memory() {
+    fn resources_config_builder_should_fails_and_returns_an_error_if_couldnt_parse_request_memory() {
         let resources_builder = ResourcesBuilder::new().with_request_memory("invalid");
 
-        let got = resources_builder.build().err().unwrap();
+        let errors = resources_builder.build().err().unwrap();
 
-        assert_eq!(got.len(), 1);
+        assert_eq!(errors.len(), 1);
         assert_eq!(
-            got.first().unwrap().to_string(),
+            errors.get(0).unwrap().to_string(),
             r"request_memory: 'invalid' doesn't match regex '^\d+(.\d+)?(m|K|M|G|T|P|E|Ki|Mi|Gi|Ti|Pi|Ei)?$'"
         );
     }
 
     #[test]
-    fn resources_config_builder_should_returns_an_error_if_couldnt_parse_request_cpu() {
+    fn resources_config_builder_should_fails_and_returns_an_error_if_couldnt_parse_request_cpu() {
         let resources_builder = ResourcesBuilder::new().with_request_cpu("invalid");
 
-        let got = resources_builder.build().err().unwrap();
+        let errors = resources_builder.build().err().unwrap();
 
-        assert_eq!(got.len(), 1);
+        assert_eq!(errors.len(), 1);
         assert_eq!(
-            got.first().unwrap().to_string(),
+            errors.get(0).unwrap().to_string(),
             r"request_cpu: 'invalid' doesn't match regex '^\d+(.\d+)?(m|K|M|G|T|P|E|Ki|Mi|Gi|Ti|Pi|Ei)?$'"
         );
     }
 
     #[test]
-    fn resources_config_builder_should_returns_an_error_if_couldnt_parse_limit_memory() {
+    fn resources_config_builder_should_fails_and_returns_an_error_if_couldnt_parse_limit_memory() {
         let resources_builder = ResourcesBuilder::new().with_limit_memory("invalid");
 
-        let got = resources_builder.build().err().unwrap();
+        let errors = resources_builder.build().err().unwrap();
 
-        assert_eq!(got.len(), 1);
+        assert_eq!(errors.len(), 1);
         assert_eq!(
-            got.first().unwrap().to_string(),
+            errors.get(0).unwrap().to_string(),
             r"limit_memory: 'invalid' doesn't match regex '^\d+(.\d+)?(m|K|M|G|T|P|E|Ki|Mi|Gi|Ti|Pi|Ei)?$'"
         );
     }
 
     #[test]
-    fn resources_config_builder_should_returns_an_error_if_couldnt_parse_limit_cpu() {
+    fn resources_config_builder_should_fails_and_returns_an_error_if_couldnt_parse_limit_cpu() {
         let resources_builder = ResourcesBuilder::new().with_limit_cpu("invalid");
 
-        let got = resources_builder.build().err().unwrap();
+        let errors = resources_builder.build().err().unwrap();
 
-        assert_eq!(got.len(), 1);
+        assert_eq!(errors.len(), 1);
         assert_eq!(
-            got.first().unwrap().to_string(),
+            errors.get(0).unwrap().to_string(),
             r"limit_cpu: 'invalid' doesn't match regex '^\d+(.\d+)?(m|K|M|G|T|P|E|Ki|Mi|Gi|Ti|Pi|Ei)?$'"
         );
     }
+
+    #[test]
+    fn resources_config_builder_should_fails_and_returns_multiple_error_if_couldnt_parse_multiple_fields() {
+        let resources_builder = ResourcesBuilder::new()
+            .with_limit_cpu("invalid")
+            .with_request_memory("invalid");
+
+        let errors = resources_builder.build().err().unwrap();
+
+        assert_eq!(errors.len(), 2);
+        assert_eq!(
+            errors.get(0).unwrap().to_string(),
+            r"limit_cpu: 'invalid' doesn't match regex '^\d+(.\d+)?(m|K|M|G|T|P|E|Ki|Mi|Gi|Ti|Pi|Ei)?$'"
+        );
+        assert_eq!(
+            errors.get(1).unwrap().to_string(),
+            r"request_memory: 'invalid' doesn't match regex '^\d+(.\d+)?(m|K|M|G|T|P|E|Ki|Mi|Gi|Ti|Pi|Ei)?$'"
+        );
+    }
 }

crates/configuration/src/shared/types.rs

@@ -144,49 +144,35 @@ mod tests {
     use super::*;
 
     #[test]
-    fn we_should_be_able_to_convert_a_str_without_whitespaces_into_a_chain() {
+    fn converting_a_str_without_whitespaces_into_a_chain_should_succeeds() {
         let got: Result<Chain, ConversionError> = "mychain".try_into();
 
         assert_eq!(got.unwrap().as_str(), "mychain");
     }
 
     #[test]
-    fn we_shouldnt_be_able_to_convert_a_str_with_whitespaces_into_a_chain() {
-        let got: Result<Chain, ConversionError> = "my chain".try_into();
-
-        assert!(matches!(
-            got.clone().unwrap_err(),
-            ConversionError::ContainsWhitespaces(_)
-        ));
-        assert_eq!(
-            got.unwrap_err().to_string(),
-            "'my chain' shouldn't contains whitespace"
-        );
-    }
-
-    #[test]
-    fn we_should_be_able_to_convert_a_str_containing_tag_name_into_an_image() {
+    fn converting_a_str_containing_tag_name_into_an_image_should_succeeds() {
         let got: Result<Image, ConversionError> = "myimage".try_into();
 
         assert_eq!(got.unwrap().as_str(), "myimage");
     }
 
     #[test]
-    fn we_should_be_able_to_convert_a_str_containing_tag_name_and_tag_version_into_an_image() {
+    fn converting_a_str_containing_tag_name_and_tag_version_into_an_image_should_succeeds() {
         let got: Result<Image, ConversionError> = "myimage:version".try_into();
 
         assert_eq!(got.unwrap().as_str(), "myimage:version");
     }
 
     #[test]
-    fn we_should_be_able_to_convert_a_str_containing_hostname_and_tag_name_into_an_image() {
+    fn converting_a_str_containing_hostname_and_tag_name_into_an_image_should_succeeds() {
         let got: Result<Image, ConversionError> = "myrepository.com/myimage".try_into();
 
         assert_eq!(got.unwrap().as_str(), "myrepository.com/myimage");
     }
 
     #[test]
-    fn we_should_be_able_to_convert_a_str_containing_hostname_tag_name_and_tag_version_into_an_image(
+    fn converting_a_str_containing_hostname_tag_name_and_tag_version_into_an_image_should_succeeds(
     ) {
         let got: Result<Image, ConversionError> = "myrepository.com/myimage:version".try_into();
 
@@ -194,21 +180,92 @@ mod tests {
     }
 
     #[test]
-    fn we_should_be_able_to_convert_a_str_containing_ip_and_tag_name_into_an_image() {
+    fn converting_a_str_containing_ip_and_tag_name_into_an_image_should_succeeds() {
         let got: Result<Image, ConversionError> = "myrepository.com/myimage".try_into();
 
         assert_eq!(got.unwrap().as_str(), "myrepository.com/myimage");
     }
 
     #[test]
-    fn we_should_be_able_to_convert_a_str_containing_ip_tag_name_and_tag_version_into_an_image() {
+    fn converting_a_str_containing_ip_tag_name_and_tag_version_into_an_image_should_succeeds(
+    ) {
         let got: Result<Image, ConversionError> = "127.0.0.1/myimage:version".try_into();
 
         assert_eq!(got.unwrap().as_str(), "127.0.0.1/myimage:version");
     }
 
     #[test]
-    fn we_shouldnt_be_able_to_convert_a_str_containing_only_ip_into_an_image() {
+    fn converting_a_str_without_whitespaces_into_a_command_should_succeeds() {
+        let got: Result<Command, ConversionError> = "mycommand".try_into();
+
+        assert_eq!(got.unwrap().as_str(), "mycommand");
+    }
+
+    #[test]
+    fn converting_an_url_into_an_asset_location_should_succeeds() {
+        let url = Url::from_str("https://mycloudstorage.com/path/to/my/file.tgz").unwrap();
+        let got: AssetLocation = url.clone().into();
+
+        assert!(matches!(got, AssetLocation::Url(value) if value == url));
+    }
+
+    #[test]
+    fn converting_a_pathbuf_into_an_asset_location_should_succeeds() {
+        let pathbuf = PathBuf::from_str("/tmp/path/to/my/file").unwrap();
+        let got: AssetLocation = pathbuf.clone().into();
+
+        assert!(matches!(got, AssetLocation::FilePath(value) if value == pathbuf));
+    }
+
+    #[test]
+    fn converting_a_str_into_an_url_asset_location_should_succeeds() {
+        let url = "https://mycloudstorage.com/path/to/my/file.tgz";
+        let got: AssetLocation = url.into();
+
+        assert!(matches!(got, AssetLocation::Url(value) if value == Url::from_str(url).unwrap()));
+    }
+
+    #[test]
+    fn converting_a_str_into_an_filepath_asset_location_should_succeeds() {
+        let filepath = "/tmp/path/to/my/file";
+        let got: AssetLocation = filepath.into();
+
+        assert!(matches!(
+            got,
+            AssetLocation::FilePath(value) if value == PathBuf::from_str(filepath).unwrap()
+        ));
+    }
+
+    #[test]
+    fn converting_a_str_into_an_flag_arg_should_succeeds() {
+        let got: Arg = "myflag".into();
+
+        assert!(matches!(got, Arg::Flag(flag) if flag == "myflag"));
+    }
+
+    #[test]
+    fn converting_a_str_tuple_into_an_option_arg_should_succeeds() {
+        let got: Arg = ("name", "value").into();
+
+        assert!(matches!(got, Arg::Option(name, value) if name == "name" && value == "value"));
+    }
+
+    #[test]
+    fn converting_a_str_with_whitespaces_into_a_chain_should_fails() {
+        let got: Result<Chain, ConversionError> = "my chain".try_into();
+
+        assert!(matches!(
+            got.clone().unwrap_err(),
+            ConversionError::ContainsWhitespaces(_)
+        ));
+        assert_eq!(
+            got.unwrap_err().to_string(),
+            "'my chain' shouldn't contains whitespace"
+        );
+    }
+
+    #[test]
+    fn converting_a_str_containing_only_ip_into_an_image_should_fails() {
         let got: Result<Image, ConversionError> = "127.0.0.1".try_into();
 
         assert!(matches!(
@@ -222,7 +279,7 @@ mod tests {
     }
 
     #[test]
-    fn we_shouldnt_be_able_to_convert_a_str_containing_only_ip_and_tag_version_into_an_image() {
+    fn converting_a_str_containing_only_ip_and_tag_version_into_an_image_should_fails() {
         let got: Result<Image, ConversionError> = "127.0.0.1:version".try_into();
 
         assert!(matches!(
@@ -231,8 +288,9 @@ mod tests {
         ));
         assert_eq!(got.unwrap_err().to_string(), "'127.0.0.1:version' doesn't match regex '^([ip]|[hostname]/)?[tag_name]:[tag_version]?$'");
     }
+
     #[test]
-    fn we_shouldnt_be_able_to_convert_a_str_containing_only_hostname_into_an_image() {
+    fn converting_a_str_containing_only_hostname_into_an_image_should_fails() {
         let got: Result<Image, ConversionError> = "myrepository.com".try_into();
 
         assert!(matches!(
@@ -243,8 +301,7 @@ mod tests {
     }
 
     #[test]
-    fn we_shouldnt_be_able_to_convert_a_str_containing_only_hostname_and_tag_version_into_an_image()
-    {
+    fn converting_a_str_containing_only_hostname_and_tag_version_into_an_image_should_fails() {
         let got: Result<Image, ConversionError> = "myrepository.com:version".try_into();
 
         assert!(matches!(
@@ -255,14 +312,7 @@ mod tests {
     }
 
     #[test]
-    fn we_should_be_able_to_convert_a_str_without_whitespaces_into_a_command() {
-        let got: Result<Command, ConversionError> = "mycommand".try_into();
-
-        assert_eq!(got.unwrap().as_str(), "mycommand");
-    }
-
-    #[test]
-    fn we_shouldnt_be_able_to_convert_a_str_with_whitespaces_into_a_command() {
+    fn converting_a_str_with_whitespaces_into_a_command_should_fails() {
         let got: Result<Command, ConversionError> = "my command".try_into();
 
         assert!(matches!(
@@ -274,53 +324,4 @@ mod tests {
             "'my command' shouldn't contains whitespace"
         );
     }
-
-    #[test]
-    fn we_should_be_able_to_convert_an_url_into_an_asset_location() {
-        let url = Url::from_str("https://mycloudstorage.com/path/to/my/file.tgz").unwrap();
-        let got: AssetLocation = url.clone().into();
-
-        assert!(matches!(got, AssetLocation::Url(value) if value == url));
-    }
-
-    #[test]
-    fn we_should_be_able_to_convert_a_pathbuf_into_an_asset_location() {
-        let pathbuf = PathBuf::from_str("/tmp/path/to/my/file").unwrap();
-        let got: AssetLocation = pathbuf.clone().into();
-
-        assert!(matches!(got, AssetLocation::FilePath(value) if value == pathbuf));
-    }
-
-    #[test]
-    fn we_should_be_able_to_convert_a_str_into_an_url_asset_location() {
-        let url = "https://mycloudstorage.com/path/to/my/file.tgz";
-        let got: AssetLocation = url.into();
-
-        assert!(matches!(got, AssetLocation::Url(value) if value == Url::from_str(url).unwrap()));
-    }
-
-    #[test]
-    fn we_should_be_able_to_convert_a_str_into_an_filepath_asset_location() {
-        let filepath = "/tmp/path/to/my/file";
-        let got: AssetLocation = filepath.into();
-
-        assert!(matches!(
-            got,
-            AssetLocation::FilePath(value) if value == PathBuf::from_str(filepath).unwrap()
-        ));
-    }
-
-    #[test]
-    fn we_should_be_able_to_convert_a_str_into_an_flag_arg() {
-        let got: Arg = "myflag".into();
-
-        assert!(matches!(got, Arg::Flag(flag) if flag == "myflag"));
-    }
-
-    #[test]
-    fn we_should_be_able_to_convert_a_str_tuple_into_an_option_arg() {
-        let got: Arg = ("name", "value").into();
-
-        assert!(matches!(got, Arg::Option(name, value) if name == "name" && value == "value"));
-    }
 }