Externalize handling of command serialization

src/client.rs

@@ -126,11 +126,11 @@ impl<C: Connector> EppClient<C> {
         Ext: Extension + 'e,
     {
         let data = data.into();
-        let epp_xml =
+        let document = <Cmd as Transaction<Ext>>::command(data.command, data.extension, id);
-            <Cmd as Transaction<Ext>>::serialize_request(data.command, data.extension, id)?;
+        let xml = document.serialize()?;
 
-        debug!("{}: request: {}", self.connection.registry, &epp_xml);
+        debug!("{}: request: {}", self.connection.registry, &xml);
-        let response = self.connection.transact(&epp_xml)?.await?;
+        let response = self.connection.transact(&xml)?.await?;
         debug!("{}: response: {}", self.connection.registry, &response);
 
         match Cmd::deserialize_response(&response) {
@@ -169,8 +169,8 @@ impl<C: Connector> EppClient<C> {
 
 #[derive(Debug)]
 pub struct RequestData<'c, 'e, C, E> {
-    command: &'c C,
+    pub(crate) command: &'c C,
-    extension: Option<&'e E>,
+    pub(crate) extension: Option<&'e E>,
 }
 
 impl<'c, C: Command> From<&'c C> for RequestData<'c, 'static, C, NoExtension> {

src/contact/check.rs

@@ -58,19 +58,14 @@ mod tests {
     use crate::common::NoExtension;
     use crate::request::Transaction;
     use crate::response::ResultCode;
-    use crate::tests::{get_xml, CLTRID, SUCCESS_MSG, SVTRID};
+    use crate::tests::{assert_serialized, get_xml, CLTRID, SUCCESS_MSG, SVTRID};
 
     #[test]
     fn command() {
-        let xml = get_xml("request/contact/check.xml").unwrap();
         let object = ContactCheck {
             contact_ids: &["eppdev-contact-1", "eppdev-contact-2"],
         };
-        let serialized =
+        assert_serialized("request/contact/check.xml", &object);
-            <ContactCheck as Transaction<NoExtension>>::serialize_request(&object, None, CLTRID)
-                .unwrap();
-
-        assert_eq!(xml, serialized);
     }
 
     #[test]

src/contact/create.rs

@@ -106,12 +106,10 @@ mod tests {
     use crate::contact::Address;
     use crate::request::Transaction;
     use crate::response::ResultCode;
-    use crate::tests::{get_xml, CLTRID, SUCCESS_MSG, SVTRID};
+    use crate::tests::{assert_serialized, get_xml, CLTRID, SUCCESS_MSG, SVTRID};
 
     #[test]
     fn command() {
-        let xml = get_xml("request/contact/create.xml").unwrap();
-
         let street = &["58", "Orchid Road"];
         let address = Address::new(street, "Paris", "Paris", "392374", "FR".parse().unwrap());
         let postal_info = PostalInfo::new("int", "John Doe", "Acme Widgets", address);
@@ -129,11 +127,7 @@ mod tests {
         );
         object.set_fax(fax);
 
-        let serialized =
+        assert_serialized("request/contact/create.xml", &object);
-            <ContactCreate as Transaction<NoExtension>>::serialize_request(&object, None, CLTRID)
-                .unwrap();
-
-        assert_eq!(xml, serialized);
     }
 
     #[test]

src/contact/delete.rs

@@ -48,19 +48,12 @@ mod tests {
     use crate::common::NoExtension;
     use crate::request::Transaction;
     use crate::response::ResultCode;
-    use crate::tests::{get_xml, CLTRID, SUCCESS_MSG, SVTRID};
+    use crate::tests::{assert_serialized, get_xml, CLTRID, SUCCESS_MSG, SVTRID};
 
     #[test]
     fn command() {
-        let xml = get_xml("request/contact/delete.xml").unwrap();
-
         let object = ContactDelete::new("eppdev-contact-3");
-
+        assert_serialized("request/contact/delete.xml", &object);
-        let serialized =
-            <ContactDelete as Transaction<NoExtension>>::serialize_request(&object, None, CLTRID)
-                .unwrap();
-
-        assert_eq!(xml, serialized);
     }
 
     #[test]

src/contact/info.rs

@@ -110,19 +110,12 @@ mod tests {
     use crate::common::NoExtension;
     use crate::request::Transaction;
     use crate::response::ResultCode;
-    use crate::tests::{get_xml, CLTRID, SUCCESS_MSG, SVTRID};
+    use crate::tests::{assert_serialized, get_xml, CLTRID, SUCCESS_MSG, SVTRID};
 
     #[test]
     fn command() {
-        let xml = get_xml("request/contact/info.xml").unwrap();
-
         let object = ContactInfo::new("eppdev-contact-3", "eppdev-387323");
-
+        assert_serialized("request/contact/info.xml", &object);
-        let serialized =
-            <ContactInfo as Transaction<NoExtension>>::serialize_request(&object, None, CLTRID)
-                .unwrap();
-
-        assert_eq!(xml, serialized);
     }
 
     #[test]

src/contact/update.rs

@@ -112,12 +112,10 @@ mod tests {
     use crate::contact::Address;
     use crate::request::Transaction;
     use crate::response::ResultCode;
-    use crate::tests::{get_xml, CLTRID, SUCCESS_MSG, SVTRID};
+    use crate::tests::{assert_serialized, get_xml, CLTRID, SUCCESS_MSG, SVTRID};
 
     #[test]
     fn command() {
-        let xml = get_xml("request/contact/update.xml").unwrap();
-
         let mut object = ContactUpdate::new("eppdev-contact-3");
 
         let street = &["58", "Orchid Road"];
@@ -135,11 +133,7 @@ mod tests {
         }];
         object.remove(remove_statuses);
 
-        let serialized =
+        assert_serialized("request/contact/update.xml", &object);
-            <ContactUpdate as Transaction<NoExtension>>::serialize_request(&object, None, CLTRID)
-                .unwrap();
-
-        assert_eq!(xml, serialized);
     }
 
     #[test]

src/domain/check.rs

@@ -56,21 +56,14 @@ mod tests {
     use crate::common::NoExtension;
     use crate::request::Transaction;
     use crate::response::ResultCode;
-    use crate::tests::{get_xml, CLTRID, SUCCESS_MSG, SVTRID};
+    use crate::tests::{assert_serialized, get_xml, CLTRID, SUCCESS_MSG, SVTRID};
 
     #[test]
     fn command() {
-        let xml = get_xml("request/domain/check.xml").unwrap();
-
         let object = DomainCheck {
             domains: &["eppdev.com", "eppdev.net"],
         };
-
+        assert_serialized("request/domain/check.xml", &object);
-        let serialized =
-            <DomainCheck as Transaction<NoExtension>>::serialize_request(&object, None, CLTRID)
-                .unwrap();
-
-        assert_eq!(xml, serialized);
     }
 
     #[test]

src/domain/create.rs

@@ -113,12 +113,10 @@ mod tests {
     use crate::domain::{HostAttr, HostAttrList, HostObjList};
     use crate::request::Transaction;
     use crate::response::ResultCode;
-    use crate::tests::{get_xml, CLTRID, SUCCESS_MSG, SVTRID};
+    use crate::tests::{assert_serialized, get_xml, CLTRID, SUCCESS_MSG, SVTRID};
 
     #[test]
     fn command() {
-        let xml = get_xml("request/domain/create.xml").unwrap();
-
         let contacts = &[
             DomainContact {
                 contact_type: "admin".into(),
@@ -143,17 +141,11 @@ mod tests {
             Some(contacts),
         );
 
-        let serialized =
+        assert_serialized("request/domain/create.xml", &object);
-            <DomainCreate as Transaction<NoExtension>>::serialize_request(&object, None, CLTRID)
-                .unwrap();
-
-        assert_eq!(xml, serialized);
     }
 
     #[test]
     fn command_with_host_obj() {
-        let xml = get_xml("request/domain/create_with_host_obj.xml").unwrap();
-
         let contacts = &[
             DomainContact {
                 contact_type: "admin".into(),
@@ -179,17 +171,11 @@ mod tests {
             Some(contacts),
         );
 
-        let serialized =
+        assert_serialized("request/domain/create_with_host_obj.xml", &object);
-            <DomainCreate as Transaction<NoExtension>>::serialize_request(&object, None, CLTRID)
-                .unwrap();
-
-        assert_eq!(xml, serialized);
     }
 
     #[test]
     fn command_with_host_attr() {
-        let xml = get_xml("request/domain/create_with_host_attr.xml").unwrap();
-
         let contacts = &[
             DomainContact {
                 contact_type: "admin".into(),
@@ -228,11 +214,7 @@ mod tests {
             Some(contacts),
         );
 
-        let serialized =
+        assert_serialized("request/domain/create_with_host_attr.xml", &object);
-            <DomainCreate as Transaction<NoExtension>>::serialize_request(&object, None, CLTRID)
-                .unwrap();
-
-        assert_eq!(xml, serialized);
     }
 
     #[test]

src/domain/delete.rs

@@ -48,19 +48,12 @@ mod tests {
     use crate::common::NoExtension;
     use crate::request::Transaction;
     use crate::response::ResultCode;
-    use crate::tests::{get_xml, CLTRID, SUCCESS_MSG, SVTRID};
+    use crate::tests::{assert_serialized, get_xml, CLTRID, SUCCESS_MSG, SVTRID};
 
     #[test]
     fn command() {
-        let xml = get_xml("request/domain/delete.xml").unwrap();
-
         let object = DomainDelete::new("eppdev.com");
-
+        assert_serialized("request/domain/delete.xml", &object);
-        let serialized =
-            <DomainDelete as Transaction<NoExtension>>::serialize_request(&object, None, CLTRID)
-                .unwrap();
-
-        assert_eq!(xml, serialized);
     }
 
     #[test]

src/domain/info.rs

@@ -136,20 +136,13 @@ mod tests {
     use crate::common::NoExtension;
     use crate::request::Transaction;
     use crate::response::ResultCode;
-    use crate::tests::{get_xml, CLTRID, SUCCESS_MSG, SVTRID};
+    use crate::tests::{assert_serialized, get_xml, CLTRID, SUCCESS_MSG, SVTRID};
     use chrono::{TimeZone, Utc};
 
     #[test]
     fn command() {
-        let xml = get_xml("request/domain/info.xml").unwrap();
-
         let object = DomainInfo::new("eppdev.com", Some("2fooBAR"));
-
+        assert_serialized("request/domain/info.xml", &object);
-        let serialized =
-            <DomainInfo as Transaction<NoExtension>>::serialize_request(&object, None, CLTRID)
-                .unwrap();
-
-        assert_eq!(xml, serialized);
     }
 
     #[test]

src/domain/renew.rs

@@ -81,22 +81,15 @@ mod tests {
     use crate::common::NoExtension;
     use crate::request::Transaction;
     use crate::response::ResultCode;
-    use crate::tests::{get_xml, CLTRID, SUCCESS_MSG, SVTRID};
+    use crate::tests::{assert_serialized, get_xml, CLTRID, SUCCESS_MSG, SVTRID};
 
     use chrono::{NaiveDate, TimeZone, Utc};
 
     #[test]
     fn command() {
-        let xml = get_xml("request/domain/renew.xml").unwrap();
-
         let exp_date = NaiveDate::from_ymd(2022, 7, 23);
         let object = DomainRenew::new("eppdev.com", exp_date, Period::years(1).unwrap());
-
+        assert_serialized("request/domain/renew.xml", &object);
-        let serialized =
-            <DomainRenew as Transaction<NoExtension>>::serialize_request(&object, None, CLTRID)
-                .unwrap();
-
-        assert_eq!(xml, serialized);
     }
 
     #[test]

src/domain/transfer.rs

@@ -139,72 +139,37 @@ mod tests {
     use crate::common::NoExtension;
     use crate::request::Transaction;
     use crate::response::ResultCode;
-    use crate::tests::{get_xml, CLTRID, SUCCESS_MSG, SVTRID};
+    use crate::tests::{assert_serialized, get_xml, CLTRID, SUCCESS_MSG, SVTRID};
 
     #[test]
     fn request_command() {
-        let xml = get_xml("request/domain/transfer_request.xml").unwrap();
-
         let object =
             DomainTransfer::new("testing.com", Some(Period::years(1).unwrap()), "epP4uthd#v");
-
+        assert_serialized("request/domain/transfer_request.xml", &object);
-        let serialized =
-            <DomainTransfer as Transaction<NoExtension>>::serialize_request(&object, None, CLTRID)
-                .unwrap();
-
-        assert_eq!(xml, serialized);
     }
 
     #[test]
     fn approve_command() {
-        let xml = get_xml("request/domain/transfer_approve.xml").unwrap();
-
         let object = DomainTransfer::approve("testing.com");
-
+        assert_serialized("request/domain/transfer_approve.xml", &object);
-        let serialized =
-            <DomainTransfer as Transaction<NoExtension>>::serialize_request(&object, None, CLTRID)
-                .unwrap();
-
-        assert_eq!(xml, serialized);
     }
 
     #[test]
     fn reject_command() {
-        let xml = get_xml("request/domain/transfer_reject.xml").unwrap();
-
         let object = DomainTransfer::reject("testing.com");
-
+        assert_serialized("request/domain/transfer_reject.xml", &object);
-        let serialized =
-            <DomainTransfer as Transaction<NoExtension>>::serialize_request(&object, None, CLTRID)
-                .unwrap();
-
-        assert_eq!(xml, serialized);
     }
 
     #[test]
     fn cancel_command() {
-        let xml = get_xml("request/domain/transfer_cancel.xml").unwrap();
-
         let object = DomainTransfer::cancel("testing.com");
-
+        assert_serialized("request/domain/transfer_cancel.xml", &object);
-        let serialized =
-            <DomainTransfer as Transaction<NoExtension>>::serialize_request(&object, None, CLTRID)
-                .unwrap();
-
-        assert_eq!(xml, serialized);
     }
 
     #[test]
     fn query_command() {
-        let xml = get_xml("request/domain/transfer_query.xml").unwrap();
-
         let object = DomainTransfer::query("testing.com", "epP4uthd#v");
-
+        assert_serialized("request/domain/transfer_query.xml", &object);
-        let serialized =
-            <DomainTransfer as Transaction<NoExtension>>::serialize_request(&object, None, CLTRID)
-                .unwrap();
-
-        assert_eq!(xml, serialized);
     }
 
     #[test]

src/domain/update.rs

@@ -105,12 +105,10 @@ mod tests {
     use crate::common::{NoExtension, ObjectStatus};
     use crate::request::Transaction;
     use crate::response::ResultCode;
-    use crate::tests::{get_xml, CLTRID, SUCCESS_MSG, SVTRID};
+    use crate::tests::{assert_serialized, get_xml, CLTRID, SUCCESS_MSG, SVTRID};
 
     #[test]
     fn command() {
-        let xml = get_xml("request/domain/update.xml").unwrap();
-
         let mut object = DomainUpdate::new("eppdev.com");
 
         let statuses = &[ObjectStatus {
@@ -142,12 +140,7 @@ mod tests {
         object.add(add);
         object.remove(remove);
         object.info(change_info);
-
+        assert_serialized("request/domain/update.xml", &object);
-        let serialized =
-            <DomainUpdate as Transaction<NoExtension>>::serialize_request(&object, None, CLTRID)
-                .unwrap();
-
-        assert_eq!(xml, serialized);
     }
 
     #[test]

src/extensions/consolidate.rs

@@ -118,13 +118,10 @@ mod tests {
     use super::{GMonthDay, Update};
     use crate::domain::update::{DomainChangeInfo, DomainUpdate};
     use crate::extensions::consolidate::UpdateWithNameStore;
-    use crate::request::Transaction;
+    use crate::tests::assert_serialized;
-    use crate::tests::{get_xml, CLTRID};
 
     #[test]
     fn command() {
-        let xml = get_xml("request/extensions/consolidate.xml").unwrap();
-
         let exp = GMonthDay::new(5, 31, None).unwrap();
 
         let consolidate_ext = Update::new(exp);
@@ -136,20 +133,14 @@ mod tests {
             auth_info: None,
         });
 
-        let serialized = <DomainUpdate as Transaction<Update>>::serialize_request(
+        assert_serialized(
-            &object,
+            "request/extensions/consolidate.xml",
-            Some(&consolidate_ext),
+            (&object, &consolidate_ext),
-            CLTRID,
+        );
-        )
-        .unwrap();
-
-        assert_eq!(xml, serialized);
     }
 
     #[test]
     fn command_with_namestore() {
-        let xml = get_xml("request/extensions/consolidate_namestore.xml").unwrap();
-
         let exp = GMonthDay::new(5, 31, None).unwrap();
 
         let consolidate_ext = UpdateWithNameStore::new(exp, "com");
@@ -161,13 +152,9 @@ mod tests {
             auth_info: None,
         });
 
-        let serialized = <DomainUpdate as Transaction<UpdateWithNameStore>>::serialize_request(
+        assert_serialized(
-            &object,
+            "request/extensions/consolidate_namestore.xml",
-            Some(&consolidate_ext),
+            (&object, &consolidate_ext),
-            CLTRID,
+        );
-        )
-        .unwrap();
-
-        assert_eq!(xml, serialized);
     }
 }

src/extensions/namestore.rs

@@ -98,26 +98,20 @@ mod tests {
     use super::NameStore;
     use crate::domain::check::DomainCheck;
     use crate::request::Transaction;
-    use crate::tests::{get_xml, CLTRID};
+    use crate::tests::{assert_serialized, get_xml};
 
     #[test]
     fn command() {
-        let xml = get_xml("request/extensions/namestore.xml").unwrap();
-
         let namestore_ext = NameStore::new("com");
 
         let object = DomainCheck {
             domains: &["example1.com", "example2.com", "example3.com"],
         };
 
-        let serialized = <DomainCheck as Transaction<NameStore>>::serialize_request(
+        assert_serialized(
-            &object,
+            "request/extensions/namestore.xml",
-            Some(&namestore_ext),
+            (&object, &namestore_ext),
-            CLTRID,
+        );
-        )
-        .unwrap();
-
-        assert_eq!(xml, serialized);
     }
 
     #[test]

src/extensions/rgp/report.rs

@@ -104,13 +104,10 @@ mod tests {
 
     use super::{RgpRestoreReport, Update};
     use crate::domain::update::{DomainChangeInfo, DomainUpdate};
-    use crate::request::Transaction;
+    use crate::tests::assert_serialized;
-    use crate::tests::{get_xml, CLTRID};
 
     #[test]
     fn command() {
-        let xml = get_xml("request/extensions/rgp_restore_report.xml").unwrap();
-
         let pre_data =
             "Pre-delete registration data goes here. Both XML and free text are allowed.";
         let post_data =
@@ -142,14 +139,9 @@ mod tests {
             auth_info: None,
         });
 
-        let serialized =
+        assert_serialized(
-            <DomainUpdate as Transaction<Update<RgpRestoreReport>>>::serialize_request(
+            "request/extensions/rgp_restore_report.xml",
-                &object,
+            (&object, &domain_restore_report),
-                Some(&domain_restore_report),
+        );
-                CLTRID,
-            )
-            .unwrap();
-
-        assert_eq!(xml, serialized);
     }
 }

src/extensions/rgp/request.rs

@@ -72,12 +72,10 @@ mod tests {
     use crate::domain::update::{DomainChangeInfo, DomainUpdate};
     use crate::request::Transaction;
     use crate::response::ResultCode;
-    use crate::tests::{get_xml, CLTRID, SUCCESS_MSG, SVTRID};
+    use crate::tests::{assert_serialized, get_xml, SUCCESS_MSG, SVTRID};
 
     #[test]
     fn request_command() {
-        let xml = get_xml("request/extensions/rgp_restore_request.xml").unwrap();
-
         let domain_restore_request = Update {
             data: RgpRestoreRequest::default(),
         };
@@ -91,15 +89,10 @@ mod tests {
 
         object.info(change_info);
 
-        let serialized =
+        assert_serialized(
-            <DomainUpdate as Transaction<Update<RgpRestoreRequest>>>::serialize_request(
+            "request/extensions/rgp_restore_request.xml",
-                &object,
+            (&object, &domain_restore_request),
-                Some(&domain_restore_request),
+        );
-                CLTRID,
-            )
-            .unwrap();
-
-        assert_eq!(xml, serialized);
     }
 
     #[test]

src/host/check.rs

@@ -60,21 +60,14 @@ mod tests {
     use crate::common::NoExtension;
     use crate::request::Transaction;
     use crate::response::ResultCode;
-    use crate::tests::{get_xml, CLTRID, SUCCESS_MSG, SVTRID};
+    use crate::tests::{assert_serialized, get_xml, CLTRID, SUCCESS_MSG, SVTRID};
 
     #[test]
     fn command() {
-        let xml = get_xml("request/host/check.xml").unwrap();
-
         let object = HostCheck {
             hosts: &["ns1.eppdev-1.com", "host1.eppdev-1.com"],
         };
-
+        assert_serialized("request/host/check.xml", &object);
-        let serialized =
-            <HostCheck as Transaction<NoExtension>>::serialize_request(&object, None, CLTRID)
-                .unwrap();
-
-        assert_eq!(xml, serialized);
     }
 
     #[test]

src/host/create.rs

@@ -80,24 +80,17 @@ mod tests {
     use crate::common::NoExtension;
     use crate::request::Transaction;
     use crate::response::ResultCode;
-    use crate::tests::{get_xml, CLTRID, SUCCESS_MSG, SVTRID};
+    use crate::tests::{assert_serialized, get_xml, CLTRID, SUCCESS_MSG, SVTRID};
 
     #[test]
     fn command() {
-        let xml = get_xml("request/host/create.xml").unwrap();
-
         let addresses = &[
             IpAddr::from([29, 245, 122, 14]),
             IpAddr::from([0x2404, 0x6800, 0x4001, 0x801, 0, 0, 0, 0x200e]),
         ];
 
         let object = HostCreate::new("host1.eppdev-1.com", Some(addresses));
-
+        assert_serialized("request/host/create.xml", &object);
-        let serialized =
-            <HostCreate as Transaction<NoExtension>>::serialize_request(&object, None, CLTRID)
-                .unwrap();
-
-        assert_eq!(xml, serialized);
     }
 
     #[test]

src/host/delete.rs

@@ -48,19 +48,12 @@ mod tests {
     use crate::common::NoExtension;
     use crate::request::Transaction;
     use crate::response::ResultCode;
-    use crate::tests::{get_xml, CLTRID, SUCCESS_MSG, SVTRID};
+    use crate::tests::{assert_serialized, get_xml, CLTRID, SUCCESS_MSG, SVTRID};
 
     #[test]
     fn command() {
-        let xml = get_xml("request/host/delete.xml").unwrap();
-
         let object = HostDelete::new("ns1.eppdev-1.com");
-
+        assert_serialized("request/host/delete.xml", &object);
-        let serialized =
-            <HostDelete as Transaction<NoExtension>>::serialize_request(&object, None, CLTRID)
-                .unwrap();
-
-        assert_eq!(xml, serialized);
     }
 
     #[test]

src/host/info.rs

@@ -112,19 +112,12 @@ mod tests {
     use crate::common::NoExtension;
     use crate::request::Transaction;
     use crate::response::ResultCode;
-    use crate::tests::{get_xml, CLTRID, SUCCESS_MSG, SVTRID};
+    use crate::tests::{assert_serialized, get_xml, CLTRID, SUCCESS_MSG, SVTRID};
 
     #[test]
     fn command() {
-        let xml = get_xml("request/host/info.xml").unwrap();
-
         let object = HostInfo::new("ns1.eppdev-1.com");
-
+        assert_serialized("request/host/info.xml", &object);
-        let serialized =
-            <HostInfo as Transaction<NoExtension>>::serialize_request(&object, None, CLTRID)
-                .unwrap();
-
-        assert_eq!(xml, serialized);
     }
 
     #[test]

src/host/update.rs

@@ -97,12 +97,10 @@ mod tests {
     use crate::common::{NoExtension, ObjectStatus};
     use crate::request::Transaction;
     use crate::response::ResultCode;
-    use crate::tests::{get_xml, CLTRID, SUCCESS_MSG, SVTRID};
+    use crate::tests::{assert_serialized, get_xml, CLTRID, SUCCESS_MSG, SVTRID};
 
     #[test]
     fn command() {
-        let xml = get_xml("request/host/update.xml").unwrap();
-
         let addr = &[IpAddr::from([
             0x2404, 0x6800, 0x4001, 0x801, 0, 0, 0, 0x200e,
         ])];
@@ -129,11 +127,7 @@ mod tests {
             name: "host2.eppdev-1.com".into(),
         });
 
-        let serialized =
+        assert_serialized("request/host/update.xml", &object);
-            <HostUpdate as Transaction<NoExtension>>::serialize_request(&object, None, CLTRID)
-                .unwrap();
-
-        assert_eq!(xml, serialized);
     }
 
     #[test]

src/login.rs

@@ -69,17 +69,13 @@ mod tests {
     use super::Login;
     use crate::request::Transaction;
     use crate::response::ResultCode;
-    use crate::tests::{get_xml, CLTRID, SUCCESS_MSG, SVTRID};
+    use crate::tests::{assert_serialized, get_xml, CLTRID, SUCCESS_MSG, SVTRID};
 
     #[test]
     fn command() {
         let ext_uris = Some(&["http://schema.ispapi.net/epp/xml/keyvalue-1.0"][..]);
-
-        let xml = get_xml("request/login.xml").unwrap();
         let object = Login::new("username", "password", ext_uris);
-        let serialized = object.serialize_request(None, CLTRID).unwrap();
+        assert_serialized("request/login.xml", &object);
-
-        assert_eq!(xml, serialized);
     }
 
     #[test]

src/logout.rs

@@ -23,15 +23,12 @@ mod tests {
     use super::Logout;
     use crate::request::Transaction;
     use crate::response::ResultCode;
-    use crate::tests::{get_xml, CLTRID, SVTRID};
+    use crate::tests::{assert_serialized, get_xml, CLTRID, SVTRID};
 
     #[test]
     fn command() {
-        let xml = get_xml("request/logout.xml").unwrap();
         let object = Logout;
-        let serialized = object.serialize_request(None, CLTRID).unwrap();
+        assert_serialized("request/logout.xml", &object);
-
-        assert_eq!(xml, serialized);
     }
 
     #[test]

src/message/ack.rs

@@ -36,17 +36,12 @@ mod tests {
     use super::MessageAck;
     use crate::request::Transaction;
     use crate::response::ResultCode;
-    use crate::tests::{get_xml, CLTRID, SUCCESS_MSG, SVTRID};
+    use crate::tests::{assert_serialized, get_xml, SUCCESS_MSG, SVTRID};
 
     #[test]
     fn command() {
-        let xml = get_xml("request/message/ack.xml").unwrap();
-
         let object = MessageAck::new(12345);
-
+        assert_serialized("request/message/ack.xml", &object);
-        let serialized = object.serialize_request(None, CLTRID).unwrap();
-
-        assert_eq!(xml, serialized);
     }
 
     #[test]

src/message/poll.rs

@@ -54,20 +54,15 @@ mod tests {
     use crate::message::poll::MessageData;
     use crate::request::Transaction;
     use crate::response::ResultCode;
-    use crate::tests::{get_xml, CLTRID, SVTRID};
+    use crate::tests::{assert_serialized, get_xml, CLTRID, SVTRID};
 
     use chrono::{TimeZone, Utc};
     use std::net::IpAddr;
 
     #[test]
     fn command() {
-        let xml = get_xml("request/message/poll.xml").unwrap();
-
         let object = MessagePoll::default();
-
+        assert_serialized("request/message/poll.xml", &object);
-        let serialized = object.serialize_request(None, CLTRID).unwrap();
-
-        assert_eq!(xml, serialized);
     }
 
     #[test]

src/request.rs

@@ -15,17 +15,17 @@ pub const EPP_LANG: &str = "en";
 
 /// Trait to set correct value for xml tags when tags are being generated from generic types
 pub trait Transaction<Ext: Extension>: Command + Sized {
-    fn serialize_request(
+    fn command<'c, 'e: 'c, 'i: 'c>(
-        &self,
+        &'c self,
-        extension: Option<&Ext>,
+        extension: Option<&'e Ext>,
-        client_tr_id: &str,
+        client_tr_id: &'i str,
-    ) -> Result<String, Error> {
+    ) -> CommandDocument<'c, Self, Ext> {
-        <CommandDocument<Self, Ext> as EppXml>::serialize(&CommandDocument::new(CommandWrapper {
+        CommandDocument::new(CommandWrapper {
             command: Self::COMMAND,
             data: self,
             extension,
             client_tr_id: client_tr_id.into(),
-        }))
+        })
     }
 
     fn deserialize_response(

src/tests/mod.rs

@@ -1,8 +1,15 @@
 //! Module for automated tests
 
-use regex::Regex;
 use std::{error::Error, fs::File, io::Read};
 
+use regex::Regex;
+
+use crate::{
+    client::RequestData,
+    request::{Command, Extension, Transaction},
+    xml::EppXml,
+};
+
 pub(crate) const RESOURCES_DIR: &str = "./tests/resources";
 pub(crate) const CLTRID: &str = "cltrid:1626454866";
 pub(crate) const SVTRID: &str = "RO-6879-1627224678242975";
@@ -27,3 +34,17 @@ pub(crate) fn get_xml(path: &str) -> Result<String, Box<dyn Error>> {
     }
     Ok(buf)
 }
+
+pub(crate) fn assert_serialized<'c, 'e, Cmd, Ext>(
+    path: &str,
+    req: impl Into<RequestData<'c, 'e, Cmd, Ext>>,
+) where
+    Cmd: Transaction<Ext> + Command + 'c,
+    Ext: Extension + 'e,
+{
+    let expected = get_xml(path).unwrap();
+    let req = req.into();
+    let document = <Cmd as Transaction<Ext>>::command(req.command, req.extension, CLTRID);
+    let actual = EppXml::serialize(&document).unwrap();
+    assert_eq!(expected, actual);
+}