test(codegen): add multipart/related test coverage

Add comprehensive test suite for multipart/related support including:

- New OpenAPI spec (multipart-related-test.json) with three test
  endpoints demonstrating different patterns: single file with metadata,
  raw multipart/related body, and multiple files with metadata

- Generated test outputs for all variants (builder, tagged, CLI,
  httpmock, positional) showing proper Vec<u8> types for binary fields
  and MultipartRelatedBody trait implementations

- Registered spec in test_output.rs for expectorate-based snapshot
  testing

The test validates the builder API from #1240 works as expected:
  client.upload_file()
      .file(file_bytes)
      .metadata(metadata)
      .send()

Also includes regenerated builder outputs with improved error messages
as a beneficial side effect of builder generation improvements.

Author: lanej

progenitor-impl/tests/output/src/buildomat_builder.rs

@@ -3002,43 +3002,31 @@ pub mod builder {
     #[derive(Debug, Clone)]
     pub struct TaskSubmit<'a> {
         client: &'a super::Client,
-        body: Result<types::builder::TaskSubmit, String>,
+        body: Result<types::TaskSubmit, String>,
     }
 
     impl<'a> TaskSubmit<'a> {
         pub fn new(client: &'a super::Client) -> Self {
             Self {
                 client: client,
-                body: Ok(::std::default::Default::default()),
+                body: Err("body was not initialized".to_string()),
             }
         }
 
         pub fn body<V>(mut self, value: V) -> Self
         where
             V: std::convert::TryInto<types::TaskSubmit>,
-            <V as std::convert::TryInto<types::TaskSubmit>>::Error: std::fmt::Display,
         {
             self.body = value
                 .try_into()
-                .map(From::from)
-                .map_err(|s| format!("conversion to `TaskSubmit` for body failed: {}", s));
-            self
-        }
-
-        pub fn body_map<F>(mut self, f: F) -> Self
-        where
-            F: std::ops::FnOnce(types::builder::TaskSubmit) -> types::builder::TaskSubmit,
-        {
-            self.body = self.body.map(f);
+                .map_err(|_| "conversion to `TaskSubmit` for body failed".to_string());
             self
         }
 
         ///Sends a `POST` request to `/v1/tasks`
         pub async fn send(self) -> Result<ResponseValue<types::TaskSubmitResult>, Error<()>> {
             let Self { client, body } = self;
-            let body = body
-                .and_then(|v| types::TaskSubmit::try_from(v).map_err(|e| e.to_string()))
-                .map_err(Error::InvalidRequest)?;
+            let body = body.map_err(Error::InvalidRequest)?;
             let url = format!("{}/v1/tasks", client.baseurl,);
             let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
             header_map.append(
@@ -3304,43 +3292,31 @@ pub mod builder {
     #[derive(Debug, Clone)]
     pub struct UserCreate<'a> {
         client: &'a super::Client,
-        body: Result<types::builder::UserCreate, String>,
+        body: Result<types::UserCreate, String>,
     }
 
     impl<'a> UserCreate<'a> {
         pub fn new(client: &'a super::Client) -> Self {
             Self {
                 client: client,
-                body: Ok(::std::default::Default::default()),
+                body: Err("body was not initialized".to_string()),
             }
         }
 
         pub fn body<V>(mut self, value: V) -> Self
         where
             V: std::convert::TryInto<types::UserCreate>,
-            <V as std::convert::TryInto<types::UserCreate>>::Error: std::fmt::Display,
         {
             self.body = value
                 .try_into()
-                .map(From::from)
-                .map_err(|s| format!("conversion to `UserCreate` for body failed: {}", s));
-            self
-        }
-
-        pub fn body_map<F>(mut self, f: F) -> Self
-        where
-            F: std::ops::FnOnce(types::builder::UserCreate) -> types::builder::UserCreate,
-        {
-            self.body = self.body.map(f);
+                .map_err(|_| "conversion to `UserCreate` for body failed".to_string());
             self
         }
 
         ///Sends a `POST` request to `/v1/users`
         pub async fn send(self) -> Result<ResponseValue<types::UserCreateResult>, Error<()>> {
             let Self { client, body } = self;
-            let body = body
-                .and_then(|v| types::UserCreate::try_from(v).map_err(|e| e.to_string()))
-                .map_err(Error::InvalidRequest)?;
+            let body = body.map_err(Error::InvalidRequest)?;
             let url = format!("{}/v1/users", client.baseurl,);
             let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
             header_map.append(
@@ -3487,43 +3463,31 @@ pub mod builder {
     #[derive(Debug, Clone)]
     pub struct WorkerBootstrap<'a> {
         client: &'a super::Client,
-        body: Result<types::builder::WorkerBootstrap, String>,
+        body: Result<types::WorkerBootstrap, String>,
     }
 
     impl<'a> WorkerBootstrap<'a> {
         pub fn new(client: &'a super::Client) -> Self {
             Self {
                 client: client,
-                body: Ok(::std::default::Default::default()),
+                body: Err("body was not initialized".to_string()),
             }
         }
 
         pub fn body<V>(mut self, value: V) -> Self
         where
             V: std::convert::TryInto<types::WorkerBootstrap>,
-            <V as std::convert::TryInto<types::WorkerBootstrap>>::Error: std::fmt::Display,
         {
             self.body = value
                 .try_into()
-                .map(From::from)
-                .map_err(|s| format!("conversion to `WorkerBootstrap` for body failed: {}", s));
-            self
-        }
-
-        pub fn body_map<F>(mut self, f: F) -> Self
-        where
-            F: std::ops::FnOnce(types::builder::WorkerBootstrap) -> types::builder::WorkerBootstrap,
-        {
-            self.body = self.body.map(f);
+                .map_err(|_| "conversion to `WorkerBootstrap` for body failed".to_string());
             self
         }
 
         ///Sends a `POST` request to `/v1/worker/bootstrap`
         pub async fn send(self) -> Result<ResponseValue<types::WorkerBootstrapResult>, Error<()>> {
             let Self { client, body } = self;
-            let body = body
-                .and_then(|v| types::WorkerBootstrap::try_from(v).map_err(|e| e.to_string()))
-                .map_err(Error::InvalidRequest)?;
+            let body = body.map_err(Error::InvalidRequest)?;
             let url = format!("{}/v1/worker/bootstrap", client.baseurl,);
             let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
             header_map.append(
@@ -3608,15 +3572,15 @@ pub mod builder {
     pub struct WorkerTaskAppend<'a> {
         client: &'a super::Client,
         task: Result<::std::string::String, String>,
-        body: Result<types::builder::WorkerAppendTask, String>,
+        body: Result<types::WorkerAppendTask, String>,
     }
 
     impl<'a> WorkerTaskAppend<'a> {
         pub fn new(client: &'a super::Client) -> Self {
             Self {
                 client: client,
                 task: Err("task was not initialized".to_string()),
-                body: Ok(::std::default::Default::default()),
+                body: Err("body was not initialized".to_string()),
             }
         }
 
@@ -3633,32 +3597,18 @@ pub mod builder {
         pub fn body<V>(mut self, value: V) -> Self
         where
             V: std::convert::TryInto<types::WorkerAppendTask>,
-            <V as std::convert::TryInto<types::WorkerAppendTask>>::Error: std::fmt::Display,
         {
             self.body = value
                 .try_into()
-                .map(From::from)
-                .map_err(|s| format!("conversion to `WorkerAppendTask` for body failed: {}", s));
-            self
-        }
-
-        pub fn body_map<F>(mut self, f: F) -> Self
-        where
-            F: std::ops::FnOnce(
-                types::builder::WorkerAppendTask,
-            ) -> types::builder::WorkerAppendTask,
-        {
-            self.body = self.body.map(f);
+                .map_err(|_| "conversion to `WorkerAppendTask` for body failed".to_string());
             self
         }
 
         ///Sends a `POST` request to `/v1/worker/task/{task}/append`
         pub async fn send(self) -> Result<ResponseValue<()>, Error<()>> {
             let Self { client, task, body } = self;
             let task = task.map_err(Error::InvalidRequest)?;
-            let body = body
-                .and_then(|v| types::WorkerAppendTask::try_from(v).map_err(|e| e.to_string()))
-                .map_err(Error::InvalidRequest)?;
+            let body = body.map_err(Error::InvalidRequest)?;
             let url = format!(
                 "{}/v1/worker/task/{}/append",
                 client.baseurl,
@@ -3780,15 +3730,15 @@ pub mod builder {
     pub struct WorkerTaskComplete<'a> {
         client: &'a super::Client,
         task: Result<::std::string::String, String>,
-        body: Result<types::builder::WorkerCompleteTask, String>,
+        body: Result<types::WorkerCompleteTask, String>,
     }
 
     impl<'a> WorkerTaskComplete<'a> {
         pub fn new(client: &'a super::Client) -> Self {
             Self {
                 client: client,
                 task: Err("task was not initialized".to_string()),
-                body: Ok(::std::default::Default::default()),
+                body: Err("body was not initialized".to_string()),
             }
         }
 
@@ -3805,32 +3755,18 @@ pub mod builder {
         pub fn body<V>(mut self, value: V) -> Self
         where
             V: std::convert::TryInto<types::WorkerCompleteTask>,
-            <V as std::convert::TryInto<types::WorkerCompleteTask>>::Error: std::fmt::Display,
         {
             self.body = value
                 .try_into()
-                .map(From::from)
-                .map_err(|s| format!("conversion to `WorkerCompleteTask` for body failed: {}", s));
-            self
-        }
-
-        pub fn body_map<F>(mut self, f: F) -> Self
-        where
-            F: std::ops::FnOnce(
-                types::builder::WorkerCompleteTask,
-            ) -> types::builder::WorkerCompleteTask,
-        {
-            self.body = self.body.map(f);
+                .map_err(|_| "conversion to `WorkerCompleteTask` for body failed".to_string());
             self
         }
 
         ///Sends a `POST` request to `/v1/worker/task/{task}/complete`
         pub async fn send(self) -> Result<ResponseValue<()>, Error<()>> {
             let Self { client, task, body } = self;
             let task = task.map_err(Error::InvalidRequest)?;
-            let body = body
-                .and_then(|v| types::WorkerCompleteTask::try_from(v).map_err(|e| e.to_string()))
-                .map_err(Error::InvalidRequest)?;
+            let body = body.map_err(Error::InvalidRequest)?;
             let url = format!(
                 "{}/v1/worker/task/{}/complete",
                 client.baseurl,
@@ -3869,15 +3805,15 @@ pub mod builder {
     pub struct WorkerTaskAddOutput<'a> {
         client: &'a super::Client,
         task: Result<::std::string::String, String>,
-        body: Result<types::builder::WorkerAddOutput, String>,
+        body: Result<types::WorkerAddOutput, String>,
     }
 
     impl<'a> WorkerTaskAddOutput<'a> {
         pub fn new(client: &'a super::Client) -> Self {
             Self {
                 client: client,
                 task: Err("task was not initialized".to_string()),
-                body: Ok(::std::default::Default::default()),
+                body: Err("body was not initialized".to_string()),
             }
         }
 
@@ -3894,30 +3830,18 @@ pub mod builder {
         pub fn body<V>(mut self, value: V) -> Self
         where
             V: std::convert::TryInto<types::WorkerAddOutput>,
-            <V as std::convert::TryInto<types::WorkerAddOutput>>::Error: std::fmt::Display,
         {
             self.body = value
                 .try_into()
-                .map(From::from)
-                .map_err(|s| format!("conversion to `WorkerAddOutput` for body failed: {}", s));
-            self
-        }
-
-        pub fn body_map<F>(mut self, f: F) -> Self
-        where
-            F: std::ops::FnOnce(types::builder::WorkerAddOutput) -> types::builder::WorkerAddOutput,
-        {
-            self.body = self.body.map(f);
+                .map_err(|_| "conversion to `WorkerAddOutput` for body failed".to_string());
             self
         }
 
         ///Sends a `POST` request to `/v1/worker/task/{task}/output`
         pub async fn send(self) -> Result<ResponseValue<()>, Error<()>> {
             let Self { client, task, body } = self;
             let task = task.map_err(Error::InvalidRequest)?;
-            let body = body
-                .and_then(|v| types::WorkerAddOutput::try_from(v).map_err(|e| e.to_string()))
-                .map_err(Error::InvalidRequest)?;
+            let body = body.map_err(Error::InvalidRequest)?;
             let url = format!(
                 "{}/v1/worker/task/{}/output",
                 client.baseurl,