pub mod operations {
# and [`Then`](httpmock::Then)"]
#![doc = r" wrappers for each operation. Each can be converted to"]
#![doc = r" its inner type with a call to `into_inner()`. This can"]
#![doc = r" be used to explicitly deviate from permitted values."]
use sdk::*;
pub struct ControlHoldWhen(httpmock::When);
impl ControlHoldWhen {
pub fn new(inner: httpmock::When) -> Self {
Self(
inner
.method(httpmock::Method::POST)
.path_matches(regex::Regex::new("^/v1/control/hold$").unwrap()),
)
}
pub fn into_inner(self) -> httpmock::When {
self.0
}
}
pub struct ControlHoldThen(httpmock::Then);
impl ControlHoldThen {
pub fn new(inner: httpmock::Then) -> Self {
Self(inner)
}
pub fn into_inner(self) -> httpmock::Then {
self.0
}
pub fn ok(self, value: ()) -> Self {
Self(
self.0
.status(200u16)
.header("content-type", "application/json")
.json_body_obj(value),
)
}
}
pub struct ControlResumeWhen(httpmock::When);
impl ControlResumeWhen {
pub fn new(inner: httpmock::When) -> Self {
Self(
inner
.method(httpmock::Method::POST)
.path_matches(regex::Regex::new("^/v1/control/resume$").unwrap()),
)
}
pub fn into_inner(self) -> httpmock::When {
self.0
}
}
pub struct ControlResumeThen(httpmock::Then);
impl ControlResumeThen {
pub fn new(inner: httpmock::Then) -> Self {
Self(inner)
}
pub fn into_inner(self) -> httpmock::Then {
self.0
}
pub fn ok(self) -> Self {
Self(self.0.status(200u16))
}
}
pub struct TaskGetWhen(httpmock::When);
impl TaskGetWhen {
pub fn new(inner: httpmock::When) -> Self {
Self(
inner
.method(httpmock::Method::GET)
.path_matches(regex::Regex::new("^/v1/task/[^/]*$").unwrap()),
)
}
pub fn into_inner(self) -> httpmock::When {
self.0
}
pub fn task(self, value: &str) -> Self {
let re = regex::Regex::new(&format!("^/v1/task/{}$", value.to_string())).unwrap();
Self(self.0.path_matches(re))
}
}
pub struct TaskGetThen(httpmock::Then);
impl TaskGetThen {
pub fn new(inner: httpmock::Then) -> Self {
Self(inner)
}
pub fn into_inner(self) -> httpmock::Then {
self.0
}
pub fn ok(self, value: &types::Task) -> Self {
Self(
self.0
.status(200u16)
.header("content-type", "application/json")
.json_body_obj(value),
)
}
}
pub struct TasksGetWhen(httpmock::When);
impl TasksGetWhen {
pub fn new(inner: httpmock::When) -> Self {
Self(
inner
.method(httpmock::Method::GET)
.path_matches(regex::Regex::new("^/v1/tasks$").unwrap()),
)
}
pub fn into_inner(self) -> httpmock::When {
self.0
}
}
pub struct TasksGetThen(httpmock::Then);
impl TasksGetThen {
pub fn new(inner: httpmock::Then) -> Self {
Self(inner)
}
pub fn into_inner(self) -> httpmock::Then {
self.0
}
pub fn ok(self, value: &Vec<types::Task>) -> Self {
Self(
self.0
.status(200u16)
.header("content-type", "application/json")
.json_body_obj(value),
)
}
}
pub struct TaskSubmitWhen(httpmock::When);
impl TaskSubmitWhen {
pub fn new(inner: httpmock::When) -> Self {
Self(
inner
.method(httpmock::Method::POST)
.path_matches(regex::Regex::new("^/v1/tasks$").unwrap()),
)
}
pub fn into_inner(self) -> httpmock::When {
self.0
}
pub fn body(self, value: &types::TaskSubmit) -> Self {
Self(self.0.json_body_obj(value))
}
}
pub struct TaskSubmitThen(httpmock::Then);
impl TaskSubmitThen {
pub fn new(inner: httpmock::Then) -> Self {
Self(inner)
}
pub fn into_inner(self) -> httpmock::Then {
self.0
}
pub fn created(self, value: &types::TaskSubmitResult) -> Self {
Self(
self.0
.status(201u16)
.header("content-type", "application/json")
.json_body_obj(value),
)
}
}
pub struct TaskEventsGetWhen(httpmock::When);
impl TaskEventsGetWhen {
pub fn new(inner: httpmock::When) -> Self {
Self(
inner
.method(httpmock::Method::GET)
.path_matches(regex::Regex::new("^/v1/tasks/[^/]*/events$").unwrap()),
)
}
pub fn into_inner(self) -> httpmock::When {
self.0
}
pub fn task(self, value: &str) -> Self {
let re =
regex::Regex::new(&format!("^/v1/tasks/{}/events$", value.to_string())).unwrap();
Self(self.0.path_matches(re))
}
pub fn minseq<T>(self, value: T) -> Self
where
T: Into<Option<u32>>,
{
if let Some(value) = value.into() {
Self(self.0.query_param("minseq", value.to_string()))
} else {
Self(self.0.matches(|req| {
req.query_params
.as_ref()
.and_then(|qs| qs.iter().find(|(key, _)| key == "minseq"))
.is_none()
}))
}
}
}
pub struct TaskEventsGetThen(httpmock::Then);
impl TaskEventsGetThen {
pub fn new(inner: httpmock::Then) -> Self {
Self(inner)
}
pub fn into_inner(self) -> httpmock::Then {
self.0
}
pub fn ok(self, value: &Vec<types::TaskEvent>) -> Self {
Self(
self.0
.status(200u16)
.header("content-type", "application/json")
.json_body_obj(value),
)
}
}
pub struct TaskOutputsGetWhen(httpmock::When);
impl TaskOutputsGetWhen {
pub fn new(inner: httpmock::When) -> Self {
Self(
inner
.method(httpmock::Method::GET)
.path_matches(regex::Regex::new("^/v1/tasks/[^/]*/outputs$").unwrap()),
)
}
pub fn into_inner(self) -> httpmock::When {
self.0
}
pub fn task(self, value: &str) -> Self {
let re =
regex::Regex::new(&format!("^/v1/tasks/{}/outputs$", value.to_string())).unwrap();
Self(self.0.path_matches(re))
}
}
pub struct TaskOutputsGetThen(httpmock::Then);
impl TaskOutputsGetThen {
pub fn new(inner: httpmock::Then) -> Self {
Self(inner)
}
pub fn into_inner(self) -> httpmock::Then {
self.0
}
pub fn ok(self, value: &Vec<types::TaskOutput>) -> Self {
Self(
self.0
.status(200u16)
.header("content-type", "application/json")
.json_body_obj(value),
)
}
}
pub struct TaskOutputDownloadWhen(httpmock::When);
impl TaskOutputDownloadWhen {
pub fn new(inner: httpmock::When) -> Self {
Self(
inner
.method(httpmock::Method::GET)
.path_matches(regex::Regex::new("^/v1/tasks/[^/]*/outputs/[^/]*$").unwrap()),
)
}
pub fn into_inner(self) -> httpmock::When {
self.0
}
pub fn task(self, value: &str) -> Self {
let re = regex::Regex::new(&format!("^/v1/tasks/{}/outputs/.*$", value.to_string()))
.unwrap();
Self(self.0.path_matches(re))
}
pub fn output(self, value: &str) -> Self {
let re = regex::Regex::new(&format!("^/v1/tasks/.*/outputs/{}$", value.to_string()))
.unwrap();
Self(self.0.path_matches(re))
}
}
pub struct TaskOutputDownloadThen(httpmock::Then);
impl TaskOutputDownloadThen {
pub fn new(inner: httpmock::Then) -> Self {
Self(inner)
}
pub fn into_inner(self) -> httpmock::Then {
self.0
}
pub fn success(self, status: u16, value: serde_json::Value) -> Self {
assert_eq!(status / 100u16, 2u16);
Self(
self.0
.status(status)
.header("content-type", "application/json")
.json_body(value),
)
}
}
pub struct UserCreateWhen(httpmock::When);
impl UserCreateWhen {
pub fn new(inner: httpmock::When) -> Self {
Self(
inner
.method(httpmock::Method::POST)
.path_matches(regex::Regex::new("^/v1/users$").unwrap()),
)
}
pub fn into_inner(self) -> httpmock::When {
self.0
}
pub fn body(self, value: &types::UserCreate) -> Self {
Self(self.0.json_body_obj(value))
}
}
pub struct UserCreateThen(httpmock::Then);
impl UserCreateThen {
pub fn new(inner: httpmock::Then) -> Self {
Self(inner)
}
pub fn into_inner(self) -> httpmock::Then {
self.0
}
pub fn created(self, value: &types::UserCreateResult) -> Self {
Self(
self.0
.status(201u16)
.header("content-type", "application/json")
.json_body_obj(value),
)
}
}
pub struct WhoamiWhen(httpmock::When);
impl WhoamiWhen {
pub fn new(inner: httpmock::When) -> Self {
Self(
inner
.method(httpmock::Method::GET)
.path_matches(regex::Regex::new("^/v1/whoami$").unwrap()),
)
}
pub fn into_inner(self) -> httpmock::When {
self.0
}
}
pub struct WhoamiThen(httpmock::Then);
impl WhoamiThen {
pub fn new(inner: httpmock::Then) -> Self {
Self(inner)
}
pub fn into_inner(self) -> httpmock::Then {
self.0
}
pub fn ok(self, value: &types::WhoamiResult) -> Self {
Self(
self.0
.status(200u16)
.header("content-type", "application/json")
.json_body_obj(value),
)
}
}
pub struct WorkerBootstrapWhen(httpmock::When);
impl WorkerBootstrapWhen {
pub fn new(inner: httpmock::When) -> Self {
Self(
inner
.method(httpmock::Method::POST)
.path_matches(regex::Regex::new("^/v1/worker/bootstrap$").unwrap()),
)
}
pub fn into_inner(self) -> httpmock::When {
self.0
}
pub fn body(self, value: &types::WorkerBootstrap) -> Self {
Self(self.0.json_body_obj(value))
}
}
pub struct WorkerBootstrapThen(httpmock::Then);
impl WorkerBootstrapThen {
pub fn new(inner: httpmock::Then) -> Self {
Self(inner)
}
pub fn into_inner(self) -> httpmock::Then {
self.0
}
pub fn created(self, value: &types::WorkerBootstrapResult) -> Self {
Self(
self.0
.status(201u16)
.header("content-type", "application/json")
.json_body_obj(value),
)
}
}
pub struct WorkerPingWhen(httpmock::When);
impl WorkerPingWhen {
pub fn new(inner: httpmock::When) -> Self {
Self(
inner
.method(httpmock::Method::GET)
.path_matches(regex::Regex::new("^/v1/worker/ping$").unwrap()),
)
}
pub fn into_inner(self) -> httpmock::When {
self.0
}
}
pub struct WorkerPingThen(httpmock::Then);
impl WorkerPingThen {
pub fn new(inner: httpmock::Then) -> Self {
Self(inner)
}
pub fn into_inner(self) -> httpmock::Then {
self.0
}
pub fn ok(self, value: &types::WorkerPingResult) -> Self {
Self(
self.0
.status(200u16)
.header("content-type", "application/json")
.json_body_obj(value),
)
}
}
pub struct WorkerTaskAppendWhen(httpmock::When);
impl WorkerTaskAppendWhen {
pub fn new(inner: httpmock::When) -> Self {
Self(
inner
.method(httpmock::Method::POST)
.path_matches(regex::Regex::new("^/v1/worker/task/[^/]*/append$").unwrap()),
)
}
pub fn into_inner(self) -> httpmock::When {
self.0
}
pub fn task(self, value: &str) -> Self {
let re = regex::Regex::new(&format!("^/v1/worker/task/{}/append$", value.to_string()))
.unwrap();
Self(self.0.path_matches(re))
}
pub fn body(self, value: &types::WorkerAppendTask) -> Self {
Self(self.0.json_body_obj(value))
}
}
pub struct WorkerTaskAppendThen(httpmock::Then);
impl WorkerTaskAppendThen {
pub fn new(inner: httpmock::Then) -> Self {
Self(inner)
}
pub fn into_inner(self) -> httpmock::Then {
self.0
}
pub fn created(self) -> Self {
Self(self.0.status(201u16))
}
}
pub struct WorkerTaskUploadChunkWhen(httpmock::When);
impl WorkerTaskUploadChunkWhen {
pub fn new(inner: httpmock::When) -> Self {
Self(
inner
.method(httpmock::Method::POST)
.path_matches(regex::Regex::new("^/v1/worker/task/[^/]*/chunk$").unwrap()),
)
}
pub fn into_inner(self) -> httpmock::When {
self.0
}
pub fn task(self, value: &str) -> Self {
let re = regex::Regex::new(&format!("^/v1/worker/task/{}/chunk$", value.to_string()))
.unwrap();
Self(self.0.path_matches(re))
}
pub fn body(self, value: serde_json::Value) -> Self {
Self(self.0.json_body(value))
}
}
pub struct WorkerTaskUploadChunkThen(httpmock::Then);
impl WorkerTaskUploadChunkThen {
pub fn new(inner: httpmock::Then) -> Self {
Self(inner)
}
pub fn into_inner(self) -> httpmock::Then {
self.0
}
pub fn created(self, value: &types::UploadedChunk) -> Self {
Self(
self.0
.status(201u16)
.header("content-type", "application/json")
.json_body_obj(value),
)
}
}
pub struct WorkerTaskCompleteWhen(httpmock::When);
impl WorkerTaskCompleteWhen {
pub fn new(inner: httpmock::When) -> Self {
Self(
inner
.method(httpmock::Method::POST)
.path_matches(regex::Regex::new("^/v1/worker/task/[^/]*/complete$").unwrap()),
)
}
pub fn into_inner(self) -> httpmock::When {
self.0
}
pub fn task(self, value: &str) -> Self {
let re =
regex::Regex::new(&format!("^/v1/worker/task/{}/complete$", value.to_string()))
.unwrap();
Self(self.0.path_matches(re))
}
pub fn body(self, value: &types::WorkerCompleteTask) -> Self {
Self(self.0.json_body_obj(value))
}
}
pub struct WorkerTaskCompleteThen(httpmock::Then);
impl WorkerTaskCompleteThen {
pub fn new(inner: httpmock::Then) -> Self {
Self(inner)
}
pub fn into_inner(self) -> httpmock::Then {
self.0
}
pub fn ok(self) -> Self {
Self(self.0.status(200u16))
}
}
pub struct WorkerTaskAddOutputWhen(httpmock::When);
impl WorkerTaskAddOutputWhen {
pub fn new(inner: httpmock::When) -> Self {
Self(
inner
.method(httpmock::Method::POST)
.path_matches(regex::Regex::new("^/v1/worker/task/[^/]*/output$").unwrap()),
)
}
pub fn into_inner(self) -> httpmock::When {
self.0
}
pub fn task(self, value: &str) -> Self {
let re = regex::Regex::new(&format!("^/v1/worker/task/{}/output$", value.to_string()))
.unwrap();
Self(self.0.path_matches(re))
}
pub fn body(self, value: &types::WorkerAddOutput) -> Self {
Self(self.0.json_body_obj(value))
}
}
pub struct WorkerTaskAddOutputThen(httpmock::Then);
impl WorkerTaskAddOutputThen {
pub fn new(inner: httpmock::Then) -> Self {
Self(inner)
}
pub fn into_inner(self) -> httpmock::Then {
self.0
}
pub fn created(self) -> Self {
Self(self.0.status(201u16))
}
}
pub struct WorkersListWhen(httpmock::When);
impl WorkersListWhen {
pub fn new(inner: httpmock::When) -> Self {
Self(
inner
.method(httpmock::Method::GET)
.path_matches(regex::Regex::new("^/v1/workers$").unwrap()),
)
}
pub fn into_inner(self) -> httpmock::When {
self.0
}
}
pub struct WorkersListThen(httpmock::Then);
impl WorkersListThen {
pub fn new(inner: httpmock::Then) -> Self {
Self(inner)
}
pub fn into_inner(self) -> httpmock::Then {
self.0
}
pub fn ok(self, value: &types::WorkersResult) -> Self {
Self(
self.0
.status(200u16)
.header("content-type", "application/json")
.json_body_obj(value),
)
}
}
pub struct WorkersRecycleWhen(httpmock::When);
impl WorkersRecycleWhen {
pub fn new(inner: httpmock::When) -> Self {
Self(
inner
.method(httpmock::Method::POST)
.path_matches(regex::Regex::new("^/v1/workers/recycle$").unwrap()),
)
}
pub fn into_inner(self) -> httpmock::When {
self.0
}
}
pub struct WorkersRecycleThen(httpmock::Then);
impl WorkersRecycleThen {
pub fn new(inner: httpmock::Then) -> Self {
Self(inner)
}
pub fn into_inner(self) -> httpmock::Then {
self.0
}
pub fn ok(self) -> Self {
Self(self.0.status(200u16))
}
}
}
#[doc = r" An extension trait for [`MockServer`](httpmock::MockServer) that"]
#[doc = r" adds a method for each operation. These are the equivalent of"]
#[doc = r" type-checked [`mock()`](httpmock::MockServer::mock) calls."]
pub trait MockServerExt {
fn control_hold<F>(&self, config_fn: F) -> httpmock::Mock
where
F: FnOnce(operations::ControlHoldWhen, operations::ControlHoldThen);
fn control_resume<F>(&self, config_fn: F) -> httpmock::Mock
where
F: FnOnce(operations::ControlResumeWhen, operations::ControlResumeThen);
fn task_get<F>(&self, config_fn: F) -> httpmock::Mock
where
F: FnOnce(operations::TaskGetWhen, operations::TaskGetThen);
fn tasks_get<F>(&self, config_fn: F) -> httpmock::Mock
where
F: FnOnce(operations::TasksGetWhen, operations::TasksGetThen);
fn task_submit<F>(&self, config_fn: F) -> httpmock::Mock
where
F: FnOnce(operations::TaskSubmitWhen, operations::TaskSubmitThen);
fn task_events_get<F>(&self, config_fn: F) -> httpmock::Mock
where
F: FnOnce(operations::TaskEventsGetWhen, operations::TaskEventsGetThen);
fn task_outputs_get<F>(&self, config_fn: F) -> httpmock::Mock
where
F: FnOnce(operations::TaskOutputsGetWhen, operations::TaskOutputsGetThen);
fn task_output_download<F>(&self, config_fn: F) -> httpmock::Mock
where
F: FnOnce(operations::TaskOutputDownloadWhen, operations::TaskOutputDownloadThen);
fn user_create<F>(&self, config_fn: F) -> httpmock::Mock
where
F: FnOnce(operations::UserCreateWhen, operations::UserCreateThen);
fn whoami<F>(&self, config_fn: F) -> httpmock::Mock
where
F: FnOnce(operations::WhoamiWhen, operations::WhoamiThen);
fn worker_bootstrap<F>(&self, config_fn: F) -> httpmock::Mock
where
F: FnOnce(operations::WorkerBootstrapWhen, operations::WorkerBootstrapThen);
fn worker_ping<F>(&self, config_fn: F) -> httpmock::Mock
where
F: FnOnce(operations::WorkerPingWhen, operations::WorkerPingThen);
fn worker_task_append<F>(&self, config_fn: F) -> httpmock::Mock
where
F: FnOnce(operations::WorkerTaskAppendWhen, operations::WorkerTaskAppendThen);
fn worker_task_upload_chunk<F>(&self, config_fn: F) -> httpmock::Mock
where
F: FnOnce(operations::WorkerTaskUploadChunkWhen, operations::WorkerTaskUploadChunkThen);
fn worker_task_complete<F>(&self, config_fn: F) -> httpmock::Mock
where
F: FnOnce(operations::WorkerTaskCompleteWhen, operations::WorkerTaskCompleteThen);
fn worker_task_add_output<F>(&self, config_fn: F) -> httpmock::Mock
where
F: FnOnce(operations::WorkerTaskAddOutputWhen, operations::WorkerTaskAddOutputThen);
fn workers_list<F>(&self, config_fn: F) -> httpmock::Mock
where
F: FnOnce(operations::WorkersListWhen, operations::WorkersListThen);
fn workers_recycle<F>(&self, config_fn: F) -> httpmock::Mock
where
F: FnOnce(operations::WorkersRecycleWhen, operations::WorkersRecycleThen);
}
impl MockServerExt for httpmock::MockServer {
fn control_hold<F>(&self, config_fn: F) -> httpmock::Mock
where
F: FnOnce(operations::ControlHoldWhen, operations::ControlHoldThen),
{
self.mock(|when, then| {
config_fn(
operations::ControlHoldWhen::new(when),
operations::ControlHoldThen::new(then),
)
})
}
fn control_resume<F>(&self, config_fn: F) -> httpmock::Mock
where
F: FnOnce(operations::ControlResumeWhen, operations::ControlResumeThen),
{
self.mock(|when, then| {
config_fn(
operations::ControlResumeWhen::new(when),
operations::ControlResumeThen::new(then),
)
})
}
fn task_get<F>(&self, config_fn: F) -> httpmock::Mock
where
F: FnOnce(operations::TaskGetWhen, operations::TaskGetThen),
{
self.mock(|when, then| {
config_fn(
operations::TaskGetWhen::new(when),
operations::TaskGetThen::new(then),
)
})
}
fn tasks_get<F>(&self, config_fn: F) -> httpmock::Mock
where
F: FnOnce(operations::TasksGetWhen, operations::TasksGetThen),
{
self.mock(|when, then| {
config_fn(
operations::TasksGetWhen::new(when),
operations::TasksGetThen::new(then),
)
})
}
fn task_submit<F>(&self, config_fn: F) -> httpmock::Mock
where
F: FnOnce(operations::TaskSubmitWhen, operations::TaskSubmitThen),
{
self.mock(|when, then| {
config_fn(
operations::TaskSubmitWhen::new(when),
operations::TaskSubmitThen::new(then),
)
})
}
fn task_events_get<F>(&self, config_fn: F) -> httpmock::Mock
where
F: FnOnce(operations::TaskEventsGetWhen, operations::TaskEventsGetThen),
{
self.mock(|when, then| {
config_fn(
operations::TaskEventsGetWhen::new(when),
operations::TaskEventsGetThen::new(then),
)
})
}
fn task_outputs_get<F>(&self, config_fn: F) -> httpmock::Mock
where
F: FnOnce(operations::TaskOutputsGetWhen, operations::TaskOutputsGetThen),
{
self.mock(|when, then| {
config_fn(
operations::TaskOutputsGetWhen::new(when),
operations::TaskOutputsGetThen::new(then),
)
})
}
fn task_output_download<F>(&self, config_fn: F) -> httpmock::Mock
where
F: FnOnce(operations::TaskOutputDownloadWhen, operations::TaskOutputDownloadThen),
{
self.mock(|when, then| {
config_fn(
operations::TaskOutputDownloadWhen::new(when),
operations::TaskOutputDownloadThen::new(then),
)
})
}
fn user_create<F>(&self, config_fn: F) -> httpmock::Mock
where
F: FnOnce(operations::UserCreateWhen, operations::UserCreateThen),
{
self.mock(|when, then| {
config_fn(
operations::UserCreateWhen::new(when),
operations::UserCreateThen::new(then),
)
})
}
fn whoami<F>(&self, config_fn: F) -> httpmock::Mock
where
F: FnOnce(operations::WhoamiWhen, operations::WhoamiThen),
{
self.mock(|when, then| {
config_fn(
operations::WhoamiWhen::new(when),
operations::WhoamiThen::new(then),
)
})
}
fn worker_bootstrap<F>(&self, config_fn: F) -> httpmock::Mock
where
F: FnOnce(operations::WorkerBootstrapWhen, operations::WorkerBootstrapThen),
{
self.mock(|when, then| {
config_fn(
operations::WorkerBootstrapWhen::new(when),
operations::WorkerBootstrapThen::new(then),
)
})
}
fn worker_ping<F>(&self, config_fn: F) -> httpmock::Mock
where
F: FnOnce(operations::WorkerPingWhen, operations::WorkerPingThen),
{
self.mock(|when, then| {
config_fn(
operations::WorkerPingWhen::new(when),
operations::WorkerPingThen::new(then),
)
})
}
fn worker_task_append<F>(&self, config_fn: F) -> httpmock::Mock
where
F: FnOnce(operations::WorkerTaskAppendWhen, operations::WorkerTaskAppendThen),
{
self.mock(|when, then| {
config_fn(
operations::WorkerTaskAppendWhen::new(when),
operations::WorkerTaskAppendThen::new(then),
)
})
}
fn worker_task_upload_chunk<F>(&self, config_fn: F) -> httpmock::Mock
where
F: FnOnce(operations::WorkerTaskUploadChunkWhen, operations::WorkerTaskUploadChunkThen),
{
self.mock(|when, then| {
config_fn(
operations::WorkerTaskUploadChunkWhen::new(when),
operations::WorkerTaskUploadChunkThen::new(then),
)
})
}
fn worker_task_complete<F>(&self, config_fn: F) -> httpmock::Mock
where
F: FnOnce(operations::WorkerTaskCompleteWhen, operations::WorkerTaskCompleteThen),
{
self.mock(|when, then| {
config_fn(
operations::WorkerTaskCompleteWhen::new(when),
operations::WorkerTaskCompleteThen::new(then),
)
})
}
fn worker_task_add_output<F>(&self, config_fn: F) -> httpmock::Mock
where
F: FnOnce(operations::WorkerTaskAddOutputWhen, operations::WorkerTaskAddOutputThen),
{
self.mock(|when, then| {
config_fn(
operations::WorkerTaskAddOutputWhen::new(when),
operations::WorkerTaskAddOutputThen::new(then),
)
})
}
fn workers_list<F>(&self, config_fn: F) -> httpmock::Mock
where
F: FnOnce(operations::WorkersListWhen, operations::WorkersListThen),
{
self.mock(|when, then| {
config_fn(
operations::WorkersListWhen::new(when),
operations::WorkersListThen::new(then),
)
})
}
fn workers_recycle<F>(&self, config_fn: F) -> httpmock::Mock
where
F: FnOnce(operations::WorkersRecycleWhen, operations::WorkersRecycleThen),
{
self.mock(|when, then| {
config_fn(
operations::WorkersRecycleWhen::new(when),
operations::WorkersRecycleThen::new(then),
)
})
}
}