#![allow(unused_mut)]
#![allow(unused_variables)]
#![allow(unused_imports)]
#![allow(clippy::redundant_clone)]
#![allow(clippy::too_many_arguments)]
#![allow(clippy::module_inception)]
pub mod models;
#[derive(Clone)]
pub struct Client {
endpoint: azure_core::http::Url,
credential: crate::Credential,
scopes: Vec<String>,
pipeline: azure_core::http::Pipeline,
}
#[derive(Clone)]
pub struct ClientBuilder {
credential: crate::Credential,
endpoint: Option<azure_core::http::Url>,
scopes: Option<Vec<String>>,
options: azure_core::http::ClientOptions,
}
azure_core::static_url!(DEFAULT_ENDPOINT, "https://vstmr.dev.azure.com");
impl ClientBuilder {
#[doc = "Create a new instance of `ClientBuilder`."]
#[must_use]
pub fn new(credential: crate::Credential) -> Self {
Self {
credential,
endpoint: None,
scopes: None,
options: azure_core::http::ClientOptions::default(),
}
}
#[doc = "Set the endpoint."]
#[must_use]
pub fn endpoint(mut self, endpoint: impl Into<azure_core::http::Url>) -> Self {
self.endpoint = Some(endpoint.into());
self
}
#[doc = "Set the scopes."]
#[must_use]
pub fn scopes(mut self, scopes: &[&str]) -> Self {
self.scopes = Some(scopes.iter().map(|scope| (*scope).to_owned()).collect());
self
}
#[doc = "Set the retry options."]
#[must_use]
pub fn retry(mut self, retry: impl Into<azure_core::http::RetryOptions>) -> Self {
self.options.retry = retry.into();
self
}
#[doc = "Set the transport options."]
#[must_use]
pub fn transport(mut self, transport: impl Into<azure_core::http::Transport>) -> Self {
self.options.transport = Some(transport.into());
self
}
#[doc = "Set per-call policies."]
#[must_use]
pub fn per_call_policies(
mut self,
policies: impl Into<Vec<std::sync::Arc<dyn azure_core::http::policies::Policy>>>,
) -> Self {
self.options.per_call_policies = policies.into();
self
}
#[doc = "Set per-try policies."]
#[must_use]
pub fn per_try_policies(
mut self,
policies: impl Into<Vec<std::sync::Arc<dyn azure_core::http::policies::Policy>>>,
) -> Self {
self.options.per_try_policies = policies.into();
self
}
#[doc = "Convert the builder into a `Client` instance."]
pub fn build(self) -> Client {
let endpoint = self.endpoint.unwrap_or_else(|| DEFAULT_ENDPOINT.to_owned());
let scopes = self
.scopes
.unwrap_or_else(|| vec![crate::ADO_SCOPE.to_string()]);
Client::new(endpoint, self.credential, scopes, self.options)
}
}
impl Client {
pub(crate) fn endpoint(&self) -> &azure_core::http::Url {
&self.endpoint
}
pub(crate) fn token_credential(&self) -> &crate::Credential {
&self.credential
}
pub(crate) fn scopes(&self) -> Vec<&str> {
self.scopes.iter().map(String::as_str).collect()
}
pub(crate) async fn send(
&self,
request: &mut azure_core::http::Request,
) -> azure_core::Result<azure_core::http::RawResponse> {
let context = azure_core::http::Context::default();
self.pipeline.send(&context, request, None).await
}
#[doc = "Create a new `ClientBuilder`."]
#[must_use]
pub fn builder(credential: crate::Credential) -> ClientBuilder {
ClientBuilder::new(credential)
}
#[doc = "Create a new `Client`."]
#[must_use]
pub fn new(
endpoint: impl Into<azure_core::http::Url>,
credential: crate::Credential,
scopes: Vec<String>,
options: azure_core::http::ClientOptions,
) -> Self {
let endpoint = endpoint.into();
let pipeline = azure_core::http::Pipeline::new(
option_env!("CARGO_PKG_NAME"),
option_env!("CARGO_PKG_VERSION"),
options,
Vec::new(),
Vec::new(),
None,
);
Self {
endpoint,
credential,
scopes,
pipeline,
}
}
pub fn attachments_client(&self) -> attachments::Client {
attachments::Client(self.clone())
}
pub fn bugs_client(&self) -> bugs::Client {
bugs::Client(self.clone())
}
pub fn codecoverage_client(&self) -> codecoverage::Client {
codecoverage::Client(self.clone())
}
pub fn filecoverage_client(&self) -> filecoverage::Client {
filecoverage::Client(self.clone())
}
pub fn history_client(&self) -> history::Client {
history::Client(self.clone())
}
pub fn message_logs_client(&self) -> message_logs::Client {
message_logs::Client(self.clone())
}
pub fn metrics_client(&self) -> metrics::Client {
metrics::Client(self.clone())
}
pub fn result_document_client(&self) -> result_document::Client {
result_document::Client(self.clone())
}
pub fn result_meta_data_client(&self) -> result_meta_data::Client {
result_meta_data::Client(self.clone())
}
pub fn result_trend_by_build_client(&self) -> result_trend_by_build::Client {
result_trend_by_build::Client(self.clone())
}
pub fn result_trend_by_release_client(&self) -> result_trend_by_release::Client {
result_trend_by_release::Client(self.clone())
}
pub fn resultdetailsbybuild_client(&self) -> resultdetailsbybuild::Client {
resultdetailsbybuild::Client(self.clone())
}
pub fn resultdetailsbyrelease_client(&self) -> resultdetailsbyrelease::Client {
resultdetailsbyrelease::Client(self.clone())
}
pub fn resultgroupsbybuild_client(&self) -> resultgroupsbybuild::Client {
resultgroupsbybuild::Client(self.clone())
}
pub fn resultgroupsbyrelease_client(&self) -> resultgroupsbyrelease::Client {
resultgroupsbyrelease::Client(self.clone())
}
pub fn results_client(&self) -> results::Client {
results::Client(self.clone())
}
pub fn resultsbybuild_client(&self) -> resultsbybuild::Client {
resultsbybuild::Client(self.clone())
}
pub fn resultsbypipeline_client(&self) -> resultsbypipeline::Client {
resultsbypipeline::Client(self.clone())
}
pub fn resultsbyrelease_client(&self) -> resultsbyrelease::Client {
resultsbyrelease::Client(self.clone())
}
pub fn resultsgroup_details_client(&self) -> resultsgroup_details::Client {
resultsgroup_details::Client(self.clone())
}
pub fn resultsummarybybuild_client(&self) -> resultsummarybybuild::Client {
resultsummarybybuild::Client(self.clone())
}
pub fn resultsummarybypipeline_client(&self) -> resultsummarybypipeline::Client {
resultsummarybypipeline::Client(self.clone())
}
pub fn resultsummarybyrelease_client(&self) -> resultsummarybyrelease::Client {
resultsummarybyrelease::Client(self.clone())
}
pub fn resultsummarybyrequirement_client(&self) -> resultsummarybyrequirement::Client {
resultsummarybyrequirement::Client(self.clone())
}
pub fn runs_client(&self) -> runs::Client {
runs::Client(self.clone())
}
pub fn runsummary_client(&self) -> runsummary::Client {
runsummary::Client(self.clone())
}
pub fn settings_client(&self) -> settings::Client {
settings::Client(self.clone())
}
pub fn similar_test_results_client(&self) -> similar_test_results::Client {
similar_test_results::Client(self.clone())
}
pub fn statistics_client(&self) -> statistics::Client {
statistics::Client(self.clone())
}
pub fn status_client(&self) -> status::Client {
status::Client(self.clone())
}
pub fn tags_client(&self) -> tags::Client {
tags::Client(self.clone())
}
pub fn tagsummary_client(&self) -> tagsummary::Client {
tagsummary::Client(self.clone())
}
pub fn test_history_client(&self) -> test_history::Client {
test_history::Client(self.clone())
}
pub fn testattachments_client(&self) -> testattachments::Client {
testattachments::Client(self.clone())
}
pub fn testfailuretype_client(&self) -> testfailuretype::Client {
testfailuretype::Client(self.clone())
}
pub fn testlog_client(&self) -> testlog::Client {
testlog::Client(self.clone())
}
pub fn testlogstoreendpoint_client(&self) -> testlogstoreendpoint::Client {
testlogstoreendpoint::Client(self.clone())
}
pub fn testsettings_client(&self) -> testsettings::Client {
testsettings::Client(self.clone())
}
pub fn workitems_client(&self) -> workitems::Client {
workitems::Client(self.clone())
}
}
pub mod codecoverage {
use super::models;
#[cfg(not(target_arch = "wasm32"))]
use futures::future::BoxFuture;
#[cfg(target_arch = "wasm32")]
use futures::future::LocalBoxFuture as BoxFuture;
pub struct Client(pub(crate) super::Client);
impl Client {
#[doc = "Arguments:"]
#[doc = "* `organization`: The name of the Azure DevOps organization."]
#[doc = "* `project`: Project ID or project name"]
pub fn get_build_code_coverage(
&self,
organization: impl Into<String>,
project: impl Into<String>,
build_id: i32,
flags: i32,
) -> get_build_code_coverage::RequestBuilder {
get_build_code_coverage::RequestBuilder {
client: self.0.clone(),
organization: organization.into(),
project: project.into(),
build_id,
flags,
}
}
#[doc = "Arguments:"]
#[doc = "* `organization`: The name of the Azure DevOps organization."]
#[doc = "* `project`: Project ID or project name"]
pub fn get(
&self,
organization: impl Into<String>,
project: impl Into<String>,
build_id: i32,
) -> get::RequestBuilder {
get::RequestBuilder {
client: self.0.clone(),
organization: organization.into(),
project: project.into(),
build_id,
delta_build_id: None,
}
}
#[doc = "http://(tfsserver):8080/tfs/DefaultCollection/_apis/test/CodeCoverage?buildId=10 Request: Json of code coverage summary"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `organization`: The name of the Azure DevOps organization."]
#[doc = "* `project`: Project ID or project name"]
pub fn update(
&self,
organization: impl Into<String>,
project: impl Into<String>,
build_id: i32,
) -> update::RequestBuilder {
update::RequestBuilder {
client: self.0.clone(),
organization: organization.into(),
project: project.into(),
build_id,
body: None,
}
}
#[doc = "Arguments:"]
#[doc = "* `organization`: The name of the Azure DevOps organization."]
#[doc = "* `project`: Project ID or project name"]
pub fn get_test_run_code_coverage(
&self,
organization: impl Into<String>,
project: impl Into<String>,
run_id: i32,
flags: i32,
) -> get_test_run_code_coverage::RequestBuilder {
get_test_run_code_coverage::RequestBuilder {
client: self.0.clone(),
organization: organization.into(),
project: project.into(),
run_id,
flags,
}
}
}
pub mod get_build_code_coverage {
use super::models;
#[cfg(not(target_arch = "wasm32"))]
use futures::future::BoxFuture;
#[cfg(target_arch = "wasm32")]
use futures::future::LocalBoxFuture as BoxFuture;
#[derive(Debug)]
pub struct Response(
azure_core::http::Response<models::BuildCoverageList, azure_core::http::JsonFormat>,
);
impl Response {
pub fn into_body(self) -> azure_core::Result<models::BuildCoverageList> {
self.0.into_model()
}
pub fn into_raw_response(self) -> azure_core::http::RawResponse {
self.0.into()
}
}
#[derive(Clone)]
#[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."]
#[doc = r""]
#[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"]
#[doc = r" parameters can be chained."]
#[doc = r""]
#[doc = r" To finalize and submit the request, invoke `.await`, which"]
#[doc = r" converts the [`RequestBuilder`] into a future,"]
#[doc = r" executes the request and returns a `Result` with the parsed"]
#[doc = r" response."]
#[doc = r""]
#[doc = r" If you need lower-level access to the raw response details"]
#[doc = r" (e.g. to inspect response headers or raw body data) then you"]
#[doc = r" can finalize the request using the"]
#[doc = r" [`RequestBuilder::send()`] method which returns a future"]
#[doc = r" that resolves to a lower-level [`Response`] value."]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) organization: String,
pub(crate) project: String,
pub(crate) build_id: i32,
pub(crate) flags: i32,
}
impl RequestBuilder {
#[doc = "Returns a future that sends the request and returns a [`Response`] object that provides low-level access to full response details."]
#[doc = ""]
#[doc = "You should typically use `.await` (which implicitly calls `IntoFuture::into_future()`) to finalize and send requests rather than `send()`."]
#[doc = "However, this function can provide more flexibility when required."]
pub fn send(self) -> BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = this.url()?;
let mut req =
azure_core::http::Request::new(url, azure_core::http::Method::Get);
if let Some(auth_header) = this
.client
.token_credential()
.http_authorization_header(&this.client.scopes())
.await?
{
req.insert_header(
azure_core::http::headers::AUTHORIZATION,
auth_header,
);
}
let build_id = &this.build_id;
req.url_mut()
.query_pairs_mut()
.append_pair("buildId", &build_id.to_string());
let flags = &this.flags;
req.url_mut()
.query_pairs_mut()
.append_pair("flags", &flags.to_string());
let req_body = azure_core::Bytes::new();
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?.into()))
}
})
}
fn url(&self) -> azure_core::Result<azure_core::http::Url> {
let mut url = azure_core::http::Url::parse(&format!(
"{}/{}/{}/_apis/testresults/codecoverage?buildId={}&flags={}",
self.client.endpoint(),
&self.organization,
&self.project,
&self.build_id,
&self.flags
))?;
let has_api_version_already = url.query_pairs().any(|(k, _)| k == "api-version");
if !has_api_version_already {
url.query_pairs_mut()
.append_pair("api-version", "7.1-preview");
}
Ok(url)
}
}
impl std::future::IntoFuture for RequestBuilder {
type Output = azure_core::Result<models::BuildCoverageList>;
type IntoFuture = BoxFuture<'static, azure_core::Result<models::BuildCoverageList>>;
#[doc = "Returns a future that sends the request and returns the parsed response body."]
#[doc = ""]
#[doc = "You should not normally call this method directly, simply invoke `.await` which implicitly calls `IntoFuture::into_future`."]
#[doc = ""]
#[doc = "See [IntoFuture documentation](https://doc.rust-lang.org/std/future/trait.IntoFuture.html) for more details."]
fn into_future(self) -> Self::IntoFuture {
Box::pin(async move { self.send().await?.into_body() })
}
}
}
pub mod get {
use super::models;
#[cfg(not(target_arch = "wasm32"))]
use futures::future::BoxFuture;
#[cfg(target_arch = "wasm32")]
use futures::future::LocalBoxFuture as BoxFuture;
#[derive(Debug)]
pub struct Response(
azure_core::http::Response<models::CodeCoverageSummary, azure_core::http::JsonFormat>,
);
impl Response {
pub fn into_body(self) -> azure_core::Result<models::CodeCoverageSummary> {
self.0.into_model()
}
pub fn into_raw_response(self) -> azure_core::http::RawResponse {
self.0.into()
}
}
#[derive(Clone)]
#[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."]
#[doc = r""]
#[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"]
#[doc = r" parameters can be chained."]
#[doc = r""]
#[doc = r" To finalize and submit the request, invoke `.await`, which"]
#[doc = r" converts the [`RequestBuilder`] into a future,"]
#[doc = r" executes the request and returns a `Result` with the parsed"]
#[doc = r" response."]
#[doc = r""]
#[doc = r" If you need lower-level access to the raw response details"]
#[doc = r" (e.g. to inspect response headers or raw body data) then you"]
#[doc = r" can finalize the request using the"]
#[doc = r" [`RequestBuilder::send()`] method which returns a future"]
#[doc = r" that resolves to a lower-level [`Response`] value."]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) organization: String,
pub(crate) project: String,
pub(crate) build_id: i32,
pub(crate) delta_build_id: Option<i32>,
}
impl RequestBuilder {
pub fn delta_build_id(mut self, delta_build_id: i32) -> Self {
self.delta_build_id = Some(delta_build_id);
self
}
#[doc = "Returns a future that sends the request and returns a [`Response`] object that provides low-level access to full response details."]
#[doc = ""]
#[doc = "You should typically use `.await` (which implicitly calls `IntoFuture::into_future()`) to finalize and send requests rather than `send()`."]
#[doc = "However, this function can provide more flexibility when required."]
pub fn send(self) -> BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = this.url()?;
let mut req =
azure_core::http::Request::new(url, azure_core::http::Method::Get);
if let Some(auth_header) = this
.client
.token_credential()
.http_authorization_header(&this.client.scopes())
.await?
{
req.insert_header(
azure_core::http::headers::AUTHORIZATION,
auth_header,
);
}
let build_id = &this.build_id;
req.url_mut()
.query_pairs_mut()
.append_pair("buildId", &build_id.to_string());
if let Some(delta_build_id) = &this.delta_build_id {
req.url_mut()
.query_pairs_mut()
.append_pair("deltaBuildId", &delta_build_id.to_string());
}
let req_body = azure_core::Bytes::new();
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?.into()))
}
})
}
fn url(&self) -> azure_core::Result<azure_core::http::Url> {
let mut url = azure_core::http::Url::parse(&format!(
"{}/{}/{}/_apis/testresults/codecoverage",
self.client.endpoint(),
&self.organization,
&self.project
))?;
let has_api_version_already = url.query_pairs().any(|(k, _)| k == "api-version");
if !has_api_version_already {
url.query_pairs_mut()
.append_pair("api-version", "7.1-preview");
}
Ok(url)
}
}
impl std::future::IntoFuture for RequestBuilder {
type Output = azure_core::Result<models::CodeCoverageSummary>;
type IntoFuture = BoxFuture<'static, azure_core::Result<models::CodeCoverageSummary>>;
#[doc = "Returns a future that sends the request and returns the parsed response body."]
#[doc = ""]
#[doc = "You should not normally call this method directly, simply invoke `.await` which implicitly calls `IntoFuture::into_future`."]
#[doc = ""]
#[doc = "See [IntoFuture documentation](https://doc.rust-lang.org/std/future/trait.IntoFuture.html) for more details."]
fn into_future(self) -> Self::IntoFuture {
Box::pin(async move { self.send().await?.into_body() })
}
}
}
pub mod update {
use super::models;
#[cfg(not(target_arch = "wasm32"))]
use futures::future::BoxFuture;
#[cfg(target_arch = "wasm32")]
use futures::future::LocalBoxFuture as BoxFuture;
#[derive(Debug)]
pub struct Response(azure_core::http::Response<(), azure_core::http::NoFormat>);
impl Response {
pub fn into_raw_response(self) -> azure_core::http::RawResponse {
self.0.into()
}
}
#[derive(Clone)]
#[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."]
#[doc = r""]
#[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"]
#[doc = r" parameters can be chained."]
#[doc = r""]
#[doc = r" To finalize and submit the request, invoke `.await`, which"]
#[doc = r" converts the [`RequestBuilder`] into a future,"]
#[doc = r" executes the request and returns a `Result` with the parsed"]
#[doc = r" response."]
#[doc = r""]
#[doc = r" If you need lower-level access to the raw response details"]
#[doc = r" (e.g. to inspect response headers or raw body data) then you"]
#[doc = r" can finalize the request using the"]
#[doc = r" [`RequestBuilder::send()`] method which returns a future"]
#[doc = r" that resolves to a lower-level [`Response`] value."]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) organization: String,
pub(crate) project: String,
pub(crate) build_id: i32,
pub(crate) body: Option<models::CodeCoverageData>,
}
impl RequestBuilder {
pub fn body(mut self, body: impl Into<models::CodeCoverageData>) -> Self {
self.body = Some(body.into());
self
}
#[doc = "Returns a future that sends the request and returns a [`Response`] object that provides low-level access to full response details."]
#[doc = ""]
#[doc = "You should typically use `.await` (which implicitly calls `IntoFuture::into_future()`) to finalize and send requests rather than `send()`."]
#[doc = "However, this function can provide more flexibility when required."]
pub fn send(self) -> BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = this.url()?;
let mut req =
azure_core::http::Request::new(url, azure_core::http::Method::Post);
if let Some(auth_header) = this
.client
.token_credential()
.http_authorization_header(&this.client.scopes())
.await?
{
req.insert_header(
azure_core::http::headers::AUTHORIZATION,
auth_header,
);
}
let build_id = &this.build_id;
req.url_mut()
.query_pairs_mut()
.append_pair("buildId", &build_id.to_string());
let req_body = if let Some(body) = &this.body {
req.insert_header("content-type", "application/json");
azure_core::json::to_json(body)?
} else {
azure_core::Bytes::new()
};
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?.into()))
}
})
}
fn url(&self) -> azure_core::Result<azure_core::http::Url> {
let mut url = azure_core::http::Url::parse(&format!(
"{}/{}/{}/_apis/testresults/codecoverage",
self.client.endpoint(),
&self.organization,
&self.project
))?;
let has_api_version_already = url.query_pairs().any(|(k, _)| k == "api-version");
if !has_api_version_already {
url.query_pairs_mut()
.append_pair("api-version", "7.1-preview");
}
Ok(url)
}
}
impl std::future::IntoFuture for RequestBuilder {
type Output = azure_core::Result<()>;
type IntoFuture = BoxFuture<'static, azure_core::Result<()>>;
#[doc = "Returns a future that sends the request and waits for the response."]
#[doc = ""]
#[doc = "You should not normally call this method directly, simply invoke `.await` which implicitly calls `IntoFuture::into_future`."]
#[doc = ""]
#[doc = "See [IntoFuture documentation](https://doc.rust-lang.org/std/future/trait.IntoFuture.html) for more details."]
fn into_future(self) -> Self::IntoFuture {
Box::pin(async move {
let _rsp = self.send().await?;
Ok(())
})
}
}
}
pub mod get_test_run_code_coverage {
use super::models;
#[cfg(not(target_arch = "wasm32"))]
use futures::future::BoxFuture;
#[cfg(target_arch = "wasm32")]
use futures::future::LocalBoxFuture as BoxFuture;
#[derive(Debug)]
pub struct Response(
azure_core::http::Response<models::TestRunCoverageList, azure_core::http::JsonFormat>,
);
impl Response {
pub fn into_body(self) -> azure_core::Result<models::TestRunCoverageList> {
self.0.into_model()
}
pub fn into_raw_response(self) -> azure_core::http::RawResponse {
self.0.into()
}
}
#[derive(Clone)]
#[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."]
#[doc = r""]
#[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"]
#[doc = r" parameters can be chained."]
#[doc = r""]
#[doc = r" To finalize and submit the request, invoke `.await`, which"]
#[doc = r" converts the [`RequestBuilder`] into a future,"]
#[doc = r" executes the request and returns a `Result` with the parsed"]
#[doc = r" response."]
#[doc = r""]
#[doc = r" If you need lower-level access to the raw response details"]
#[doc = r" (e.g. to inspect response headers or raw body data) then you"]
#[doc = r" can finalize the request using the"]
#[doc = r" [`RequestBuilder::send()`] method which returns a future"]
#[doc = r" that resolves to a lower-level [`Response`] value."]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) organization: String,
pub(crate) project: String,
pub(crate) run_id: i32,
pub(crate) flags: i32,
}
impl RequestBuilder {
#[doc = "Returns a future that sends the request and returns a [`Response`] object that provides low-level access to full response details."]
#[doc = ""]
#[doc = "You should typically use `.await` (which implicitly calls `IntoFuture::into_future()`) to finalize and send requests rather than `send()`."]
#[doc = "However, this function can provide more flexibility when required."]
pub fn send(self) -> BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = this.url()?;
let mut req =
azure_core::http::Request::new(url, azure_core::http::Method::Get);
if let Some(auth_header) = this
.client
.token_credential()
.http_authorization_header(&this.client.scopes())
.await?
{
req.insert_header(
azure_core::http::headers::AUTHORIZATION,
auth_header,
);
}
let flags = &this.flags;
req.url_mut()
.query_pairs_mut()
.append_pair("flags", &flags.to_string());
let req_body = azure_core::Bytes::new();
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?.into()))
}
})
}
fn url(&self) -> azure_core::Result<azure_core::http::Url> {
let mut url = azure_core::http::Url::parse(&format!(
"{}/{}/{}/_apis/testresults/runs/{}/codecoverage",
self.client.endpoint(),
&self.organization,
&self.project,
&self.run_id
))?;
let has_api_version_already = url.query_pairs().any(|(k, _)| k == "api-version");
if !has_api_version_already {
url.query_pairs_mut()
.append_pair("api-version", "7.1-preview");
}
Ok(url)
}
}
impl std::future::IntoFuture for RequestBuilder {
type Output = azure_core::Result<models::TestRunCoverageList>;
type IntoFuture = BoxFuture<'static, azure_core::Result<models::TestRunCoverageList>>;
#[doc = "Returns a future that sends the request and returns the parsed response body."]
#[doc = ""]
#[doc = "You should not normally call this method directly, simply invoke `.await` which implicitly calls `IntoFuture::into_future`."]
#[doc = ""]
#[doc = "See [IntoFuture documentation](https://doc.rust-lang.org/std/future/trait.IntoFuture.html) for more details."]
fn into_future(self) -> Self::IntoFuture {
Box::pin(async move { self.send().await?.into_body() })
}
}
}
}
pub mod runs {
use super::models;
#[cfg(not(target_arch = "wasm32"))]
use futures::future::BoxFuture;
#[cfg(target_arch = "wasm32")]
use futures::future::LocalBoxFuture as BoxFuture;
pub struct Client(pub(crate) super::Client);
impl Client {
#[doc = "Query Test Runs based on filters. Mandatory fields are minLastUpdatedDate and maxLastUpdatedDate."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `organization`: The name of the Azure DevOps organization."]
#[doc = "* `project`: Project ID or project name"]
#[doc = "* `min_last_updated_date`: Minimum Last Modified Date of run to be queried (Mandatory)."]
#[doc = "* `max_last_updated_date`: Maximum Last Modified Date of run to be queried (Mandatory, difference between min and max date can be atmost 7 days)."]
pub fn query(
&self,
organization: impl Into<String>,
project: impl Into<String>,
min_last_updated_date: impl Into<time::OffsetDateTime>,
max_last_updated_date: impl Into<time::OffsetDateTime>,
) -> query::RequestBuilder {
query::RequestBuilder {
client: self.0.clone(),
organization: organization.into(),
project: project.into(),
min_last_updated_date: min_last_updated_date.into(),
max_last_updated_date: max_last_updated_date.into(),
state: None,
plan_ids: None,
is_automated: None,
publish_context: None,
build_ids: None,
build_def_ids: None,
branch_name: None,
release_ids: None,
release_def_ids: None,
release_env_ids: None,
release_env_def_ids: None,
run_title: None,
top: None,
continuation_token: None,
}
}
#[doc = "Arguments:"]
#[doc = "* `organization`: The name of the Azure DevOps organization."]
#[doc = "* `project`: Project ID or project name"]
pub fn list(
&self,
organization: impl Into<String>,
project: impl Into<String>,
) -> list::RequestBuilder {
list::RequestBuilder {
client: self.0.clone(),
organization: organization.into(),
project: project.into(),
build_uri: None,
owner: None,
tmi_run_id: None,
plan_id: None,
include_run_details: None,
automated: None,
skip: None,
top: None,
}
}
#[doc = "Arguments:"]
#[doc = "* `organization`: The name of the Azure DevOps organization."]
#[doc = "* `project`: Project ID or project name"]
pub fn create(
&self,
organization: impl Into<String>,
body: impl Into<models::RunCreateModel>,
project: impl Into<String>,
) -> create::RequestBuilder {
create::RequestBuilder {
client: self.0.clone(),
organization: organization.into(),
body: body.into(),
project: project.into(),
}
}
#[doc = "Arguments:"]
#[doc = "* `organization`: The name of the Azure DevOps organization."]
#[doc = "* `project`: Project ID or project name"]
pub fn get(
&self,
organization: impl Into<String>,
project: impl Into<String>,
run_id: i32,
) -> get::RequestBuilder {
get::RequestBuilder {
client: self.0.clone(),
organization: organization.into(),
project: project.into(),
run_id,
include_details: None,
include_tags: None,
}
}
#[doc = "Arguments:"]
#[doc = "* `organization`: The name of the Azure DevOps organization."]
#[doc = "* `project`: Project ID or project name"]
pub fn update(
&self,
organization: impl Into<String>,
body: impl Into<models::RunUpdateModel>,
project: impl Into<String>,
run_id: i32,
) -> update::RequestBuilder {
update::RequestBuilder {
client: self.0.clone(),
organization: organization.into(),
body: body.into(),
project: project.into(),
run_id,
}
}
#[doc = "Arguments:"]
#[doc = "* `organization`: The name of the Azure DevOps organization."]
#[doc = "* `project`: Project ID or project name"]
pub fn delete(
&self,
organization: impl Into<String>,
project: impl Into<String>,
run_id: i32,
) -> delete::RequestBuilder {
delete::RequestBuilder {
client: self.0.clone(),
organization: organization.into(),
project: project.into(),
run_id,
}
}
}
pub mod query {
use super::models;
#[cfg(not(target_arch = "wasm32"))]
use futures::future::BoxFuture;
#[cfg(target_arch = "wasm32")]
use futures::future::LocalBoxFuture as BoxFuture;
#[derive(Debug)]
pub struct Response(
azure_core::http::Response<models::TestRunList, azure_core::http::JsonFormat>,
);
impl Response {
pub fn into_body(self) -> azure_core::Result<models::TestRunList> {
self.0.into_model()
}
pub fn into_raw_response(self) -> azure_core::http::RawResponse {
self.0.into()
}
}
#[derive(Clone)]
#[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."]
#[doc = r""]
#[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"]
#[doc = r" parameters can be chained."]
#[doc = r""]
#[doc = r" To finalize and submit the request, invoke `.await`, which"]
#[doc = r" converts the [`RequestBuilder`] into a future,"]
#[doc = r" executes the request and returns a `Result` with the parsed"]
#[doc = r" response."]
#[doc = r""]
#[doc = r" If you need lower-level access to the raw response details"]
#[doc = r" (e.g. to inspect response headers or raw body data) then you"]
#[doc = r" can finalize the request using the"]
#[doc = r" [`RequestBuilder::send()`] method which returns a future"]
#[doc = r" that resolves to a lower-level [`Response`] value."]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) organization: String,
pub(crate) project: String,
pub(crate) min_last_updated_date: time::OffsetDateTime,
pub(crate) max_last_updated_date: time::OffsetDateTime,
pub(crate) state: Option<models::TestRunState>,
pub(crate) plan_ids: Option<String>,
pub(crate) is_automated: Option<bool>,
pub(crate) publish_context: Option<models::TestRunPublishContext>,
pub(crate) build_ids: Option<String>,
pub(crate) build_def_ids: Option<String>,
pub(crate) branch_name: Option<String>,
pub(crate) release_ids: Option<String>,
pub(crate) release_def_ids: Option<String>,
pub(crate) release_env_ids: Option<String>,
pub(crate) release_env_def_ids: Option<String>,
pub(crate) run_title: Option<String>,
pub(crate) top: Option<i32>,
pub(crate) continuation_token: Option<String>,
}
impl RequestBuilder {
#[doc = "Current state of the Runs to be queried."]
pub fn state(mut self, state: impl Into<models::TestRunState>) -> Self {
self.state = Some(state.into());
self
}
#[doc = "Plan Ids of the Runs to be queried, comma separated list of valid ids."]
pub fn plan_ids(mut self, plan_ids: impl Into<String>) -> Self {
self.plan_ids = Some(plan_ids.into());
self
}
#[doc = "Automation type of the Runs to be queried."]
pub fn is_automated(mut self, is_automated: bool) -> Self {
self.is_automated = Some(is_automated);
self
}
#[doc = "PublishContext of the Runs to be queried."]
pub fn publish_context(
mut self,
publish_context: impl Into<models::TestRunPublishContext>,
) -> Self {
self.publish_context = Some(publish_context.into());
self
}
#[doc = "Build Ids of the Runs to be queried, comma separated list of valid ids."]
pub fn build_ids(mut self, build_ids: impl Into<String>) -> Self {
self.build_ids = Some(build_ids.into());
self
}
#[doc = "Build Definition Ids of the Runs to be queried, comma separated list of valid ids."]
pub fn build_def_ids(mut self, build_def_ids: impl Into<String>) -> Self {
self.build_def_ids = Some(build_def_ids.into());
self
}
#[doc = "Source Branch name of the Runs to be queried."]
pub fn branch_name(mut self, branch_name: impl Into<String>) -> Self {
self.branch_name = Some(branch_name.into());
self
}
#[doc = "Release Ids of the Runs to be queried, comma separated list of valid ids."]
pub fn release_ids(mut self, release_ids: impl Into<String>) -> Self {
self.release_ids = Some(release_ids.into());
self
}
#[doc = "Release Definition Ids of the Runs to be queried, comma separated list of valid ids."]
pub fn release_def_ids(mut self, release_def_ids: impl Into<String>) -> Self {
self.release_def_ids = Some(release_def_ids.into());
self
}
#[doc = "Release Environment Ids of the Runs to be queried, comma separated list of valid ids."]
pub fn release_env_ids(mut self, release_env_ids: impl Into<String>) -> Self {
self.release_env_ids = Some(release_env_ids.into());
self
}
#[doc = "Release Environment Definition Ids of the Runs to be queried, comma separated list of valid ids."]
pub fn release_env_def_ids(mut self, release_env_def_ids: impl Into<String>) -> Self {
self.release_env_def_ids = Some(release_env_def_ids.into());
self
}
#[doc = "Run Title of the Runs to be queried."]
pub fn run_title(mut self, run_title: impl Into<String>) -> Self {
self.run_title = Some(run_title.into());
self
}
#[doc = "Number of runs to be queried. Limit is 100"]
pub fn top(mut self, top: i32) -> Self {
self.top = Some(top);
self
}
#[doc = "continuation token received from previous batch or null for first batch. It is not supposed to be created (or altered, if received from last batch) by user."]
pub fn continuation_token(mut self, continuation_token: impl Into<String>) -> Self {
self.continuation_token = Some(continuation_token.into());
self
}
#[doc = "Returns a future that sends the request and returns a [`Response`] object that provides low-level access to full response details."]
#[doc = ""]
#[doc = "You should typically use `.await` (which implicitly calls `IntoFuture::into_future()`) to finalize and send requests rather than `send()`."]
#[doc = "However, this function can provide more flexibility when required."]
pub fn send(self) -> BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = this.url()?;
let mut req =
azure_core::http::Request::new(url, azure_core::http::Method::Get);
if let Some(auth_header) = this
.client
.token_credential()
.http_authorization_header(&this.client.scopes())
.await?
{
req.insert_header(
azure_core::http::headers::AUTHORIZATION,
auth_header,
);
}
let min_last_updated_date = &this.min_last_updated_date;
let formatted_date_time =
crate::date_time::format_date_time(min_last_updated_date)?;
req.url_mut()
.query_pairs_mut()
.append_pair("minLastUpdatedDate", &formatted_date_time);
let max_last_updated_date = &this.max_last_updated_date;
let formatted_date_time =
crate::date_time::format_date_time(max_last_updated_date)?;
req.url_mut()
.query_pairs_mut()
.append_pair("maxLastUpdatedDate", &formatted_date_time);
if let Some(state) = &this.state {
req.url_mut()
.query_pairs_mut()
.append_pair("state", &state.to_string());
}
if let Some(plan_ids) = &this.plan_ids {
req.url_mut()
.query_pairs_mut()
.append_pair("planIds", plan_ids);
}
if let Some(is_automated) = &this.is_automated {
req.url_mut()
.query_pairs_mut()
.append_pair("isAutomated", &is_automated.to_string());
}
if let Some(publish_context) = &this.publish_context {
req.url_mut()
.query_pairs_mut()
.append_pair("publishContext", &publish_context.to_string());
}
if let Some(build_ids) = &this.build_ids {
req.url_mut()
.query_pairs_mut()
.append_pair("buildIds", build_ids);
}
if let Some(build_def_ids) = &this.build_def_ids {
req.url_mut()
.query_pairs_mut()
.append_pair("buildDefIds", build_def_ids);
}
if let Some(branch_name) = &this.branch_name {
req.url_mut()
.query_pairs_mut()
.append_pair("branchName", branch_name);
}
if let Some(release_ids) = &this.release_ids {
req.url_mut()
.query_pairs_mut()
.append_pair("releaseIds", release_ids);
}
if let Some(release_def_ids) = &this.release_def_ids {
req.url_mut()
.query_pairs_mut()
.append_pair("releaseDefIds", release_def_ids);
}
if let Some(release_env_ids) = &this.release_env_ids {
req.url_mut()
.query_pairs_mut()
.append_pair("releaseEnvIds", release_env_ids);
}
if let Some(release_env_def_ids) = &this.release_env_def_ids {
req.url_mut()
.query_pairs_mut()
.append_pair("releaseEnvDefIds", release_env_def_ids);
}
if let Some(run_title) = &this.run_title {
req.url_mut()
.query_pairs_mut()
.append_pair("runTitle", run_title);
}
if let Some(top) = &this.top {
req.url_mut()
.query_pairs_mut()
.append_pair("$top", &top.to_string());
}
if let Some(continuation_token) = &this.continuation_token {
req.url_mut()
.query_pairs_mut()
.append_pair("continuationToken", continuation_token);
}
let req_body = azure_core::Bytes::new();
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?.into()))
}
})
}
fn url(&self) -> azure_core::Result<azure_core::http::Url> {
let mut url = azure_core::http::Url::parse(&format!(
"{}/{}/{}/_apis/testresults/runs?minLastUpdatedDate={}&maxLastUpdatedDate={}",
self.client.endpoint(),
&self.organization,
&self.project,
&self.min_last_updated_date,
&self.max_last_updated_date
))?;
let has_api_version_already = url.query_pairs().any(|(k, _)| k == "api-version");
if !has_api_version_already {
url.query_pairs_mut()
.append_pair("api-version", "7.1-preview");
}
Ok(url)
}
}
impl std::future::IntoFuture for RequestBuilder {
type Output = azure_core::Result<models::TestRunList>;
type IntoFuture = BoxFuture<'static, azure_core::Result<models::TestRunList>>;
#[doc = "Returns a future that sends the request and returns the parsed response body."]
#[doc = ""]
#[doc = "You should not normally call this method directly, simply invoke `.await` which implicitly calls `IntoFuture::into_future`."]
#[doc = ""]
#[doc = "See [IntoFuture documentation](https://doc.rust-lang.org/std/future/trait.IntoFuture.html) for more details."]
fn into_future(self) -> Self::IntoFuture {
Box::pin(async move { self.send().await?.into_body() })
}
}
}
pub mod list {
use super::models;
#[cfg(not(target_arch = "wasm32"))]
use futures::future::BoxFuture;
#[cfg(target_arch = "wasm32")]
use futures::future::LocalBoxFuture as BoxFuture;
#[derive(Debug)]
pub struct Response(
azure_core::http::Response<models::TestRunList, azure_core::http::JsonFormat>,
);
impl Response {
pub fn into_body(self) -> azure_core::Result<models::TestRunList> {
self.0.into_model()
}
pub fn into_raw_response(self) -> azure_core::http::RawResponse {
self.0.into()
}
}
#[derive(Clone)]
#[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."]
#[doc = r""]
#[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"]
#[doc = r" parameters can be chained."]
#[doc = r""]
#[doc = r" To finalize and submit the request, invoke `.await`, which"]
#[doc = r" converts the [`RequestBuilder`] into a future,"]
#[doc = r" executes the request and returns a `Result` with the parsed"]
#[doc = r" response."]
#[doc = r""]
#[doc = r" If you need lower-level access to the raw response details"]
#[doc = r" (e.g. to inspect response headers or raw body data) then you"]
#[doc = r" can finalize the request using the"]
#[doc = r" [`RequestBuilder::send()`] method which returns a future"]
#[doc = r" that resolves to a lower-level [`Response`] value."]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) organization: String,
pub(crate) project: String,
pub(crate) build_uri: Option<String>,
pub(crate) owner: Option<String>,
pub(crate) tmi_run_id: Option<String>,
pub(crate) plan_id: Option<i32>,
pub(crate) include_run_details: Option<bool>,
pub(crate) automated: Option<bool>,
pub(crate) skip: Option<i32>,
pub(crate) top: Option<i32>,
}
impl RequestBuilder {
pub fn build_uri(mut self, build_uri: impl Into<String>) -> Self {
self.build_uri = Some(build_uri.into());
self
}
pub fn owner(mut self, owner: impl Into<String>) -> Self {
self.owner = Some(owner.into());
self
}
pub fn tmi_run_id(mut self, tmi_run_id: impl Into<String>) -> Self {
self.tmi_run_id = Some(tmi_run_id.into());
self
}
pub fn plan_id(mut self, plan_id: i32) -> Self {
self.plan_id = Some(plan_id);
self
}
pub fn include_run_details(mut self, include_run_details: bool) -> Self {
self.include_run_details = Some(include_run_details);
self
}
pub fn automated(mut self, automated: bool) -> Self {
self.automated = Some(automated);
self
}
pub fn skip(mut self, skip: i32) -> Self {
self.skip = Some(skip);
self
}
pub fn top(mut self, top: i32) -> Self {
self.top = Some(top);
self
}
#[doc = "Returns a future that sends the request and returns a [`Response`] object that provides low-level access to full response details."]
#[doc = ""]
#[doc = "You should typically use `.await` (which implicitly calls `IntoFuture::into_future()`) to finalize and send requests rather than `send()`."]
#[doc = "However, this function can provide more flexibility when required."]
pub fn send(self) -> BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = this.url()?;
let mut req =
azure_core::http::Request::new(url, azure_core::http::Method::Get);
if let Some(auth_header) = this
.client
.token_credential()
.http_authorization_header(&this.client.scopes())
.await?
{
req.insert_header(
azure_core::http::headers::AUTHORIZATION,
auth_header,
);
}
if let Some(build_uri) = &this.build_uri {
req.url_mut()
.query_pairs_mut()
.append_pair("buildUri", build_uri);
}
if let Some(owner) = &this.owner {
req.url_mut().query_pairs_mut().append_pair("owner", owner);
}
if let Some(tmi_run_id) = &this.tmi_run_id {
req.url_mut()
.query_pairs_mut()
.append_pair("tmiRunId", tmi_run_id);
}
if let Some(plan_id) = &this.plan_id {
req.url_mut()
.query_pairs_mut()
.append_pair("planId", &plan_id.to_string());
}
if let Some(include_run_details) = &this.include_run_details {
req.url_mut()
.query_pairs_mut()
.append_pair("includeRunDetails", &include_run_details.to_string());
}
if let Some(automated) = &this.automated {
req.url_mut()
.query_pairs_mut()
.append_pair("automated", &automated.to_string());
}
if let Some(skip) = &this.skip {
req.url_mut()
.query_pairs_mut()
.append_pair("$skip", &skip.to_string());
}
if let Some(top) = &this.top {
req.url_mut()
.query_pairs_mut()
.append_pair("$top", &top.to_string());
}
let req_body = azure_core::Bytes::new();
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?.into()))
}
})
}
fn url(&self) -> azure_core::Result<azure_core::http::Url> {
let mut url = azure_core::http::Url::parse(&format!(
"{}/{}/{}/_apis/testresults/runs",
self.client.endpoint(),
&self.organization,
&self.project
))?;
let has_api_version_already = url.query_pairs().any(|(k, _)| k == "api-version");
if !has_api_version_already {
url.query_pairs_mut()
.append_pair("api-version", "7.1-preview");
}
Ok(url)
}
}
impl std::future::IntoFuture for RequestBuilder {
type Output = azure_core::Result<models::TestRunList>;
type IntoFuture = BoxFuture<'static, azure_core::Result<models::TestRunList>>;
#[doc = "Returns a future that sends the request and returns the parsed response body."]
#[doc = ""]
#[doc = "You should not normally call this method directly, simply invoke `.await` which implicitly calls `IntoFuture::into_future`."]
#[doc = ""]
#[doc = "See [IntoFuture documentation](https://doc.rust-lang.org/std/future/trait.IntoFuture.html) for more details."]
fn into_future(self) -> Self::IntoFuture {
Box::pin(async move { self.send().await?.into_body() })
}
}
}
pub mod create {
use super::models;
#[cfg(not(target_arch = "wasm32"))]
use futures::future::BoxFuture;
#[cfg(target_arch = "wasm32")]
use futures::future::LocalBoxFuture as BoxFuture;
#[derive(Debug)]
pub struct Response(
azure_core::http::Response<models::TestRun, azure_core::http::JsonFormat>,
);
impl Response {
pub fn into_body(self) -> azure_core::Result<models::TestRun> {
self.0.into_model()
}
pub fn into_raw_response(self) -> azure_core::http::RawResponse {
self.0.into()
}
}
#[derive(Clone)]
#[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."]
#[doc = r""]
#[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"]
#[doc = r" parameters can be chained."]
#[doc = r""]
#[doc = r" To finalize and submit the request, invoke `.await`, which"]
#[doc = r" converts the [`RequestBuilder`] into a future,"]
#[doc = r" executes the request and returns a `Result` with the parsed"]
#[doc = r" response."]
#[doc = r""]
#[doc = r" If you need lower-level access to the raw response details"]
#[doc = r" (e.g. to inspect response headers or raw body data) then you"]
#[doc = r" can finalize the request using the"]
#[doc = r" [`RequestBuilder::send()`] method which returns a future"]
#[doc = r" that resolves to a lower-level [`Response`] value."]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) organization: String,
pub(crate) body: models::RunCreateModel,
pub(crate) project: String,
}
impl RequestBuilder {
#[doc = "Returns a future that sends the request and returns a [`Response`] object that provides low-level access to full response details."]
#[doc = ""]
#[doc = "You should typically use `.await` (which implicitly calls `IntoFuture::into_future()`) to finalize and send requests rather than `send()`."]
#[doc = "However, this function can provide more flexibility when required."]
pub fn send(self) -> BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = this.url()?;
let mut req =
azure_core::http::Request::new(url, azure_core::http::Method::Post);
if let Some(auth_header) = this
.client
.token_credential()
.http_authorization_header(&this.client.scopes())
.await?
{
req.insert_header(
azure_core::http::headers::AUTHORIZATION,
auth_header,
);
}
req.insert_header("content-type", "application/json");
let req_body = azure_core::json::to_json(&this.body)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?.into()))
}
})
}
fn url(&self) -> azure_core::Result<azure_core::http::Url> {
let mut url = azure_core::http::Url::parse(&format!(
"{}/{}/{}/_apis/testresults/runs",
self.client.endpoint(),
&self.organization,
&self.project
))?;
let has_api_version_already = url.query_pairs().any(|(k, _)| k == "api-version");
if !has_api_version_already {
url.query_pairs_mut()
.append_pair("api-version", "7.1-preview");
}
Ok(url)
}
}
impl std::future::IntoFuture for RequestBuilder {
type Output = azure_core::Result<models::TestRun>;
type IntoFuture = BoxFuture<'static, azure_core::Result<models::TestRun>>;
#[doc = "Returns a future that sends the request and returns the parsed response body."]
#[doc = ""]
#[doc = "You should not normally call this method directly, simply invoke `.await` which implicitly calls `IntoFuture::into_future`."]
#[doc = ""]
#[doc = "See [IntoFuture documentation](https://doc.rust-lang.org/std/future/trait.IntoFuture.html) for more details."]
fn into_future(self) -> Self::IntoFuture {
Box::pin(async move { self.send().await?.into_body() })
}
}
}
pub mod get {
use super::models;
#[cfg(not(target_arch = "wasm32"))]
use futures::future::BoxFuture;
#[cfg(target_arch = "wasm32")]
use futures::future::LocalBoxFuture as BoxFuture;
#[derive(Debug)]
pub struct Response(
azure_core::http::Response<models::TestRun, azure_core::http::JsonFormat>,
);
impl Response {
pub fn into_body(self) -> azure_core::Result<models::TestRun> {
self.0.into_model()
}
pub fn into_raw_response(self) -> azure_core::http::RawResponse {
self.0.into()
}
}
#[derive(Clone)]
#[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."]
#[doc = r""]
#[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"]
#[doc = r" parameters can be chained."]
#[doc = r""]
#[doc = r" To finalize and submit the request, invoke `.await`, which"]
#[doc = r" converts the [`RequestBuilder`] into a future,"]
#[doc = r" executes the request and returns a `Result` with the parsed"]
#[doc = r" response."]
#[doc = r""]
#[doc = r" If you need lower-level access to the raw response details"]
#[doc = r" (e.g. to inspect response headers or raw body data) then you"]
#[doc = r" can finalize the request using the"]
#[doc = r" [`RequestBuilder::send()`] method which returns a future"]
#[doc = r" that resolves to a lower-level [`Response`] value."]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) organization: String,
pub(crate) project: String,
pub(crate) run_id: i32,
pub(crate) include_details: Option<bool>,
pub(crate) include_tags: Option<bool>,
}
impl RequestBuilder {
pub fn include_details(mut self, include_details: bool) -> Self {
self.include_details = Some(include_details);
self
}
pub fn include_tags(mut self, include_tags: bool) -> Self {
self.include_tags = Some(include_tags);
self
}
#[doc = "Returns a future that sends the request and returns a [`Response`] object that provides low-level access to full response details."]
#[doc = ""]
#[doc = "You should typically use `.await` (which implicitly calls `IntoFuture::into_future()`) to finalize and send requests rather than `send()`."]
#[doc = "However, this function can provide more flexibility when required."]
pub fn send(self) -> BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = this.url()?;
let mut req =
azure_core::http::Request::new(url, azure_core::http::Method::Get);
if let Some(auth_header) = this
.client
.token_credential()
.http_authorization_header(&this.client.scopes())
.await?
{
req.insert_header(
azure_core::http::headers::AUTHORIZATION,
auth_header,
);
}
if let Some(include_details) = &this.include_details {
req.url_mut()
.query_pairs_mut()
.append_pair("includeDetails", &include_details.to_string());
}
if let Some(include_tags) = &this.include_tags {
req.url_mut()
.query_pairs_mut()
.append_pair("includeTags", &include_tags.to_string());
}
let req_body = azure_core::Bytes::new();
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?.into()))
}
})
}
fn url(&self) -> azure_core::Result<azure_core::http::Url> {
let mut url = azure_core::http::Url::parse(&format!(
"{}/{}/{}/_apis/testresults/runs/{}",
self.client.endpoint(),
&self.organization,
&self.project,
&self.run_id
))?;
let has_api_version_already = url.query_pairs().any(|(k, _)| k == "api-version");
if !has_api_version_already {
url.query_pairs_mut()
.append_pair("api-version", "7.1-preview");
}
Ok(url)
}
}
impl std::future::IntoFuture for RequestBuilder {
type Output = azure_core::Result<models::TestRun>;
type IntoFuture = BoxFuture<'static, azure_core::Result<models::TestRun>>;
#[doc = "Returns a future that sends the request and returns the parsed response body."]
#[doc = ""]
#[doc = "You should not normally call this method directly, simply invoke `.await` which implicitly calls `IntoFuture::into_future`."]
#[doc = ""]
#[doc = "See [IntoFuture documentation](https://doc.rust-lang.org/std/future/trait.IntoFuture.html) for more details."]
fn into_future(self) -> Self::IntoFuture {
Box::pin(async move { self.send().await?.into_body() })
}
}
}
pub mod update {
use super::models;
#[cfg(not(target_arch = "wasm32"))]
use futures::future::BoxFuture;
#[cfg(target_arch = "wasm32")]
use futures::future::LocalBoxFuture as BoxFuture;
#[derive(Debug)]
pub struct Response(
azure_core::http::Response<models::TestRun, azure_core::http::JsonFormat>,
);
impl Response {
pub fn into_body(self) -> azure_core::Result<models::TestRun> {
self.0.into_model()
}
pub fn into_raw_response(self) -> azure_core::http::RawResponse {
self.0.into()
}
}
#[derive(Clone)]
#[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."]
#[doc = r""]
#[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"]
#[doc = r" parameters can be chained."]
#[doc = r""]
#[doc = r" To finalize and submit the request, invoke `.await`, which"]
#[doc = r" converts the [`RequestBuilder`] into a future,"]
#[doc = r" executes the request and returns a `Result` with the parsed"]
#[doc = r" response."]
#[doc = r""]
#[doc = r" If you need lower-level access to the raw response details"]
#[doc = r" (e.g. to inspect response headers or raw body data) then you"]
#[doc = r" can finalize the request using the"]
#[doc = r" [`RequestBuilder::send()`] method which returns a future"]
#[doc = r" that resolves to a lower-level [`Response`] value."]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) organization: String,
pub(crate) body: models::RunUpdateModel,
pub(crate) project: String,
pub(crate) run_id: i32,
}
impl RequestBuilder {
#[doc = "Returns a future that sends the request and returns a [`Response`] object that provides low-level access to full response details."]
#[doc = ""]
#[doc = "You should typically use `.await` (which implicitly calls `IntoFuture::into_future()`) to finalize and send requests rather than `send()`."]
#[doc = "However, this function can provide more flexibility when required."]
pub fn send(self) -> BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = this.url()?;
let mut req =
azure_core::http::Request::new(url, azure_core::http::Method::Patch);
if let Some(auth_header) = this
.client
.token_credential()
.http_authorization_header(&this.client.scopes())
.await?
{
req.insert_header(
azure_core::http::headers::AUTHORIZATION,
auth_header,
);
}
req.insert_header("content-type", "application/json");
let req_body = azure_core::json::to_json(&this.body)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?.into()))
}
})
}
fn url(&self) -> azure_core::Result<azure_core::http::Url> {
let mut url = azure_core::http::Url::parse(&format!(
"{}/{}/{}/_apis/testresults/runs/{}",
self.client.endpoint(),
&self.organization,
&self.project,
&self.run_id
))?;
let has_api_version_already = url.query_pairs().any(|(k, _)| k == "api-version");
if !has_api_version_already {
url.query_pairs_mut()
.append_pair("api-version", "7.1-preview");
}
Ok(url)
}
}
impl std::future::IntoFuture for RequestBuilder {
type Output = azure_core::Result<models::TestRun>;
type IntoFuture = BoxFuture<'static, azure_core::Result<models::TestRun>>;
#[doc = "Returns a future that sends the request and returns the parsed response body."]
#[doc = ""]
#[doc = "You should not normally call this method directly, simply invoke `.await` which implicitly calls `IntoFuture::into_future`."]
#[doc = ""]
#[doc = "See [IntoFuture documentation](https://doc.rust-lang.org/std/future/trait.IntoFuture.html) for more details."]
fn into_future(self) -> Self::IntoFuture {
Box::pin(async move { self.send().await?.into_body() })
}
}
}
pub mod delete {
use super::models;
#[cfg(not(target_arch = "wasm32"))]
use futures::future::BoxFuture;
#[cfg(target_arch = "wasm32")]
use futures::future::LocalBoxFuture as BoxFuture;
#[derive(Debug)]
pub struct Response(azure_core::http::Response<(), azure_core::http::NoFormat>);
impl Response {
pub fn into_raw_response(self) -> azure_core::http::RawResponse {
self.0.into()
}
}
#[derive(Clone)]
#[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."]
#[doc = r""]
#[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"]
#[doc = r" parameters can be chained."]
#[doc = r""]
#[doc = r" To finalize and submit the request, invoke `.await`, which"]
#[doc = r" converts the [`RequestBuilder`] into a future,"]
#[doc = r" executes the request and returns a `Result` with the parsed"]
#[doc = r" response."]
#[doc = r""]
#[doc = r" If you need lower-level access to the raw response details"]
#[doc = r" (e.g. to inspect response headers or raw body data) then you"]
#[doc = r" can finalize the request using the"]
#[doc = r" [`RequestBuilder::send()`] method which returns a future"]
#[doc = r" that resolves to a lower-level [`Response`] value."]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) organization: String,
pub(crate) project: String,
pub(crate) run_id: i32,
}
impl RequestBuilder {
#[doc = "Returns a future that sends the request and returns a [`Response`] object that provides low-level access to full response details."]
#[doc = ""]
#[doc = "You should typically use `.await` (which implicitly calls `IntoFuture::into_future()`) to finalize and send requests rather than `send()`."]
#[doc = "However, this function can provide more flexibility when required."]
pub fn send(self) -> BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = this.url()?;
let mut req =
azure_core::http::Request::new(url, azure_core::http::Method::Delete);
if let Some(auth_header) = this
.client
.token_credential()
.http_authorization_header(&this.client.scopes())
.await?
{
req.insert_header(
azure_core::http::headers::AUTHORIZATION,
auth_header,
);
}
let req_body = azure_core::Bytes::new();
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?.into()))
}
})
}
fn url(&self) -> azure_core::Result<azure_core::http::Url> {
let mut url = azure_core::http::Url::parse(&format!(
"{}/{}/{}/_apis/testresults/runs/{}",
self.client.endpoint(),
&self.organization,
&self.project,
&self.run_id
))?;
let has_api_version_already = url.query_pairs().any(|(k, _)| k == "api-version");
if !has_api_version_already {
url.query_pairs_mut()
.append_pair("api-version", "7.1-preview");
}
Ok(url)
}
}
impl std::future::IntoFuture for RequestBuilder {
type Output = azure_core::Result<()>;
type IntoFuture = BoxFuture<'static, azure_core::Result<()>>;
#[doc = "Returns a future that sends the request and waits for the response."]
#[doc = ""]
#[doc = "You should not normally call this method directly, simply invoke `.await` which implicitly calls `IntoFuture::into_future`."]
#[doc = ""]
#[doc = "See [IntoFuture documentation](https://doc.rust-lang.org/std/future/trait.IntoFuture.html) for more details."]
fn into_future(self) -> Self::IntoFuture {
Box::pin(async move {
let _rsp = self.send().await?;
Ok(())
})
}
}
}
}
pub mod testlog {
use super::models;
#[cfg(not(target_arch = "wasm32"))]
use futures::future::BoxFuture;
#[cfg(target_arch = "wasm32")]
use futures::future::LocalBoxFuture as BoxFuture;
pub struct Client(pub(crate) super::Client);
impl Client {
#[doc = "Get list of test subresult attachments reference"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `organization`: The name of the Azure DevOps organization."]
#[doc = "* `project`: Project ID or project name"]
#[doc = "* `run_id`: Id of the test run that contains the results"]
#[doc = "* `result_id`: Id of the test result that contains subresult"]
#[doc = "* `sub_result_id`: Id of the test subresult"]
#[doc = "* `type_`: type of the attachments to get"]
pub fn get_test_sub_result_logs(
&self,
organization: impl Into<String>,
project: impl Into<String>,
run_id: i32,
result_id: i32,
sub_result_id: i32,
type_: impl Into<models::TestLogType>,
) -> get_test_sub_result_logs::RequestBuilder {
get_test_sub_result_logs::RequestBuilder {
client: self.0.clone(),
organization: organization.into(),
project: project.into(),
run_id,
result_id,
sub_result_id,
type_: type_.into(),
directory_path: None,
file_name_prefix: None,
fetch_meta_data: None,
top: None,
continuation_token: None,
}
}
#[doc = "Get list of test result attachments reference"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `organization`: The name of the Azure DevOps organization."]
#[doc = "* `project`: Project ID or project name"]
#[doc = "* `run_id`: Id of the test run that contains the result"]
#[doc = "* `result_id`: Id of the test result"]
#[doc = "* `type_`: type of attachments to get"]
pub fn get_test_result_logs(
&self,
organization: impl Into<String>,
project: impl Into<String>,
run_id: i32,
result_id: i32,
type_: impl Into<models::TestLogType>,
) -> get_test_result_logs::RequestBuilder {
get_test_result_logs::RequestBuilder {
client: self.0.clone(),
organization: organization.into(),
project: project.into(),
run_id,
result_id,
type_: type_.into(),
directory_path: None,
file_name_prefix: None,
fetch_meta_data: None,
top: None,
continuation_token: None,
}
}
#[doc = "Get list of test run attachments reference"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `organization`: The name of the Azure DevOps organization."]
#[doc = "* `project`: Project ID or project name"]
#[doc = "* `run_id`: Id of the test run"]
#[doc = "* `type_`: type of the attachments to get"]
pub fn get_test_run_logs(
&self,
organization: impl Into<String>,
project: impl Into<String>,
run_id: i32,
type_: impl Into<models::TestLogType>,
) -> get_test_run_logs::RequestBuilder {
get_test_run_logs::RequestBuilder {
client: self.0.clone(),
organization: organization.into(),
project: project.into(),
run_id,
type_: type_.into(),
directory_path: None,
file_name_prefix: None,
fetch_meta_data: None,
top: None,
continuation_token: None,
}
}
#[doc = "Get list of build attachments reference"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `organization`: The name of the Azure DevOps organization."]
#[doc = "* `project`: Project ID or project name"]
#[doc = "* `build_id`: Id of the build to get"]
#[doc = "* `type_`: type of the attachment to get"]
pub fn get_test_logs_for_build(
&self,
organization: impl Into<String>,
project: impl Into<String>,
build_id: i32,
type_: impl Into<models::TestLogType>,
) -> get_test_logs_for_build::RequestBuilder {
get_test_logs_for_build::RequestBuilder {
client: self.0.clone(),
organization: organization.into(),
project: project.into(),
build_id,
type_: type_.into(),
directory_path: None,
file_name_prefix: None,
fetch_meta_data: None,
top: None,
continuation_token: None,
}
}
}
pub mod get_test_sub_result_logs {
use super::models;
#[cfg(not(target_arch = "wasm32"))]
use futures::future::BoxFuture;
#[cfg(target_arch = "wasm32")]
use futures::future::LocalBoxFuture as BoxFuture;
#[derive(Debug)]
pub struct Response(
azure_core::http::Response<models::TestLogList, azure_core::http::JsonFormat>,
);
impl Response {
pub fn into_body(self) -> azure_core::Result<models::TestLogList> {
self.0.into_model()
}
pub fn into_raw_response(self) -> azure_core::http::RawResponse {
self.0.into()
}
}
#[derive(Clone)]
#[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."]
#[doc = r""]
#[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"]
#[doc = r" parameters can be chained."]
#[doc = r""]
#[doc = r" To finalize and submit the request, invoke `.await`, which"]
#[doc = r" converts the [`RequestBuilder`] into a future,"]
#[doc = r" executes the request and returns a `Result` with the parsed"]
#[doc = r" response."]
#[doc = r""]
#[doc = r" If you need lower-level access to the raw response details"]
#[doc = r" (e.g. to inspect response headers or raw body data) then you"]
#[doc = r" can finalize the request using the"]
#[doc = r" [`RequestBuilder::send()`] method which returns a future"]
#[doc = r" that resolves to a lower-level [`Response`] value."]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) organization: String,
pub(crate) project: String,
pub(crate) run_id: i32,
pub(crate) result_id: i32,
pub(crate) sub_result_id: i32,
pub(crate) type_: models::TestLogType,
pub(crate) directory_path: Option<String>,
pub(crate) file_name_prefix: Option<String>,
pub(crate) fetch_meta_data: Option<bool>,
pub(crate) top: Option<i32>,
pub(crate) continuation_token: Option<String>,
}
impl RequestBuilder {
#[doc = "directory path of the attachment to get"]
pub fn directory_path(mut self, directory_path: impl Into<String>) -> Self {
self.directory_path = Some(directory_path.into());
self
}
#[doc = "Filename prefix to filter the list of attachmentss"]
pub fn file_name_prefix(mut self, file_name_prefix: impl Into<String>) -> Self {
self.file_name_prefix = Some(file_name_prefix.into());
self
}
#[doc = "Default is false, set if metadata is needed"]
pub fn fetch_meta_data(mut self, fetch_meta_data: bool) -> Self {
self.fetch_meta_data = Some(fetch_meta_data);
self
}
#[doc = "Number of attachment references to return"]
pub fn top(mut self, top: i32) -> Self {
self.top = Some(top);
self
}
#[doc = "Header to pass the continuation token"]
pub fn continuation_token(mut self, continuation_token: impl Into<String>) -> Self {
self.continuation_token = Some(continuation_token.into());
self
}
#[doc = "Returns a future that sends the request and returns a [`Response`] object that provides low-level access to full response details."]
#[doc = ""]
#[doc = "You should typically use `.await` (which implicitly calls `IntoFuture::into_future()`) to finalize and send requests rather than `send()`."]
#[doc = "However, this function can provide more flexibility when required."]
pub fn send(self) -> BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = this.url()?;
let mut req =
azure_core::http::Request::new(url, azure_core::http::Method::Get);
if let Some(auth_header) = this
.client
.token_credential()
.http_authorization_header(&this.client.scopes())
.await?
{
req.insert_header(
azure_core::http::headers::AUTHORIZATION,
auth_header,
);
}
let sub_result_id = &this.sub_result_id;
req.url_mut()
.query_pairs_mut()
.append_pair("subResultId", &sub_result_id.to_string());
let type_ = &this.type_;
req.url_mut()
.query_pairs_mut()
.append_pair("type", &type_.to_string());
if let Some(directory_path) = &this.directory_path {
req.url_mut()
.query_pairs_mut()
.append_pair("directoryPath", directory_path);
}
if let Some(file_name_prefix) = &this.file_name_prefix {
req.url_mut()
.query_pairs_mut()
.append_pair("fileNamePrefix", file_name_prefix);
}
if let Some(fetch_meta_data) = &this.fetch_meta_data {
req.url_mut()
.query_pairs_mut()
.append_pair("fetchMetaData", &fetch_meta_data.to_string());
}
if let Some(top) = &this.top {
req.url_mut()
.query_pairs_mut()
.append_pair("top", &top.to_string());
}
if let Some(continuation_token) = &this.continuation_token {
req.insert_header("continuationtoken", continuation_token);
}
let req_body = azure_core::Bytes::new();
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?.into()))
}
})
}
fn url(&self) -> azure_core::Result<azure_core::http::Url> {
let mut url = azure_core::http::Url::parse(&format!(
"{}/{}/{}/_apis/testresults/runs/{}/results/{}/testlog?subResultId={}&type={}",
self.client.endpoint(),
&self.organization,
&self.project,
&self.run_id,
&self.result_id,
&self.sub_result_id,
&self.type_
))?;
let has_api_version_already = url.query_pairs().any(|(k, _)| k == "api-version");
if !has_api_version_already {
url.query_pairs_mut()
.append_pair("api-version", "7.1-preview");
}
Ok(url)
}
}
impl std::future::IntoFuture for RequestBuilder {
type Output = azure_core::Result<models::TestLogList>;
type IntoFuture = BoxFuture<'static, azure_core::Result<models::TestLogList>>;
#[doc = "Returns a future that sends the request and returns the parsed response body."]
#[doc = ""]
#[doc = "You should not normally call this method directly, simply invoke `.await` which implicitly calls `IntoFuture::into_future`."]
#[doc = ""]
#[doc = "See [IntoFuture documentation](https://doc.rust-lang.org/std/future/trait.IntoFuture.html) for more details."]
fn into_future(self) -> Self::IntoFuture {
Box::pin(async move { self.send().await?.into_body() })
}
}
}
pub mod get_test_result_logs {
use super::models;
#[cfg(not(target_arch = "wasm32"))]
use futures::future::BoxFuture;
#[cfg(target_arch = "wasm32")]
use futures::future::LocalBoxFuture as BoxFuture;
#[derive(Debug)]
pub struct Response(
azure_core::http::Response<models::TestLogList, azure_core::http::JsonFormat>,
);
impl Response {
pub fn into_body(self) -> azure_core::Result<models::TestLogList> {
self.0.into_model()
}
pub fn into_raw_response(self) -> azure_core::http::RawResponse {
self.0.into()
}
}
#[derive(Clone)]
#[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."]
#[doc = r""]
#[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"]
#[doc = r" parameters can be chained."]
#[doc = r""]
#[doc = r" To finalize and submit the request, invoke `.await`, which"]
#[doc = r" converts the [`RequestBuilder`] into a future,"]
#[doc = r" executes the request and returns a `Result` with the parsed"]
#[doc = r" response."]
#[doc = r""]
#[doc = r" If you need lower-level access to the raw response details"]
#[doc = r" (e.g. to inspect response headers or raw body data) then you"]
#[doc = r" can finalize the request using the"]
#[doc = r" [`RequestBuilder::send()`] method which returns a future"]
#[doc = r" that resolves to a lower-level [`Response`] value."]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) organization: String,
pub(crate) project: String,
pub(crate) run_id: i32,
pub(crate) result_id: i32,
pub(crate) type_: models::TestLogType,
pub(crate) directory_path: Option<String>,
pub(crate) file_name_prefix: Option<String>,
pub(crate) fetch_meta_data: Option<bool>,
pub(crate) top: Option<i32>,
pub(crate) continuation_token: Option<String>,
}
impl RequestBuilder {
#[doc = "Directory path of attachments to get"]
pub fn directory_path(mut self, directory_path: impl Into<String>) -> Self {
self.directory_path = Some(directory_path.into());
self
}
#[doc = "Filename prefix to filter the list of attachments"]
pub fn file_name_prefix(mut self, file_name_prefix: impl Into<String>) -> Self {
self.file_name_prefix = Some(file_name_prefix.into());
self
}
#[doc = "Default is false, set if metadata is needed"]
pub fn fetch_meta_data(mut self, fetch_meta_data: bool) -> Self {
self.fetch_meta_data = Some(fetch_meta_data);
self
}
#[doc = "Number of attachment references to return"]
pub fn top(mut self, top: i32) -> Self {
self.top = Some(top);
self
}
#[doc = "Header to pass the continuation token"]
pub fn continuation_token(mut self, continuation_token: impl Into<String>) -> Self {
self.continuation_token = Some(continuation_token.into());
self
}
#[doc = "Returns a future that sends the request and returns a [`Response`] object that provides low-level access to full response details."]
#[doc = ""]
#[doc = "You should typically use `.await` (which implicitly calls `IntoFuture::into_future()`) to finalize and send requests rather than `send()`."]
#[doc = "However, this function can provide more flexibility when required."]
pub fn send(self) -> BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = this.url()?;
let mut req =
azure_core::http::Request::new(url, azure_core::http::Method::Get);
if let Some(auth_header) = this
.client
.token_credential()
.http_authorization_header(&this.client.scopes())
.await?
{
req.insert_header(
azure_core::http::headers::AUTHORIZATION,
auth_header,
);
}
let type_ = &this.type_;
req.url_mut()
.query_pairs_mut()
.append_pair("type", &type_.to_string());
if let Some(directory_path) = &this.directory_path {
req.url_mut()
.query_pairs_mut()
.append_pair("directoryPath", directory_path);
}
if let Some(file_name_prefix) = &this.file_name_prefix {
req.url_mut()
.query_pairs_mut()
.append_pair("fileNamePrefix", file_name_prefix);
}
if let Some(fetch_meta_data) = &this.fetch_meta_data {
req.url_mut()
.query_pairs_mut()
.append_pair("fetchMetaData", &fetch_meta_data.to_string());
}
if let Some(top) = &this.top {
req.url_mut()
.query_pairs_mut()
.append_pair("top", &top.to_string());
}
if let Some(continuation_token) = &this.continuation_token {
req.insert_header("continuationtoken", continuation_token);
}
let req_body = azure_core::Bytes::new();
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?.into()))
}
})
}
fn url(&self) -> azure_core::Result<azure_core::http::Url> {
let mut url = azure_core::http::Url::parse(&format!(
"{}/{}/{}/_apis/testresults/runs/{}/results/{}/testlog",
self.client.endpoint(),
&self.organization,
&self.project,
&self.run_id,
&self.result_id
))?;
let has_api_version_already = url.query_pairs().any(|(k, _)| k == "api-version");
if !has_api_version_already {
url.query_pairs_mut()
.append_pair("api-version", "7.1-preview");
}
Ok(url)
}
}
impl std::future::IntoFuture for RequestBuilder {
type Output = azure_core::Result<models::TestLogList>;
type IntoFuture = BoxFuture<'static, azure_core::Result<models::TestLogList>>;
#[doc = "Returns a future that sends the request and returns the parsed response body."]
#[doc = ""]
#[doc = "You should not normally call this method directly, simply invoke `.await` which implicitly calls `IntoFuture::into_future`."]
#[doc = ""]
#[doc = "See [IntoFuture documentation](https://doc.rust-lang.org/std/future/trait.IntoFuture.html) for more details."]
fn into_future(self) -> Self::IntoFuture {
Box::pin(async move { self.send().await?.into_body() })
}
}
}
pub mod get_test_run_logs {
use super::models;
#[cfg(not(target_arch = "wasm32"))]
use futures::future::BoxFuture;
#[cfg(target_arch = "wasm32")]
use futures::future::LocalBoxFuture as BoxFuture;
#[derive(Debug)]
pub struct Response(
azure_core::http::Response<models::TestLogList, azure_core::http::JsonFormat>,
);
impl Response {
pub fn into_body(self) -> azure_core::Result<models::TestLogList> {
self.0.into_model()
}
pub fn into_raw_response(self) -> azure_core::http::RawResponse {
self.0.into()
}
}
#[derive(Clone)]
#[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."]
#[doc = r""]
#[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"]
#[doc = r" parameters can be chained."]
#[doc = r""]
#[doc = r" To finalize and submit the request, invoke `.await`, which"]
#[doc = r" converts the [`RequestBuilder`] into a future,"]
#[doc = r" executes the request and returns a `Result` with the parsed"]
#[doc = r" response."]
#[doc = r""]
#[doc = r" If you need lower-level access to the raw response details"]
#[doc = r" (e.g. to inspect response headers or raw body data) then you"]
#[doc = r" can finalize the request using the"]
#[doc = r" [`RequestBuilder::send()`] method which returns a future"]
#[doc = r" that resolves to a lower-level [`Response`] value."]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) organization: String,
pub(crate) project: String,
pub(crate) run_id: i32,
pub(crate) type_: models::TestLogType,
pub(crate) directory_path: Option<String>,
pub(crate) file_name_prefix: Option<String>,
pub(crate) fetch_meta_data: Option<bool>,
pub(crate) top: Option<i32>,
pub(crate) continuation_token: Option<String>,
}
impl RequestBuilder {
#[doc = "directory path for which attachments are needed"]
pub fn directory_path(mut self, directory_path: impl Into<String>) -> Self {
self.directory_path = Some(directory_path.into());
self
}
#[doc = "Filename prefix to filter the list of attachments"]
pub fn file_name_prefix(mut self, file_name_prefix: impl Into<String>) -> Self {
self.file_name_prefix = Some(file_name_prefix.into());
self
}
#[doc = "Default is false, set if metadata is needed"]
pub fn fetch_meta_data(mut self, fetch_meta_data: bool) -> Self {
self.fetch_meta_data = Some(fetch_meta_data);
self
}
#[doc = "Number of attachment references to return"]
pub fn top(mut self, top: i32) -> Self {
self.top = Some(top);
self
}
#[doc = "Header to pass the continuation token"]
pub fn continuation_token(mut self, continuation_token: impl Into<String>) -> Self {
self.continuation_token = Some(continuation_token.into());
self
}
#[doc = "Returns a future that sends the request and returns a [`Response`] object that provides low-level access to full response details."]
#[doc = ""]
#[doc = "You should typically use `.await` (which implicitly calls `IntoFuture::into_future()`) to finalize and send requests rather than `send()`."]
#[doc = "However, this function can provide more flexibility when required."]
pub fn send(self) -> BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = this.url()?;
let mut req =
azure_core::http::Request::new(url, azure_core::http::Method::Get);
if let Some(auth_header) = this
.client
.token_credential()
.http_authorization_header(&this.client.scopes())
.await?
{
req.insert_header(
azure_core::http::headers::AUTHORIZATION,
auth_header,
);
}
let type_ = &this.type_;
req.url_mut()
.query_pairs_mut()
.append_pair("type", &type_.to_string());
if let Some(directory_path) = &this.directory_path {
req.url_mut()
.query_pairs_mut()
.append_pair("directoryPath", directory_path);
}
if let Some(file_name_prefix) = &this.file_name_prefix {
req.url_mut()
.query_pairs_mut()
.append_pair("fileNamePrefix", file_name_prefix);
}
if let Some(fetch_meta_data) = &this.fetch_meta_data {
req.url_mut()
.query_pairs_mut()
.append_pair("fetchMetaData", &fetch_meta_data.to_string());
}
if let Some(top) = &this.top {
req.url_mut()
.query_pairs_mut()
.append_pair("top", &top.to_string());
}
if let Some(continuation_token) = &this.continuation_token {
req.insert_header("continuationtoken", continuation_token);
}
let req_body = azure_core::Bytes::new();
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?.into()))
}
})
}
fn url(&self) -> azure_core::Result<azure_core::http::Url> {
let mut url = azure_core::http::Url::parse(&format!(
"{}/{}/{}/_apis/testresults/runs/{}/testlog",
self.client.endpoint(),
&self.organization,
&self.project,
&self.run_id
))?;
let has_api_version_already = url.query_pairs().any(|(k, _)| k == "api-version");
if !has_api_version_already {
url.query_pairs_mut()
.append_pair("api-version", "7.1-preview");
}
Ok(url)
}
}
impl std::future::IntoFuture for RequestBuilder {
type Output = azure_core::Result<models::TestLogList>;
type IntoFuture = BoxFuture<'static, azure_core::Result<models::TestLogList>>;
#[doc = "Returns a future that sends the request and returns the parsed response body."]
#[doc = ""]
#[doc = "You should not normally call this method directly, simply invoke `.await` which implicitly calls `IntoFuture::into_future`."]
#[doc = ""]
#[doc = "See [IntoFuture documentation](https://doc.rust-lang.org/std/future/trait.IntoFuture.html) for more details."]
fn into_future(self) -> Self::IntoFuture {
Box::pin(async move { self.send().await?.into_body() })
}
}
}
pub mod get_test_logs_for_build {
use super::models;
#[cfg(not(target_arch = "wasm32"))]
use futures::future::BoxFuture;
#[cfg(target_arch = "wasm32")]
use futures::future::LocalBoxFuture as BoxFuture;
#[derive(Debug)]
pub struct Response(
azure_core::http::Response<models::TestLogList, azure_core::http::JsonFormat>,
);
impl Response {
pub fn into_body(self) -> azure_core::Result<models::TestLogList> {
self.0.into_model()
}
pub fn into_raw_response(self) -> azure_core::http::RawResponse {
self.0.into()
}
}
#[derive(Clone)]
#[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."]
#[doc = r""]
#[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"]
#[doc = r" parameters can be chained."]
#[doc = r""]
#[doc = r" To finalize and submit the request, invoke `.await`, which"]
#[doc = r" converts the [`RequestBuilder`] into a future,"]
#[doc = r" executes the request and returns a `Result` with the parsed"]
#[doc = r" response."]
#[doc = r""]
#[doc = r" If you need lower-level access to the raw response details"]
#[doc = r" (e.g. to inspect response headers or raw body data) then you"]
#[doc = r" can finalize the request using the"]
#[doc = r" [`RequestBuilder::send()`] method which returns a future"]
#[doc = r" that resolves to a lower-level [`Response`] value."]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) organization: String,
pub(crate) project: String,
pub(crate) build_id: i32,
pub(crate) type_: models::TestLogType,
pub(crate) directory_path: Option<String>,
pub(crate) file_name_prefix: Option<String>,
pub(crate) fetch_meta_data: Option<bool>,
pub(crate) top: Option<i32>,
pub(crate) continuation_token: Option<String>,
}
impl RequestBuilder {
#[doc = "directory path for which attachments are needed"]
pub fn directory_path(mut self, directory_path: impl Into<String>) -> Self {
self.directory_path = Some(directory_path.into());
self
}
#[doc = "Filename prefix to filter the list of attachments"]
pub fn file_name_prefix(mut self, file_name_prefix: impl Into<String>) -> Self {
self.file_name_prefix = Some(file_name_prefix.into());
self
}
#[doc = "Default is false, set if metadata is needed"]
pub fn fetch_meta_data(mut self, fetch_meta_data: bool) -> Self {
self.fetch_meta_data = Some(fetch_meta_data);
self
}
#[doc = "Number of test attachments reference to return"]
pub fn top(mut self, top: i32) -> Self {
self.top = Some(top);
self
}
#[doc = "Header to pass the continuation token"]
pub fn continuation_token(mut self, continuation_token: impl Into<String>) -> Self {
self.continuation_token = Some(continuation_token.into());
self
}
#[doc = "Returns a future that sends the request and returns a [`Response`] object that provides low-level access to full response details."]
#[doc = ""]
#[doc = "You should typically use `.await` (which implicitly calls `IntoFuture::into_future()`) to finalize and send requests rather than `send()`."]
#[doc = "However, this function can provide more flexibility when required."]
pub fn send(self) -> BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = this.url()?;
let mut req =
azure_core::http::Request::new(url, azure_core::http::Method::Get);
if let Some(auth_header) = this
.client
.token_credential()
.http_authorization_header(&this.client.scopes())
.await?
{
req.insert_header(
azure_core::http::headers::AUTHORIZATION,
auth_header,
);
}
let build_id = &this.build_id;
req.url_mut()
.query_pairs_mut()
.append_pair("buildId", &build_id.to_string());
let type_ = &this.type_;
req.url_mut()
.query_pairs_mut()
.append_pair("type", &type_.to_string());
if let Some(directory_path) = &this.directory_path {
req.url_mut()
.query_pairs_mut()
.append_pair("directoryPath", directory_path);
}
if let Some(file_name_prefix) = &this.file_name_prefix {
req.url_mut()
.query_pairs_mut()
.append_pair("fileNamePrefix", file_name_prefix);
}
if let Some(fetch_meta_data) = &this.fetch_meta_data {
req.url_mut()
.query_pairs_mut()
.append_pair("fetchMetaData", &fetch_meta_data.to_string());
}
if let Some(top) = &this.top {
req.url_mut()
.query_pairs_mut()
.append_pair("top", &top.to_string());
}
if let Some(continuation_token) = &this.continuation_token {
req.insert_header("continuationtoken", continuation_token);
}
let req_body = azure_core::Bytes::new();
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?.into()))
}
})
}
fn url(&self) -> azure_core::Result<azure_core::http::Url> {
let mut url = azure_core::http::Url::parse(&format!(
"{}/{}/{}/_apis/testresults/testlog",
self.client.endpoint(),
&self.organization,
&self.project
))?;
let has_api_version_already = url.query_pairs().any(|(k, _)| k == "api-version");
if !has_api_version_already {
url.query_pairs_mut()
.append_pair("api-version", "7.1-preview");
}
Ok(url)
}
}
impl std::future::IntoFuture for RequestBuilder {
type Output = azure_core::Result<models::TestLogList>;
type IntoFuture = BoxFuture<'static, azure_core::Result<models::TestLogList>>;
#[doc = "Returns a future that sends the request and returns the parsed response body."]
#[doc = ""]
#[doc = "You should not normally call this method directly, simply invoke `.await` which implicitly calls `IntoFuture::into_future`."]
#[doc = ""]
#[doc = "See [IntoFuture documentation](https://doc.rust-lang.org/std/future/trait.IntoFuture.html) for more details."]
fn into_future(self) -> Self::IntoFuture {
Box::pin(async move { self.send().await?.into_body() })
}
}
}
}
pub mod testlogstoreendpoint {
use super::models;
#[cfg(not(target_arch = "wasm32"))]
use futures::future::BoxFuture;
#[cfg(target_arch = "wasm32")]
use futures::future::LocalBoxFuture as BoxFuture;
pub struct Client(pub(crate) super::Client);
impl Client {
#[doc = "Get SAS Uri of a test subresults attachment"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `organization`: The name of the Azure DevOps organization."]
#[doc = "* `project`: Project ID or project name"]
#[doc = "* `run_id`: Id of the test run that contains result"]
#[doc = "* `result_id`: Id of the test result that contains subresult"]
#[doc = "* `sub_result_id`: Id of the test subresult whose file sas uri is needed"]
#[doc = "* `type_`: type of the file"]
#[doc = "* `file_path`: filePath for which sas uri is needed"]
pub fn get_test_log_store_endpoint_details_for_sub_result_log(
&self,
organization: impl Into<String>,
project: impl Into<String>,
run_id: i32,
result_id: i32,
sub_result_id: i32,
type_: impl Into<models::TestLogType>,
file_path: impl Into<String>,
) -> get_test_log_store_endpoint_details_for_sub_result_log::RequestBuilder {
get_test_log_store_endpoint_details_for_sub_result_log::RequestBuilder {
client: self.0.clone(),
organization: organization.into(),
project: project.into(),
run_id,
result_id,
sub_result_id,
type_: type_.into(),
file_path: file_path.into(),
}
}
#[doc = "Get SAS Uri of a test results attachment"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `organization`: The name of the Azure DevOps organization."]
#[doc = "* `project`: Project ID or project name"]
#[doc = "* `run_id`: Id of the test run that contains result"]
#[doc = "* `result_id`: Id of the test result whose files need to be downloaded"]
#[doc = "* `type_`: type of the file"]
#[doc = "* `file_path`: filePath for which sas uri is needed"]
pub fn get_test_log_store_endpoint_details_for_result_log(
&self,
organization: impl Into<String>,
project: impl Into<String>,
run_id: i32,
result_id: i32,
type_: impl Into<models::TestLogType>,
file_path: impl Into<String>,
) -> get_test_log_store_endpoint_details_for_result_log::RequestBuilder {
get_test_log_store_endpoint_details_for_result_log::RequestBuilder {
client: self.0.clone(),
organization: organization.into(),
project: project.into(),
run_id,
result_id,
type_: type_.into(),
file_path: file_path.into(),
}
}
#[doc = "Create empty file for a result and Get Sas uri for the file"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `organization`: The name of the Azure DevOps organization."]
#[doc = "* `project`: Project ID or project name"]
#[doc = "* `run_id`: Id of the test run that contains the result"]
#[doc = "* `result_id`: Id of the test results that contains sub result"]
#[doc = "* `sub_result_id`: Id of the test sub result whose file sas uri is needed"]
#[doc = "* `file_path`: file path inside the sub result for which sas uri is needed"]
#[doc = "* `type_`: Type of the file for download"]
pub fn test_log_store_endpoint_details_for_result(
&self,
organization: impl Into<String>,
project: impl Into<String>,
run_id: i32,
result_id: i32,
sub_result_id: i32,
file_path: impl Into<String>,
type_: impl Into<models::TestLogType>,
) -> test_log_store_endpoint_details_for_result::RequestBuilder {
test_log_store_endpoint_details_for_result::RequestBuilder {
client: self.0.clone(),
organization: organization.into(),
project: project.into(),
run_id,
result_id,
sub_result_id,
file_path: file_path.into(),
type_: type_.into(),
}
}
#[doc = "Get SAS Uri of a test run attachment"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `organization`: The name of the Azure DevOps organization."]
#[doc = "* `project`: Project ID or project name"]
#[doc = "* `run_id`: Id of the test run whose file has to be downloaded"]
#[doc = "* `type_`: type of the file"]
#[doc = "* `file_path`: filePath for which sas uri is needed"]
pub fn get_test_log_store_endpoint_details_for_run_log(
&self,
organization: impl Into<String>,
project: impl Into<String>,
run_id: i32,
type_: impl Into<models::TestLogType>,
file_path: impl Into<String>,
) -> get_test_log_store_endpoint_details_for_run_log::RequestBuilder {
get_test_log_store_endpoint_details_for_run_log::RequestBuilder {
client: self.0.clone(),
organization: organization.into(),
project: project.into(),
run_id,
type_: type_.into(),
file_path: file_path.into(),
}
}
#[doc = "Create empty file for a run and Get Sas uri for the file"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `organization`: The name of the Azure DevOps organization."]
#[doc = "* `project`: Project ID or project name"]
#[doc = "* `run_id`: Id of the run to get endpoint details"]
#[doc = "* `test_log_store_operation_type`: Type of operation to perform using sas uri"]
pub fn test_log_store_endpoint_details_for_run(
&self,
organization: impl Into<String>,
project: impl Into<String>,
run_id: i32,
test_log_store_operation_type: impl Into<models::TestLogStoreOperationType>,
) -> test_log_store_endpoint_details_for_run::RequestBuilder {
test_log_store_endpoint_details_for_run::RequestBuilder {
client: self.0.clone(),
organization: organization.into(),
project: project.into(),
run_id,
test_log_store_operation_type: test_log_store_operation_type.into(),
file_path: None,
type_: None,
}
}
#[doc = "Get SAS Uri of a build attachment"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `organization`: The name of the Azure DevOps organization."]
#[doc = "* `project`: Project ID or project name"]
#[doc = "* `build`: Id of the build to get"]
#[doc = "* `type_`: type of the file"]
#[doc = "* `file_path`: filePath for which sas uri is needed"]
pub fn get_test_log_store_endpoint_details_for_build_log(
&self,
organization: impl Into<String>,
project: impl Into<String>,
build: i32,
type_: impl Into<models::TestLogType>,
file_path: impl Into<String>,
) -> get_test_log_store_endpoint_details_for_build_log::RequestBuilder {
get_test_log_store_endpoint_details_for_build_log::RequestBuilder {
client: self.0.clone(),
organization: organization.into(),
project: project.into(),
build,
type_: type_.into(),
file_path: file_path.into(),
}
}
#[doc = "Create and Get sas uri of the build container"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `organization`: The name of the Azure DevOps organization."]
#[doc = "* `project`: Project ID or project name"]
#[doc = "* `build_id`: Id of the build to get"]
#[doc = "* `test_log_store_operation_type`: Type of operation to perform using sas uri"]
pub fn test_log_store_endpoint_details_for_build(
&self,
organization: impl Into<String>,
project: impl Into<String>,
build_id: i32,
test_log_store_operation_type: impl Into<models::TestLogStoreOperationType>,
) -> test_log_store_endpoint_details_for_build::RequestBuilder {
test_log_store_endpoint_details_for_build::RequestBuilder {
client: self.0.clone(),
organization: organization.into(),
project: project.into(),
build_id,
test_log_store_operation_type: test_log_store_operation_type.into(),
}
}
}
pub mod get_test_log_store_endpoint_details_for_sub_result_log {
use super::models;
#[cfg(not(target_arch = "wasm32"))]
use futures::future::BoxFuture;
#[cfg(target_arch = "wasm32")]
use futures::future::LocalBoxFuture as BoxFuture;
#[derive(Debug)]
pub struct Response(
azure_core::http::Response<
models::TestLogStoreEndpointDetails,
azure_core::http::JsonFormat,
>,
);
impl Response {
pub fn into_body(self) -> azure_core::Result<models::TestLogStoreEndpointDetails> {
self.0.into_model()
}
pub fn into_raw_response(self) -> azure_core::http::RawResponse {
self.0.into()
}
}
#[derive(Clone)]
#[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."]
#[doc = r""]
#[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"]
#[doc = r" parameters can be chained."]
#[doc = r""]
#[doc = r" To finalize and submit the request, invoke `.await`, which"]
#[doc = r" converts the [`RequestBuilder`] into a future,"]
#[doc = r" executes the request and returns a `Result` with the parsed"]
#[doc = r" response."]
#[doc = r""]
#[doc = r" If you need lower-level access to the raw response details"]
#[doc = r" (e.g. to inspect response headers or raw body data) then you"]
#[doc = r" can finalize the request using the"]
#[doc = r" [`RequestBuilder::send()`] method which returns a future"]
#[doc = r" that resolves to a lower-level [`Response`] value."]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) organization: String,
pub(crate) project: String,
pub(crate) run_id: i32,
pub(crate) result_id: i32,
pub(crate) sub_result_id: i32,
pub(crate) type_: models::TestLogType,
pub(crate) file_path: String,
}
impl RequestBuilder {
#[doc = "Returns a future that sends the request and returns a [`Response`] object that provides low-level access to full response details."]
#[doc = ""]
#[doc = "You should typically use `.await` (which implicitly calls `IntoFuture::into_future()`) to finalize and send requests rather than `send()`."]
#[doc = "However, this function can provide more flexibility when required."]
pub fn send(self) -> BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = this.url()?;
let mut req =
azure_core::http::Request::new(url, azure_core::http::Method::Get);
if let Some(auth_header) = this
.client
.token_credential()
.http_authorization_header(&this.client.scopes())
.await?
{
req.insert_header(
azure_core::http::headers::AUTHORIZATION,
auth_header,
);
}
let sub_result_id = &this.sub_result_id;
req.url_mut()
.query_pairs_mut()
.append_pair("subResultId", &sub_result_id.to_string());
let type_ = &this.type_;
req.url_mut()
.query_pairs_mut()
.append_pair("type", &type_.to_string());
let file_path = &this.file_path;
req.url_mut()
.query_pairs_mut()
.append_pair("filePath", file_path);
let req_body = azure_core::Bytes::new();
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?.into()))
}
})
}
fn url(&self) -> azure_core::Result<azure_core::http::Url> {
let mut url = azure_core :: http :: Url :: parse (& format ! ("{}/{}/{}/_apis/testresults/runs/{}/results/{}/testlogstoreendpoint?subResultId={}&type={}&filePath={}" , self . client . endpoint () , & self . organization , & self . project , & self . run_id , & self . result_id , & self . sub_result_id , & self . type_ , & self . file_path)) ? ;
let has_api_version_already = url.query_pairs().any(|(k, _)| k == "api-version");
if !has_api_version_already {
url.query_pairs_mut()
.append_pair("api-version", "7.1-preview");
}
Ok(url)
}
}
impl std::future::IntoFuture for RequestBuilder {
type Output = azure_core::Result<models::TestLogStoreEndpointDetails>;
type IntoFuture =
BoxFuture<'static, azure_core::Result<models::TestLogStoreEndpointDetails>>;
#[doc = "Returns a future that sends the request and returns the parsed response body."]
#[doc = ""]
#[doc = "You should not normally call this method directly, simply invoke `.await` which implicitly calls `IntoFuture::into_future`."]
#[doc = ""]
#[doc = "See [IntoFuture documentation](https://doc.rust-lang.org/std/future/trait.IntoFuture.html) for more details."]
fn into_future(self) -> Self::IntoFuture {
Box::pin(async move { self.send().await?.into_body() })
}
}
}
pub mod get_test_log_store_endpoint_details_for_result_log {
use super::models;
#[cfg(not(target_arch = "wasm32"))]
use futures::future::BoxFuture;
#[cfg(target_arch = "wasm32")]
use futures::future::LocalBoxFuture as BoxFuture;
#[derive(Debug)]
pub struct Response(
azure_core::http::Response<
models::TestLogStoreEndpointDetails,
azure_core::http::JsonFormat,
>,
);
impl Response {
pub fn into_body(self) -> azure_core::Result<models::TestLogStoreEndpointDetails> {
self.0.into_model()
}
pub fn into_raw_response(self) -> azure_core::http::RawResponse {
self.0.into()
}
}
#[derive(Clone)]
#[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."]
#[doc = r""]
#[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"]
#[doc = r" parameters can be chained."]
#[doc = r""]
#[doc = r" To finalize and submit the request, invoke `.await`, which"]
#[doc = r" converts the [`RequestBuilder`] into a future,"]
#[doc = r" executes the request and returns a `Result` with the parsed"]
#[doc = r" response."]
#[doc = r""]
#[doc = r" If you need lower-level access to the raw response details"]
#[doc = r" (e.g. to inspect response headers or raw body data) then you"]
#[doc = r" can finalize the request using the"]
#[doc = r" [`RequestBuilder::send()`] method which returns a future"]
#[doc = r" that resolves to a lower-level [`Response`] value."]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) organization: String,
pub(crate) project: String,
pub(crate) run_id: i32,
pub(crate) result_id: i32,
pub(crate) type_: models::TestLogType,
pub(crate) file_path: String,
}
impl RequestBuilder {
#[doc = "Returns a future that sends the request and returns a [`Response`] object that provides low-level access to full response details."]
#[doc = ""]
#[doc = "You should typically use `.await` (which implicitly calls `IntoFuture::into_future()`) to finalize and send requests rather than `send()`."]
#[doc = "However, this function can provide more flexibility when required."]
pub fn send(self) -> BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = this.url()?;
let mut req =
azure_core::http::Request::new(url, azure_core::http::Method::Get);
if let Some(auth_header) = this
.client
.token_credential()
.http_authorization_header(&this.client.scopes())
.await?
{
req.insert_header(
azure_core::http::headers::AUTHORIZATION,
auth_header,
);
}
let type_ = &this.type_;
req.url_mut()
.query_pairs_mut()
.append_pair("type", &type_.to_string());
let file_path = &this.file_path;
req.url_mut()
.query_pairs_mut()
.append_pair("filePath", file_path);
let req_body = azure_core::Bytes::new();
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?.into()))
}
})
}
fn url(&self) -> azure_core::Result<azure_core::http::Url> {
let mut url = azure_core::http::Url::parse(&format!(
"{}/{}/{}/_apis/testresults/runs/{}/results/{}/testlogstoreendpoint",
self.client.endpoint(),
&self.organization,
&self.project,
&self.run_id,
&self.result_id
))?;
let has_api_version_already = url.query_pairs().any(|(k, _)| k == "api-version");
if !has_api_version_already {
url.query_pairs_mut()
.append_pair("api-version", "7.1-preview");
}
Ok(url)
}
}
impl std::future::IntoFuture for RequestBuilder {
type Output = azure_core::Result<models::TestLogStoreEndpointDetails>;
type IntoFuture =
BoxFuture<'static, azure_core::Result<models::TestLogStoreEndpointDetails>>;
#[doc = "Returns a future that sends the request and returns the parsed response body."]
#[doc = ""]
#[doc = "You should not normally call this method directly, simply invoke `.await` which implicitly calls `IntoFuture::into_future`."]
#[doc = ""]
#[doc = "See [IntoFuture documentation](https://doc.rust-lang.org/std/future/trait.IntoFuture.html) for more details."]
fn into_future(self) -> Self::IntoFuture {
Box::pin(async move { self.send().await?.into_body() })
}
}
}
pub mod test_log_store_endpoint_details_for_result {
use super::models;
#[cfg(not(target_arch = "wasm32"))]
use futures::future::BoxFuture;
#[cfg(target_arch = "wasm32")]
use futures::future::LocalBoxFuture as BoxFuture;
#[derive(Debug)]
pub struct Response(
azure_core::http::Response<
models::TestLogStoreEndpointDetails,
azure_core::http::JsonFormat,
>,
);
impl Response {
pub fn into_body(self) -> azure_core::Result<models::TestLogStoreEndpointDetails> {
self.0.into_model()
}
pub fn into_raw_response(self) -> azure_core::http::RawResponse {
self.0.into()
}
}
#[derive(Clone)]
#[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."]
#[doc = r""]
#[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"]
#[doc = r" parameters can be chained."]
#[doc = r""]
#[doc = r" To finalize and submit the request, invoke `.await`, which"]
#[doc = r" converts the [`RequestBuilder`] into a future,"]
#[doc = r" executes the request and returns a `Result` with the parsed"]
#[doc = r" response."]
#[doc = r""]
#[doc = r" If you need lower-level access to the raw response details"]
#[doc = r" (e.g. to inspect response headers or raw body data) then you"]
#[doc = r" can finalize the request using the"]
#[doc = r" [`RequestBuilder::send()`] method which returns a future"]
#[doc = r" that resolves to a lower-level [`Response`] value."]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) organization: String,
pub(crate) project: String,
pub(crate) run_id: i32,
pub(crate) result_id: i32,
pub(crate) sub_result_id: i32,
pub(crate) file_path: String,
pub(crate) type_: models::TestLogType,
}
impl RequestBuilder {
#[doc = "Returns a future that sends the request and returns a [`Response`] object that provides low-level access to full response details."]
#[doc = ""]
#[doc = "You should typically use `.await` (which implicitly calls `IntoFuture::into_future()`) to finalize and send requests rather than `send()`."]
#[doc = "However, this function can provide more flexibility when required."]
pub fn send(self) -> BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = this.url()?;
let mut req =
azure_core::http::Request::new(url, azure_core::http::Method::Post);
if let Some(auth_header) = this
.client
.token_credential()
.http_authorization_header(&this.client.scopes())
.await?
{
req.insert_header(
azure_core::http::headers::AUTHORIZATION,
auth_header,
);
}
let sub_result_id = &this.sub_result_id;
req.url_mut()
.query_pairs_mut()
.append_pair("subResultId", &sub_result_id.to_string());
let file_path = &this.file_path;
req.url_mut()
.query_pairs_mut()
.append_pair("filePath", file_path);
let type_ = &this.type_;
req.url_mut()
.query_pairs_mut()
.append_pair("type", &type_.to_string());
let req_body = azure_core::Bytes::new();
req.insert_header(azure_core::http::headers::CONTENT_LENGTH, "0");
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?.into()))
}
})
}
fn url(&self) -> azure_core::Result<azure_core::http::Url> {
let mut url = azure_core::http::Url::parse(&format!(
"{}/{}/{}/_apis/testresults/runs/{}/results/{}/testlogstoreendpoint",
self.client.endpoint(),
&self.organization,
&self.project,
&self.run_id,
&self.result_id
))?;
let has_api_version_already = url.query_pairs().any(|(k, _)| k == "api-version");
if !has_api_version_already {
url.query_pairs_mut()
.append_pair("api-version", "7.1-preview");
}
Ok(url)
}
}
impl std::future::IntoFuture for RequestBuilder {
type Output = azure_core::Result<models::TestLogStoreEndpointDetails>;
type IntoFuture =
BoxFuture<'static, azure_core::Result<models::TestLogStoreEndpointDetails>>;
#[doc = "Returns a future that sends the request and returns the parsed response body."]
#[doc = ""]
#[doc = "You should not normally call this method directly, simply invoke `.await` which implicitly calls `IntoFuture::into_future`."]
#[doc = ""]
#[doc = "See [IntoFuture documentation](https://doc.rust-lang.org/std/future/trait.IntoFuture.html) for more details."]
fn into_future(self) -> Self::IntoFuture {
Box::pin(async move { self.send().await?.into_body() })
}
}
}
pub mod get_test_log_store_endpoint_details_for_run_log {
use super::models;
#[cfg(not(target_arch = "wasm32"))]
use futures::future::BoxFuture;
#[cfg(target_arch = "wasm32")]
use futures::future::LocalBoxFuture as BoxFuture;
#[derive(Debug)]
pub struct Response(
azure_core::http::Response<
models::TestLogStoreEndpointDetails,
azure_core::http::JsonFormat,
>,
);
impl Response {
pub fn into_body(self) -> azure_core::Result<models::TestLogStoreEndpointDetails> {
self.0.into_model()
}
pub fn into_raw_response(self) -> azure_core::http::RawResponse {
self.0.into()
}
}
#[derive(Clone)]
#[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."]
#[doc = r""]
#[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"]
#[doc = r" parameters can be chained."]
#[doc = r""]
#[doc = r" To finalize and submit the request, invoke `.await`, which"]
#[doc = r" converts the [`RequestBuilder`] into a future,"]
#[doc = r" executes the request and returns a `Result` with the parsed"]
#[doc = r" response."]
#[doc = r""]
#[doc = r" If you need lower-level access to the raw response details"]
#[doc = r" (e.g. to inspect response headers or raw body data) then you"]
#[doc = r" can finalize the request using the"]
#[doc = r" [`RequestBuilder::send()`] method which returns a future"]
#[doc = r" that resolves to a lower-level [`Response`] value."]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) organization: String,
pub(crate) project: String,
pub(crate) run_id: i32,
pub(crate) type_: models::TestLogType,
pub(crate) file_path: String,
}
impl RequestBuilder {
#[doc = "Returns a future that sends the request and returns a [`Response`] object that provides low-level access to full response details."]
#[doc = ""]
#[doc = "You should typically use `.await` (which implicitly calls `IntoFuture::into_future()`) to finalize and send requests rather than `send()`."]
#[doc = "However, this function can provide more flexibility when required."]
pub fn send(self) -> BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = this.url()?;
let mut req =
azure_core::http::Request::new(url, azure_core::http::Method::Get);
if let Some(auth_header) = this
.client
.token_credential()
.http_authorization_header(&this.client.scopes())
.await?
{
req.insert_header(
azure_core::http::headers::AUTHORIZATION,
auth_header,
);
}
let type_ = &this.type_;
req.url_mut()
.query_pairs_mut()
.append_pair("type", &type_.to_string());
let file_path = &this.file_path;
req.url_mut()
.query_pairs_mut()
.append_pair("filePath", file_path);
let req_body = azure_core::Bytes::new();
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?.into()))
}
})
}
fn url(&self) -> azure_core::Result<azure_core::http::Url> {
let mut url = azure_core::http::Url::parse(&format!(
"{}/{}/{}/_apis/testresults/runs/{}/testlogstoreendpoint",
self.client.endpoint(),
&self.organization,
&self.project,
&self.run_id
))?;
let has_api_version_already = url.query_pairs().any(|(k, _)| k == "api-version");
if !has_api_version_already {
url.query_pairs_mut()
.append_pair("api-version", "7.1-preview");
}
Ok(url)
}
}
impl std::future::IntoFuture for RequestBuilder {
type Output = azure_core::Result<models::TestLogStoreEndpointDetails>;
type IntoFuture =
BoxFuture<'static, azure_core::Result<models::TestLogStoreEndpointDetails>>;
#[doc = "Returns a future that sends the request and returns the parsed response body."]
#[doc = ""]
#[doc = "You should not normally call this method directly, simply invoke `.await` which implicitly calls `IntoFuture::into_future`."]
#[doc = ""]
#[doc = "See [IntoFuture documentation](https://doc.rust-lang.org/std/future/trait.IntoFuture.html) for more details."]
fn into_future(self) -> Self::IntoFuture {
Box::pin(async move { self.send().await?.into_body() })
}
}
}
pub mod test_log_store_endpoint_details_for_run {
use super::models;
#[cfg(not(target_arch = "wasm32"))]
use futures::future::BoxFuture;
#[cfg(target_arch = "wasm32")]
use futures::future::LocalBoxFuture as BoxFuture;
#[derive(Debug)]
pub struct Response(
azure_core::http::Response<
models::TestLogStoreEndpointDetails,
azure_core::http::JsonFormat,
>,
);
impl Response {
pub fn into_body(self) -> azure_core::Result<models::TestLogStoreEndpointDetails> {
self.0.into_model()
}
pub fn into_raw_response(self) -> azure_core::http::RawResponse {
self.0.into()
}
}
#[derive(Clone)]
#[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."]
#[doc = r""]
#[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"]
#[doc = r" parameters can be chained."]
#[doc = r""]
#[doc = r" To finalize and submit the request, invoke `.await`, which"]
#[doc = r" converts the [`RequestBuilder`] into a future,"]
#[doc = r" executes the request and returns a `Result` with the parsed"]
#[doc = r" response."]
#[doc = r""]
#[doc = r" If you need lower-level access to the raw response details"]
#[doc = r" (e.g. to inspect response headers or raw body data) then you"]
#[doc = r" can finalize the request using the"]
#[doc = r" [`RequestBuilder::send()`] method which returns a future"]
#[doc = r" that resolves to a lower-level [`Response`] value."]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) organization: String,
pub(crate) project: String,
pub(crate) run_id: i32,
pub(crate) test_log_store_operation_type: models::TestLogStoreOperationType,
pub(crate) file_path: Option<String>,
pub(crate) type_: Option<models::TestLogType>,
}
impl RequestBuilder {
#[doc = "file path to create an empty file"]
pub fn file_path(mut self, file_path: impl Into<String>) -> Self {
self.file_path = Some(file_path.into());
self
}
#[doc = "Default is GeneralAttachment, type of empty file to be created"]
pub fn type_(mut self, type_: impl Into<models::TestLogType>) -> Self {
self.type_ = Some(type_.into());
self
}
#[doc = "Returns a future that sends the request and returns a [`Response`] object that provides low-level access to full response details."]
#[doc = ""]
#[doc = "You should typically use `.await` (which implicitly calls `IntoFuture::into_future()`) to finalize and send requests rather than `send()`."]
#[doc = "However, this function can provide more flexibility when required."]
pub fn send(self) -> BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = this.url()?;
let mut req =
azure_core::http::Request::new(url, azure_core::http::Method::Post);
if let Some(auth_header) = this
.client
.token_credential()
.http_authorization_header(&this.client.scopes())
.await?
{
req.insert_header(
azure_core::http::headers::AUTHORIZATION,
auth_header,
);
}
let test_log_store_operation_type = &this.test_log_store_operation_type;
req.url_mut().query_pairs_mut().append_pair(
"testLogStoreOperationType",
&test_log_store_operation_type.to_string(),
);
if let Some(file_path) = &this.file_path {
req.url_mut()
.query_pairs_mut()
.append_pair("filePath", file_path);
}
if let Some(type_) = &this.type_ {
req.url_mut()
.query_pairs_mut()
.append_pair("type", &type_.to_string());
}
let req_body = azure_core::Bytes::new();
req.insert_header(azure_core::http::headers::CONTENT_LENGTH, "0");
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?.into()))
}
})
}
fn url(&self) -> azure_core::Result<azure_core::http::Url> {
let mut url = azure_core::http::Url::parse(&format!(
"{}/{}/{}/_apis/testresults/runs/{}/testlogstoreendpoint",
self.client.endpoint(),
&self.organization,
&self.project,
&self.run_id
))?;
let has_api_version_already = url.query_pairs().any(|(k, _)| k == "api-version");
if !has_api_version_already {
url.query_pairs_mut()
.append_pair("api-version", "7.1-preview");
}
Ok(url)
}
}
impl std::future::IntoFuture for RequestBuilder {
type Output = azure_core::Result<models::TestLogStoreEndpointDetails>;
type IntoFuture =
BoxFuture<'static, azure_core::Result<models::TestLogStoreEndpointDetails>>;
#[doc = "Returns a future that sends the request and returns the parsed response body."]
#[doc = ""]
#[doc = "You should not normally call this method directly, simply invoke `.await` which implicitly calls `IntoFuture::into_future`."]
#[doc = ""]
#[doc = "See [IntoFuture documentation](https://doc.rust-lang.org/std/future/trait.IntoFuture.html) for more details."]
fn into_future(self) -> Self::IntoFuture {
Box::pin(async move { self.send().await?.into_body() })
}
}
}
pub mod get_test_log_store_endpoint_details_for_build_log {
use super::models;
#[cfg(not(target_arch = "wasm32"))]
use futures::future::BoxFuture;
#[cfg(target_arch = "wasm32")]
use futures::future::LocalBoxFuture as BoxFuture;
#[derive(Debug)]
pub struct Response(
azure_core::http::Response<
models::TestLogStoreEndpointDetails,
azure_core::http::JsonFormat,
>,
);
impl Response {
pub fn into_body(self) -> azure_core::Result<models::TestLogStoreEndpointDetails> {
self.0.into_model()
}
pub fn into_raw_response(self) -> azure_core::http::RawResponse {
self.0.into()
}
}
#[derive(Clone)]
#[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."]
#[doc = r""]
#[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"]
#[doc = r" parameters can be chained."]
#[doc = r""]
#[doc = r" To finalize and submit the request, invoke `.await`, which"]
#[doc = r" converts the [`RequestBuilder`] into a future,"]
#[doc = r" executes the request and returns a `Result` with the parsed"]
#[doc = r" response."]
#[doc = r""]
#[doc = r" If you need lower-level access to the raw response details"]
#[doc = r" (e.g. to inspect response headers or raw body data) then you"]
#[doc = r" can finalize the request using the"]
#[doc = r" [`RequestBuilder::send()`] method which returns a future"]
#[doc = r" that resolves to a lower-level [`Response`] value."]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) organization: String,
pub(crate) project: String,
pub(crate) build: i32,
pub(crate) type_: models::TestLogType,
pub(crate) file_path: String,
}
impl RequestBuilder {
#[doc = "Returns a future that sends the request and returns a [`Response`] object that provides low-level access to full response details."]
#[doc = ""]
#[doc = "You should typically use `.await` (which implicitly calls `IntoFuture::into_future()`) to finalize and send requests rather than `send()`."]
#[doc = "However, this function can provide more flexibility when required."]
pub fn send(self) -> BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = this.url()?;
let mut req =
azure_core::http::Request::new(url, azure_core::http::Method::Get);
if let Some(auth_header) = this
.client
.token_credential()
.http_authorization_header(&this.client.scopes())
.await?
{
req.insert_header(
azure_core::http::headers::AUTHORIZATION,
auth_header,
);
}
let build = &this.build;
req.url_mut()
.query_pairs_mut()
.append_pair("build", &build.to_string());
let type_ = &this.type_;
req.url_mut()
.query_pairs_mut()
.append_pair("type", &type_.to_string());
let file_path = &this.file_path;
req.url_mut()
.query_pairs_mut()
.append_pair("filePath", file_path);
let req_body = azure_core::Bytes::new();
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?.into()))
}
})
}
fn url(&self) -> azure_core::Result<azure_core::http::Url> {
let mut url = azure_core::http::Url::parse(&format!(
"{}/{}/{}/_apis/testresults/testlogstoreendpoint",
self.client.endpoint(),
&self.organization,
&self.project
))?;
let has_api_version_already = url.query_pairs().any(|(k, _)| k == "api-version");
if !has_api_version_already {
url.query_pairs_mut()
.append_pair("api-version", "7.1-preview");
}
Ok(url)
}
}
impl std::future::IntoFuture for RequestBuilder {
type Output = azure_core::Result<models::TestLogStoreEndpointDetails>;
type IntoFuture =
BoxFuture<'static, azure_core::Result<models::TestLogStoreEndpointDetails>>;
#[doc = "Returns a future that sends the request and returns the parsed response body."]
#[doc = ""]
#[doc = "You should not normally call this method directly, simply invoke `.await` which implicitly calls `IntoFuture::into_future`."]
#[doc = ""]
#[doc = "See [IntoFuture documentation](https://doc.rust-lang.org/std/future/trait.IntoFuture.html) for more details."]
fn into_future(self) -> Self::IntoFuture {
Box::pin(async move { self.send().await?.into_body() })
}
}
}
pub mod test_log_store_endpoint_details_for_build {
use super::models;
#[cfg(not(target_arch = "wasm32"))]
use futures::future::BoxFuture;
#[cfg(target_arch = "wasm32")]
use futures::future::LocalBoxFuture as BoxFuture;
#[derive(Debug)]
pub struct Response(
azure_core::http::Response<
models::TestLogStoreEndpointDetails,
azure_core::http::JsonFormat,
>,
);
impl Response {
pub fn into_body(self) -> azure_core::Result<models::TestLogStoreEndpointDetails> {
self.0.into_model()
}
pub fn into_raw_response(self) -> azure_core::http::RawResponse {
self.0.into()
}
}
#[derive(Clone)]
#[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."]
#[doc = r""]
#[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"]
#[doc = r" parameters can be chained."]
#[doc = r""]
#[doc = r" To finalize and submit the request, invoke `.await`, which"]
#[doc = r" converts the [`RequestBuilder`] into a future,"]
#[doc = r" executes the request and returns a `Result` with the parsed"]
#[doc = r" response."]
#[doc = r""]
#[doc = r" If you need lower-level access to the raw response details"]
#[doc = r" (e.g. to inspect response headers or raw body data) then you"]
#[doc = r" can finalize the request using the"]
#[doc = r" [`RequestBuilder::send()`] method which returns a future"]
#[doc = r" that resolves to a lower-level [`Response`] value."]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) organization: String,
pub(crate) project: String,
pub(crate) build_id: i32,
pub(crate) test_log_store_operation_type: models::TestLogStoreOperationType,
}
impl RequestBuilder {
#[doc = "Returns a future that sends the request and returns a [`Response`] object that provides low-level access to full response details."]
#[doc = ""]
#[doc = "You should typically use `.await` (which implicitly calls `IntoFuture::into_future()`) to finalize and send requests rather than `send()`."]
#[doc = "However, this function can provide more flexibility when required."]
pub fn send(self) -> BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = this.url()?;
let mut req =
azure_core::http::Request::new(url, azure_core::http::Method::Post);
if let Some(auth_header) = this
.client
.token_credential()
.http_authorization_header(&this.client.scopes())
.await?
{
req.insert_header(
azure_core::http::headers::AUTHORIZATION,
auth_header,
);
}
let build_id = &this.build_id;
req.url_mut()
.query_pairs_mut()
.append_pair("buildId", &build_id.to_string());
let test_log_store_operation_type = &this.test_log_store_operation_type;
req.url_mut().query_pairs_mut().append_pair(
"testLogStoreOperationType",
&test_log_store_operation_type.to_string(),
);
let req_body = azure_core::Bytes::new();
req.insert_header(azure_core::http::headers::CONTENT_LENGTH, "0");
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?.into()))
}
})
}
fn url(&self) -> azure_core::Result<azure_core::http::Url> {
let mut url = azure_core::http::Url::parse(&format!(
"{}/{}/{}/_apis/testresults/testlogstoreendpoint",
self.client.endpoint(),
&self.organization,
&self.project
))?;
let has_api_version_already = url.query_pairs().any(|(k, _)| k == "api-version");
if !has_api_version_already {
url.query_pairs_mut()
.append_pair("api-version", "7.1-preview");
}
Ok(url)
}
}
impl std::future::IntoFuture for RequestBuilder {
type Output = azure_core::Result<models::TestLogStoreEndpointDetails>;
type IntoFuture =
BoxFuture<'static, azure_core::Result<models::TestLogStoreEndpointDetails>>;
#[doc = "Returns a future that sends the request and returns the parsed response body."]
#[doc = ""]
#[doc = "You should not normally call this method directly, simply invoke `.await` which implicitly calls `IntoFuture::into_future`."]
#[doc = ""]
#[doc = "See [IntoFuture documentation](https://doc.rust-lang.org/std/future/trait.IntoFuture.html) for more details."]
fn into_future(self) -> Self::IntoFuture {
Box::pin(async move { self.send().await?.into_body() })
}
}
}
}
pub mod attachments {
use super::models;
#[cfg(not(target_arch = "wasm32"))]
use futures::future::BoxFuture;
#[cfg(target_arch = "wasm32")]
use futures::future::LocalBoxFuture as BoxFuture;
pub struct Client(pub(crate) super::Client);
impl Client {
#[doc = "Returns attachment references for test sub result."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `organization`: The name of the Azure DevOps organization."]
#[doc = "* `project`: Project ID or project name"]
pub fn get_test_sub_result_attachments(
&self,
organization: impl Into<String>,
project: impl Into<String>,
run_id: i32,
test_case_result_id: i32,
test_sub_result_id: i32,
) -> get_test_sub_result_attachments::RequestBuilder {
get_test_sub_result_attachments::RequestBuilder {
client: self.0.clone(),
organization: organization.into(),
project: project.into(),
run_id,
test_case_result_id,
test_sub_result_id,
}
}
#[doc = "Arguments:"]
#[doc = "* `organization`: The name of the Azure DevOps organization."]
#[doc = "* `project`: Project ID or project name"]
pub fn create_test_sub_result_attachment(
&self,
organization: impl Into<String>,
body: impl Into<models::TestAttachmentRequestModel>,
project: impl Into<String>,
run_id: i32,
test_case_result_id: i32,
test_sub_result_id: i32,
) -> create_test_sub_result_attachment::RequestBuilder {
create_test_sub_result_attachment::RequestBuilder {
client: self.0.clone(),
organization: organization.into(),
body: body.into(),
project: project.into(),
run_id,
test_case_result_id,
test_sub_result_id,
}
}
#[doc = "Arguments:"]
#[doc = "* `organization`: The name of the Azure DevOps organization."]
#[doc = "* `project`: Project ID or project name"]
pub fn create_test_iteration_result_attachment(
&self,
organization: impl Into<String>,
body: impl Into<models::TestAttachmentRequestModel>,
project: impl Into<String>,
run_id: i32,
test_case_result_id: i32,
iteration_id: i32,
) -> create_test_iteration_result_attachment::RequestBuilder {
create_test_iteration_result_attachment::RequestBuilder {
client: self.0.clone(),
organization: organization.into(),
body: body.into(),
project: project.into(),
run_id,
test_case_result_id,
iteration_id,
action_path: None,
}
}
#[doc = "Returns a test sub result attachment"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `organization`: The name of the Azure DevOps organization."]
#[doc = "* `project`: Project ID or project name"]
pub fn get_test_sub_result_attachment_zip(
&self,
organization: impl Into<String>,
project: impl Into<String>,
run_id: i32,
test_case_result_id: i32,
attachment_id: i32,
test_sub_result_id: i32,
) -> get_test_sub_result_attachment_zip::RequestBuilder {
get_test_sub_result_attachment_zip::RequestBuilder {
client: self.0.clone(),
organization: organization.into(),
project: project.into(),
run_id,
test_case_result_id,
attachment_id,
test_sub_result_id,
}
}
#[doc = "Returns a test iteration attachment"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `organization`: The name of the Azure DevOps organization."]
#[doc = "* `project`: Project ID or project name"]
pub fn get_test_iteration_attachment_zip(
&self,
organization: impl Into<String>,
project: impl Into<String>,
run_id: i32,
test_case_result_id: i32,
attachment_id: i32,
iteration_id: i32,
) -> get_test_iteration_attachment_zip::RequestBuilder {
get_test_iteration_attachment_zip::RequestBuilder {
client: self.0.clone(),
organization: organization.into(),
project: project.into(),
run_id,
test_case_result_id,
attachment_id,
iteration_id,
}
}
#[doc = "Arguments:"]
#[doc = "* `organization`: The name of the Azure DevOps organization."]
#[doc = "* `project`: Project ID or project name"]
pub fn get_test_run_attachments(
&self,
organization: impl Into<String>,
project: impl Into<String>,
run_id: i32,
) -> get_test_run_attachments::RequestBuilder {
get_test_run_attachments::RequestBuilder {
client: self.0.clone(),
organization: organization.into(),
project: project.into(),
run_id,
}
}
#[doc = "Arguments:"]
#[doc = "* `organization`: The name of the Azure DevOps organization."]
#[doc = "* `project`: Project ID or project name"]
pub fn create_test_run_attachment(
&self,
organization: impl Into<String>,
body: impl Into<models::TestAttachmentRequestModel>,
project: impl Into<String>,
run_id: i32,
) -> create_test_run_attachment::RequestBuilder {
create_test_run_attachment::RequestBuilder {
client: self.0.clone(),
organization: organization.into(),
body: body.into(),
project: project.into(),
run_id,
}
}
#[doc = "Returns a test run attachment"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `organization`: The name of the Azure DevOps organization."]
#[doc = "* `project`: Project ID or project name"]
pub fn get_test_run_attachment_zip(
&self,
organization: impl Into<String>,
project: impl Into<String>,
run_id: i32,
attachment_id: i32,
) -> get_test_run_attachment_zip::RequestBuilder {
get_test_run_attachment_zip::RequestBuilder {
client: self.0.clone(),
organization: organization.into(),
project: project.into(),
run_id,
attachment_id,
}
}
#[doc = "Arguments:"]
#[doc = "* `organization`: The name of the Azure DevOps organization."]
#[doc = "* `project`: Project ID or project name"]
pub fn delete_test_run_attachment(
&self,
organization: impl Into<String>,
project: impl Into<String>,
run_id: i32,
attachment_id: i32,
) -> delete_test_run_attachment::RequestBuilder {
delete_test_run_attachment::RequestBuilder {
client: self.0.clone(),
organization: organization.into(),
project: project.into(),
run_id,
attachment_id,
}
}
#[doc = "Arguments:"]
#[doc = "* `organization`: The name of the Azure DevOps organization."]
#[doc = "* `project`: Project ID or project name"]
pub fn get_test_result_attachments(
&self,
organization: impl Into<String>,
project: impl Into<String>,
run_id: i32,
test_case_result_id: i32,
) -> get_test_result_attachments::RequestBuilder {
get_test_result_attachments::RequestBuilder {
client: self.0.clone(),
organization: organization.into(),
project: project.into(),
run_id,
test_case_result_id,
}
}
#[doc = "Arguments:"]
#[doc = "* `organization`: The name of the Azure DevOps organization."]
#[doc = "* `project`: Project ID or project name"]
pub fn create_test_result_attachment(
&self,
organization: impl Into<String>,
body: impl Into<models::TestAttachmentRequestModel>,
project: impl Into<String>,
run_id: i32,
test_case_result_id: i32,
) -> create_test_result_attachment::RequestBuilder {
create_test_result_attachment::RequestBuilder {
client: self.0.clone(),
organization: organization.into(),
body: body.into(),
project: project.into(),
run_id,
test_case_result_id,
}
}
#[doc = "Returns a test result attachment"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `organization`: The name of the Azure DevOps organization."]
#[doc = "* `project`: Project ID or project name"]
pub fn get_test_result_attachment_zip(
&self,
organization: impl Into<String>,
project: impl Into<String>,
run_id: i32,
test_case_result_id: i32,
attachment_id: i32,
) -> get_test_result_attachment_zip::RequestBuilder {
get_test_result_attachment_zip::RequestBuilder {
client: self.0.clone(),
organization: organization.into(),
project: project.into(),
run_id,
test_case_result_id,
attachment_id,
}
}
#[doc = "Arguments:"]
#[doc = "* `organization`: The name of the Azure DevOps organization."]
#[doc = "* `project`: Project ID or project name"]
pub fn delete_test_result_attachment(
&self,
organization: impl Into<String>,
project: impl Into<String>,
run_id: i32,
test_case_result_id: i32,
attachment_id: i32,
) -> delete_test_result_attachment::RequestBuilder {
delete_test_result_attachment::RequestBuilder {
client: self.0.clone(),
organization: organization.into(),
project: project.into(),
run_id,
test_case_result_id,
attachment_id,
}
}
}
pub mod get_test_sub_result_attachments {
use super::models;
#[cfg(not(target_arch = "wasm32"))]
use futures::future::BoxFuture;
#[cfg(target_arch = "wasm32")]
use futures::future::LocalBoxFuture as BoxFuture;
#[derive(Debug)]
pub struct Response(
azure_core::http::Response<models::TestAttachmentList, azure_core::http::JsonFormat>,
);
impl Response {
pub fn into_body(self) -> azure_core::Result<models::TestAttachmentList> {
self.0.into_model()
}
pub fn into_raw_response(self) -> azure_core::http::RawResponse {
self.0.into()
}
}
#[derive(Clone)]
#[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."]
#[doc = r""]
#[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"]
#[doc = r" parameters can be chained."]
#[doc = r""]
#[doc = r" To finalize and submit the request, invoke `.await`, which"]
#[doc = r" converts the [`RequestBuilder`] into a future,"]
#[doc = r" executes the request and returns a `Result` with the parsed"]
#[doc = r" response."]
#[doc = r""]
#[doc = r" If you need lower-level access to the raw response details"]
#[doc = r" (e.g. to inspect response headers or raw body data) then you"]
#[doc = r" can finalize the request using the"]
#[doc = r" [`RequestBuilder::send()`] method which returns a future"]
#[doc = r" that resolves to a lower-level [`Response`] value."]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) organization: String,
pub(crate) project: String,
pub(crate) run_id: i32,
pub(crate) test_case_result_id: i32,
pub(crate) test_sub_result_id: i32,
}
impl RequestBuilder {
#[doc = "Returns a future that sends the request and returns a [`Response`] object that provides low-level access to full response details."]
#[doc = ""]
#[doc = "You should typically use `.await` (which implicitly calls `IntoFuture::into_future()`) to finalize and send requests rather than `send()`."]
#[doc = "However, this function can provide more flexibility when required."]
pub fn send(self) -> BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = this.url()?;
let mut req =
azure_core::http::Request::new(url, azure_core::http::Method::Get);
if let Some(auth_header) = this
.client
.token_credential()
.http_authorization_header(&this.client.scopes())
.await?
{
req.insert_header(
azure_core::http::headers::AUTHORIZATION,
auth_header,
);
}
let test_sub_result_id = &this.test_sub_result_id;
req.url_mut()
.query_pairs_mut()
.append_pair("testSubResultId", &test_sub_result_id.to_string());
let req_body = azure_core::Bytes::new();
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?.into()))
}
})
}
fn url(&self) -> azure_core::Result<azure_core::http::Url> {
let mut url = azure_core::http::Url::parse(&format!(
"{}/{}/{}/_apis/testresults/runs/{}/results/{}/attachments?testSubResultId={}",
self.client.endpoint(),
&self.organization,
&self.project,
&self.run_id,
&self.test_case_result_id,
&self.test_sub_result_id
))?;
let has_api_version_already = url.query_pairs().any(|(k, _)| k == "api-version");
if !has_api_version_already {
url.query_pairs_mut()
.append_pair("api-version", "7.1-preview");
}
Ok(url)
}
}
impl std::future::IntoFuture for RequestBuilder {
type Output = azure_core::Result<models::TestAttachmentList>;
type IntoFuture = BoxFuture<'static, azure_core::Result<models::TestAttachmentList>>;
#[doc = "Returns a future that sends the request and returns the parsed response body."]
#[doc = ""]
#[doc = "You should not normally call this method directly, simply invoke `.await` which implicitly calls `IntoFuture::into_future`."]
#[doc = ""]
#[doc = "See [IntoFuture documentation](https://doc.rust-lang.org/std/future/trait.IntoFuture.html) for more details."]
fn into_future(self) -> Self::IntoFuture {
Box::pin(async move { self.send().await?.into_body() })
}
}
}
pub mod create_test_sub_result_attachment {
use super::models;
#[cfg(not(target_arch = "wasm32"))]
use futures::future::BoxFuture;
#[cfg(target_arch = "wasm32")]
use futures::future::LocalBoxFuture as BoxFuture;
#[derive(Debug)]
pub struct Response(
azure_core::http::Response<
models::TestAttachmentReference,
azure_core::http::JsonFormat,
>,
);
impl Response {
pub fn into_body(self) -> azure_core::Result<models::TestAttachmentReference> {
self.0.into_model()
}
pub fn into_raw_response(self) -> azure_core::http::RawResponse {
self.0.into()
}
}
#[derive(Clone)]
#[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."]
#[doc = r""]
#[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"]
#[doc = r" parameters can be chained."]
#[doc = r""]
#[doc = r" To finalize and submit the request, invoke `.await`, which"]
#[doc = r" converts the [`RequestBuilder`] into a future,"]
#[doc = r" executes the request and returns a `Result` with the parsed"]
#[doc = r" response."]
#[doc = r""]
#[doc = r" If you need lower-level access to the raw response details"]
#[doc = r" (e.g. to inspect response headers or raw body data) then you"]
#[doc = r" can finalize the request using the"]
#[doc = r" [`RequestBuilder::send()`] method which returns a future"]
#[doc = r" that resolves to a lower-level [`Response`] value."]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) organization: String,
pub(crate) body: models::TestAttachmentRequestModel,
pub(crate) project: String,
pub(crate) run_id: i32,
pub(crate) test_case_result_id: i32,
pub(crate) test_sub_result_id: i32,
}
impl RequestBuilder {
#[doc = "Returns a future that sends the request and returns a [`Response`] object that provides low-level access to full response details."]
#[doc = ""]
#[doc = "You should typically use `.await` (which implicitly calls `IntoFuture::into_future()`) to finalize and send requests rather than `send()`."]
#[doc = "However, this function can provide more flexibility when required."]
pub fn send(self) -> BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = this.url()?;
let mut req =
azure_core::http::Request::new(url, azure_core::http::Method::Post);
if let Some(auth_header) = this
.client
.token_credential()
.http_authorization_header(&this.client.scopes())
.await?
{
req.insert_header(
azure_core::http::headers::AUTHORIZATION,
auth_header,
);
}
req.insert_header("content-type", "application/json");
let req_body = azure_core::json::to_json(&this.body)?;
let test_sub_result_id = &this.test_sub_result_id;
req.url_mut()
.query_pairs_mut()
.append_pair("testSubResultId", &test_sub_result_id.to_string());
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?.into()))
}
})
}
fn url(&self) -> azure_core::Result<azure_core::http::Url> {
let mut url = azure_core::http::Url::parse(&format!(
"{}/{}/{}/_apis/testresults/runs/{}/results/{}/attachments?testSubResultId={}",
self.client.endpoint(),
&self.organization,
&self.project,
&self.run_id,
&self.test_case_result_id,
&self.test_sub_result_id
))?;
let has_api_version_already = url.query_pairs().any(|(k, _)| k == "api-version");
if !has_api_version_already {
url.query_pairs_mut()
.append_pair("api-version", "7.1-preview");
}
Ok(url)
}
}
impl std::future::IntoFuture for RequestBuilder {
type Output = azure_core::Result<models::TestAttachmentReference>;
type IntoFuture =
BoxFuture<'static, azure_core::Result<models::TestAttachmentReference>>;
#[doc = "Returns a future that sends the request and returns the parsed response body."]
#[doc = ""]
#[doc = "You should not normally call this method directly, simply invoke `.await` which implicitly calls `IntoFuture::into_future`."]
#[doc = ""]
#[doc = "See [IntoFuture documentation](https://doc.rust-lang.org/std/future/trait.IntoFuture.html) for more details."]
fn into_future(self) -> Self::IntoFuture {
Box::pin(async move { self.send().await?.into_body() })
}
}
}
pub mod create_test_iteration_result_attachment {
use super::models;
#[cfg(not(target_arch = "wasm32"))]
use futures::future::BoxFuture;
#[cfg(target_arch = "wasm32")]
use futures::future::LocalBoxFuture as BoxFuture;
#[derive(Debug)]
pub struct Response(
azure_core::http::Response<
models::TestAttachmentReference,
azure_core::http::JsonFormat,
>,
);
impl Response {
pub fn into_body(self) -> azure_core::Result<models::TestAttachmentReference> {
self.0.into_model()
}
pub fn into_raw_response(self) -> azure_core::http::RawResponse {
self.0.into()
}
}
#[derive(Clone)]
#[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."]
#[doc = r""]
#[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"]
#[doc = r" parameters can be chained."]
#[doc = r""]
#[doc = r" To finalize and submit the request, invoke `.await`, which"]
#[doc = r" converts the [`RequestBuilder`] into a future,"]
#[doc = r" executes the request and returns a `Result` with the parsed"]
#[doc = r" response."]
#[doc = r""]
#[doc = r" If you need lower-level access to the raw response details"]
#[doc = r" (e.g. to inspect response headers or raw body data) then you"]
#[doc = r" can finalize the request using the"]
#[doc = r" [`RequestBuilder::send()`] method which returns a future"]
#[doc = r" that resolves to a lower-level [`Response`] value."]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) organization: String,
pub(crate) body: models::TestAttachmentRequestModel,
pub(crate) project: String,
pub(crate) run_id: i32,
pub(crate) test_case_result_id: i32,
pub(crate) iteration_id: i32,
pub(crate) action_path: Option<String>,
}
impl RequestBuilder {
pub fn action_path(mut self, action_path: impl Into<String>) -> Self {
self.action_path = Some(action_path.into());
self
}
#[doc = "Returns a future that sends the request and returns a [`Response`] object that provides low-level access to full response details."]
#[doc = ""]
#[doc = "You should typically use `.await` (which implicitly calls `IntoFuture::into_future()`) to finalize and send requests rather than `send()`."]
#[doc = "However, this function can provide more flexibility when required."]
pub fn send(self) -> BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = this.url()?;
let mut req =
azure_core::http::Request::new(url, azure_core::http::Method::Post);
if let Some(auth_header) = this
.client
.token_credential()
.http_authorization_header(&this.client.scopes())
.await?
{
req.insert_header(
azure_core::http::headers::AUTHORIZATION,
auth_header,
);
}
req.insert_header("content-type", "application/json");
let req_body = azure_core::json::to_json(&this.body)?;
let iteration_id = &this.iteration_id;
req.url_mut()
.query_pairs_mut()
.append_pair("iterationId", &iteration_id.to_string());
if let Some(action_path) = &this.action_path {
req.url_mut()
.query_pairs_mut()
.append_pair("actionPath", action_path);
}
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?.into()))
}
})
}
fn url(&self) -> azure_core::Result<azure_core::http::Url> {
let mut url = azure_core::http::Url::parse(&format!(
"{}/{}/{}/_apis/testresults/runs/{}/results/{}/attachments?iterationId={}",
self.client.endpoint(),
&self.organization,
&self.project,
&self.run_id,
&self.test_case_result_id,
&self.iteration_id
))?;
let has_api_version_already = url.query_pairs().any(|(k, _)| k == "api-version");
if !has_api_version_already {
url.query_pairs_mut()
.append_pair("api-version", "7.1-preview");
}
Ok(url)
}
}
impl std::future::IntoFuture for RequestBuilder {
type Output = azure_core::Result<models::TestAttachmentReference>;
type IntoFuture =
BoxFuture<'static, azure_core::Result<models::TestAttachmentReference>>;
#[doc = "Returns a future that sends the request and returns the parsed response body."]
#[doc = ""]
#[doc = "You should not normally call this method directly, simply invoke `.await` which implicitly calls `IntoFuture::into_future`."]
#[doc = ""]
#[doc = "See [IntoFuture documentation](https://doc.rust-lang.org/std/future/trait.IntoFuture.html) for more details."]
fn into_future(self) -> Self::IntoFuture {
Box::pin(async move { self.send().await?.into_body() })
}
}
}
pub mod get_test_sub_result_attachment_zip {
use super::models;
#[cfg(not(target_arch = "wasm32"))]
use futures::future::BoxFuture;
#[cfg(target_arch = "wasm32")]
use futures::future::LocalBoxFuture as BoxFuture;
#[derive(Debug)]
pub struct Response(azure_core::http::Response<String, azure_core::http::JsonFormat>);
impl Response {
pub fn into_body(self) -> azure_core::Result<String> {
self.0.into_model()
}
pub fn into_raw_response(self) -> azure_core::http::RawResponse {
self.0.into()
}
}
#[derive(Clone)]
#[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."]
#[doc = r""]
#[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"]
#[doc = r" parameters can be chained."]
#[doc = r""]
#[doc = r" To finalize and submit the request, invoke `.await`, which"]
#[doc = r" converts the [`RequestBuilder`] into a future,"]
#[doc = r" executes the request and returns a `Result` with the parsed"]
#[doc = r" response."]
#[doc = r""]
#[doc = r" If you need lower-level access to the raw response details"]
#[doc = r" (e.g. to inspect response headers or raw body data) then you"]
#[doc = r" can finalize the request using the"]
#[doc = r" [`RequestBuilder::send()`] method which returns a future"]
#[doc = r" that resolves to a lower-level [`Response`] value."]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) organization: String,
pub(crate) project: String,
pub(crate) run_id: i32,
pub(crate) test_case_result_id: i32,
pub(crate) attachment_id: i32,
pub(crate) test_sub_result_id: i32,
}
impl RequestBuilder {
#[doc = "Returns a future that sends the request and returns a [`Response`] object that provides low-level access to full response details."]
#[doc = ""]
#[doc = "You should typically use `.await` (which implicitly calls `IntoFuture::into_future()`) to finalize and send requests rather than `send()`."]
#[doc = "However, this function can provide more flexibility when required."]
pub fn send(self) -> BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = this.url()?;
let mut req =
azure_core::http::Request::new(url, azure_core::http::Method::Get);
if let Some(auth_header) = this
.client
.token_credential()
.http_authorization_header(&this.client.scopes())
.await?
{
req.insert_header(
azure_core::http::headers::AUTHORIZATION,
auth_header,
);
}
let test_sub_result_id = &this.test_sub_result_id;
req.url_mut()
.query_pairs_mut()
.append_pair("testSubResultId", &test_sub_result_id.to_string());
let req_body = azure_core::Bytes::new();
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?.into()))
}
})
}
fn url(&self) -> azure_core::Result<azure_core::http::Url> {
let mut url = azure_core :: http :: Url :: parse (& format ! ("{}/{}/{}/_apis/testresults/runs/{}/results/{}/attachments/{}?testSubResultId={}" , self . client . endpoint () , & self . organization , & self . project , & self . run_id , & self . test_case_result_id , & self . attachment_id , & self . test_sub_result_id)) ? ;
let has_api_version_already = url.query_pairs().any(|(k, _)| k == "api-version");
if !has_api_version_already {
url.query_pairs_mut()
.append_pair("api-version", "7.1-preview");
}
Ok(url)
}
}
impl std::future::IntoFuture for RequestBuilder {
type Output = azure_core::Result<String>;
type IntoFuture = BoxFuture<'static, azure_core::Result<String>>;
#[doc = "Returns a future that sends the request and returns the parsed response body."]
#[doc = ""]
#[doc = "You should not normally call this method directly, simply invoke `.await` which implicitly calls `IntoFuture::into_future`."]
#[doc = ""]
#[doc = "See [IntoFuture documentation](https://doc.rust-lang.org/std/future/trait.IntoFuture.html) for more details."]
fn into_future(self) -> Self::IntoFuture {
Box::pin(async move { self.send().await?.into_body() })
}
}
}
pub mod get_test_iteration_attachment_zip {
use super::models;
#[cfg(not(target_arch = "wasm32"))]
use futures::future::BoxFuture;
#[cfg(target_arch = "wasm32")]
use futures::future::LocalBoxFuture as BoxFuture;
#[derive(Debug)]
pub struct Response(azure_core::http::Response<String, azure_core::http::JsonFormat>);
impl Response {
pub fn into_body(self) -> azure_core::Result<String> {
self.0.into_model()
}
pub fn into_raw_response(self) -> azure_core::http::RawResponse {
self.0.into()
}
}
#[derive(Clone)]
#[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."]
#[doc = r""]
#[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"]
#[doc = r" parameters can be chained."]
#[doc = r""]
#[doc = r" To finalize and submit the request, invoke `.await`, which"]
#[doc = r" converts the [`RequestBuilder`] into a future,"]
#[doc = r" executes the request and returns a `Result` with the parsed"]
#[doc = r" response."]
#[doc = r""]
#[doc = r" If you need lower-level access to the raw response details"]
#[doc = r" (e.g. to inspect response headers or raw body data) then you"]
#[doc = r" can finalize the request using the"]
#[doc = r" [`RequestBuilder::send()`] method which returns a future"]
#[doc = r" that resolves to a lower-level [`Response`] value."]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) organization: String,
pub(crate) project: String,
pub(crate) run_id: i32,
pub(crate) test_case_result_id: i32,
pub(crate) attachment_id: i32,
pub(crate) iteration_id: i32,
}
impl RequestBuilder {
#[doc = "Returns a future that sends the request and returns a [`Response`] object that provides low-level access to full response details."]
#[doc = ""]
#[doc = "You should typically use `.await` (which implicitly calls `IntoFuture::into_future()`) to finalize and send requests rather than `send()`."]
#[doc = "However, this function can provide more flexibility when required."]
pub fn send(self) -> BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = this.url()?;
let mut req =
azure_core::http::Request::new(url, azure_core::http::Method::Get);
if let Some(auth_header) = this
.client
.token_credential()
.http_authorization_header(&this.client.scopes())
.await?
{
req.insert_header(
azure_core::http::headers::AUTHORIZATION,
auth_header,
);
}
let iteration_id = &this.iteration_id;
req.url_mut()
.query_pairs_mut()
.append_pair("iterationId", &iteration_id.to_string());
let req_body = azure_core::Bytes::new();
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?.into()))
}
})
}
fn url(&self) -> azure_core::Result<azure_core::http::Url> {
let mut url = azure_core::http::Url::parse(&format!(
"{}/{}/{}/_apis/testresults/runs/{}/results/{}/attachments/{}?iterationId={}",
self.client.endpoint(),
&self.organization,
&self.project,
&self.run_id,
&self.test_case_result_id,
&self.attachment_id,
&self.iteration_id
))?;
let has_api_version_already = url.query_pairs().any(|(k, _)| k == "api-version");
if !has_api_version_already {
url.query_pairs_mut()
.append_pair("api-version", "7.1-preview");
}
Ok(url)
}
}
impl std::future::IntoFuture for RequestBuilder {
type Output = azure_core::Result<String>;
type IntoFuture = BoxFuture<'static, azure_core::Result<String>>;
#[doc = "Returns a future that sends the request and returns the parsed response body."]
#[doc = ""]
#[doc = "You should not normally call this method directly, simply invoke `.await` which implicitly calls `IntoFuture::into_future`."]
#[doc = ""]
#[doc = "See [IntoFuture documentation](https://doc.rust-lang.org/std/future/trait.IntoFuture.html) for more details."]
fn into_future(self) -> Self::IntoFuture {
Box::pin(async move { self.send().await?.into_body() })
}
}
}
pub mod get_test_run_attachments {
use super::models;
#[cfg(not(target_arch = "wasm32"))]
use futures::future::BoxFuture;
#[cfg(target_arch = "wasm32")]
use futures::future::LocalBoxFuture as BoxFuture;
#[derive(Debug)]
pub struct Response(
azure_core::http::Response<models::TestAttachmentList, azure_core::http::JsonFormat>,
);
impl Response {
pub fn into_body(self) -> azure_core::Result<models::TestAttachmentList> {
self.0.into_model()
}
pub fn into_raw_response(self) -> azure_core::http::RawResponse {
self.0.into()
}
}
#[derive(Clone)]
#[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."]
#[doc = r""]
#[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"]
#[doc = r" parameters can be chained."]
#[doc = r""]
#[doc = r" To finalize and submit the request, invoke `.await`, which"]
#[doc = r" converts the [`RequestBuilder`] into a future,"]
#[doc = r" executes the request and returns a `Result` with the parsed"]
#[doc = r" response."]
#[doc = r""]
#[doc = r" If you need lower-level access to the raw response details"]
#[doc = r" (e.g. to inspect response headers or raw body data) then you"]
#[doc = r" can finalize the request using the"]
#[doc = r" [`RequestBuilder::send()`] method which returns a future"]
#[doc = r" that resolves to a lower-level [`Response`] value."]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) organization: String,
pub(crate) project: String,
pub(crate) run_id: i32,
}
impl RequestBuilder {
#[doc = "Returns a future that sends the request and returns a [`Response`] object that provides low-level access to full response details."]
#[doc = ""]
#[doc = "You should typically use `.await` (which implicitly calls `IntoFuture::into_future()`) to finalize and send requests rather than `send()`."]
#[doc = "However, this function can provide more flexibility when required."]
pub fn send(self) -> BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = this.url()?;
let mut req =
azure_core::http::Request::new(url, azure_core::http::Method::Get);
if let Some(auth_header) = this
.client
.token_credential()
.http_authorization_header(&this.client.scopes())
.await?
{
req.insert_header(
azure_core::http::headers::AUTHORIZATION,
auth_header,
);
}
let req_body = azure_core::Bytes::new();
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?.into()))
}
})
}
fn url(&self) -> azure_core::Result<azure_core::http::Url> {
let mut url = azure_core::http::Url::parse(&format!(
"{}/{}/{}/_apis/testresults/runs/{}/attachments",
self.client.endpoint(),
&self.organization,
&self.project,
&self.run_id
))?;
let has_api_version_already = url.query_pairs().any(|(k, _)| k == "api-version");
if !has_api_version_already {
url.query_pairs_mut()
.append_pair("api-version", "7.1-preview");
}
Ok(url)
}
}
impl std::future::IntoFuture for RequestBuilder {
type Output = azure_core::Result<models::TestAttachmentList>;
type IntoFuture = BoxFuture<'static, azure_core::Result<models::TestAttachmentList>>;
#[doc = "Returns a future that sends the request and returns the parsed response body."]
#[doc = ""]
#[doc = "You should not normally call this method directly, simply invoke `.await` which implicitly calls `IntoFuture::into_future`."]
#[doc = ""]
#[doc = "See [IntoFuture documentation](https://doc.rust-lang.org/std/future/trait.IntoFuture.html) for more details."]
fn into_future(self) -> Self::IntoFuture {
Box::pin(async move { self.send().await?.into_body() })
}
}
}
pub mod create_test_run_attachment {
use super::models;
#[cfg(not(target_arch = "wasm32"))]
use futures::future::BoxFuture;
#[cfg(target_arch = "wasm32")]
use futures::future::LocalBoxFuture as BoxFuture;
#[derive(Debug)]
pub struct Response(
azure_core::http::Response<
models::TestAttachmentReference,
azure_core::http::JsonFormat,
>,
);
impl Response {
pub fn into_body(self) -> azure_core::Result<models::TestAttachmentReference> {
self.0.into_model()
}
pub fn into_raw_response(self) -> azure_core::http::RawResponse {
self.0.into()
}
}
#[derive(Clone)]
#[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."]
#[doc = r""]
#[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"]
#[doc = r" parameters can be chained."]
#[doc = r""]
#[doc = r" To finalize and submit the request, invoke `.await`, which"]
#[doc = r" converts the [`RequestBuilder`] into a future,"]
#[doc = r" executes the request and returns a `Result` with the parsed"]
#[doc = r" response."]
#[doc = r""]
#[doc = r" If you need lower-level access to the raw response details"]
#[doc = r" (e.g. to inspect response headers or raw body data) then you"]
#[doc = r" can finalize the request using the"]
#[doc = r" [`RequestBuilder::send()`] method which returns a future"]
#[doc = r" that resolves to a lower-level [`Response`] value."]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) organization: String,
pub(crate) body: models::TestAttachmentRequestModel,
pub(crate) project: String,
pub(crate) run_id: i32,
}
impl RequestBuilder {
#[doc = "Returns a future that sends the request and returns a [`Response`] object that provides low-level access to full response details."]
#[doc = ""]
#[doc = "You should typically use `.await` (which implicitly calls `IntoFuture::into_future()`) to finalize and send requests rather than `send()`."]
#[doc = "However, this function can provide more flexibility when required."]
pub fn send(self) -> BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = this.url()?;
let mut req =
azure_core::http::Request::new(url, azure_core::http::Method::Post);
if let Some(auth_header) = this
.client
.token_credential()
.http_authorization_header(&this.client.scopes())
.await?
{
req.insert_header(
azure_core::http::headers::AUTHORIZATION,
auth_header,
);
}
req.insert_header("content-type", "application/json");
let req_body = azure_core::json::to_json(&this.body)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?.into()))
}
})
}
fn url(&self) -> azure_core::Result<azure_core::http::Url> {
let mut url = azure_core::http::Url::parse(&format!(
"{}/{}/{}/_apis/testresults/runs/{}/attachments",
self.client.endpoint(),
&self.organization,
&self.project,
&self.run_id
))?;
let has_api_version_already = url.query_pairs().any(|(k, _)| k == "api-version");
if !has_api_version_already {
url.query_pairs_mut()
.append_pair("api-version", "7.1-preview");
}
Ok(url)
}
}
impl std::future::IntoFuture for RequestBuilder {
type Output = azure_core::Result<models::TestAttachmentReference>;
type IntoFuture =
BoxFuture<'static, azure_core::Result<models::TestAttachmentReference>>;
#[doc = "Returns a future that sends the request and returns the parsed response body."]
#[doc = ""]
#[doc = "You should not normally call this method directly, simply invoke `.await` which implicitly calls `IntoFuture::into_future`."]
#[doc = ""]
#[doc = "See [IntoFuture documentation](https://doc.rust-lang.org/std/future/trait.IntoFuture.html) for more details."]
fn into_future(self) -> Self::IntoFuture {
Box::pin(async move { self.send().await?.into_body() })
}
}
}
pub mod get_test_run_attachment_zip {
use super::models;
#[cfg(not(target_arch = "wasm32"))]
use futures::future::BoxFuture;
#[cfg(target_arch = "wasm32")]
use futures::future::LocalBoxFuture as BoxFuture;
#[derive(Debug)]
pub struct Response(azure_core::http::Response<String, azure_core::http::JsonFormat>);
impl Response {
pub fn into_body(self) -> azure_core::Result<String> {
self.0.into_model()
}
pub fn into_raw_response(self) -> azure_core::http::RawResponse {
self.0.into()
}
}
#[derive(Clone)]
#[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."]
#[doc = r""]
#[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"]
#[doc = r" parameters can be chained."]
#[doc = r""]
#[doc = r" To finalize and submit the request, invoke `.await`, which"]
#[doc = r" converts the [`RequestBuilder`] into a future,"]
#[doc = r" executes the request and returns a `Result` with the parsed"]
#[doc = r" response."]
#[doc = r""]
#[doc = r" If you need lower-level access to the raw response details"]
#[doc = r" (e.g. to inspect response headers or raw body data) then you"]
#[doc = r" can finalize the request using the"]
#[doc = r" [`RequestBuilder::send()`] method which returns a future"]
#[doc = r" that resolves to a lower-level [`Response`] value."]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) organization: String,
pub(crate) project: String,
pub(crate) run_id: i32,
pub(crate) attachment_id: i32,
}
impl RequestBuilder {
#[doc = "Returns a future that sends the request and returns a [`Response`] object that provides low-level access to full response details."]
#[doc = ""]
#[doc = "You should typically use `.await` (which implicitly calls `IntoFuture::into_future()`) to finalize and send requests rather than `send()`."]
#[doc = "However, this function can provide more flexibility when required."]
pub fn send(self) -> BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = this.url()?;
let mut req =
azure_core::http::Request::new(url, azure_core::http::Method::Get);
if let Some(auth_header) = this
.client
.token_credential()
.http_authorization_header(&this.client.scopes())
.await?
{
req.insert_header(
azure_core::http::headers::AUTHORIZATION,
auth_header,
);
}
let req_body = azure_core::Bytes::new();
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?.into()))
}
})
}
fn url(&self) -> azure_core::Result<azure_core::http::Url> {
let mut url = azure_core::http::Url::parse(&format!(
"{}/{}/{}/_apis/testresults/runs/{}/attachments/{}",
self.client.endpoint(),
&self.organization,
&self.project,
&self.run_id,
&self.attachment_id
))?;
let has_api_version_already = url.query_pairs().any(|(k, _)| k == "api-version");
if !has_api_version_already {
url.query_pairs_mut()
.append_pair("api-version", "7.1-preview");
}
Ok(url)
}
}
impl std::future::IntoFuture for RequestBuilder {
type Output = azure_core::Result<String>;
type IntoFuture = BoxFuture<'static, azure_core::Result<String>>;
#[doc = "Returns a future that sends the request and returns the parsed response body."]
#[doc = ""]
#[doc = "You should not normally call this method directly, simply invoke `.await` which implicitly calls `IntoFuture::into_future`."]
#[doc = ""]
#[doc = "See [IntoFuture documentation](https://doc.rust-lang.org/std/future/trait.IntoFuture.html) for more details."]
fn into_future(self) -> Self::IntoFuture {
Box::pin(async move { self.send().await?.into_body() })
}
}
}
pub mod delete_test_run_attachment {
use super::models;
#[cfg(not(target_arch = "wasm32"))]
use futures::future::BoxFuture;
#[cfg(target_arch = "wasm32")]
use futures::future::LocalBoxFuture as BoxFuture;
#[derive(Debug)]
pub struct Response(azure_core::http::Response<(), azure_core::http::NoFormat>);
impl Response {
pub fn into_raw_response(self) -> azure_core::http::RawResponse {
self.0.into()
}
}
#[derive(Clone)]
#[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."]
#[doc = r""]
#[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"]
#[doc = r" parameters can be chained."]
#[doc = r""]
#[doc = r" To finalize and submit the request, invoke `.await`, which"]
#[doc = r" converts the [`RequestBuilder`] into a future,"]
#[doc = r" executes the request and returns a `Result` with the parsed"]
#[doc = r" response."]
#[doc = r""]
#[doc = r" If you need lower-level access to the raw response details"]
#[doc = r" (e.g. to inspect response headers or raw body data) then you"]
#[doc = r" can finalize the request using the"]
#[doc = r" [`RequestBuilder::send()`] method which returns a future"]
#[doc = r" that resolves to a lower-level [`Response`] value."]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) organization: String,
pub(crate) project: String,
pub(crate) run_id: i32,
pub(crate) attachment_id: i32,
}
impl RequestBuilder {
#[doc = "Returns a future that sends the request and returns a [`Response`] object that provides low-level access to full response details."]
#[doc = ""]
#[doc = "You should typically use `.await` (which implicitly calls `IntoFuture::into_future()`) to finalize and send requests rather than `send()`."]
#[doc = "However, this function can provide more flexibility when required."]
pub fn send(self) -> BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = this.url()?;
let mut req =
azure_core::http::Request::new(url, azure_core::http::Method::Delete);
if let Some(auth_header) = this
.client
.token_credential()
.http_authorization_header(&this.client.scopes())
.await?
{
req.insert_header(
azure_core::http::headers::AUTHORIZATION,
auth_header,
);
}
let req_body = azure_core::Bytes::new();
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?.into()))
}
})
}
fn url(&self) -> azure_core::Result<azure_core::http::Url> {
let mut url = azure_core::http::Url::parse(&format!(
"{}/{}/{}/_apis/testresults/runs/{}/attachments/{}",
self.client.endpoint(),
&self.organization,
&self.project,
&self.run_id,
&self.attachment_id
))?;
let has_api_version_already = url.query_pairs().any(|(k, _)| k == "api-version");
if !has_api_version_already {
url.query_pairs_mut()
.append_pair("api-version", "7.1-preview");
}
Ok(url)
}
}
impl std::future::IntoFuture for RequestBuilder {
type Output = azure_core::Result<()>;
type IntoFuture = BoxFuture<'static, azure_core::Result<()>>;
#[doc = "Returns a future that sends the request and waits for the response."]
#[doc = ""]
#[doc = "You should not normally call this method directly, simply invoke `.await` which implicitly calls `IntoFuture::into_future`."]
#[doc = ""]
#[doc = "See [IntoFuture documentation](https://doc.rust-lang.org/std/future/trait.IntoFuture.html) for more details."]
fn into_future(self) -> Self::IntoFuture {
Box::pin(async move {
let _rsp = self.send().await?;
Ok(())
})
}
}
}
pub mod get_test_result_attachments {
use super::models;
#[cfg(not(target_arch = "wasm32"))]
use futures::future::BoxFuture;
#[cfg(target_arch = "wasm32")]
use futures::future::LocalBoxFuture as BoxFuture;
#[derive(Debug)]
pub struct Response(
azure_core::http::Response<models::TestAttachmentList, azure_core::http::JsonFormat>,
);
impl Response {
pub fn into_body(self) -> azure_core::Result<models::TestAttachmentList> {
self.0.into_model()
}
pub fn into_raw_response(self) -> azure_core::http::RawResponse {
self.0.into()
}
}
#[derive(Clone)]
#[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."]
#[doc = r""]
#[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"]
#[doc = r" parameters can be chained."]
#[doc = r""]
#[doc = r" To finalize and submit the request, invoke `.await`, which"]
#[doc = r" converts the [`RequestBuilder`] into a future,"]
#[doc = r" executes the request and returns a `Result` with the parsed"]
#[doc = r" response."]
#[doc = r""]
#[doc = r" If you need lower-level access to the raw response details"]
#[doc = r" (e.g. to inspect response headers or raw body data) then you"]
#[doc = r" can finalize the request using the"]
#[doc = r" [`RequestBuilder::send()`] method which returns a future"]
#[doc = r" that resolves to a lower-level [`Response`] value."]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) organization: String,
pub(crate) project: String,
pub(crate) run_id: i32,
pub(crate) test_case_result_id: i32,
}
impl RequestBuilder {
#[doc = "Returns a future that sends the request and returns a [`Response`] object that provides low-level access to full response details."]
#[doc = ""]
#[doc = "You should typically use `.await` (which implicitly calls `IntoFuture::into_future()`) to finalize and send requests rather than `send()`."]
#[doc = "However, this function can provide more flexibility when required."]
pub fn send(self) -> BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = this.url()?;
let mut req =
azure_core::http::Request::new(url, azure_core::http::Method::Get);
if let Some(auth_header) = this
.client
.token_credential()
.http_authorization_header(&this.client.scopes())
.await?
{
req.insert_header(
azure_core::http::headers::AUTHORIZATION,
auth_header,
);
}
let req_body = azure_core::Bytes::new();
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?.into()))
}
})
}
fn url(&self) -> azure_core::Result<azure_core::http::Url> {
let mut url = azure_core::http::Url::parse(&format!(
"{}/{}/{}/_apis/testresults/runs/{}/results/{}/attachments",
self.client.endpoint(),
&self.organization,
&self.project,
&self.run_id,
&self.test_case_result_id
))?;
let has_api_version_already = url.query_pairs().any(|(k, _)| k == "api-version");
if !has_api_version_already {
url.query_pairs_mut()
.append_pair("api-version", "7.1-preview");
}
Ok(url)
}
}
impl std::future::IntoFuture for RequestBuilder {
type Output = azure_core::Result<models::TestAttachmentList>;
type IntoFuture = BoxFuture<'static, azure_core::Result<models::TestAttachmentList>>;
#[doc = "Returns a future that sends the request and returns the parsed response body."]
#[doc = ""]
#[doc = "You should not normally call this method directly, simply invoke `.await` which implicitly calls `IntoFuture::into_future`."]
#[doc = ""]
#[doc = "See [IntoFuture documentation](https://doc.rust-lang.org/std/future/trait.IntoFuture.html) for more details."]
fn into_future(self) -> Self::IntoFuture {
Box::pin(async move { self.send().await?.into_body() })
}
}
}
pub mod create_test_result_attachment {
use super::models;
#[cfg(not(target_arch = "wasm32"))]
use futures::future::BoxFuture;
#[cfg(target_arch = "wasm32")]
use futures::future::LocalBoxFuture as BoxFuture;
#[derive(Debug)]
pub struct Response(
azure_core::http::Response<
models::TestAttachmentReference,
azure_core::http::JsonFormat,
>,
);
impl Response {
pub fn into_body(self) -> azure_core::Result<models::TestAttachmentReference> {
self.0.into_model()
}
pub fn into_raw_response(self) -> azure_core::http::RawResponse {
self.0.into()
}
}
#[derive(Clone)]
#[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."]
#[doc = r""]
#[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"]
#[doc = r" parameters can be chained."]
#[doc = r""]
#[doc = r" To finalize and submit the request, invoke `.await`, which"]
#[doc = r" converts the [`RequestBuilder`] into a future,"]
#[doc = r" executes the request and returns a `Result` with the parsed"]
#[doc = r" response."]
#[doc = r""]
#[doc = r" If you need lower-level access to the raw response details"]
#[doc = r" (e.g. to inspect response headers or raw body data) then you"]
#[doc = r" can finalize the request using the"]
#[doc = r" [`RequestBuilder::send()`] method which returns a future"]
#[doc = r" that resolves to a lower-level [`Response`] value."]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) organization: String,
pub(crate) body: models::TestAttachmentRequestModel,
pub(crate) project: String,
pub(crate) run_id: i32,
pub(crate) test_case_result_id: i32,
}
impl RequestBuilder {
#[doc = "Returns a future that sends the request and returns a [`Response`] object that provides low-level access to full response details."]
#[doc = ""]
#[doc = "You should typically use `.await` (which implicitly calls `IntoFuture::into_future()`) to finalize and send requests rather than `send()`."]
#[doc = "However, this function can provide more flexibility when required."]
pub fn send(self) -> BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = this.url()?;
let mut req =
azure_core::http::Request::new(url, azure_core::http::Method::Post);
if let Some(auth_header) = this
.client
.token_credential()
.http_authorization_header(&this.client.scopes())
.await?
{
req.insert_header(
azure_core::http::headers::AUTHORIZATION,
auth_header,
);
}
req.insert_header("content-type", "application/json");
let req_body = azure_core::json::to_json(&this.body)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?.into()))
}
})
}
fn url(&self) -> azure_core::Result<azure_core::http::Url> {
let mut url = azure_core::http::Url::parse(&format!(
"{}/{}/{}/_apis/testresults/runs/{}/results/{}/attachments",
self.client.endpoint(),
&self.organization,
&self.project,
&self.run_id,
&self.test_case_result_id
))?;
let has_api_version_already = url.query_pairs().any(|(k, _)| k == "api-version");
if !has_api_version_already {
url.query_pairs_mut()
.append_pair("api-version", "7.1-preview");
}
Ok(url)
}
}
impl std::future::IntoFuture for RequestBuilder {
type Output = azure_core::Result<models::TestAttachmentReference>;
type IntoFuture =
BoxFuture<'static, azure_core::Result<models::TestAttachmentReference>>;
#[doc = "Returns a future that sends the request and returns the parsed response body."]
#[doc = ""]
#[doc = "You should not normally call this method directly, simply invoke `.await` which implicitly calls `IntoFuture::into_future`."]
#[doc = ""]
#[doc = "See [IntoFuture documentation](https://doc.rust-lang.org/std/future/trait.IntoFuture.html) for more details."]
fn into_future(self) -> Self::IntoFuture {
Box::pin(async move { self.send().await?.into_body() })
}
}
}
pub mod get_test_result_attachment_zip {
use super::models;
#[cfg(not(target_arch = "wasm32"))]
use futures::future::BoxFuture;
#[cfg(target_arch = "wasm32")]
use futures::future::LocalBoxFuture as BoxFuture;
#[derive(Debug)]
pub struct Response(azure_core::http::Response<String, azure_core::http::JsonFormat>);
impl Response {
pub fn into_body(self) -> azure_core::Result<String> {
self.0.into_model()
}
pub fn into_raw_response(self) -> azure_core::http::RawResponse {
self.0.into()
}
}
#[derive(Clone)]
#[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."]
#[doc = r""]
#[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"]
#[doc = r" parameters can be chained."]
#[doc = r""]
#[doc = r" To finalize and submit the request, invoke `.await`, which"]
#[doc = r" converts the [`RequestBuilder`] into a future,"]
#[doc = r" executes the request and returns a `Result` with the parsed"]
#[doc = r" response."]
#[doc = r""]
#[doc = r" If you need lower-level access to the raw response details"]
#[doc = r" (e.g. to inspect response headers or raw body data) then you"]
#[doc = r" can finalize the request using the"]
#[doc = r" [`RequestBuilder::send()`] method which returns a future"]
#[doc = r" that resolves to a lower-level [`Response`] value."]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) organization: String,
pub(crate) project: String,
pub(crate) run_id: i32,
pub(crate) test_case_result_id: i32,
pub(crate) attachment_id: i32,
}
impl RequestBuilder {
#[doc = "Returns a future that sends the request and returns a [`Response`] object that provides low-level access to full response details."]
#[doc = ""]
#[doc = "You should typically use `.await` (which implicitly calls `IntoFuture::into_future()`) to finalize and send requests rather than `send()`."]
#[doc = "However, this function can provide more flexibility when required."]
pub fn send(self) -> BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = this.url()?;
let mut req =
azure_core::http::Request::new(url, azure_core::http::Method::Get);
if let Some(auth_header) = this
.client
.token_credential()
.http_authorization_header(&this.client.scopes())
.await?
{
req.insert_header(
azure_core::http::headers::AUTHORIZATION,
auth_header,
);
}
let req_body = azure_core::Bytes::new();
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?.into()))
}
})
}
fn url(&self) -> azure_core::Result<azure_core::http::Url> {
let mut url = azure_core::http::Url::parse(&format!(
"{}/{}/{}/_apis/testresults/runs/{}/results/{}/attachments/{}",
self.client.endpoint(),
&self.organization,
&self.project,
&self.run_id,
&self.test_case_result_id,
&self.attachment_id
))?;
let has_api_version_already = url.query_pairs().any(|(k, _)| k == "api-version");
if !has_api_version_already {
url.query_pairs_mut()
.append_pair("api-version", "7.1-preview");
}
Ok(url)
}
}
impl std::future::IntoFuture for RequestBuilder {
type Output = azure_core::Result<String>;
type IntoFuture = BoxFuture<'static, azure_core::Result<String>>;
#[doc = "Returns a future that sends the request and returns the parsed response body."]
#[doc = ""]
#[doc = "You should not normally call this method directly, simply invoke `.await` which implicitly calls `IntoFuture::into_future`."]
#[doc = ""]
#[doc = "See [IntoFuture documentation](https://doc.rust-lang.org/std/future/trait.IntoFuture.html) for more details."]
fn into_future(self) -> Self::IntoFuture {
Box::pin(async move { self.send().await?.into_body() })
}
}
}
pub mod delete_test_result_attachment {
use super::models;
#[cfg(not(target_arch = "wasm32"))]
use futures::future::BoxFuture;
#[cfg(target_arch = "wasm32")]
use futures::future::LocalBoxFuture as BoxFuture;
#[derive(Debug)]
pub struct Response(azure_core::http::Response<(), azure_core::http::NoFormat>);
impl Response {
pub fn into_raw_response(self) -> azure_core::http::RawResponse {
self.0.into()
}
}
#[derive(Clone)]
#[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."]
#[doc = r""]
#[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"]
#[doc = r" parameters can be chained."]
#[doc = r""]
#[doc = r" To finalize and submit the request, invoke `.await`, which"]
#[doc = r" converts the [`RequestBuilder`] into a future,"]
#[doc = r" executes the request and returns a `Result` with the parsed"]
#[doc = r" response."]
#[doc = r""]
#[doc = r" If you need lower-level access to the raw response details"]
#[doc = r" (e.g. to inspect response headers or raw body data) then you"]
#[doc = r" can finalize the request using the"]
#[doc = r" [`RequestBuilder::send()`] method which returns a future"]
#[doc = r" that resolves to a lower-level [`Response`] value."]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) organization: String,
pub(crate) project: String,
pub(crate) run_id: i32,
pub(crate) test_case_result_id: i32,
pub(crate) attachment_id: i32,
}
impl RequestBuilder {
#[doc = "Returns a future that sends the request and returns a [`Response`] object that provides low-level access to full response details."]
#[doc = ""]
#[doc = "You should typically use `.await` (which implicitly calls `IntoFuture::into_future()`) to finalize and send requests rather than `send()`."]
#[doc = "However, this function can provide more flexibility when required."]
pub fn send(self) -> BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = this.url()?;
let mut req =
azure_core::http::Request::new(url, azure_core::http::Method::Delete);
if let Some(auth_header) = this
.client
.token_credential()
.http_authorization_header(&this.client.scopes())
.await?
{
req.insert_header(
azure_core::http::headers::AUTHORIZATION,
auth_header,
);
}
let req_body = azure_core::Bytes::new();
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?.into()))
}
})
}
fn url(&self) -> azure_core::Result<azure_core::http::Url> {
let mut url = azure_core::http::Url::parse(&format!(
"{}/{}/{}/_apis/testresults/runs/{}/results/{}/attachments/{}",
self.client.endpoint(),
&self.organization,
&self.project,
&self.run_id,
&self.test_case_result_id,
&self.attachment_id
))?;
let has_api_version_already = url.query_pairs().any(|(k, _)| k == "api-version");
if !has_api_version_already {
url.query_pairs_mut()
.append_pair("api-version", "7.1-preview");
}
Ok(url)
}
}
impl std::future::IntoFuture for RequestBuilder {
type Output = azure_core::Result<()>;
type IntoFuture = BoxFuture<'static, azure_core::Result<()>>;
#[doc = "Returns a future that sends the request and waits for the response."]
#[doc = ""]
#[doc = "You should not normally call this method directly, simply invoke `.await` which implicitly calls `IntoFuture::into_future`."]
#[doc = ""]
#[doc = "See [IntoFuture documentation](https://doc.rust-lang.org/std/future/trait.IntoFuture.html) for more details."]
fn into_future(self) -> Self::IntoFuture {
Box::pin(async move {
let _rsp = self.send().await?;
Ok(())
})
}
}
}
}
pub mod testattachments {
use super::models;
#[cfg(not(target_arch = "wasm32"))]
use futures::future::BoxFuture;
#[cfg(target_arch = "wasm32")]
use futures::future::LocalBoxFuture as BoxFuture;
pub struct Client(pub(crate) super::Client);
impl Client {
#[doc = "Returns the attachment with the specified filename for the specified runId from the LogStore."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `organization`: The name of the Azure DevOps organization."]
#[doc = "* `project`: Project ID or project name"]
#[doc = "* `run_id`: Test RunId"]
#[doc = "* `filename`: Attachment FileName"]
pub fn get(
&self,
organization: impl Into<String>,
project: impl Into<String>,
run_id: i32,
filename: impl Into<String>,
) -> get::RequestBuilder {
get::RequestBuilder {
client: self.0.clone(),
organization: organization.into(),
project: project.into(),
run_id,
filename: filename.into(),
}
}
#[doc = "Returns a list of attachments for the specified runId from the LogStore."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `organization`: The name of the Azure DevOps organization."]
#[doc = "* `project`: Project ID or project name"]
#[doc = "* `run_id`: Test RunId"]
pub fn list(
&self,
organization: impl Into<String>,
project: impl Into<String>,
run_id: i32,
) -> list::RequestBuilder {
list::RequestBuilder {
client: self.0.clone(),
organization: organization.into(),
project: project.into(),
run_id,
}
}
#[doc = "Creates an attachment in the LogStore for the specified runId."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `organization`: The name of the Azure DevOps organization."]
#[doc = "* `body`: Contains attachment info like stream, filename, comment, attachmentType"]
#[doc = "* `project`: Project ID or project name"]
#[doc = "* `run_id`: Test RunId"]
pub fn create_test_run_log_store_attachment(
&self,
organization: impl Into<String>,
body: impl Into<models::TestAttachmentRequestModel>,
project: impl Into<String>,
run_id: i32,
) -> create_test_run_log_store_attachment::RequestBuilder {
create_test_run_log_store_attachment::RequestBuilder {
client: self.0.clone(),
organization: organization.into(),
body: body.into(),
project: project.into(),
run_id,
}
}
#[doc = "Deletes the attachment with the specified filename for the specified runId from the LogStore."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `organization`: The name of the Azure DevOps organization."]
#[doc = "* `project`: Project ID or project name"]
#[doc = "* `run_id`: Test RunId"]
#[doc = "* `filename`: Attachment FileName"]
pub fn delete(
&self,
organization: impl Into<String>,
project: impl Into<String>,
run_id: i32,
filename: impl Into<String>,
) -> delete::RequestBuilder {
delete::RequestBuilder {
client: self.0.clone(),
organization: organization.into(),
project: project.into(),
run_id,
filename: filename.into(),
}
}
#[doc = "Creates an attachment in the LogStore for the specified buildId."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `organization`: The name of the Azure DevOps organization."]
#[doc = "* `body`: Contains attachment info like stream, filename, comment, attachmentType"]
#[doc = "* `project`: Project ID or project name"]
#[doc = "* `build_id`: BuildId"]
pub fn create_build_attachment_in_log_store(
&self,
organization: impl Into<String>,
body: impl Into<models::TestAttachmentRequestModel>,
project: impl Into<String>,
build_id: i32,
) -> create_build_attachment_in_log_store::RequestBuilder {
create_build_attachment_in_log_store::RequestBuilder {
client: self.0.clone(),
organization: organization.into(),
body: body.into(),
project: project.into(),
build_id,
}
}
}
pub mod get {
use super::models;
#[cfg(not(target_arch = "wasm32"))]
use futures::future::BoxFuture;
#[cfg(target_arch = "wasm32")]
use futures::future::LocalBoxFuture as BoxFuture;
#[derive(Debug)]
pub struct Response(azure_core::http::Response<String, azure_core::http::JsonFormat>);
impl Response {
pub fn into_body(self) -> azure_core::Result<String> {
self.0.into_model()
}
pub fn into_raw_response(self) -> azure_core::http::RawResponse {
self.0.into()
}
}
#[derive(Clone)]
#[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."]
#[doc = r""]
#[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"]
#[doc = r" parameters can be chained."]
#[doc = r""]
#[doc = r" To finalize and submit the request, invoke `.await`, which"]
#[doc = r" converts the [`RequestBuilder`] into a future,"]
#[doc = r" executes the request and returns a `Result` with the parsed"]
#[doc = r" response."]
#[doc = r""]
#[doc = r" If you need lower-level access to the raw response details"]
#[doc = r" (e.g. to inspect response headers or raw body data) then you"]
#[doc = r" can finalize the request using the"]
#[doc = r" [`RequestBuilder::send()`] method which returns a future"]
#[doc = r" that resolves to a lower-level [`Response`] value."]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) organization: String,
pub(crate) project: String,
pub(crate) run_id: i32,
pub(crate) filename: String,
}
impl RequestBuilder {
#[doc = "Returns a future that sends the request and returns a [`Response`] object that provides low-level access to full response details."]
#[doc = ""]
#[doc = "You should typically use `.await` (which implicitly calls `IntoFuture::into_future()`) to finalize and send requests rather than `send()`."]
#[doc = "However, this function can provide more flexibility when required."]
pub fn send(self) -> BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = this.url()?;
let mut req =
azure_core::http::Request::new(url, azure_core::http::Method::Get);
if let Some(auth_header) = this
.client
.token_credential()
.http_authorization_header(&this.client.scopes())
.await?
{
req.insert_header(
azure_core::http::headers::AUTHORIZATION,
auth_header,
);
}
let filename = &this.filename;
req.url_mut()
.query_pairs_mut()
.append_pair("filename", filename);
let req_body = azure_core::Bytes::new();
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?.into()))
}
})
}
fn url(&self) -> azure_core::Result<azure_core::http::Url> {
let mut url = azure_core::http::Url::parse(&format!(
"{}/{}/{}/_apis/testresults/runs/{}/testattachments?filename={}",
self.client.endpoint(),
&self.organization,
&self.project,
&self.run_id,
&self.filename
))?;
let has_api_version_already = url.query_pairs().any(|(k, _)| k == "api-version");
if !has_api_version_already {
url.query_pairs_mut()
.append_pair("api-version", "7.1-preview");
}
Ok(url)
}
}
impl std::future::IntoFuture for RequestBuilder {
type Output = azure_core::Result<String>;
type IntoFuture = BoxFuture<'static, azure_core::Result<String>>;
#[doc = "Returns a future that sends the request and returns the parsed response body."]
#[doc = ""]
#[doc = "You should not normally call this method directly, simply invoke `.await` which implicitly calls `IntoFuture::into_future`."]
#[doc = ""]
#[doc = "See [IntoFuture documentation](https://doc.rust-lang.org/std/future/trait.IntoFuture.html) for more details."]
fn into_future(self) -> Self::IntoFuture {
Box::pin(async move { self.send().await?.into_body() })
}
}
}
pub mod list {
use super::models;
#[cfg(not(target_arch = "wasm32"))]
use futures::future::BoxFuture;
#[cfg(target_arch = "wasm32")]
use futures::future::LocalBoxFuture as BoxFuture;
#[derive(Debug)]
pub struct Response(
azure_core::http::Response<
models::TestLogStoreAttachmentList,
azure_core::http::JsonFormat,
>,
);
impl Response {
pub fn into_body(self) -> azure_core::Result<models::TestLogStoreAttachmentList> {
self.0.into_model()
}
pub fn into_raw_response(self) -> azure_core::http::RawResponse {
self.0.into()
}
}
#[derive(Clone)]
#[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."]
#[doc = r""]
#[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"]
#[doc = r" parameters can be chained."]
#[doc = r""]
#[doc = r" To finalize and submit the request, invoke `.await`, which"]
#[doc = r" converts the [`RequestBuilder`] into a future,"]
#[doc = r" executes the request and returns a `Result` with the parsed"]
#[doc = r" response."]
#[doc = r""]
#[doc = r" If you need lower-level access to the raw response details"]
#[doc = r" (e.g. to inspect response headers or raw body data) then you"]
#[doc = r" can finalize the request using the"]
#[doc = r" [`RequestBuilder::send()`] method which returns a future"]
#[doc = r" that resolves to a lower-level [`Response`] value."]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) organization: String,
pub(crate) project: String,
pub(crate) run_id: i32,
}
impl RequestBuilder {
#[doc = "Returns a future that sends the request and returns a [`Response`] object that provides low-level access to full response details."]
#[doc = ""]
#[doc = "You should typically use `.await` (which implicitly calls `IntoFuture::into_future()`) to finalize and send requests rather than `send()`."]
#[doc = "However, this function can provide more flexibility when required."]
pub fn send(self) -> BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = this.url()?;
let mut req =
azure_core::http::Request::new(url, azure_core::http::Method::Get);
if let Some(auth_header) = this
.client
.token_credential()
.http_authorization_header(&this.client.scopes())
.await?
{
req.insert_header(
azure_core::http::headers::AUTHORIZATION,
auth_header,
);
}
let req_body = azure_core::Bytes::new();
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?.into()))
}
})
}
fn url(&self) -> azure_core::Result<azure_core::http::Url> {
let mut url = azure_core::http::Url::parse(&format!(
"{}/{}/{}/_apis/testresults/runs/{}/testattachments",
self.client.endpoint(),
&self.organization,
&self.project,
&self.run_id
))?;
let has_api_version_already = url.query_pairs().any(|(k, _)| k == "api-version");
if !has_api_version_already {
url.query_pairs_mut()
.append_pair("api-version", "7.1-preview");
}
Ok(url)
}
}
impl std::future::IntoFuture for RequestBuilder {
type Output = azure_core::Result<models::TestLogStoreAttachmentList>;
type IntoFuture =
BoxFuture<'static, azure_core::Result<models::TestLogStoreAttachmentList>>;
#[doc = "Returns a future that sends the request and returns the parsed response body."]
#[doc = ""]
#[doc = "You should not normally call this method directly, simply invoke `.await` which implicitly calls `IntoFuture::into_future`."]
#[doc = ""]
#[doc = "See [IntoFuture documentation](https://doc.rust-lang.org/std/future/trait.IntoFuture.html) for more details."]
fn into_future(self) -> Self::IntoFuture {
Box::pin(async move { self.send().await?.into_body() })
}
}
}
pub mod create_test_run_log_store_attachment {
use super::models;
#[cfg(not(target_arch = "wasm32"))]
use futures::future::BoxFuture;
#[cfg(target_arch = "wasm32")]
use futures::future::LocalBoxFuture as BoxFuture;
#[derive(Debug)]
pub struct Response(
azure_core::http::Response<
models::TestLogStoreAttachmentReference,
azure_core::http::JsonFormat,
>,
);
impl Response {
pub fn into_body(self) -> azure_core::Result<models::TestLogStoreAttachmentReference> {
self.0.into_model()
}
pub fn into_raw_response(self) -> azure_core::http::RawResponse {
self.0.into()
}
}
#[derive(Clone)]
#[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."]
#[doc = r""]
#[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"]
#[doc = r" parameters can be chained."]
#[doc = r""]
#[doc = r" To finalize and submit the request, invoke `.await`, which"]
#[doc = r" converts the [`RequestBuilder`] into a future,"]
#[doc = r" executes the request and returns a `Result` with the parsed"]
#[doc = r" response."]
#[doc = r""]
#[doc = r" If you need lower-level access to the raw response details"]
#[doc = r" (e.g. to inspect response headers or raw body data) then you"]
#[doc = r" can finalize the request using the"]
#[doc = r" [`RequestBuilder::send()`] method which returns a future"]
#[doc = r" that resolves to a lower-level [`Response`] value."]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) organization: String,
pub(crate) body: models::TestAttachmentRequestModel,
pub(crate) project: String,
pub(crate) run_id: i32,
}
impl RequestBuilder {
#[doc = "Returns a future that sends the request and returns a [`Response`] object that provides low-level access to full response details."]
#[doc = ""]
#[doc = "You should typically use `.await` (which implicitly calls `IntoFuture::into_future()`) to finalize and send requests rather than `send()`."]
#[doc = "However, this function can provide more flexibility when required."]
pub fn send(self) -> BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = this.url()?;
let mut req =
azure_core::http::Request::new(url, azure_core::http::Method::Post);
if let Some(auth_header) = this
.client
.token_credential()
.http_authorization_header(&this.client.scopes())
.await?
{
req.insert_header(
azure_core::http::headers::AUTHORIZATION,
auth_header,
);
}
req.insert_header("content-type", "application/json");
let req_body = azure_core::json::to_json(&this.body)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?.into()))
}
})
}
fn url(&self) -> azure_core::Result<azure_core::http::Url> {
let mut url = azure_core::http::Url::parse(&format!(
"{}/{}/{}/_apis/testresults/runs/{}/testattachments",
self.client.endpoint(),
&self.organization,
&self.project,
&self.run_id
))?;
let has_api_version_already = url.query_pairs().any(|(k, _)| k == "api-version");
if !has_api_version_already {
url.query_pairs_mut()
.append_pair("api-version", "7.1-preview");
}
Ok(url)
}
}
impl std::future::IntoFuture for RequestBuilder {
type Output = azure_core::Result<models::TestLogStoreAttachmentReference>;
type IntoFuture =
BoxFuture<'static, azure_core::Result<models::TestLogStoreAttachmentReference>>;
#[doc = "Returns a future that sends the request and returns the parsed response body."]
#[doc = ""]
#[doc = "You should not normally call this method directly, simply invoke `.await` which implicitly calls `IntoFuture::into_future`."]
#[doc = ""]
#[doc = "See [IntoFuture documentation](https://doc.rust-lang.org/std/future/trait.IntoFuture.html) for more details."]
fn into_future(self) -> Self::IntoFuture {
Box::pin(async move { self.send().await?.into_body() })
}
}
}
pub mod delete {
use super::models;
#[cfg(not(target_arch = "wasm32"))]
use futures::future::BoxFuture;
#[cfg(target_arch = "wasm32")]
use futures::future::LocalBoxFuture as BoxFuture;
#[derive(Debug)]
pub struct Response(azure_core::http::Response<(), azure_core::http::NoFormat>);
impl Response {
pub fn into_raw_response(self) -> azure_core::http::RawResponse {
self.0.into()
}
}
#[derive(Clone)]
#[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."]
#[doc = r""]
#[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"]
#[doc = r" parameters can be chained."]
#[doc = r""]
#[doc = r" To finalize and submit the request, invoke `.await`, which"]
#[doc = r" converts the [`RequestBuilder`] into a future,"]
#[doc = r" executes the request and returns a `Result` with the parsed"]
#[doc = r" response."]
#[doc = r""]
#[doc = r" If you need lower-level access to the raw response details"]
#[doc = r" (e.g. to inspect response headers or raw body data) then you"]
#[doc = r" can finalize the request using the"]
#[doc = r" [`RequestBuilder::send()`] method which returns a future"]
#[doc = r" that resolves to a lower-level [`Response`] value."]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) organization: String,
pub(crate) project: String,
pub(crate) run_id: i32,
pub(crate) filename: String,
}
impl RequestBuilder {
#[doc = "Returns a future that sends the request and returns a [`Response`] object that provides low-level access to full response details."]
#[doc = ""]
#[doc = "You should typically use `.await` (which implicitly calls `IntoFuture::into_future()`) to finalize and send requests rather than `send()`."]
#[doc = "However, this function can provide more flexibility when required."]
pub fn send(self) -> BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = this.url()?;
let mut req =
azure_core::http::Request::new(url, azure_core::http::Method::Delete);
if let Some(auth_header) = this
.client
.token_credential()
.http_authorization_header(&this.client.scopes())
.await?
{
req.insert_header(
azure_core::http::headers::AUTHORIZATION,
auth_header,
);
}
let filename = &this.filename;
req.url_mut()
.query_pairs_mut()
.append_pair("filename", filename);
let req_body = azure_core::Bytes::new();
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?.into()))
}
})
}
fn url(&self) -> azure_core::Result<azure_core::http::Url> {
let mut url = azure_core::http::Url::parse(&format!(
"{}/{}/{}/_apis/testresults/runs/{}/testattachments",
self.client.endpoint(),
&self.organization,
&self.project,
&self.run_id
))?;
let has_api_version_already = url.query_pairs().any(|(k, _)| k == "api-version");
if !has_api_version_already {
url.query_pairs_mut()
.append_pair("api-version", "7.1-preview");
}
Ok(url)
}
}
impl std::future::IntoFuture for RequestBuilder {
type Output = azure_core::Result<()>;
type IntoFuture = BoxFuture<'static, azure_core::Result<()>>;
#[doc = "Returns a future that sends the request and waits for the response."]
#[doc = ""]
#[doc = "You should not normally call this method directly, simply invoke `.await` which implicitly calls `IntoFuture::into_future`."]
#[doc = ""]
#[doc = "See [IntoFuture documentation](https://doc.rust-lang.org/std/future/trait.IntoFuture.html) for more details."]
fn into_future(self) -> Self::IntoFuture {
Box::pin(async move {
let _rsp = self.send().await?;
Ok(())
})
}
}
}
pub mod create_build_attachment_in_log_store {
use super::models;
#[cfg(not(target_arch = "wasm32"))]
use futures::future::BoxFuture;
#[cfg(target_arch = "wasm32")]
use futures::future::LocalBoxFuture as BoxFuture;
#[derive(Debug)]
pub struct Response(azure_core::http::Response<(), azure_core::http::NoFormat>);
impl Response {
pub fn into_raw_response(self) -> azure_core::http::RawResponse {
self.0.into()
}
}
#[derive(Clone)]
#[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."]
#[doc = r""]
#[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"]
#[doc = r" parameters can be chained."]
#[doc = r""]
#[doc = r" To finalize and submit the request, invoke `.await`, which"]
#[doc = r" converts the [`RequestBuilder`] into a future,"]
#[doc = r" executes the request and returns a `Result` with the parsed"]
#[doc = r" response."]
#[doc = r""]
#[doc = r" If you need lower-level access to the raw response details"]
#[doc = r" (e.g. to inspect response headers or raw body data) then you"]
#[doc = r" can finalize the request using the"]
#[doc = r" [`RequestBuilder::send()`] method which returns a future"]
#[doc = r" that resolves to a lower-level [`Response`] value."]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) organization: String,
pub(crate) body: models::TestAttachmentRequestModel,
pub(crate) project: String,
pub(crate) build_id: i32,
}
impl RequestBuilder {
#[doc = "Returns a future that sends the request and returns a [`Response`] object that provides low-level access to full response details."]
#[doc = ""]
#[doc = "You should typically use `.await` (which implicitly calls `IntoFuture::into_future()`) to finalize and send requests rather than `send()`."]
#[doc = "However, this function can provide more flexibility when required."]
pub fn send(self) -> BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = this.url()?;
let mut req =
azure_core::http::Request::new(url, azure_core::http::Method::Post);
if let Some(auth_header) = this
.client
.token_credential()
.http_authorization_header(&this.client.scopes())
.await?
{
req.insert_header(
azure_core::http::headers::AUTHORIZATION,
auth_header,
);
}
req.insert_header("content-type", "application/json");
let req_body = azure_core::json::to_json(&this.body)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?.into()))
}
})
}
fn url(&self) -> azure_core::Result<azure_core::http::Url> {
let mut url = azure_core::http::Url::parse(&format!(
"{}/{}/{}/_apis/testresults/uploadbuildattachments/{}",
self.client.endpoint(),
&self.organization,
&self.project,
&self.build_id
))?;
let has_api_version_already = url.query_pairs().any(|(k, _)| k == "api-version");
if !has_api_version_already {
url.query_pairs_mut()
.append_pair("api-version", "7.1-preview");
}
Ok(url)
}
}
impl std::future::IntoFuture for RequestBuilder {
type Output = azure_core::Result<()>;
type IntoFuture = BoxFuture<'static, azure_core::Result<()>>;
#[doc = "Returns a future that sends the request and waits for the response."]
#[doc = ""]
#[doc = "You should not normally call this method directly, simply invoke `.await` which implicitly calls `IntoFuture::into_future`."]
#[doc = ""]
#[doc = "See [IntoFuture documentation](https://doc.rust-lang.org/std/future/trait.IntoFuture.html) for more details."]
fn into_future(self) -> Self::IntoFuture {
Box::pin(async move {
let _rsp = self.send().await?;
Ok(())
})
}
}
}
}
pub mod tags {
use super::models;
#[cfg(not(target_arch = "wasm32"))]
use futures::future::BoxFuture;
#[cfg(target_arch = "wasm32")]
use futures::future::LocalBoxFuture as BoxFuture;
pub struct Client(pub(crate) super::Client);
impl Client {
#[doc = "Arguments:"]
#[doc = "* `organization`: The name of the Azure DevOps organization."]
#[doc = "* `project`: Project ID or project name"]
pub fn get_test_tags_for_release(
&self,
organization: impl Into<String>,
project: impl Into<String>,
release_id: i32,
release_env_id: i32,
) -> get_test_tags_for_release::RequestBuilder {
get_test_tags_for_release::RequestBuilder {
client: self.0.clone(),
organization: organization.into(),
project: project.into(),
release_id,
release_env_id,
}
}
#[doc = "Arguments:"]
#[doc = "* `organization`: The name of the Azure DevOps organization."]
#[doc = "* `project`: Project ID or project name"]
pub fn update(
&self,
organization: impl Into<String>,
body: impl Into<models::TestTagsUpdateModel>,
project: impl Into<String>,
run_id: i32,
) -> update::RequestBuilder {
update::RequestBuilder {
client: self.0.clone(),
organization: organization.into(),
body: body.into(),
project: project.into(),
run_id,
}
}
#[doc = "Arguments:"]
#[doc = "* `organization`: The name of the Azure DevOps organization."]
#[doc = "* `project`: Project ID or project name"]
pub fn get_test_tags_for_build(
&self,
organization: impl Into<String>,
project: impl Into<String>,
build_id: i32,
) -> get_test_tags_for_build::RequestBuilder {
get_test_tags_for_build::RequestBuilder {
client: self.0.clone(),
organization: organization.into(),
project: project.into(),
build_id,
}
}
}
pub mod get_test_tags_for_release {
use super::models;
#[cfg(not(target_arch = "wasm32"))]
use futures::future::BoxFuture;
#[cfg(target_arch = "wasm32")]
use futures::future::LocalBoxFuture as BoxFuture;
#[derive(Debug)]
pub struct Response(
azure_core::http::Response<models::TestTagList, azure_core::http::JsonFormat>,
);
impl Response {
pub fn into_body(self) -> azure_core::Result<models::TestTagList> {
self.0.into_model()
}
pub fn into_raw_response(self) -> azure_core::http::RawResponse {
self.0.into()
}
}
#[derive(Clone)]
#[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."]
#[doc = r""]
#[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"]
#[doc = r" parameters can be chained."]
#[doc = r""]
#[doc = r" To finalize and submit the request, invoke `.await`, which"]
#[doc = r" converts the [`RequestBuilder`] into a future,"]
#[doc = r" executes the request and returns a `Result` with the parsed"]
#[doc = r" response."]
#[doc = r""]
#[doc = r" If you need lower-level access to the raw response details"]
#[doc = r" (e.g. to inspect response headers or raw body data) then you"]
#[doc = r" can finalize the request using the"]
#[doc = r" [`RequestBuilder::send()`] method which returns a future"]
#[doc = r" that resolves to a lower-level [`Response`] value."]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) organization: String,
pub(crate) project: String,
pub(crate) release_id: i32,
pub(crate) release_env_id: i32,
}
impl RequestBuilder {
#[doc = "Returns a future that sends the request and returns a [`Response`] object that provides low-level access to full response details."]
#[doc = ""]
#[doc = "You should typically use `.await` (which implicitly calls `IntoFuture::into_future()`) to finalize and send requests rather than `send()`."]
#[doc = "However, this function can provide more flexibility when required."]
pub fn send(self) -> BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = this.url()?;
let mut req =
azure_core::http::Request::new(url, azure_core::http::Method::Get);
if let Some(auth_header) = this
.client
.token_credential()
.http_authorization_header(&this.client.scopes())
.await?
{
req.insert_header(
azure_core::http::headers::AUTHORIZATION,
auth_header,
);
}
let release_id = &this.release_id;
req.url_mut()
.query_pairs_mut()
.append_pair("releaseId", &release_id.to_string());
let release_env_id = &this.release_env_id;
req.url_mut()
.query_pairs_mut()
.append_pair("releaseEnvId", &release_env_id.to_string());
let req_body = azure_core::Bytes::new();
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?.into()))
}
})
}
fn url(&self) -> azure_core::Result<azure_core::http::Url> {
let mut url = azure_core::http::Url::parse(&format!(
"{}/{}/{}/_apis/testresults/tags?releaseId={}&releaseEnvId={}",
self.client.endpoint(),
&self.organization,
&self.project,
&self.release_id,
&self.release_env_id
))?;
let has_api_version_already = url.query_pairs().any(|(k, _)| k == "api-version");
if !has_api_version_already {
url.query_pairs_mut()
.append_pair("api-version", "7.1-preview");
}
Ok(url)
}
}
impl std::future::IntoFuture for RequestBuilder {
type Output = azure_core::Result<models::TestTagList>;
type IntoFuture = BoxFuture<'static, azure_core::Result<models::TestTagList>>;
#[doc = "Returns a future that sends the request and returns the parsed response body."]
#[doc = ""]
#[doc = "You should not normally call this method directly, simply invoke `.await` which implicitly calls `IntoFuture::into_future`."]
#[doc = ""]
#[doc = "See [IntoFuture documentation](https://doc.rust-lang.org/std/future/trait.IntoFuture.html) for more details."]
fn into_future(self) -> Self::IntoFuture {
Box::pin(async move { self.send().await?.into_body() })
}
}
}
pub mod update {
use super::models;
#[cfg(not(target_arch = "wasm32"))]
use futures::future::BoxFuture;
#[cfg(target_arch = "wasm32")]
use futures::future::LocalBoxFuture as BoxFuture;
#[derive(Debug)]
pub struct Response(
azure_core::http::Response<models::TestTagList, azure_core::http::JsonFormat>,
);
impl Response {
pub fn into_body(self) -> azure_core::Result<models::TestTagList> {
self.0.into_model()
}
pub fn into_raw_response(self) -> azure_core::http::RawResponse {
self.0.into()
}
}
#[derive(Clone)]
#[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."]
#[doc = r""]
#[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"]
#[doc = r" parameters can be chained."]
#[doc = r""]
#[doc = r" To finalize and submit the request, invoke `.await`, which"]
#[doc = r" converts the [`RequestBuilder`] into a future,"]
#[doc = r" executes the request and returns a `Result` with the parsed"]
#[doc = r" response."]
#[doc = r""]
#[doc = r" If you need lower-level access to the raw response details"]
#[doc = r" (e.g. to inspect response headers or raw body data) then you"]
#[doc = r" can finalize the request using the"]
#[doc = r" [`RequestBuilder::send()`] method which returns a future"]
#[doc = r" that resolves to a lower-level [`Response`] value."]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) organization: String,
pub(crate) body: models::TestTagsUpdateModel,
pub(crate) project: String,
pub(crate) run_id: i32,
}
impl RequestBuilder {
#[doc = "Returns a future that sends the request and returns a [`Response`] object that provides low-level access to full response details."]
#[doc = ""]
#[doc = "You should typically use `.await` (which implicitly calls `IntoFuture::into_future()`) to finalize and send requests rather than `send()`."]
#[doc = "However, this function can provide more flexibility when required."]
pub fn send(self) -> BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = this.url()?;
let mut req =
azure_core::http::Request::new(url, azure_core::http::Method::Patch);
if let Some(auth_header) = this
.client
.token_credential()
.http_authorization_header(&this.client.scopes())
.await?
{
req.insert_header(
azure_core::http::headers::AUTHORIZATION,
auth_header,
);
}
req.insert_header("content-type", "application/json");
let req_body = azure_core::json::to_json(&this.body)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?.into()))
}
})
}
fn url(&self) -> azure_core::Result<azure_core::http::Url> {
let mut url = azure_core::http::Url::parse(&format!(
"{}/{}/{}/_apis/testresults/runs/{}/tags",
self.client.endpoint(),
&self.organization,
&self.project,
&self.run_id
))?;
let has_api_version_already = url.query_pairs().any(|(k, _)| k == "api-version");
if !has_api_version_already {
url.query_pairs_mut()
.append_pair("api-version", "7.1-preview");
}
Ok(url)
}
}
impl std::future::IntoFuture for RequestBuilder {
type Output = azure_core::Result<models::TestTagList>;
type IntoFuture = BoxFuture<'static, azure_core::Result<models::TestTagList>>;
#[doc = "Returns a future that sends the request and returns the parsed response body."]
#[doc = ""]
#[doc = "You should not normally call this method directly, simply invoke `.await` which implicitly calls `IntoFuture::into_future`."]
#[doc = ""]
#[doc = "See [IntoFuture documentation](https://doc.rust-lang.org/std/future/trait.IntoFuture.html) for more details."]
fn into_future(self) -> Self::IntoFuture {
Box::pin(async move { self.send().await?.into_body() })
}
}
}
pub mod get_test_tags_for_build {
use super::models;
#[cfg(not(target_arch = "wasm32"))]
use futures::future::BoxFuture;
#[cfg(target_arch = "wasm32")]
use futures::future::LocalBoxFuture as BoxFuture;
#[derive(Debug)]
pub struct Response(
azure_core::http::Response<models::TestTagList, azure_core::http::JsonFormat>,
);
impl Response {
pub fn into_body(self) -> azure_core::Result<models::TestTagList> {
self.0.into_model()
}
pub fn into_raw_response(self) -> azure_core::http::RawResponse {
self.0.into()
}
}
#[derive(Clone)]
#[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."]
#[doc = r""]
#[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"]
#[doc = r" parameters can be chained."]
#[doc = r""]
#[doc = r" To finalize and submit the request, invoke `.await`, which"]
#[doc = r" converts the [`RequestBuilder`] into a future,"]
#[doc = r" executes the request and returns a `Result` with the parsed"]
#[doc = r" response."]
#[doc = r""]
#[doc = r" If you need lower-level access to the raw response details"]
#[doc = r" (e.g. to inspect response headers or raw body data) then you"]
#[doc = r" can finalize the request using the"]
#[doc = r" [`RequestBuilder::send()`] method which returns a future"]
#[doc = r" that resolves to a lower-level [`Response`] value."]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) organization: String,
pub(crate) project: String,
pub(crate) build_id: i32,
}
impl RequestBuilder {
#[doc = "Returns a future that sends the request and returns a [`Response`] object that provides low-level access to full response details."]
#[doc = ""]
#[doc = "You should typically use `.await` (which implicitly calls `IntoFuture::into_future()`) to finalize and send requests rather than `send()`."]
#[doc = "However, this function can provide more flexibility when required."]
pub fn send(self) -> BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = this.url()?;
let mut req =
azure_core::http::Request::new(url, azure_core::http::Method::Get);
if let Some(auth_header) = this
.client
.token_credential()
.http_authorization_header(&this.client.scopes())
.await?
{
req.insert_header(
azure_core::http::headers::AUTHORIZATION,
auth_header,
);
}
let build_id = &this.build_id;
req.url_mut()
.query_pairs_mut()
.append_pair("buildId", &build_id.to_string());
let req_body = azure_core::Bytes::new();
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?.into()))
}
})
}
fn url(&self) -> azure_core::Result<azure_core::http::Url> {
let mut url = azure_core::http::Url::parse(&format!(
"{}/{}/{}/_apis/testresults/tags",
self.client.endpoint(),
&self.organization,
&self.project
))?;
let has_api_version_already = url.query_pairs().any(|(k, _)| k == "api-version");
if !has_api_version_already {
url.query_pairs_mut()
.append_pair("api-version", "7.1-preview");
}
Ok(url)
}
}
impl std::future::IntoFuture for RequestBuilder {
type Output = azure_core::Result<models::TestTagList>;
type IntoFuture = BoxFuture<'static, azure_core::Result<models::TestTagList>>;
#[doc = "Returns a future that sends the request and returns the parsed response body."]
#[doc = ""]
#[doc = "You should not normally call this method directly, simply invoke `.await` which implicitly calls `IntoFuture::into_future`."]
#[doc = ""]
#[doc = "See [IntoFuture documentation](https://doc.rust-lang.org/std/future/trait.IntoFuture.html) for more details."]
fn into_future(self) -> Self::IntoFuture {
Box::pin(async move { self.send().await?.into_body() })
}
}
}
}
pub mod tagsummary {
use super::models;
#[cfg(not(target_arch = "wasm32"))]
use futures::future::BoxFuture;
#[cfg(target_arch = "wasm32")]
use futures::future::LocalBoxFuture as BoxFuture;
pub struct Client(pub(crate) super::Client);
impl Client {
#[doc = "Arguments:"]
#[doc = "* `organization`: The name of the Azure DevOps organization."]
#[doc = "* `project`: Project ID or project name"]
pub fn get_test_tag_summary_for_release(
&self,
organization: impl Into<String>,
project: impl Into<String>,
release_id: i32,
release_env_id: i32,
) -> get_test_tag_summary_for_release::RequestBuilder {
get_test_tag_summary_for_release::RequestBuilder {
client: self.0.clone(),
organization: organization.into(),
project: project.into(),
release_id,
release_env_id,
}
}
#[doc = "Arguments:"]
#[doc = "* `organization`: The name of the Azure DevOps organization."]
#[doc = "* `project`: Project ID or project name"]
pub fn get_test_tag_summary_for_build(
&self,
organization: impl Into<String>,
project: impl Into<String>,
build_id: i32,
) -> get_test_tag_summary_for_build::RequestBuilder {
get_test_tag_summary_for_build::RequestBuilder {
client: self.0.clone(),
organization: organization.into(),
project: project.into(),
build_id,
}
}
}
pub mod get_test_tag_summary_for_release {
use super::models;
#[cfg(not(target_arch = "wasm32"))]
use futures::future::BoxFuture;
#[cfg(target_arch = "wasm32")]
use futures::future::LocalBoxFuture as BoxFuture;
#[derive(Debug)]
pub struct Response(
azure_core::http::Response<models::TestTagSummary, azure_core::http::JsonFormat>,
);
impl Response {
pub fn into_body(self) -> azure_core::Result<models::TestTagSummary> {
self.0.into_model()
}
pub fn into_raw_response(self) -> azure_core::http::RawResponse {
self.0.into()
}
}
#[derive(Clone)]
#[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."]
#[doc = r""]
#[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"]
#[doc = r" parameters can be chained."]
#[doc = r""]
#[doc = r" To finalize and submit the request, invoke `.await`, which"]
#[doc = r" converts the [`RequestBuilder`] into a future,"]
#[doc = r" executes the request and returns a `Result` with the parsed"]
#[doc = r" response."]
#[doc = r""]
#[doc = r" If you need lower-level access to the raw response details"]
#[doc = r" (e.g. to inspect response headers or raw body data) then you"]
#[doc = r" can finalize the request using the"]
#[doc = r" [`RequestBuilder::send()`] method which returns a future"]
#[doc = r" that resolves to a lower-level [`Response`] value."]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) organization: String,
pub(crate) project: String,
pub(crate) release_id: i32,
pub(crate) release_env_id: i32,
}
impl RequestBuilder {
#[doc = "Returns a future that sends the request and returns a [`Response`] object that provides low-level access to full response details."]
#[doc = ""]
#[doc = "You should typically use `.await` (which implicitly calls `IntoFuture::into_future()`) to finalize and send requests rather than `send()`."]
#[doc = "However, this function can provide more flexibility when required."]
pub fn send(self) -> BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = this.url()?;
let mut req =
azure_core::http::Request::new(url, azure_core::http::Method::Get);
if let Some(auth_header) = this
.client
.token_credential()
.http_authorization_header(&this.client.scopes())
.await?
{
req.insert_header(
azure_core::http::headers::AUTHORIZATION,
auth_header,
);
}
let release_id = &this.release_id;
req.url_mut()
.query_pairs_mut()
.append_pair("releaseId", &release_id.to_string());
let release_env_id = &this.release_env_id;
req.url_mut()
.query_pairs_mut()
.append_pair("releaseEnvId", &release_env_id.to_string());
let req_body = azure_core::Bytes::new();
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?.into()))
}
})
}
fn url(&self) -> azure_core::Result<azure_core::http::Url> {
let mut url = azure_core::http::Url::parse(&format!(
"{}/{}/{}/_apis/testresults/tagsummary?releaseId={}&releaseEnvId={}",
self.client.endpoint(),
&self.organization,
&self.project,
&self.release_id,
&self.release_env_id
))?;
let has_api_version_already = url.query_pairs().any(|(k, _)| k == "api-version");
if !has_api_version_already {
url.query_pairs_mut()
.append_pair("api-version", "7.1-preview");
}
Ok(url)
}
}
impl std::future::IntoFuture for RequestBuilder {
type Output = azure_core::Result<models::TestTagSummary>;
type IntoFuture = BoxFuture<'static, azure_core::Result<models::TestTagSummary>>;
#[doc = "Returns a future that sends the request and returns the parsed response body."]
#[doc = ""]
#[doc = "You should not normally call this method directly, simply invoke `.await` which implicitly calls `IntoFuture::into_future`."]
#[doc = ""]
#[doc = "See [IntoFuture documentation](https://doc.rust-lang.org/std/future/trait.IntoFuture.html) for more details."]
fn into_future(self) -> Self::IntoFuture {
Box::pin(async move { self.send().await?.into_body() })
}
}
}
pub mod get_test_tag_summary_for_build {
use super::models;
#[cfg(not(target_arch = "wasm32"))]
use futures::future::BoxFuture;
#[cfg(target_arch = "wasm32")]
use futures::future::LocalBoxFuture as BoxFuture;
#[derive(Debug)]
pub struct Response(
azure_core::http::Response<models::TestTagSummary, azure_core::http::JsonFormat>,
);
impl Response {
pub fn into_body(self) -> azure_core::Result<models::TestTagSummary> {
self.0.into_model()
}
pub fn into_raw_response(self) -> azure_core::http::RawResponse {
self.0.into()
}
}
#[derive(Clone)]
#[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."]
#[doc = r""]
#[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"]
#[doc = r" parameters can be chained."]
#[doc = r""]
#[doc = r" To finalize and submit the request, invoke `.await`, which"]
#[doc = r" converts the [`RequestBuilder`] into a future,"]
#[doc = r" executes the request and returns a `Result` with the parsed"]
#[doc = r" response."]
#[doc = r""]
#[doc = r" If you need lower-level access to the raw response details"]
#[doc = r" (e.g. to inspect response headers or raw body data) then you"]
#[doc = r" can finalize the request using the"]
#[doc = r" [`RequestBuilder::send()`] method which returns a future"]
#[doc = r" that resolves to a lower-level [`Response`] value."]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) organization: String,
pub(crate) project: String,
pub(crate) build_id: i32,
}
impl RequestBuilder {
#[doc = "Returns a future that sends the request and returns a [`Response`] object that provides low-level access to full response details."]
#[doc = ""]
#[doc = "You should typically use `.await` (which implicitly calls `IntoFuture::into_future()`) to finalize and send requests rather than `send()`."]
#[doc = "However, this function can provide more flexibility when required."]
pub fn send(self) -> BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = this.url()?;
let mut req =
azure_core::http::Request::new(url, azure_core::http::Method::Get);
if let Some(auth_header) = this
.client
.token_credential()
.http_authorization_header(&this.client.scopes())
.await?
{
req.insert_header(
azure_core::http::headers::AUTHORIZATION,
auth_header,
);
}
let build_id = &this.build_id;
req.url_mut()
.query_pairs_mut()
.append_pair("buildId", &build_id.to_string());
let req_body = azure_core::Bytes::new();
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?.into()))
}
})
}
fn url(&self) -> azure_core::Result<azure_core::http::Url> {
let mut url = azure_core::http::Url::parse(&format!(
"{}/{}/{}/_apis/testresults/tagsummary",
self.client.endpoint(),
&self.organization,
&self.project
))?;
let has_api_version_already = url.query_pairs().any(|(k, _)| k == "api-version");
if !has_api_version_already {
url.query_pairs_mut()
.append_pair("api-version", "7.1-preview");
}
Ok(url)
}
}
impl std::future::IntoFuture for RequestBuilder {
type Output = azure_core::Result<models::TestTagSummary>;
type IntoFuture = BoxFuture<'static, azure_core::Result<models::TestTagSummary>>;
#[doc = "Returns a future that sends the request and returns the parsed response body."]
#[doc = ""]
#[doc = "You should not normally call this method directly, simply invoke `.await` which implicitly calls `IntoFuture::into_future`."]
#[doc = ""]
#[doc = "See [IntoFuture documentation](https://doc.rust-lang.org/std/future/trait.IntoFuture.html) for more details."]
fn into_future(self) -> Self::IntoFuture {
Box::pin(async move { self.send().await?.into_body() })
}
}
}
}
pub mod workitems {
use super::models;
#[cfg(not(target_arch = "wasm32"))]
use futures::future::BoxFuture;
#[cfg(target_arch = "wasm32")]
use futures::future::LocalBoxFuture as BoxFuture;
pub struct Client(pub(crate) super::Client);
impl Client {
#[doc = "Arguments:"]
#[doc = "* `organization`: The name of the Azure DevOps organization."]
#[doc = "* `project`: Project ID or project name"]
pub fn query_test_method_linked_work_items(
&self,
organization: impl Into<String>,
project: impl Into<String>,
test_name: impl Into<String>,
) -> query_test_method_linked_work_items::RequestBuilder {
query_test_method_linked_work_items::RequestBuilder {
client: self.0.clone(),
organization: organization.into(),
project: project.into(),
test_name: test_name.into(),
}
}
#[doc = "Query Test Result WorkItems based on filter"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `organization`: The name of the Azure DevOps organization."]
#[doc = "* `project`: Project ID or project name"]
#[doc = "* `work_item_category`: can take values Microsoft.BugCategory or all(for getting all workitems)"]
pub fn query_test_result_work_items(
&self,
organization: impl Into<String>,
project: impl Into<String>,
work_item_category: impl Into<String>,
) -> query_test_result_work_items::RequestBuilder {
query_test_result_work_items::RequestBuilder {
client: self.0.clone(),
organization: organization.into(),
project: project.into(),
work_item_category: work_item_category.into(),
automated_test_name: None,
test_case_id: None,
max_complete_date: None,
days: None,
work_item_count: None,
}
}
#[doc = "Arguments:"]
#[doc = "* `organization`: The name of the Azure DevOps organization."]
#[doc = "* `project`: Project ID or project name"]
pub fn list(
&self,
organization: impl Into<String>,
project: impl Into<String>,
run_id: i32,
test_case_result_id: i32,
) -> list::RequestBuilder {
list::RequestBuilder {
client: self.0.clone(),
organization: organization.into(),
project: project.into(),
run_id,
test_case_result_id,
}
}
#[doc = "Arguments:"]
#[doc = "* `organization`: The name of the Azure DevOps organization."]
#[doc = "* `project`: Project ID or project name"]
pub fn add(
&self,
organization: impl Into<String>,
body: impl Into<models::WorkItemToTestLinks>,
project: impl Into<String>,
) -> add::RequestBuilder {
add::RequestBuilder {
client: self.0.clone(),
organization: organization.into(),
body: body.into(),
project: project.into(),
}
}
#[doc = "Arguments:"]
#[doc = "* `organization`: The name of the Azure DevOps organization."]
#[doc = "* `project`: Project ID or project name"]
pub fn delete(
&self,
organization: impl Into<String>,
project: impl Into<String>,
test_name: impl Into<String>,
work_item_id: i32,
) -> delete::RequestBuilder {
delete::RequestBuilder {
client: self.0.clone(),
organization: organization.into(),
project: project.into(),
test_name: test_name.into(),
work_item_id,
}
}
}
pub mod query_test_method_linked_work_items {
use super::models;
#[cfg(not(target_arch = "wasm32"))]
use futures::future::BoxFuture;
#[cfg(target_arch = "wasm32")]
use futures::future::LocalBoxFuture as BoxFuture;
#[derive(Debug)]
pub struct Response(
azure_core::http::Response<models::TestToWorkItemLinks, azure_core::http::JsonFormat>,
);
impl Response {
pub fn into_body(self) -> azure_core::Result<models::TestToWorkItemLinks> {
self.0.into_model()
}
pub fn into_raw_response(self) -> azure_core::http::RawResponse {
self.0.into()
}
}
#[derive(Clone)]
#[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."]
#[doc = r""]
#[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"]
#[doc = r" parameters can be chained."]
#[doc = r""]
#[doc = r" To finalize and submit the request, invoke `.await`, which"]
#[doc = r" converts the [`RequestBuilder`] into a future,"]
#[doc = r" executes the request and returns a `Result` with the parsed"]
#[doc = r" response."]
#[doc = r""]
#[doc = r" If you need lower-level access to the raw response details"]
#[doc = r" (e.g. to inspect response headers or raw body data) then you"]
#[doc = r" can finalize the request using the"]
#[doc = r" [`RequestBuilder::send()`] method which returns a future"]
#[doc = r" that resolves to a lower-level [`Response`] value."]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) organization: String,
pub(crate) project: String,
pub(crate) test_name: String,
}
impl RequestBuilder {
#[doc = "Returns a future that sends the request and returns a [`Response`] object that provides low-level access to full response details."]
#[doc = ""]
#[doc = "You should typically use `.await` (which implicitly calls `IntoFuture::into_future()`) to finalize and send requests rather than `send()`."]
#[doc = "However, this function can provide more flexibility when required."]
pub fn send(self) -> BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = this.url()?;
let mut req =
azure_core::http::Request::new(url, azure_core::http::Method::Post);
if let Some(auth_header) = this
.client
.token_credential()
.http_authorization_header(&this.client.scopes())
.await?
{
req.insert_header(
azure_core::http::headers::AUTHORIZATION,
auth_header,
);
}
let test_name = &this.test_name;
req.url_mut()
.query_pairs_mut()
.append_pair("testName", test_name);
let req_body = azure_core::Bytes::new();
req.insert_header(azure_core::http::headers::CONTENT_LENGTH, "0");
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?.into()))
}
})
}
fn url(&self) -> azure_core::Result<azure_core::http::Url> {
let mut url = azure_core::http::Url::parse(&format!(
"{}/{}/{}/_apis/testresults/testmethods/workitems?testName={}",
self.client.endpoint(),
&self.organization,
&self.project,
&self.test_name
))?;
let has_api_version_already = url.query_pairs().any(|(k, _)| k == "api-version");
if !has_api_version_already {
url.query_pairs_mut()
.append_pair("api-version", "7.1-preview");
}
Ok(url)
}
}
impl std::future::IntoFuture for RequestBuilder {
type Output = azure_core::Result<models::TestToWorkItemLinks>;
type IntoFuture = BoxFuture<'static, azure_core::Result<models::TestToWorkItemLinks>>;
#[doc = "Returns a future that sends the request and returns the parsed response body."]
#[doc = ""]
#[doc = "You should not normally call this method directly, simply invoke `.await` which implicitly calls `IntoFuture::into_future`."]
#[doc = ""]
#[doc = "See [IntoFuture documentation](https://doc.rust-lang.org/std/future/trait.IntoFuture.html) for more details."]
fn into_future(self) -> Self::IntoFuture {
Box::pin(async move { self.send().await?.into_body() })
}
}
}
pub mod query_test_result_work_items {
use super::models;
#[cfg(not(target_arch = "wasm32"))]
use futures::future::BoxFuture;
#[cfg(target_arch = "wasm32")]
use futures::future::LocalBoxFuture as BoxFuture;
#[derive(Debug)]
pub struct Response(
azure_core::http::Response<models::WorkItemReferenceList, azure_core::http::JsonFormat>,
);
impl Response {
pub fn into_body(self) -> azure_core::Result<models::WorkItemReferenceList> {
self.0.into_model()
}
pub fn into_raw_response(self) -> azure_core::http::RawResponse {
self.0.into()
}
}
#[derive(Clone)]
#[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."]
#[doc = r""]
#[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"]
#[doc = r" parameters can be chained."]
#[doc = r""]
#[doc = r" To finalize and submit the request, invoke `.await`, which"]
#[doc = r" converts the [`RequestBuilder`] into a future,"]
#[doc = r" executes the request and returns a `Result` with the parsed"]
#[doc = r" response."]
#[doc = r""]
#[doc = r" If you need lower-level access to the raw response details"]
#[doc = r" (e.g. to inspect response headers or raw body data) then you"]
#[doc = r" can finalize the request using the"]
#[doc = r" [`RequestBuilder::send()`] method which returns a future"]
#[doc = r" that resolves to a lower-level [`Response`] value."]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) organization: String,
pub(crate) project: String,
pub(crate) work_item_category: String,
pub(crate) automated_test_name: Option<String>,
pub(crate) test_case_id: Option<i32>,
pub(crate) max_complete_date: Option<time::OffsetDateTime>,
pub(crate) days: Option<i32>,
pub(crate) work_item_count: Option<i32>,
}
impl RequestBuilder {
pub fn automated_test_name(mut self, automated_test_name: impl Into<String>) -> Self {
self.automated_test_name = Some(automated_test_name.into());
self
}
pub fn test_case_id(mut self, test_case_id: i32) -> Self {
self.test_case_id = Some(test_case_id);
self
}
pub fn max_complete_date(
mut self,
max_complete_date: impl Into<time::OffsetDateTime>,
) -> Self {
self.max_complete_date = Some(max_complete_date.into());
self
}
pub fn days(mut self, days: i32) -> Self {
self.days = Some(days);
self
}
pub fn work_item_count(mut self, work_item_count: i32) -> Self {
self.work_item_count = Some(work_item_count);
self
}
#[doc = "Returns a future that sends the request and returns a [`Response`] object that provides low-level access to full response details."]
#[doc = ""]
#[doc = "You should typically use `.await` (which implicitly calls `IntoFuture::into_future()`) to finalize and send requests rather than `send()`."]
#[doc = "However, this function can provide more flexibility when required."]
pub fn send(self) -> BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = this.url()?;
let mut req =
azure_core::http::Request::new(url, azure_core::http::Method::Get);
if let Some(auth_header) = this
.client
.token_credential()
.http_authorization_header(&this.client.scopes())
.await?
{
req.insert_header(
azure_core::http::headers::AUTHORIZATION,
auth_header,
);
}
let work_item_category = &this.work_item_category;
req.url_mut()
.query_pairs_mut()
.append_pair("workItemCategory", work_item_category);
if let Some(automated_test_name) = &this.automated_test_name {
req.url_mut()
.query_pairs_mut()
.append_pair("automatedTestName", automated_test_name);
}
if let Some(test_case_id) = &this.test_case_id {
req.url_mut()
.query_pairs_mut()
.append_pair("testCaseId", &test_case_id.to_string());
}
if let Some(max_complete_date) = &this.max_complete_date {
let formatted_date_time =
crate::date_time::format_date_time(max_complete_date)?;
req.url_mut()
.query_pairs_mut()
.append_pair("maxCompleteDate", &formatted_date_time);
}
if let Some(days) = &this.days {
req.url_mut()
.query_pairs_mut()
.append_pair("days", &days.to_string());
}
if let Some(work_item_count) = &this.work_item_count {
req.url_mut()
.query_pairs_mut()
.append_pair("$workItemCount", &work_item_count.to_string());
}
let req_body = azure_core::Bytes::new();
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?.into()))
}
})
}
fn url(&self) -> azure_core::Result<azure_core::http::Url> {
let mut url = azure_core::http::Url::parse(&format!(
"{}/{}/{}/_apis/testresults/results/workitems",
self.client.endpoint(),
&self.organization,
&self.project
))?;
let has_api_version_already = url.query_pairs().any(|(k, _)| k == "api-version");
if !has_api_version_already {
url.query_pairs_mut()
.append_pair("api-version", "7.1-preview");
}
Ok(url)
}
}
impl std::future::IntoFuture for RequestBuilder {
type Output = azure_core::Result<models::WorkItemReferenceList>;
type IntoFuture = BoxFuture<'static, azure_core::Result<models::WorkItemReferenceList>>;
#[doc = "Returns a future that sends the request and returns the parsed response body."]
#[doc = ""]
#[doc = "You should not normally call this method directly, simply invoke `.await` which implicitly calls `IntoFuture::into_future`."]
#[doc = ""]
#[doc = "See [IntoFuture documentation](https://doc.rust-lang.org/std/future/trait.IntoFuture.html) for more details."]
fn into_future(self) -> Self::IntoFuture {
Box::pin(async move { self.send().await?.into_body() })
}
}
}
pub mod list {
use super::models;
#[cfg(not(target_arch = "wasm32"))]
use futures::future::BoxFuture;
#[cfg(target_arch = "wasm32")]
use futures::future::LocalBoxFuture as BoxFuture;
#[derive(Debug)]
pub struct Response(
azure_core::http::Response<models::WorkItemReferenceList, azure_core::http::JsonFormat>,
);
impl Response {
pub fn into_body(self) -> azure_core::Result<models::WorkItemReferenceList> {
self.0.into_model()
}
pub fn into_raw_response(self) -> azure_core::http::RawResponse {
self.0.into()
}
}
#[derive(Clone)]
#[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."]
#[doc = r""]
#[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"]
#[doc = r" parameters can be chained."]
#[doc = r""]
#[doc = r" To finalize and submit the request, invoke `.await`, which"]
#[doc = r" converts the [`RequestBuilder`] into a future,"]
#[doc = r" executes the request and returns a `Result` with the parsed"]
#[doc = r" response."]
#[doc = r""]
#[doc = r" If you need lower-level access to the raw response details"]
#[doc = r" (e.g. to inspect response headers or raw body data) then you"]
#[doc = r" can finalize the request using the"]
#[doc = r" [`RequestBuilder::send()`] method which returns a future"]
#[doc = r" that resolves to a lower-level [`Response`] value."]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) organization: String,
pub(crate) project: String,
pub(crate) run_id: i32,
pub(crate) test_case_result_id: i32,
}
impl RequestBuilder {
#[doc = "Returns a future that sends the request and returns a [`Response`] object that provides low-level access to full response details."]
#[doc = ""]
#[doc = "You should typically use `.await` (which implicitly calls `IntoFuture::into_future()`) to finalize and send requests rather than `send()`."]
#[doc = "However, this function can provide more flexibility when required."]
pub fn send(self) -> BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = this.url()?;
let mut req =
azure_core::http::Request::new(url, azure_core::http::Method::Get);
if let Some(auth_header) = this
.client
.token_credential()
.http_authorization_header(&this.client.scopes())
.await?
{
req.insert_header(
azure_core::http::headers::AUTHORIZATION,
auth_header,
);
}
let req_body = azure_core::Bytes::new();
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?.into()))
}
})
}
fn url(&self) -> azure_core::Result<azure_core::http::Url> {
let mut url = azure_core::http::Url::parse(&format!(
"{}/{}/{}/_apis/testresults/runs/{}/results/{}/workitems",
self.client.endpoint(),
&self.organization,
&self.project,
&self.run_id,
&self.test_case_result_id
))?;
let has_api_version_already = url.query_pairs().any(|(k, _)| k == "api-version");
if !has_api_version_already {
url.query_pairs_mut()
.append_pair("api-version", "7.1-preview");
}
Ok(url)
}
}
impl std::future::IntoFuture for RequestBuilder {
type Output = azure_core::Result<models::WorkItemReferenceList>;
type IntoFuture = BoxFuture<'static, azure_core::Result<models::WorkItemReferenceList>>;
#[doc = "Returns a future that sends the request and returns the parsed response body."]
#[doc = ""]
#[doc = "You should not normally call this method directly, simply invoke `.await` which implicitly calls `IntoFuture::into_future`."]
#[doc = ""]
#[doc = "See [IntoFuture documentation](https://doc.rust-lang.org/std/future/trait.IntoFuture.html) for more details."]
fn into_future(self) -> Self::IntoFuture {
Box::pin(async move { self.send().await?.into_body() })
}
}
}
pub mod add {
use super::models;
#[cfg(not(target_arch = "wasm32"))]
use futures::future::BoxFuture;
#[cfg(target_arch = "wasm32")]
use futures::future::LocalBoxFuture as BoxFuture;
#[derive(Debug)]
pub struct Response(
azure_core::http::Response<models::WorkItemToTestLinks, azure_core::http::JsonFormat>,
);
impl Response {
pub fn into_body(self) -> azure_core::Result<models::WorkItemToTestLinks> {
self.0.into_model()
}
pub fn into_raw_response(self) -> azure_core::http::RawResponse {
self.0.into()
}
}
#[derive(Clone)]
#[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."]
#[doc = r""]
#[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"]
#[doc = r" parameters can be chained."]
#[doc = r""]
#[doc = r" To finalize and submit the request, invoke `.await`, which"]
#[doc = r" converts the [`RequestBuilder`] into a future,"]
#[doc = r" executes the request and returns a `Result` with the parsed"]
#[doc = r" response."]
#[doc = r""]
#[doc = r" If you need lower-level access to the raw response details"]
#[doc = r" (e.g. to inspect response headers or raw body data) then you"]
#[doc = r" can finalize the request using the"]
#[doc = r" [`RequestBuilder::send()`] method which returns a future"]
#[doc = r" that resolves to a lower-level [`Response`] value."]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) organization: String,
pub(crate) body: models::WorkItemToTestLinks,
pub(crate) project: String,
}
impl RequestBuilder {
#[doc = "Returns a future that sends the request and returns a [`Response`] object that provides low-level access to full response details."]
#[doc = ""]
#[doc = "You should typically use `.await` (which implicitly calls `IntoFuture::into_future()`) to finalize and send requests rather than `send()`."]
#[doc = "However, this function can provide more flexibility when required."]
pub fn send(self) -> BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = this.url()?;
let mut req =
azure_core::http::Request::new(url, azure_core::http::Method::Post);
if let Some(auth_header) = this
.client
.token_credential()
.http_authorization_header(&this.client.scopes())
.await?
{
req.insert_header(
azure_core::http::headers::AUTHORIZATION,
auth_header,
);
}
req.insert_header("content-type", "application/json");
let req_body = azure_core::json::to_json(&this.body)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?.into()))
}
})
}
fn url(&self) -> azure_core::Result<azure_core::http::Url> {
let mut url = azure_core::http::Url::parse(&format!(
"{}/{}/{}/_apis/testresults/testmethods/workitems",
self.client.endpoint(),
&self.organization,
&self.project
))?;
let has_api_version_already = url.query_pairs().any(|(k, _)| k == "api-version");
if !has_api_version_already {
url.query_pairs_mut()
.append_pair("api-version", "7.1-preview");
}
Ok(url)
}
}
impl std::future::IntoFuture for RequestBuilder {
type Output = azure_core::Result<models::WorkItemToTestLinks>;
type IntoFuture = BoxFuture<'static, azure_core::Result<models::WorkItemToTestLinks>>;
#[doc = "Returns a future that sends the request and returns the parsed response body."]
#[doc = ""]
#[doc = "You should not normally call this method directly, simply invoke `.await` which implicitly calls `IntoFuture::into_future`."]
#[doc = ""]
#[doc = "See [IntoFuture documentation](https://doc.rust-lang.org/std/future/trait.IntoFuture.html) for more details."]
fn into_future(self) -> Self::IntoFuture {
Box::pin(async move { self.send().await?.into_body() })
}
}
}
pub mod delete {
use super::models;
#[cfg(not(target_arch = "wasm32"))]
use futures::future::BoxFuture;
#[cfg(target_arch = "wasm32")]
use futures::future::LocalBoxFuture as BoxFuture;
#[derive(Debug)]
pub struct Response(azure_core::http::Response<bool, azure_core::http::JsonFormat>);
impl Response {
pub fn into_body(self) -> azure_core::Result<bool> {
self.0.into_model()
}
pub fn into_raw_response(self) -> azure_core::http::RawResponse {
self.0.into()
}
}
#[derive(Clone)]
#[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."]
#[doc = r""]
#[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"]
#[doc = r" parameters can be chained."]
#[doc = r""]
#[doc = r" To finalize and submit the request, invoke `.await`, which"]
#[doc = r" converts the [`RequestBuilder`] into a future,"]
#[doc = r" executes the request and returns a `Result` with the parsed"]
#[doc = r" response."]
#[doc = r""]
#[doc = r" If you need lower-level access to the raw response details"]
#[doc = r" (e.g. to inspect response headers or raw body data) then you"]
#[doc = r" can finalize the request using the"]
#[doc = r" [`RequestBuilder::send()`] method which returns a future"]
#[doc = r" that resolves to a lower-level [`Response`] value."]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) organization: String,
pub(crate) project: String,
pub(crate) test_name: String,
pub(crate) work_item_id: i32,
}
impl RequestBuilder {
#[doc = "Returns a future that sends the request and returns a [`Response`] object that provides low-level access to full response details."]
#[doc = ""]
#[doc = "You should typically use `.await` (which implicitly calls `IntoFuture::into_future()`) to finalize and send requests rather than `send()`."]
#[doc = "However, this function can provide more flexibility when required."]
pub fn send(self) -> BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = this.url()?;
let mut req =
azure_core::http::Request::new(url, azure_core::http::Method::Delete);
if let Some(auth_header) = this
.client
.token_credential()
.http_authorization_header(&this.client.scopes())
.await?
{
req.insert_header(
azure_core::http::headers::AUTHORIZATION,
auth_header,
);
}
let test_name = &this.test_name;
req.url_mut()
.query_pairs_mut()
.append_pair("testName", test_name);
let work_item_id = &this.work_item_id;
req.url_mut()
.query_pairs_mut()
.append_pair("workItemId", &work_item_id.to_string());
let req_body = azure_core::Bytes::new();
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?.into()))
}
})
}
fn url(&self) -> azure_core::Result<azure_core::http::Url> {
let mut url = azure_core::http::Url::parse(&format!(
"{}/{}/{}/_apis/testresults/testmethods/workitems",
self.client.endpoint(),
&self.organization,
&self.project
))?;
let has_api_version_already = url.query_pairs().any(|(k, _)| k == "api-version");
if !has_api_version_already {
url.query_pairs_mut()
.append_pair("api-version", "7.1-preview");
}
Ok(url)
}
}
impl std::future::IntoFuture for RequestBuilder {
type Output = azure_core::Result<bool>;
type IntoFuture = BoxFuture<'static, azure_core::Result<bool>>;
#[doc = "Returns a future that sends the request and returns the parsed response body."]
#[doc = ""]
#[doc = "You should not normally call this method directly, simply invoke `.await` which implicitly calls `IntoFuture::into_future`."]
#[doc = ""]
#[doc = "See [IntoFuture documentation](https://doc.rust-lang.org/std/future/trait.IntoFuture.html) for more details."]
fn into_future(self) -> Self::IntoFuture {
Box::pin(async move { self.send().await?.into_body() })
}
}
}
}
pub mod filecoverage {
use super::models;
#[cfg(not(target_arch = "wasm32"))]
use futures::future::BoxFuture;
#[cfg(target_arch = "wasm32")]
use futures::future::LocalBoxFuture as BoxFuture;
pub struct Client(pub(crate) super::Client);
impl Client {
#[doc = "Get file coverage for the specified file"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `organization`: The name of the Azure DevOps organization."]
#[doc = "* `body`: File details with pull request iteration context"]
#[doc = "* `project`: Project ID or project name"]
pub fn get(
&self,
organization: impl Into<String>,
body: impl Into<models::FileCoverageRequest>,
project: impl Into<String>,
) -> get::RequestBuilder {
get::RequestBuilder {
client: self.0.clone(),
organization: organization.into(),
body: body.into(),
project: project.into(),
}
}
}
pub mod get {
use super::models;
#[cfg(not(target_arch = "wasm32"))]
use futures::future::BoxFuture;
#[cfg(target_arch = "wasm32")]
use futures::future::LocalBoxFuture as BoxFuture;
#[derive(Debug)]
pub struct Response(azure_core::http::Response<String, azure_core::http::JsonFormat>);
impl Response {
pub fn into_body(self) -> azure_core::Result<String> {
self.0.into_model()
}
pub fn into_raw_response(self) -> azure_core::http::RawResponse {
self.0.into()
}
}
#[derive(Clone)]
#[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."]
#[doc = r""]
#[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"]
#[doc = r" parameters can be chained."]
#[doc = r""]
#[doc = r" To finalize and submit the request, invoke `.await`, which"]
#[doc = r" converts the [`RequestBuilder`] into a future,"]
#[doc = r" executes the request and returns a `Result` with the parsed"]
#[doc = r" response."]
#[doc = r""]
#[doc = r" If you need lower-level access to the raw response details"]
#[doc = r" (e.g. to inspect response headers or raw body data) then you"]
#[doc = r" can finalize the request using the"]
#[doc = r" [`RequestBuilder::send()`] method which returns a future"]
#[doc = r" that resolves to a lower-level [`Response`] value."]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) organization: String,
pub(crate) body: models::FileCoverageRequest,
pub(crate) project: String,
}
impl RequestBuilder {
#[doc = "Returns a future that sends the request and returns a [`Response`] object that provides low-level access to full response details."]
#[doc = ""]
#[doc = "You should typically use `.await` (which implicitly calls `IntoFuture::into_future()`) to finalize and send requests rather than `send()`."]
#[doc = "However, this function can provide more flexibility when required."]
pub fn send(self) -> BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = this.url()?;
let mut req =
azure_core::http::Request::new(url, azure_core::http::Method::Post);
if let Some(auth_header) = this
.client
.token_credential()
.http_authorization_header(&this.client.scopes())
.await?
{
req.insert_header(
azure_core::http::headers::AUTHORIZATION,
auth_header,
);
}
req.insert_header("content-type", "application/json");
let req_body = azure_core::json::to_json(&this.body)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?.into()))
}
})
}
fn url(&self) -> azure_core::Result<azure_core::http::Url> {
let mut url = azure_core::http::Url::parse(&format!(
"{}/{}/{}/_apis/testresults/codecoverage/filecoverage",
self.client.endpoint(),
&self.organization,
&self.project
))?;
let has_api_version_already = url.query_pairs().any(|(k, _)| k == "api-version");
if !has_api_version_already {
url.query_pairs_mut()
.append_pair("api-version", "7.1-preview");
}
Ok(url)
}
}
impl std::future::IntoFuture for RequestBuilder {
type Output = azure_core::Result<String>;
type IntoFuture = BoxFuture<'static, azure_core::Result<String>>;
#[doc = "Returns a future that sends the request and returns the parsed response body."]
#[doc = ""]
#[doc = "You should not normally call this method directly, simply invoke `.await` which implicitly calls `IntoFuture::into_future`."]
#[doc = ""]
#[doc = "See [IntoFuture documentation](https://doc.rust-lang.org/std/future/trait.IntoFuture.html) for more details."]
fn into_future(self) -> Self::IntoFuture {
Box::pin(async move { self.send().await?.into_body() })
}
}
}
}
pub mod status {
use super::models;
#[cfg(not(target_arch = "wasm32"))]
use futures::future::BoxFuture;
#[cfg(target_arch = "wasm32")]
use futures::future::LocalBoxFuture as BoxFuture;
pub struct Client(pub(crate) super::Client);
impl Client {
#[doc = "<p>Gets the coverage status for the last successful build of a definition, optionally scoped to a specific branch</p>"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `organization`: The name of the Azure DevOps organization."]
#[doc = "* `project`: Project ID or project name"]
#[doc = "* `definition`: The ID or name of the definition."]
pub fn get(
&self,
organization: impl Into<String>,
project: impl Into<String>,
definition: impl Into<String>,
) -> get::RequestBuilder {
get::RequestBuilder {
client: self.0.clone(),
organization: organization.into(),
project: project.into(),
definition: definition.into(),
branch_name: None,
label: None,
}
}
}
pub mod get {
use super::models;
#[cfg(not(target_arch = "wasm32"))]
use futures::future::BoxFuture;
#[cfg(target_arch = "wasm32")]
use futures::future::LocalBoxFuture as BoxFuture;
#[derive(Debug)]
pub struct Response(azure_core::http::Response<String, azure_core::http::JsonFormat>);
impl Response {
pub fn into_body(self) -> azure_core::Result<String> {
self.0.into_model()
}
pub fn into_raw_response(self) -> azure_core::http::RawResponse {
self.0.into()
}
}
#[derive(Clone)]
#[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."]
#[doc = r""]
#[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"]
#[doc = r" parameters can be chained."]
#[doc = r""]
#[doc = r" To finalize and submit the request, invoke `.await`, which"]
#[doc = r" converts the [`RequestBuilder`] into a future,"]
#[doc = r" executes the request and returns a `Result` with the parsed"]
#[doc = r" response."]
#[doc = r""]
#[doc = r" If you need lower-level access to the raw response details"]
#[doc = r" (e.g. to inspect response headers or raw body data) then you"]
#[doc = r" can finalize the request using the"]
#[doc = r" [`RequestBuilder::send()`] method which returns a future"]
#[doc = r" that resolves to a lower-level [`Response`] value."]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) organization: String,
pub(crate) project: String,
pub(crate) definition: String,
pub(crate) branch_name: Option<String>,
pub(crate) label: Option<String>,
}
impl RequestBuilder {
#[doc = "The branch name."]
pub fn branch_name(mut self, branch_name: impl Into<String>) -> Self {
self.branch_name = Some(branch_name.into());
self
}
#[doc = "The String to replace the default text on the left side of the badge."]
pub fn label(mut self, label: impl Into<String>) -> Self {
self.label = Some(label.into());
self
}
#[doc = "Returns a future that sends the request and returns a [`Response`] object that provides low-level access to full response details."]
#[doc = ""]
#[doc = "You should typically use `.await` (which implicitly calls `IntoFuture::into_future()`) to finalize and send requests rather than `send()`."]
#[doc = "However, this function can provide more flexibility when required."]
pub fn send(self) -> BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = this.url()?;
let mut req =
azure_core::http::Request::new(url, azure_core::http::Method::Get);
if let Some(auth_header) = this
.client
.token_credential()
.http_authorization_header(&this.client.scopes())
.await?
{
req.insert_header(
azure_core::http::headers::AUTHORIZATION,
auth_header,
);
}
if let Some(branch_name) = &this.branch_name {
req.url_mut()
.query_pairs_mut()
.append_pair("branchName", branch_name);
}
if let Some(label) = &this.label {
req.url_mut().query_pairs_mut().append_pair("label", label);
}
let req_body = azure_core::Bytes::new();
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?.into()))
}
})
}
fn url(&self) -> azure_core::Result<azure_core::http::Url> {
let mut url = azure_core::http::Url::parse(&format!(
"{}/{}/{}/_apis/testresults/codecoverage/status/{}",
self.client.endpoint(),
&self.organization,
&self.project,
&self.definition
))?;
let has_api_version_already = url.query_pairs().any(|(k, _)| k == "api-version");
if !has_api_version_already {
url.query_pairs_mut()
.append_pair("api-version", "7.1-preview");
}
Ok(url)
}
}
impl std::future::IntoFuture for RequestBuilder {
type Output = azure_core::Result<String>;
type IntoFuture = BoxFuture<'static, azure_core::Result<String>>;
#[doc = "Returns a future that sends the request and returns the parsed response body."]
#[doc = ""]
#[doc = "You should not normally call this method directly, simply invoke `.await` which implicitly calls `IntoFuture::into_future`."]
#[doc = ""]
#[doc = "See [IntoFuture documentation](https://doc.rust-lang.org/std/future/trait.IntoFuture.html) for more details."]
fn into_future(self) -> Self::IntoFuture {
Box::pin(async move { self.send().await?.into_body() })
}
}
}
}
pub mod metrics {
use super::models;
#[cfg(not(target_arch = "wasm32"))]
use futures::future::BoxFuture;
#[cfg(target_arch = "wasm32")]
use futures::future::LocalBoxFuture as BoxFuture;
pub struct Client(pub(crate) super::Client);
impl Client {
#[doc = "Get summary of test results."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `organization`: The name of the Azure DevOps organization."]
#[doc = "* `project`: Project ID or project name"]
#[doc = "* `pipeline_id`: Pipeline Id. This is same as build Id."]
pub fn get(
&self,
organization: impl Into<String>,
project: impl Into<String>,
pipeline_id: i32,
) -> get::RequestBuilder {
get::RequestBuilder {
client: self.0.clone(),
organization: organization.into(),
project: project.into(),
pipeline_id,
stage_name: None,
phase_name: None,
job_name: None,
metric_names: None,
group_by_node: None,
}
}
}
pub mod get {
use super::models;
#[cfg(not(target_arch = "wasm32"))]
use futures::future::BoxFuture;
#[cfg(target_arch = "wasm32")]
use futures::future::LocalBoxFuture as BoxFuture;
#[derive(Debug)]
pub struct Response(
azure_core::http::Response<models::PipelineTestMetrics, azure_core::http::JsonFormat>,
);
impl Response {
pub fn into_body(self) -> azure_core::Result<models::PipelineTestMetrics> {
self.0.into_model()
}
pub fn into_raw_response(self) -> azure_core::http::RawResponse {
self.0.into()
}
}
#[derive(Clone)]
#[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."]
#[doc = r""]
#[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"]
#[doc = r" parameters can be chained."]
#[doc = r""]
#[doc = r" To finalize and submit the request, invoke `.await`, which"]
#[doc = r" converts the [`RequestBuilder`] into a future,"]
#[doc = r" executes the request and returns a `Result` with the parsed"]
#[doc = r" response."]
#[doc = r""]
#[doc = r" If you need lower-level access to the raw response details"]
#[doc = r" (e.g. to inspect response headers or raw body data) then you"]
#[doc = r" can finalize the request using the"]
#[doc = r" [`RequestBuilder::send()`] method which returns a future"]
#[doc = r" that resolves to a lower-level [`Response`] value."]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) organization: String,
pub(crate) project: String,
pub(crate) pipeline_id: i32,
pub(crate) stage_name: Option<String>,
pub(crate) phase_name: Option<String>,
pub(crate) job_name: Option<String>,
pub(crate) metric_names: Option<String>,
pub(crate) group_by_node: Option<bool>,
}
impl RequestBuilder {
#[doc = "Name of the stage. Maximum supported length for name is 256 character."]
pub fn stage_name(mut self, stage_name: impl Into<String>) -> Self {
self.stage_name = Some(stage_name.into());
self
}
#[doc = "Name of the phase. Maximum supported length for name is 256 character."]
pub fn phase_name(mut self, phase_name: impl Into<String>) -> Self {
self.phase_name = Some(phase_name.into());
self
}
#[doc = "Matrixing in YAML generates copies of a job with different inputs in matrix. JobName is the name of those input. Maximum supported length for name is 256 character."]
pub fn job_name(mut self, job_name: impl Into<String>) -> Self {
self.job_name = Some(job_name.into());
self
}
pub fn metric_names(mut self, metric_names: impl Into<String>) -> Self {
self.metric_names = Some(metric_names.into());
self
}
#[doc = "Group summary for each node of the pipleine heirarchy"]
pub fn group_by_node(mut self, group_by_node: bool) -> Self {
self.group_by_node = Some(group_by_node);
self
}
#[doc = "Returns a future that sends the request and returns a [`Response`] object that provides low-level access to full response details."]
#[doc = ""]
#[doc = "You should typically use `.await` (which implicitly calls `IntoFuture::into_future()`) to finalize and send requests rather than `send()`."]
#[doc = "However, this function can provide more flexibility when required."]
pub fn send(self) -> BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = this.url()?;
let mut req =
azure_core::http::Request::new(url, azure_core::http::Method::Get);
if let Some(auth_header) = this
.client
.token_credential()
.http_authorization_header(&this.client.scopes())
.await?
{
req.insert_header(
azure_core::http::headers::AUTHORIZATION,
auth_header,
);
}
let pipeline_id = &this.pipeline_id;
req.url_mut()
.query_pairs_mut()
.append_pair("pipelineId", &pipeline_id.to_string());
if let Some(stage_name) = &this.stage_name {
req.url_mut()
.query_pairs_mut()
.append_pair("stageName", stage_name);
}
if let Some(phase_name) = &this.phase_name {
req.url_mut()
.query_pairs_mut()
.append_pair("phaseName", phase_name);
}
if let Some(job_name) = &this.job_name {
req.url_mut()
.query_pairs_mut()
.append_pair("jobName", job_name);
}
if let Some(metric_names) = &this.metric_names {
req.url_mut()
.query_pairs_mut()
.append_pair("metricNames", metric_names);
}
if let Some(group_by_node) = &this.group_by_node {
req.url_mut()
.query_pairs_mut()
.append_pair("groupByNode", &group_by_node.to_string());
}
let req_body = azure_core::Bytes::new();
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?.into()))
}
})
}
fn url(&self) -> azure_core::Result<azure_core::http::Url> {
let mut url = azure_core::http::Url::parse(&format!(
"{}/{}/{}/_apis/testresults/metrics",
self.client.endpoint(),
&self.organization,
&self.project
))?;
let has_api_version_already = url.query_pairs().any(|(k, _)| k == "api-version");
if !has_api_version_already {
url.query_pairs_mut()
.append_pair("api-version", "7.1-preview");
}
Ok(url)
}
}
impl std::future::IntoFuture for RequestBuilder {
type Output = azure_core::Result<models::PipelineTestMetrics>;
type IntoFuture = BoxFuture<'static, azure_core::Result<models::PipelineTestMetrics>>;
#[doc = "Returns a future that sends the request and returns the parsed response body."]
#[doc = ""]
#[doc = "You should not normally call this method directly, simply invoke `.await` which implicitly calls `IntoFuture::into_future`."]
#[doc = ""]
#[doc = "See [IntoFuture documentation](https://doc.rust-lang.org/std/future/trait.IntoFuture.html) for more details."]
fn into_future(self) -> Self::IntoFuture {
Box::pin(async move { self.send().await?.into_body() })
}
}
}
}
pub mod resultdetailsbybuild {
use super::models;
#[cfg(not(target_arch = "wasm32"))]
use futures::future::BoxFuture;
#[cfg(target_arch = "wasm32")]
use futures::future::LocalBoxFuture as BoxFuture;
pub struct Client(pub(crate) super::Client);
impl Client {
#[doc = "Arguments:"]
#[doc = "* `organization`: The name of the Azure DevOps organization."]
#[doc = "* `project`: Project ID or project name"]
pub fn get(
&self,
organization: impl Into<String>,
project: impl Into<String>,
build_id: i32,
) -> get::RequestBuilder {
get::RequestBuilder {
client: self.0.clone(),
organization: organization.into(),
project: project.into(),
build_id,
publish_context: None,
group_by: None,
filter: None,
orderby: None,
should_include_results: None,
query_run_summary_for_in_progress: None,
}
}
}
pub mod get {
use super::models;
#[cfg(not(target_arch = "wasm32"))]
use futures::future::BoxFuture;
#[cfg(target_arch = "wasm32")]
use futures::future::LocalBoxFuture as BoxFuture;
#[derive(Debug)]
pub struct Response(
azure_core::http::Response<models::TestResultsDetails, azure_core::http::JsonFormat>,
);
impl Response {
pub fn into_body(self) -> azure_core::Result<models::TestResultsDetails> {
self.0.into_model()
}
pub fn into_raw_response(self) -> azure_core::http::RawResponse {
self.0.into()
}
}
#[derive(Clone)]
#[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."]
#[doc = r""]
#[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"]
#[doc = r" parameters can be chained."]
#[doc = r""]
#[doc = r" To finalize and submit the request, invoke `.await`, which"]
#[doc = r" converts the [`RequestBuilder`] into a future,"]
#[doc = r" executes the request and returns a `Result` with the parsed"]
#[doc = r" response."]
#[doc = r""]
#[doc = r" If you need lower-level access to the raw response details"]
#[doc = r" (e.g. to inspect response headers or raw body data) then you"]
#[doc = r" can finalize the request using the"]
#[doc = r" [`RequestBuilder::send()`] method which returns a future"]
#[doc = r" that resolves to a lower-level [`Response`] value."]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) organization: String,
pub(crate) project: String,
pub(crate) build_id: i32,
pub(crate) publish_context: Option<String>,
pub(crate) group_by: Option<String>,
pub(crate) filter: Option<String>,
pub(crate) orderby: Option<String>,
pub(crate) should_include_results: Option<bool>,
pub(crate) query_run_summary_for_in_progress: Option<bool>,
}
impl RequestBuilder {
pub fn publish_context(mut self, publish_context: impl Into<String>) -> Self {
self.publish_context = Some(publish_context.into());
self
}
pub fn group_by(mut self, group_by: impl Into<String>) -> Self {
self.group_by = Some(group_by.into());
self
}
pub fn filter(mut self, filter: impl Into<String>) -> Self {
self.filter = Some(filter.into());
self
}
pub fn orderby(mut self, orderby: impl Into<String>) -> Self {
self.orderby = Some(orderby.into());
self
}
pub fn should_include_results(mut self, should_include_results: bool) -> Self {
self.should_include_results = Some(should_include_results);
self
}
pub fn query_run_summary_for_in_progress(
mut self,
query_run_summary_for_in_progress: bool,
) -> Self {
self.query_run_summary_for_in_progress = Some(query_run_summary_for_in_progress);
self
}
#[doc = "Returns a future that sends the request and returns a [`Response`] object that provides low-level access to full response details."]
#[doc = ""]
#[doc = "You should typically use `.await` (which implicitly calls `IntoFuture::into_future()`) to finalize and send requests rather than `send()`."]
#[doc = "However, this function can provide more flexibility when required."]
pub fn send(self) -> BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = this.url()?;
let mut req =
azure_core::http::Request::new(url, azure_core::http::Method::Get);
if let Some(auth_header) = this
.client
.token_credential()
.http_authorization_header(&this.client.scopes())
.await?
{
req.insert_header(
azure_core::http::headers::AUTHORIZATION,
auth_header,
);
}
let build_id = &this.build_id;
req.url_mut()
.query_pairs_mut()
.append_pair("buildId", &build_id.to_string());
if let Some(publish_context) = &this.publish_context {
req.url_mut()
.query_pairs_mut()
.append_pair("publishContext", publish_context);
}
if let Some(group_by) = &this.group_by {
req.url_mut()
.query_pairs_mut()
.append_pair("groupBy", group_by);
}
if let Some(filter) = &this.filter {
req.url_mut()
.query_pairs_mut()
.append_pair("$filter", filter);
}
if let Some(orderby) = &this.orderby {
req.url_mut()
.query_pairs_mut()
.append_pair("$orderby", orderby);
}
if let Some(should_include_results) = &this.should_include_results {
req.url_mut().query_pairs_mut().append_pair(
"shouldIncludeResults",
&should_include_results.to_string(),
);
}
if let Some(query_run_summary_for_in_progress) =
&this.query_run_summary_for_in_progress
{
req.url_mut().query_pairs_mut().append_pair(
"queryRunSummaryForInProgress",
&query_run_summary_for_in_progress.to_string(),
);
}
let req_body = azure_core::Bytes::new();
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?.into()))
}
})
}
fn url(&self) -> azure_core::Result<azure_core::http::Url> {
let mut url = azure_core::http::Url::parse(&format!(
"{}/{}/{}/_apis/testresults/resultdetailsbybuild",
self.client.endpoint(),
&self.organization,
&self.project
))?;
let has_api_version_already = url.query_pairs().any(|(k, _)| k == "api-version");
if !has_api_version_already {
url.query_pairs_mut()
.append_pair("api-version", "7.1-preview");
}
Ok(url)
}
}
impl std::future::IntoFuture for RequestBuilder {
type Output = azure_core::Result<models::TestResultsDetails>;
type IntoFuture = BoxFuture<'static, azure_core::Result<models::TestResultsDetails>>;
#[doc = "Returns a future that sends the request and returns the parsed response body."]
#[doc = ""]
#[doc = "You should not normally call this method directly, simply invoke `.await` which implicitly calls `IntoFuture::into_future`."]
#[doc = ""]
#[doc = "See [IntoFuture documentation](https://doc.rust-lang.org/std/future/trait.IntoFuture.html) for more details."]
fn into_future(self) -> Self::IntoFuture {
Box::pin(async move { self.send().await?.into_body() })
}
}
}
}
pub mod resultdetailsbyrelease {
use super::models;
#[cfg(not(target_arch = "wasm32"))]
use futures::future::BoxFuture;
#[cfg(target_arch = "wasm32")]
use futures::future::LocalBoxFuture as BoxFuture;
pub struct Client(pub(crate) super::Client);
impl Client {
#[doc = "Arguments:"]
#[doc = "* `organization`: The name of the Azure DevOps organization."]
#[doc = "* `project`: Project ID or project name"]
pub fn get(
&self,
organization: impl Into<String>,
project: impl Into<String>,
release_id: i32,
release_env_id: i32,
) -> get::RequestBuilder {
get::RequestBuilder {
client: self.0.clone(),
organization: organization.into(),
project: project.into(),
release_id,
release_env_id,
publish_context: None,
group_by: None,
filter: None,
orderby: None,
should_include_results: None,
query_run_summary_for_in_progress: None,
}
}
}
pub mod get {
use super::models;
#[cfg(not(target_arch = "wasm32"))]
use futures::future::BoxFuture;
#[cfg(target_arch = "wasm32")]
use futures::future::LocalBoxFuture as BoxFuture;
#[derive(Debug)]
pub struct Response(
azure_core::http::Response<models::TestResultsDetails, azure_core::http::JsonFormat>,
);
impl Response {
pub fn into_body(self) -> azure_core::Result<models::TestResultsDetails> {
self.0.into_model()
}
pub fn into_raw_response(self) -> azure_core::http::RawResponse {
self.0.into()
}
}
#[derive(Clone)]
#[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."]
#[doc = r""]
#[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"]
#[doc = r" parameters can be chained."]
#[doc = r""]
#[doc = r" To finalize and submit the request, invoke `.await`, which"]
#[doc = r" converts the [`RequestBuilder`] into a future,"]
#[doc = r" executes the request and returns a `Result` with the parsed"]
#[doc = r" response."]
#[doc = r""]
#[doc = r" If you need lower-level access to the raw response details"]
#[doc = r" (e.g. to inspect response headers or raw body data) then you"]
#[doc = r" can finalize the request using the"]
#[doc = r" [`RequestBuilder::send()`] method which returns a future"]
#[doc = r" that resolves to a lower-level [`Response`] value."]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) organization: String,
pub(crate) project: String,
pub(crate) release_id: i32,
pub(crate) release_env_id: i32,
pub(crate) publish_context: Option<String>,
pub(crate) group_by: Option<String>,
pub(crate) filter: Option<String>,
pub(crate) orderby: Option<String>,
pub(crate) should_include_results: Option<bool>,
pub(crate) query_run_summary_for_in_progress: Option<bool>,
}
impl RequestBuilder {
pub fn publish_context(mut self, publish_context: impl Into<String>) -> Self {
self.publish_context = Some(publish_context.into());
self
}
pub fn group_by(mut self, group_by: impl Into<String>) -> Self {
self.group_by = Some(group_by.into());
self
}
pub fn filter(mut self, filter: impl Into<String>) -> Self {
self.filter = Some(filter.into());
self
}
pub fn orderby(mut self, orderby: impl Into<String>) -> Self {
self.orderby = Some(orderby.into());
self
}
pub fn should_include_results(mut self, should_include_results: bool) -> Self {
self.should_include_results = Some(should_include_results);
self
}
pub fn query_run_summary_for_in_progress(
mut self,
query_run_summary_for_in_progress: bool,
) -> Self {
self.query_run_summary_for_in_progress = Some(query_run_summary_for_in_progress);
self
}
#[doc = "Returns a future that sends the request and returns a [`Response`] object that provides low-level access to full response details."]
#[doc = ""]
#[doc = "You should typically use `.await` (which implicitly calls `IntoFuture::into_future()`) to finalize and send requests rather than `send()`."]
#[doc = "However, this function can provide more flexibility when required."]
pub fn send(self) -> BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = this.url()?;
let mut req =
azure_core::http::Request::new(url, azure_core::http::Method::Get);
if let Some(auth_header) = this
.client
.token_credential()
.http_authorization_header(&this.client.scopes())
.await?
{
req.insert_header(
azure_core::http::headers::AUTHORIZATION,
auth_header,
);
}
let release_id = &this.release_id;
req.url_mut()
.query_pairs_mut()
.append_pair("releaseId", &release_id.to_string());
let release_env_id = &this.release_env_id;
req.url_mut()
.query_pairs_mut()
.append_pair("releaseEnvId", &release_env_id.to_string());
if let Some(publish_context) = &this.publish_context {
req.url_mut()
.query_pairs_mut()
.append_pair("publishContext", publish_context);
}
if let Some(group_by) = &this.group_by {
req.url_mut()
.query_pairs_mut()
.append_pair("groupBy", group_by);
}
if let Some(filter) = &this.filter {
req.url_mut()
.query_pairs_mut()
.append_pair("$filter", filter);
}
if let Some(orderby) = &this.orderby {
req.url_mut()
.query_pairs_mut()
.append_pair("$orderby", orderby);
}
if let Some(should_include_results) = &this.should_include_results {
req.url_mut().query_pairs_mut().append_pair(
"shouldIncludeResults",
&should_include_results.to_string(),
);
}
if let Some(query_run_summary_for_in_progress) =
&this.query_run_summary_for_in_progress
{
req.url_mut().query_pairs_mut().append_pair(
"queryRunSummaryForInProgress",
&query_run_summary_for_in_progress.to_string(),
);
}
let req_body = azure_core::Bytes::new();
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?.into()))
}
})
}
fn url(&self) -> azure_core::Result<azure_core::http::Url> {
let mut url = azure_core::http::Url::parse(&format!(
"{}/{}/{}/_apis/testresults/resultdetailsbyrelease",
self.client.endpoint(),
&self.organization,
&self.project
))?;
let has_api_version_already = url.query_pairs().any(|(k, _)| k == "api-version");
if !has_api_version_already {
url.query_pairs_mut()
.append_pair("api-version", "7.1-preview");
}
Ok(url)
}
}
impl std::future::IntoFuture for RequestBuilder {
type Output = azure_core::Result<models::TestResultsDetails>;
type IntoFuture = BoxFuture<'static, azure_core::Result<models::TestResultsDetails>>;
#[doc = "Returns a future that sends the request and returns the parsed response body."]
#[doc = ""]
#[doc = "You should not normally call this method directly, simply invoke `.await` which implicitly calls `IntoFuture::into_future`."]
#[doc = ""]
#[doc = "See [IntoFuture documentation](https://doc.rust-lang.org/std/future/trait.IntoFuture.html) for more details."]
fn into_future(self) -> Self::IntoFuture {
Box::pin(async move { self.send().await?.into_body() })
}
}
}
}
pub mod resultgroupsbybuild {
use super::models;
#[cfg(not(target_arch = "wasm32"))]
use futures::future::BoxFuture;
#[cfg(target_arch = "wasm32")]
use futures::future::LocalBoxFuture as BoxFuture;
pub struct Client(pub(crate) super::Client);
impl Client {
#[doc = "Arguments:"]
#[doc = "* `organization`: The name of the Azure DevOps organization."]
#[doc = "* `project`: Project ID or project name"]
pub fn list(
&self,
organization: impl Into<String>,
project: impl Into<String>,
build_id: i32,
publish_context: impl Into<String>,
) -> list::RequestBuilder {
list::RequestBuilder {
client: self.0.clone(),
organization: organization.into(),
project: project.into(),
build_id,
publish_context: publish_context.into(),
fields: None,
continuation_token: None,
}
}
}
pub mod list {
use super::models;
#[cfg(not(target_arch = "wasm32"))]
use futures::future::BoxFuture;
#[cfg(target_arch = "wasm32")]
use futures::future::LocalBoxFuture as BoxFuture;
#[derive(Debug)]
pub struct Response(
azure_core::http::Response<
models::FieldDetailsForTestResultsList,
azure_core::http::JsonFormat,
>,
);
impl Response {
pub fn into_body(self) -> azure_core::Result<models::FieldDetailsForTestResultsList> {
self.0.into_model()
}
pub fn into_raw_response(self) -> azure_core::http::RawResponse {
self.0.into()
}
}
#[derive(Clone)]
#[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."]
#[doc = r""]
#[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"]
#[doc = r" parameters can be chained."]
#[doc = r""]
#[doc = r" To finalize and submit the request, invoke `.await`, which"]
#[doc = r" converts the [`RequestBuilder`] into a future,"]
#[doc = r" executes the request and returns a `Result` with the parsed"]
#[doc = r" response."]
#[doc = r""]
#[doc = r" If you need lower-level access to the raw response details"]
#[doc = r" (e.g. to inspect response headers or raw body data) then you"]
#[doc = r" can finalize the request using the"]
#[doc = r" [`RequestBuilder::send()`] method which returns a future"]
#[doc = r" that resolves to a lower-level [`Response`] value."]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) organization: String,
pub(crate) project: String,
pub(crate) build_id: i32,
pub(crate) publish_context: String,
pub(crate) fields: Option<String>,
pub(crate) continuation_token: Option<String>,
}
impl RequestBuilder {
pub fn fields(mut self, fields: impl Into<String>) -> Self {
self.fields = Some(fields.into());
self
}
pub fn continuation_token(mut self, continuation_token: impl Into<String>) -> Self {
self.continuation_token = Some(continuation_token.into());
self
}
#[doc = "Returns a future that sends the request and returns a [`Response`] object that provides low-level access to full response details."]
#[doc = ""]
#[doc = "You should typically use `.await` (which implicitly calls `IntoFuture::into_future()`) to finalize and send requests rather than `send()`."]
#[doc = "However, this function can provide more flexibility when required."]
pub fn send(self) -> BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = this.url()?;
let mut req =
azure_core::http::Request::new(url, azure_core::http::Method::Get);
if let Some(auth_header) = this
.client
.token_credential()
.http_authorization_header(&this.client.scopes())
.await?
{
req.insert_header(
azure_core::http::headers::AUTHORIZATION,
auth_header,
);
}
let build_id = &this.build_id;
req.url_mut()
.query_pairs_mut()
.append_pair("buildId", &build_id.to_string());
let publish_context = &this.publish_context;
req.url_mut()
.query_pairs_mut()
.append_pair("publishContext", publish_context);
if let Some(fields) = &this.fields {
req.url_mut()
.query_pairs_mut()
.append_pair("fields", fields);
}
if let Some(continuation_token) = &this.continuation_token {
req.url_mut()
.query_pairs_mut()
.append_pair("continuationToken", continuation_token);
}
let req_body = azure_core::Bytes::new();
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?.into()))
}
})
}
fn url(&self) -> azure_core::Result<azure_core::http::Url> {
let mut url = azure_core::http::Url::parse(&format!(
"{}/{}/{}/_apis/testresults/resultgroupsbybuild",
self.client.endpoint(),
&self.organization,
&self.project
))?;
let has_api_version_already = url.query_pairs().any(|(k, _)| k == "api-version");
if !has_api_version_already {
url.query_pairs_mut()
.append_pair("api-version", "7.1-preview");
}
Ok(url)
}
}
impl std::future::IntoFuture for RequestBuilder {
type Output = azure_core::Result<models::FieldDetailsForTestResultsList>;
type IntoFuture =
BoxFuture<'static, azure_core::Result<models::FieldDetailsForTestResultsList>>;
#[doc = "Returns a future that sends the request and returns the parsed response body."]
#[doc = ""]
#[doc = "You should not normally call this method directly, simply invoke `.await` which implicitly calls `IntoFuture::into_future`."]
#[doc = ""]
#[doc = "See [IntoFuture documentation](https://doc.rust-lang.org/std/future/trait.IntoFuture.html) for more details."]
fn into_future(self) -> Self::IntoFuture {
Box::pin(async move { self.send().await?.into_body() })
}
}
}
}
pub mod resultgroupsbyrelease {
use super::models;
#[cfg(not(target_arch = "wasm32"))]
use futures::future::BoxFuture;
#[cfg(target_arch = "wasm32")]
use futures::future::LocalBoxFuture as BoxFuture;
pub struct Client(pub(crate) super::Client);
impl Client {
#[doc = "Arguments:"]
#[doc = "* `organization`: The name of the Azure DevOps organization."]
#[doc = "* `project`: Project ID or project name"]
pub fn list(
&self,
organization: impl Into<String>,
project: impl Into<String>,
release_id: i32,
publish_context: impl Into<String>,
) -> list::RequestBuilder {
list::RequestBuilder {
client: self.0.clone(),
organization: organization.into(),
project: project.into(),
release_id,
publish_context: publish_context.into(),
release_env_id: None,
fields: None,
continuation_token: None,
}
}
}
pub mod list {
use super::models;
#[cfg(not(target_arch = "wasm32"))]
use futures::future::BoxFuture;
#[cfg(target_arch = "wasm32")]
use futures::future::LocalBoxFuture as BoxFuture;
#[derive(Debug)]
pub struct Response(
azure_core::http::Response<
models::FieldDetailsForTestResultsList,
azure_core::http::JsonFormat,
>,
);
impl Response {
pub fn into_body(self) -> azure_core::Result<models::FieldDetailsForTestResultsList> {
self.0.into_model()
}
pub fn into_raw_response(self) -> azure_core::http::RawResponse {
self.0.into()
}
}
#[derive(Clone)]
#[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."]
#[doc = r""]
#[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"]
#[doc = r" parameters can be chained."]
#[doc = r""]
#[doc = r" To finalize and submit the request, invoke `.await`, which"]
#[doc = r" converts the [`RequestBuilder`] into a future,"]
#[doc = r" executes the request and returns a `Result` with the parsed"]
#[doc = r" response."]
#[doc = r""]
#[doc = r" If you need lower-level access to the raw response details"]
#[doc = r" (e.g. to inspect response headers or raw body data) then you"]
#[doc = r" can finalize the request using the"]
#[doc = r" [`RequestBuilder::send()`] method which returns a future"]
#[doc = r" that resolves to a lower-level [`Response`] value."]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) organization: String,
pub(crate) project: String,
pub(crate) release_id: i32,
pub(crate) publish_context: String,
pub(crate) release_env_id: Option<i32>,
pub(crate) fields: Option<String>,
pub(crate) continuation_token: Option<String>,
}
impl RequestBuilder {
pub fn release_env_id(mut self, release_env_id: i32) -> Self {
self.release_env_id = Some(release_env_id);
self
}
pub fn fields(mut self, fields: impl Into<String>) -> Self {
self.fields = Some(fields.into());
self
}
pub fn continuation_token(mut self, continuation_token: impl Into<String>) -> Self {
self.continuation_token = Some(continuation_token.into());
self
}
#[doc = "Returns a future that sends the request and returns a [`Response`] object that provides low-level access to full response details."]
#[doc = ""]
#[doc = "You should typically use `.await` (which implicitly calls `IntoFuture::into_future()`) to finalize and send requests rather than `send()`."]
#[doc = "However, this function can provide more flexibility when required."]
pub fn send(self) -> BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = this.url()?;
let mut req =
azure_core::http::Request::new(url, azure_core::http::Method::Get);
if let Some(auth_header) = this
.client
.token_credential()
.http_authorization_header(&this.client.scopes())
.await?
{
req.insert_header(
azure_core::http::headers::AUTHORIZATION,
auth_header,
);
}
let release_id = &this.release_id;
req.url_mut()
.query_pairs_mut()
.append_pair("releaseId", &release_id.to_string());
let publish_context = &this.publish_context;
req.url_mut()
.query_pairs_mut()
.append_pair("publishContext", publish_context);
if let Some(release_env_id) = &this.release_env_id {
req.url_mut()
.query_pairs_mut()
.append_pair("releaseEnvId", &release_env_id.to_string());
}
if let Some(fields) = &this.fields {
req.url_mut()
.query_pairs_mut()
.append_pair("fields", fields);
}
if let Some(continuation_token) = &this.continuation_token {
req.url_mut()
.query_pairs_mut()
.append_pair("continuationToken", continuation_token);
}
let req_body = azure_core::Bytes::new();
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?.into()))
}
})
}
fn url(&self) -> azure_core::Result<azure_core::http::Url> {
let mut url = azure_core::http::Url::parse(&format!(
"{}/{}/{}/_apis/testresults/resultgroupsbyrelease",
self.client.endpoint(),
&self.organization,
&self.project
))?;
let has_api_version_already = url.query_pairs().any(|(k, _)| k == "api-version");
if !has_api_version_already {
url.query_pairs_mut()
.append_pair("api-version", "7.1-preview");
}
Ok(url)
}
}
impl std::future::IntoFuture for RequestBuilder {
type Output = azure_core::Result<models::FieldDetailsForTestResultsList>;
type IntoFuture =
BoxFuture<'static, azure_core::Result<models::FieldDetailsForTestResultsList>>;
#[doc = "Returns a future that sends the request and returns the parsed response body."]
#[doc = ""]
#[doc = "You should not normally call this method directly, simply invoke `.await` which implicitly calls `IntoFuture::into_future`."]
#[doc = ""]
#[doc = "See [IntoFuture documentation](https://doc.rust-lang.org/std/future/trait.IntoFuture.html) for more details."]
fn into_future(self) -> Self::IntoFuture {
Box::pin(async move { self.send().await?.into_body() })
}
}
}
}
pub mod results {
use super::models;
#[cfg(not(target_arch = "wasm32"))]
use futures::future::BoxFuture;
#[cfg(target_arch = "wasm32")]
use futures::future::LocalBoxFuture as BoxFuture;
pub struct Client(pub(crate) super::Client);
impl Client {
#[doc = "Arguments:"]
#[doc = "* `organization`: The name of the Azure DevOps organization."]
#[doc = "* `project`: Project ID or project name"]
pub fn get_test_results_by_query(
&self,
organization: impl Into<String>,
body: impl Into<models::TestResultsQuery>,
project: impl Into<String>,
) -> get_test_results_by_query::RequestBuilder {
get_test_results_by_query::RequestBuilder {
client: self.0.clone(),
organization: organization.into(),
body: body.into(),
project: project.into(),
}
}
#[doc = "Arguments:"]
#[doc = "* `organization`: The name of the Azure DevOps organization."]
#[doc = "* `project`: Project ID or project name"]
pub fn get_test_results_by_query_wiql(
&self,
organization: impl Into<String>,
body: impl Into<models::QueryModel>,
project: impl Into<String>,
) -> get_test_results_by_query_wiql::RequestBuilder {
get_test_results_by_query_wiql::RequestBuilder {
client: self.0.clone(),
organization: organization.into(),
body: body.into(),
project: project.into(),
include_result_details: None,
include_iteration_details: None,
skip: None,
top: None,
}
}
#[doc = "Arguments:"]
#[doc = "* `organization`: The name of the Azure DevOps organization."]
#[doc = "* `project`: Project ID or project name"]
pub fn get_test_results(
&self,
organization: impl Into<String>,
project: impl Into<String>,
run_id: i32,
) -> get_test_results::RequestBuilder {
get_test_results::RequestBuilder {
client: self.0.clone(),
organization: organization.into(),
project: project.into(),
run_id,
details_to_include: None,
skip: None,
top: None,
outcomes: None,
new_tests_only: None,
}
}
#[doc = "Arguments:"]
#[doc = "* `organization`: The name of the Azure DevOps organization."]
#[doc = "* `project`: Project ID or project name"]
pub fn add(
&self,
organization: impl Into<String>,
body: Vec<models::TestCaseResult>,
project: impl Into<String>,
run_id: i32,
) -> add::RequestBuilder {
add::RequestBuilder {
client: self.0.clone(),
organization: organization.into(),
body,
project: project.into(),
run_id,
}
}
#[doc = "Arguments:"]
#[doc = "* `organization`: The name of the Azure DevOps organization."]
#[doc = "* `project`: Project ID or project name"]
pub fn update(
&self,
organization: impl Into<String>,
body: Vec<models::TestCaseResult>,
project: impl Into<String>,
run_id: i32,
) -> update::RequestBuilder {
update::RequestBuilder {
client: self.0.clone(),
organization: organization.into(),
body,
project: project.into(),
run_id,
}
}
#[doc = "Arguments:"]
#[doc = "* `organization`: The name of the Azure DevOps organization."]
#[doc = "* `project`: Project ID or project name"]
pub fn get_test_result_by_id(
&self,
organization: impl Into<String>,
project: impl Into<String>,
run_id: i32,
test_result_id: i32,
) -> get_test_result_by_id::RequestBuilder {
get_test_result_by_id::RequestBuilder {
client: self.0.clone(),
organization: organization.into(),
project: project.into(),
run_id,
test_result_id,
details_to_include: None,
}
}
}
pub mod get_test_results_by_query {
use super::models;
#[cfg(not(target_arch = "wasm32"))]
use futures::future::BoxFuture;
#[cfg(target_arch = "wasm32")]
use futures::future::LocalBoxFuture as BoxFuture;
#[derive(Debug)]
pub struct Response(
azure_core::http::Response<models::TestResultsQuery, azure_core::http::JsonFormat>,
);
impl Response {
pub fn into_body(self) -> azure_core::Result<models::TestResultsQuery> {
self.0.into_model()
}
pub fn into_raw_response(self) -> azure_core::http::RawResponse {
self.0.into()
}
}
#[derive(Clone)]
#[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."]
#[doc = r""]
#[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"]
#[doc = r" parameters can be chained."]
#[doc = r""]
#[doc = r" To finalize and submit the request, invoke `.await`, which"]
#[doc = r" converts the [`RequestBuilder`] into a future,"]
#[doc = r" executes the request and returns a `Result` with the parsed"]
#[doc = r" response."]
#[doc = r""]
#[doc = r" If you need lower-level access to the raw response details"]
#[doc = r" (e.g. to inspect response headers or raw body data) then you"]
#[doc = r" can finalize the request using the"]
#[doc = r" [`RequestBuilder::send()`] method which returns a future"]
#[doc = r" that resolves to a lower-level [`Response`] value."]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) organization: String,
pub(crate) body: models::TestResultsQuery,
pub(crate) project: String,
}
impl RequestBuilder {
#[doc = "Returns a future that sends the request and returns a [`Response`] object that provides low-level access to full response details."]
#[doc = ""]
#[doc = "You should typically use `.await` (which implicitly calls `IntoFuture::into_future()`) to finalize and send requests rather than `send()`."]
#[doc = "However, this function can provide more flexibility when required."]
pub fn send(self) -> BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = this.url()?;
let mut req =
azure_core::http::Request::new(url, azure_core::http::Method::Post);
if let Some(auth_header) = this
.client
.token_credential()
.http_authorization_header(&this.client.scopes())
.await?
{
req.insert_header(
azure_core::http::headers::AUTHORIZATION,
auth_header,
);
}
req.insert_header("content-type", "application/json");
let req_body = azure_core::json::to_json(&this.body)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?.into()))
}
})
}
fn url(&self) -> azure_core::Result<azure_core::http::Url> {
let mut url = azure_core::http::Url::parse(&format!(
"{}/{}/{}/_apis/testresults/results",
self.client.endpoint(),
&self.organization,
&self.project
))?;
let has_api_version_already = url.query_pairs().any(|(k, _)| k == "api-version");
if !has_api_version_already {
url.query_pairs_mut()
.append_pair("api-version", "7.1-preview");
}
Ok(url)
}
}
impl std::future::IntoFuture for RequestBuilder {
type Output = azure_core::Result<models::TestResultsQuery>;
type IntoFuture = BoxFuture<'static, azure_core::Result<models::TestResultsQuery>>;
#[doc = "Returns a future that sends the request and returns the parsed response body."]
#[doc = ""]
#[doc = "You should not normally call this method directly, simply invoke `.await` which implicitly calls `IntoFuture::into_future`."]
#[doc = ""]
#[doc = "See [IntoFuture documentation](https://doc.rust-lang.org/std/future/trait.IntoFuture.html) for more details."]
fn into_future(self) -> Self::IntoFuture {
Box::pin(async move { self.send().await?.into_body() })
}
}
}
pub mod get_test_results_by_query_wiql {
use super::models;
#[cfg(not(target_arch = "wasm32"))]
use futures::future::BoxFuture;
#[cfg(target_arch = "wasm32")]
use futures::future::LocalBoxFuture as BoxFuture;
#[derive(Debug)]
pub struct Response(
azure_core::http::Response<models::TestCaseResultList, azure_core::http::JsonFormat>,
);
impl Response {
pub fn into_body(self) -> azure_core::Result<models::TestCaseResultList> {
self.0.into_model()
}
pub fn into_raw_response(self) -> azure_core::http::RawResponse {
self.0.into()
}
}
#[derive(Clone)]
#[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."]
#[doc = r""]
#[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"]
#[doc = r" parameters can be chained."]
#[doc = r""]
#[doc = r" To finalize and submit the request, invoke `.await`, which"]
#[doc = r" converts the [`RequestBuilder`] into a future,"]
#[doc = r" executes the request and returns a `Result` with the parsed"]
#[doc = r" response."]
#[doc = r""]
#[doc = r" If you need lower-level access to the raw response details"]
#[doc = r" (e.g. to inspect response headers or raw body data) then you"]
#[doc = r" can finalize the request using the"]
#[doc = r" [`RequestBuilder::send()`] method which returns a future"]
#[doc = r" that resolves to a lower-level [`Response`] value."]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) organization: String,
pub(crate) body: models::QueryModel,
pub(crate) project: String,
pub(crate) include_result_details: Option<bool>,
pub(crate) include_iteration_details: Option<bool>,
pub(crate) skip: Option<i32>,
pub(crate) top: Option<i32>,
}
impl RequestBuilder {
pub fn include_result_details(mut self, include_result_details: bool) -> Self {
self.include_result_details = Some(include_result_details);
self
}
pub fn include_iteration_details(mut self, include_iteration_details: bool) -> Self {
self.include_iteration_details = Some(include_iteration_details);
self
}
pub fn skip(mut self, skip: i32) -> Self {
self.skip = Some(skip);
self
}
pub fn top(mut self, top: i32) -> Self {
self.top = Some(top);
self
}
#[doc = "Returns a future that sends the request and returns a [`Response`] object that provides low-level access to full response details."]
#[doc = ""]
#[doc = "You should typically use `.await` (which implicitly calls `IntoFuture::into_future()`) to finalize and send requests rather than `send()`."]
#[doc = "However, this function can provide more flexibility when required."]
pub fn send(self) -> BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = this.url()?;
let mut req =
azure_core::http::Request::new(url, azure_core::http::Method::Post);
if let Some(auth_header) = this
.client
.token_credential()
.http_authorization_header(&this.client.scopes())
.await?
{
req.insert_header(
azure_core::http::headers::AUTHORIZATION,
auth_header,
);
}
req.insert_header("content-type", "application/json");
let req_body = azure_core::json::to_json(&this.body)?;
if let Some(include_result_details) = &this.include_result_details {
req.url_mut().query_pairs_mut().append_pair(
"includeResultDetails",
&include_result_details.to_string(),
);
}
if let Some(include_iteration_details) = &this.include_iteration_details {
req.url_mut().query_pairs_mut().append_pair(
"includeIterationDetails",
&include_iteration_details.to_string(),
);
}
if let Some(skip) = &this.skip {
req.url_mut()
.query_pairs_mut()
.append_pair("$skip", &skip.to_string());
}
if let Some(top) = &this.top {
req.url_mut()
.query_pairs_mut()
.append_pair("$top", &top.to_string());
}
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?.into()))
}
})
}
fn url(&self) -> azure_core::Result<azure_core::http::Url> {
let mut url = azure_core::http::Url::parse(&format!(
"{}/{}/{}/_apis/testresults/results/query",
self.client.endpoint(),
&self.organization,
&self.project
))?;
let has_api_version_already = url.query_pairs().any(|(k, _)| k == "api-version");
if !has_api_version_already {
url.query_pairs_mut()
.append_pair("api-version", "7.1-preview");
}
Ok(url)
}
}
impl std::future::IntoFuture for RequestBuilder {
type Output = azure_core::Result<models::TestCaseResultList>;
type IntoFuture = BoxFuture<'static, azure_core::Result<models::TestCaseResultList>>;
#[doc = "Returns a future that sends the request and returns the parsed response body."]
#[doc = ""]
#[doc = "You should not normally call this method directly, simply invoke `.await` which implicitly calls `IntoFuture::into_future`."]
#[doc = ""]
#[doc = "See [IntoFuture documentation](https://doc.rust-lang.org/std/future/trait.IntoFuture.html) for more details."]
fn into_future(self) -> Self::IntoFuture {
Box::pin(async move { self.send().await?.into_body() })
}
}
}
pub mod get_test_results {
use super::models;
#[cfg(not(target_arch = "wasm32"))]
use futures::future::BoxFuture;
#[cfg(target_arch = "wasm32")]
use futures::future::LocalBoxFuture as BoxFuture;
#[derive(Debug)]
pub struct Response(
azure_core::http::Response<models::TestCaseResultList, azure_core::http::JsonFormat>,
);
impl Response {
pub fn into_body(self) -> azure_core::Result<models::TestCaseResultList> {
self.0.into_model()
}
pub fn into_raw_response(self) -> azure_core::http::RawResponse {
self.0.into()
}
}
#[derive(Clone)]
#[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."]
#[doc = r""]
#[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"]
#[doc = r" parameters can be chained."]
#[doc = r""]
#[doc = r" To finalize and submit the request, invoke `.await`, which"]
#[doc = r" converts the [`RequestBuilder`] into a future,"]
#[doc = r" executes the request and returns a `Result` with the parsed"]
#[doc = r" response."]
#[doc = r""]
#[doc = r" If you need lower-level access to the raw response details"]
#[doc = r" (e.g. to inspect response headers or raw body data) then you"]
#[doc = r" can finalize the request using the"]
#[doc = r" [`RequestBuilder::send()`] method which returns a future"]
#[doc = r" that resolves to a lower-level [`Response`] value."]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) organization: String,
pub(crate) project: String,
pub(crate) run_id: i32,
pub(crate) details_to_include: Option<models::ResultDetails>,
pub(crate) skip: Option<i32>,
pub(crate) top: Option<i32>,
pub(crate) outcomes: Option<String>,
pub(crate) new_tests_only: Option<bool>,
}
impl RequestBuilder {
pub fn details_to_include(
mut self,
details_to_include: impl Into<models::ResultDetails>,
) -> Self {
self.details_to_include = Some(details_to_include.into());
self
}
pub fn skip(mut self, skip: i32) -> Self {
self.skip = Some(skip);
self
}
pub fn top(mut self, top: i32) -> Self {
self.top = Some(top);
self
}
pub fn outcomes(mut self, outcomes: impl Into<String>) -> Self {
self.outcomes = Some(outcomes.into());
self
}
pub fn new_tests_only(mut self, new_tests_only: bool) -> Self {
self.new_tests_only = Some(new_tests_only);
self
}
#[doc = "Returns a future that sends the request and returns a [`Response`] object that provides low-level access to full response details."]
#[doc = ""]
#[doc = "You should typically use `.await` (which implicitly calls `IntoFuture::into_future()`) to finalize and send requests rather than `send()`."]
#[doc = "However, this function can provide more flexibility when required."]
pub fn send(self) -> BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = this.url()?;
let mut req =
azure_core::http::Request::new(url, azure_core::http::Method::Get);
if let Some(auth_header) = this
.client
.token_credential()
.http_authorization_header(&this.client.scopes())
.await?
{
req.insert_header(
azure_core::http::headers::AUTHORIZATION,
auth_header,
);
}
if let Some(details_to_include) = &this.details_to_include {
req.url_mut()
.query_pairs_mut()
.append_pair("detailsToInclude", &details_to_include.to_string());
}
if let Some(skip) = &this.skip {
req.url_mut()
.query_pairs_mut()
.append_pair("$skip", &skip.to_string());
}
if let Some(top) = &this.top {
req.url_mut()
.query_pairs_mut()
.append_pair("$top", &top.to_string());
}
if let Some(outcomes) = &this.outcomes {
req.url_mut()
.query_pairs_mut()
.append_pair("outcomes", outcomes);
}
if let Some(new_tests_only) = &this.new_tests_only {
req.url_mut()
.query_pairs_mut()
.append_pair("$newTestsOnly", &new_tests_only.to_string());
}
let req_body = azure_core::Bytes::new();
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?.into()))
}
})
}
fn url(&self) -> azure_core::Result<azure_core::http::Url> {
let mut url = azure_core::http::Url::parse(&format!(
"{}/{}/{}/_apis/testresults/runs/{}/results",
self.client.endpoint(),
&self.organization,
&self.project,
&self.run_id
))?;
let has_api_version_already = url.query_pairs().any(|(k, _)| k == "api-version");
if !has_api_version_already {
url.query_pairs_mut()
.append_pair("api-version", "7.1-preview");
}
Ok(url)
}
}
impl std::future::IntoFuture for RequestBuilder {
type Output = azure_core::Result<models::TestCaseResultList>;
type IntoFuture = BoxFuture<'static, azure_core::Result<models::TestCaseResultList>>;
#[doc = "Returns a future that sends the request and returns the parsed response body."]
#[doc = ""]
#[doc = "You should not normally call this method directly, simply invoke `.await` which implicitly calls `IntoFuture::into_future`."]
#[doc = ""]
#[doc = "See [IntoFuture documentation](https://doc.rust-lang.org/std/future/trait.IntoFuture.html) for more details."]
fn into_future(self) -> Self::IntoFuture {
Box::pin(async move { self.send().await?.into_body() })
}
}
}
pub mod add {
use super::models;
#[cfg(not(target_arch = "wasm32"))]
use futures::future::BoxFuture;
#[cfg(target_arch = "wasm32")]
use futures::future::LocalBoxFuture as BoxFuture;
#[derive(Debug)]
pub struct Response(
azure_core::http::Response<models::TestCaseResultList, azure_core::http::JsonFormat>,
);
impl Response {
pub fn into_body(self) -> azure_core::Result<models::TestCaseResultList> {
self.0.into_model()
}
pub fn into_raw_response(self) -> azure_core::http::RawResponse {
self.0.into()
}
}
#[derive(Clone)]
#[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."]
#[doc = r""]
#[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"]
#[doc = r" parameters can be chained."]
#[doc = r""]
#[doc = r" To finalize and submit the request, invoke `.await`, which"]
#[doc = r" converts the [`RequestBuilder`] into a future,"]
#[doc = r" executes the request and returns a `Result` with the parsed"]
#[doc = r" response."]
#[doc = r""]
#[doc = r" If you need lower-level access to the raw response details"]
#[doc = r" (e.g. to inspect response headers or raw body data) then you"]
#[doc = r" can finalize the request using the"]
#[doc = r" [`RequestBuilder::send()`] method which returns a future"]
#[doc = r" that resolves to a lower-level [`Response`] value."]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) organization: String,
pub(crate) body: Vec<models::TestCaseResult>,
pub(crate) project: String,
pub(crate) run_id: i32,
}
impl RequestBuilder {
#[doc = "Returns a future that sends the request and returns a [`Response`] object that provides low-level access to full response details."]
#[doc = ""]
#[doc = "You should typically use `.await` (which implicitly calls `IntoFuture::into_future()`) to finalize and send requests rather than `send()`."]
#[doc = "However, this function can provide more flexibility when required."]
pub fn send(self) -> BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = this.url()?;
let mut req =
azure_core::http::Request::new(url, azure_core::http::Method::Post);
if let Some(auth_header) = this
.client
.token_credential()
.http_authorization_header(&this.client.scopes())
.await?
{
req.insert_header(
azure_core::http::headers::AUTHORIZATION,
auth_header,
);
}
req.insert_header("content-type", "application/json");
let req_body = azure_core::json::to_json(&this.body)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?.into()))
}
})
}
fn url(&self) -> azure_core::Result<azure_core::http::Url> {
let mut url = azure_core::http::Url::parse(&format!(
"{}/{}/{}/_apis/testresults/runs/{}/results",
self.client.endpoint(),
&self.organization,
&self.project,
&self.run_id
))?;
let has_api_version_already = url.query_pairs().any(|(k, _)| k == "api-version");
if !has_api_version_already {
url.query_pairs_mut()
.append_pair("api-version", "7.1-preview");
}
Ok(url)
}
}
impl std::future::IntoFuture for RequestBuilder {
type Output = azure_core::Result<models::TestCaseResultList>;
type IntoFuture = BoxFuture<'static, azure_core::Result<models::TestCaseResultList>>;
#[doc = "Returns a future that sends the request and returns the parsed response body."]
#[doc = ""]
#[doc = "You should not normally call this method directly, simply invoke `.await` which implicitly calls `IntoFuture::into_future`."]
#[doc = ""]
#[doc = "See [IntoFuture documentation](https://doc.rust-lang.org/std/future/trait.IntoFuture.html) for more details."]
fn into_future(self) -> Self::IntoFuture {
Box::pin(async move { self.send().await?.into_body() })
}
}
}
pub mod update {
use super::models;
#[cfg(not(target_arch = "wasm32"))]
use futures::future::BoxFuture;
#[cfg(target_arch = "wasm32")]
use futures::future::LocalBoxFuture as BoxFuture;
#[derive(Debug)]
pub struct Response(
azure_core::http::Response<models::TestCaseResultList, azure_core::http::JsonFormat>,
);
impl Response {
pub fn into_body(self) -> azure_core::Result<models::TestCaseResultList> {
self.0.into_model()
}
pub fn into_raw_response(self) -> azure_core::http::RawResponse {
self.0.into()
}
}
#[derive(Clone)]
#[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."]
#[doc = r""]
#[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"]
#[doc = r" parameters can be chained."]
#[doc = r""]
#[doc = r" To finalize and submit the request, invoke `.await`, which"]
#[doc = r" converts the [`RequestBuilder`] into a future,"]
#[doc = r" executes the request and returns a `Result` with the parsed"]
#[doc = r" response."]
#[doc = r""]
#[doc = r" If you need lower-level access to the raw response details"]
#[doc = r" (e.g. to inspect response headers or raw body data) then you"]
#[doc = r" can finalize the request using the"]
#[doc = r" [`RequestBuilder::send()`] method which returns a future"]
#[doc = r" that resolves to a lower-level [`Response`] value."]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) organization: String,
pub(crate) body: Vec<models::TestCaseResult>,
pub(crate) project: String,
pub(crate) run_id: i32,
}
impl RequestBuilder {
#[doc = "Returns a future that sends the request and returns a [`Response`] object that provides low-level access to full response details."]
#[doc = ""]
#[doc = "You should typically use `.await` (which implicitly calls `IntoFuture::into_future()`) to finalize and send requests rather than `send()`."]
#[doc = "However, this function can provide more flexibility when required."]
pub fn send(self) -> BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = this.url()?;
let mut req =
azure_core::http::Request::new(url, azure_core::http::Method::Patch);
if let Some(auth_header) = this
.client
.token_credential()
.http_authorization_header(&this.client.scopes())
.await?
{
req.insert_header(
azure_core::http::headers::AUTHORIZATION,
auth_header,
);
}
req.insert_header("content-type", "application/json");
let req_body = azure_core::json::to_json(&this.body)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?.into()))
}
})
}
fn url(&self) -> azure_core::Result<azure_core::http::Url> {
let mut url = azure_core::http::Url::parse(&format!(
"{}/{}/{}/_apis/testresults/runs/{}/results",
self.client.endpoint(),
&self.organization,
&self.project,
&self.run_id
))?;
let has_api_version_already = url.query_pairs().any(|(k, _)| k == "api-version");
if !has_api_version_already {
url.query_pairs_mut()
.append_pair("api-version", "7.1-preview");
}
Ok(url)
}
}
impl std::future::IntoFuture for RequestBuilder {
type Output = azure_core::Result<models::TestCaseResultList>;
type IntoFuture = BoxFuture<'static, azure_core::Result<models::TestCaseResultList>>;
#[doc = "Returns a future that sends the request and returns the parsed response body."]
#[doc = ""]
#[doc = "You should not normally call this method directly, simply invoke `.await` which implicitly calls `IntoFuture::into_future`."]
#[doc = ""]
#[doc = "See [IntoFuture documentation](https://doc.rust-lang.org/std/future/trait.IntoFuture.html) for more details."]
fn into_future(self) -> Self::IntoFuture {
Box::pin(async move { self.send().await?.into_body() })
}
}
}
pub mod get_test_result_by_id {
use super::models;
#[cfg(not(target_arch = "wasm32"))]
use futures::future::BoxFuture;
#[cfg(target_arch = "wasm32")]
use futures::future::LocalBoxFuture as BoxFuture;
#[derive(Debug)]
pub struct Response(
azure_core::http::Response<models::TestCaseResult, azure_core::http::JsonFormat>,
);
impl Response {
pub fn into_body(self) -> azure_core::Result<models::TestCaseResult> {
self.0.into_model()
}
pub fn into_raw_response(self) -> azure_core::http::RawResponse {
self.0.into()
}
}
#[derive(Clone)]
#[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."]
#[doc = r""]
#[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"]
#[doc = r" parameters can be chained."]
#[doc = r""]
#[doc = r" To finalize and submit the request, invoke `.await`, which"]
#[doc = r" converts the [`RequestBuilder`] into a future,"]
#[doc = r" executes the request and returns a `Result` with the parsed"]
#[doc = r" response."]
#[doc = r""]
#[doc = r" If you need lower-level access to the raw response details"]
#[doc = r" (e.g. to inspect response headers or raw body data) then you"]
#[doc = r" can finalize the request using the"]
#[doc = r" [`RequestBuilder::send()`] method which returns a future"]
#[doc = r" that resolves to a lower-level [`Response`] value."]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) organization: String,
pub(crate) project: String,
pub(crate) run_id: i32,
pub(crate) test_result_id: i32,
pub(crate) details_to_include: Option<models::ResultDetails>,
}
impl RequestBuilder {
pub fn details_to_include(
mut self,
details_to_include: impl Into<models::ResultDetails>,
) -> Self {
self.details_to_include = Some(details_to_include.into());
self
}
#[doc = "Returns a future that sends the request and returns a [`Response`] object that provides low-level access to full response details."]
#[doc = ""]
#[doc = "You should typically use `.await` (which implicitly calls `IntoFuture::into_future()`) to finalize and send requests rather than `send()`."]
#[doc = "However, this function can provide more flexibility when required."]
pub fn send(self) -> BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = this.url()?;
let mut req =
azure_core::http::Request::new(url, azure_core::http::Method::Get);
if let Some(auth_header) = this
.client
.token_credential()
.http_authorization_header(&this.client.scopes())
.await?
{
req.insert_header(
azure_core::http::headers::AUTHORIZATION,
auth_header,
);
}
if let Some(details_to_include) = &this.details_to_include {
req.url_mut()
.query_pairs_mut()
.append_pair("detailsToInclude", &details_to_include.to_string());
}
let req_body = azure_core::Bytes::new();
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?.into()))
}
})
}
fn url(&self) -> azure_core::Result<azure_core::http::Url> {
let mut url = azure_core::http::Url::parse(&format!(
"{}/{}/{}/_apis/testresults/runs/{}/results/{}",
self.client.endpoint(),
&self.organization,
&self.project,
&self.run_id,
&self.test_result_id
))?;
let has_api_version_already = url.query_pairs().any(|(k, _)| k == "api-version");
if !has_api_version_already {
url.query_pairs_mut()
.append_pair("api-version", "7.1-preview");
}
Ok(url)
}
}
impl std::future::IntoFuture for RequestBuilder {
type Output = azure_core::Result<models::TestCaseResult>;
type IntoFuture = BoxFuture<'static, azure_core::Result<models::TestCaseResult>>;
#[doc = "Returns a future that sends the request and returns the parsed response body."]
#[doc = ""]
#[doc = "You should not normally call this method directly, simply invoke `.await` which implicitly calls `IntoFuture::into_future`."]
#[doc = ""]
#[doc = "See [IntoFuture documentation](https://doc.rust-lang.org/std/future/trait.IntoFuture.html) for more details."]
fn into_future(self) -> Self::IntoFuture {
Box::pin(async move { self.send().await?.into_body() })
}
}
}
}
pub mod history {
use super::models;
#[cfg(not(target_arch = "wasm32"))]
use futures::future::BoxFuture;
#[cfg(target_arch = "wasm32")]
use futures::future::LocalBoxFuture as BoxFuture;
pub struct Client(pub(crate) super::Client);
impl Client {
#[doc = "Arguments:"]
#[doc = "* `organization`: The name of the Azure DevOps organization."]
#[doc = "* `project`: Project ID or project name"]
pub fn query(
&self,
organization: impl Into<String>,
body: impl Into<models::ResultsFilter>,
project: impl Into<String>,
) -> query::RequestBuilder {
query::RequestBuilder {
client: self.0.clone(),
organization: organization.into(),
body: body.into(),
project: project.into(),
}
}
}
pub mod query {
use super::models;
#[cfg(not(target_arch = "wasm32"))]
use futures::future::BoxFuture;
#[cfg(target_arch = "wasm32")]
use futures::future::LocalBoxFuture as BoxFuture;
#[derive(Debug)]
pub struct Response(
azure_core::http::Response<models::TestResultHistory, azure_core::http::JsonFormat>,
);
impl Response {
pub fn into_body(self) -> azure_core::Result<models::TestResultHistory> {
self.0.into_model()
}
pub fn into_raw_response(self) -> azure_core::http::RawResponse {
self.0.into()
}
}
#[derive(Clone)]
#[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."]
#[doc = r""]
#[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"]
#[doc = r" parameters can be chained."]
#[doc = r""]
#[doc = r" To finalize and submit the request, invoke `.await`, which"]
#[doc = r" converts the [`RequestBuilder`] into a future,"]
#[doc = r" executes the request and returns a `Result` with the parsed"]
#[doc = r" response."]
#[doc = r""]
#[doc = r" If you need lower-level access to the raw response details"]
#[doc = r" (e.g. to inspect response headers or raw body data) then you"]
#[doc = r" can finalize the request using the"]
#[doc = r" [`RequestBuilder::send()`] method which returns a future"]
#[doc = r" that resolves to a lower-level [`Response`] value."]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) organization: String,
pub(crate) body: models::ResultsFilter,
pub(crate) project: String,
}
impl RequestBuilder {
#[doc = "Returns a future that sends the request and returns a [`Response`] object that provides low-level access to full response details."]
#[doc = ""]
#[doc = "You should typically use `.await` (which implicitly calls `IntoFuture::into_future()`) to finalize and send requests rather than `send()`."]
#[doc = "However, this function can provide more flexibility when required."]
pub fn send(self) -> BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = this.url()?;
let mut req =
azure_core::http::Request::new(url, azure_core::http::Method::Post);
if let Some(auth_header) = this
.client
.token_credential()
.http_authorization_header(&this.client.scopes())
.await?
{
req.insert_header(
azure_core::http::headers::AUTHORIZATION,
auth_header,
);
}
req.insert_header("content-type", "application/json");
let req_body = azure_core::json::to_json(&this.body)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?.into()))
}
})
}
fn url(&self) -> azure_core::Result<azure_core::http::Url> {
let mut url = azure_core::http::Url::parse(&format!(
"{}/{}/{}/_apis/testresults/results/history",
self.client.endpoint(),
&self.organization,
&self.project
))?;
let has_api_version_already = url.query_pairs().any(|(k, _)| k == "api-version");
if !has_api_version_already {
url.query_pairs_mut()
.append_pair("api-version", "7.1-preview");
}
Ok(url)
}
}
impl std::future::IntoFuture for RequestBuilder {
type Output = azure_core::Result<models::TestResultHistory>;
type IntoFuture = BoxFuture<'static, azure_core::Result<models::TestResultHistory>>;
#[doc = "Returns a future that sends the request and returns the parsed response body."]
#[doc = ""]
#[doc = "You should not normally call this method directly, simply invoke `.await` which implicitly calls `IntoFuture::into_future`."]
#[doc = ""]
#[doc = "See [IntoFuture documentation](https://doc.rust-lang.org/std/future/trait.IntoFuture.html) for more details."]
fn into_future(self) -> Self::IntoFuture {
Box::pin(async move { self.send().await?.into_body() })
}
}
}
}
pub mod result_meta_data {
use super::models;
#[cfg(not(target_arch = "wasm32"))]
use futures::future::BoxFuture;
#[cfg(target_arch = "wasm32")]
use futures::future::LocalBoxFuture as BoxFuture;
pub struct Client(pub(crate) super::Client);
impl Client {
#[doc = "Get list of test Result meta data details for corresponding testcasereferenceId"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `organization`: The name of the Azure DevOps organization."]
#[doc = "* `body`: TestCaseReference Ids of the test Result to be queried, comma separated list of valid ids (limit no. of ids 200)."]
#[doc = "* `project`: Project ID or project name"]
pub fn query(
&self,
organization: impl Into<String>,
body: Vec<String>,
project: impl Into<String>,
) -> query::RequestBuilder {
query::RequestBuilder {
client: self.0.clone(),
organization: organization.into(),
body,
project: project.into(),
details_to_include: None,
}
}
#[doc = "Update properties of test result meta data"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `organization`: The name of the Azure DevOps organization."]
#[doc = "* `body`: TestResultMetaData update input TestResultMetaDataUpdateInput"]
#[doc = "* `project`: Project ID or project name"]
#[doc = "* `test_case_reference_id`: TestCaseReference Id of Test Result to be updated."]
pub fn update(
&self,
organization: impl Into<String>,
body: impl Into<models::TestResultMetaDataUpdateInput>,
project: impl Into<String>,
test_case_reference_id: i32,
) -> update::RequestBuilder {
update::RequestBuilder {
client: self.0.clone(),
organization: organization.into(),
body: body.into(),
project: project.into(),
test_case_reference_id,
}
}
}
pub mod query {
use super::models;
#[cfg(not(target_arch = "wasm32"))]
use futures::future::BoxFuture;
#[cfg(target_arch = "wasm32")]
use futures::future::LocalBoxFuture as BoxFuture;
#[derive(Debug)]
pub struct Response(
azure_core::http::Response<
models::TestResultMetaDataList,
azure_core::http::JsonFormat,
>,
);
impl Response {
pub fn into_body(self) -> azure_core::Result<models::TestResultMetaDataList> {
self.0.into_model()
}
pub fn into_raw_response(self) -> azure_core::http::RawResponse {
self.0.into()
}
}
#[derive(Clone)]
#[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."]
#[doc = r""]
#[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"]
#[doc = r" parameters can be chained."]
#[doc = r""]
#[doc = r" To finalize and submit the request, invoke `.await`, which"]
#[doc = r" converts the [`RequestBuilder`] into a future,"]
#[doc = r" executes the request and returns a `Result` with the parsed"]
#[doc = r" response."]
#[doc = r""]
#[doc = r" If you need lower-level access to the raw response details"]
#[doc = r" (e.g. to inspect response headers or raw body data) then you"]
#[doc = r" can finalize the request using the"]
#[doc = r" [`RequestBuilder::send()`] method which returns a future"]
#[doc = r" that resolves to a lower-level [`Response`] value."]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) organization: String,
pub(crate) body: Vec<String>,
pub(crate) project: String,
pub(crate) details_to_include: Option<models::ResultMetaDataDetails>,
}
impl RequestBuilder {
#[doc = "Details to include with test results metadata. Default is None. Other values are FlakyIdentifiers."]
pub fn details_to_include(
mut self,
details_to_include: impl Into<models::ResultMetaDataDetails>,
) -> Self {
self.details_to_include = Some(details_to_include.into());
self
}
#[doc = "Returns a future that sends the request and returns a [`Response`] object that provides low-level access to full response details."]
#[doc = ""]
#[doc = "You should typically use `.await` (which implicitly calls `IntoFuture::into_future()`) to finalize and send requests rather than `send()`."]
#[doc = "However, this function can provide more flexibility when required."]
pub fn send(self) -> BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = this.url()?;
let mut req =
azure_core::http::Request::new(url, azure_core::http::Method::Post);
if let Some(auth_header) = this
.client
.token_credential()
.http_authorization_header(&this.client.scopes())
.await?
{
req.insert_header(
azure_core::http::headers::AUTHORIZATION,
auth_header,
);
}
req.insert_header("content-type", "application/json");
let req_body = azure_core::json::to_json(&this.body)?;
if let Some(details_to_include) = &this.details_to_include {
req.url_mut()
.query_pairs_mut()
.append_pair("detailsToInclude", &details_to_include.to_string());
}
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?.into()))
}
})
}
fn url(&self) -> azure_core::Result<azure_core::http::Url> {
let mut url = azure_core::http::Url::parse(&format!(
"{}/{}/{}/_apis/testresults/results/resultmetadata",
self.client.endpoint(),
&self.organization,
&self.project
))?;
let has_api_version_already = url.query_pairs().any(|(k, _)| k == "api-version");
if !has_api_version_already {
url.query_pairs_mut()
.append_pair("api-version", "7.1-preview");
}
Ok(url)
}
}
impl std::future::IntoFuture for RequestBuilder {
type Output = azure_core::Result<models::TestResultMetaDataList>;
type IntoFuture =
BoxFuture<'static, azure_core::Result<models::TestResultMetaDataList>>;
#[doc = "Returns a future that sends the request and returns the parsed response body."]
#[doc = ""]
#[doc = "You should not normally call this method directly, simply invoke `.await` which implicitly calls `IntoFuture::into_future`."]
#[doc = ""]
#[doc = "See [IntoFuture documentation](https://doc.rust-lang.org/std/future/trait.IntoFuture.html) for more details."]
fn into_future(self) -> Self::IntoFuture {
Box::pin(async move { self.send().await?.into_body() })
}
}
}
pub mod update {
use super::models;
#[cfg(not(target_arch = "wasm32"))]
use futures::future::BoxFuture;
#[cfg(target_arch = "wasm32")]
use futures::future::LocalBoxFuture as BoxFuture;
#[derive(Debug)]
pub struct Response(
azure_core::http::Response<models::TestResultMetaData, azure_core::http::JsonFormat>,
);
impl Response {
pub fn into_body(self) -> azure_core::Result<models::TestResultMetaData> {
self.0.into_model()
}
pub fn into_raw_response(self) -> azure_core::http::RawResponse {
self.0.into()
}
}
#[derive(Clone)]
#[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."]
#[doc = r""]
#[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"]
#[doc = r" parameters can be chained."]
#[doc = r""]
#[doc = r" To finalize and submit the request, invoke `.await`, which"]
#[doc = r" converts the [`RequestBuilder`] into a future,"]
#[doc = r" executes the request and returns a `Result` with the parsed"]
#[doc = r" response."]
#[doc = r""]
#[doc = r" If you need lower-level access to the raw response details"]
#[doc = r" (e.g. to inspect response headers or raw body data) then you"]
#[doc = r" can finalize the request using the"]
#[doc = r" [`RequestBuilder::send()`] method which returns a future"]
#[doc = r" that resolves to a lower-level [`Response`] value."]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) organization: String,
pub(crate) body: models::TestResultMetaDataUpdateInput,
pub(crate) project: String,
pub(crate) test_case_reference_id: i32,
}
impl RequestBuilder {
#[doc = "Returns a future that sends the request and returns a [`Response`] object that provides low-level access to full response details."]
#[doc = ""]
#[doc = "You should typically use `.await` (which implicitly calls `IntoFuture::into_future()`) to finalize and send requests rather than `send()`."]
#[doc = "However, this function can provide more flexibility when required."]
pub fn send(self) -> BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = this.url()?;
let mut req =
azure_core::http::Request::new(url, azure_core::http::Method::Patch);
if let Some(auth_header) = this
.client
.token_credential()
.http_authorization_header(&this.client.scopes())
.await?
{
req.insert_header(
azure_core::http::headers::AUTHORIZATION,
auth_header,
);
}
req.insert_header("content-type", "application/json");
let req_body = azure_core::json::to_json(&this.body)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?.into()))
}
})
}
fn url(&self) -> azure_core::Result<azure_core::http::Url> {
let mut url = azure_core::http::Url::parse(&format!(
"{}/{}/{}/_apis/testresults/results/resultmetadata/{}",
self.client.endpoint(),
&self.organization,
&self.project,
&self.test_case_reference_id
))?;
let has_api_version_already = url.query_pairs().any(|(k, _)| k == "api-version");
if !has_api_version_already {
url.query_pairs_mut()
.append_pair("api-version", "7.1-preview");
}
Ok(url)
}
}
impl std::future::IntoFuture for RequestBuilder {
type Output = azure_core::Result<models::TestResultMetaData>;
type IntoFuture = BoxFuture<'static, azure_core::Result<models::TestResultMetaData>>;
#[doc = "Returns a future that sends the request and returns the parsed response body."]
#[doc = ""]
#[doc = "You should not normally call this method directly, simply invoke `.await` which implicitly calls `IntoFuture::into_future`."]
#[doc = ""]
#[doc = "See [IntoFuture documentation](https://doc.rust-lang.org/std/future/trait.IntoFuture.html) for more details."]
fn into_future(self) -> Self::IntoFuture {
Box::pin(async move { self.send().await?.into_body() })
}
}
}
}
pub mod test_history {
use super::models;
#[cfg(not(target_arch = "wasm32"))]
use futures::future::BoxFuture;
#[cfg(target_arch = "wasm32")]
use futures::future::LocalBoxFuture as BoxFuture;
pub struct Client(pub(crate) super::Client);
impl Client {
#[doc = "Get history of a test method using TestHistoryQuery"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `organization`: The name of the Azure DevOps organization."]
#[doc = "* `body`: TestHistoryQuery to get history"]
#[doc = "* `project`: Project ID or project name"]
pub fn query(
&self,
organization: impl Into<String>,
body: impl Into<models::TestHistoryQuery>,
project: impl Into<String>,
) -> query::RequestBuilder {
query::RequestBuilder {
client: self.0.clone(),
organization: organization.into(),
body: body.into(),
project: project.into(),
}
}
}
pub mod query {
use super::models;
#[cfg(not(target_arch = "wasm32"))]
use futures::future::BoxFuture;
#[cfg(target_arch = "wasm32")]
use futures::future::LocalBoxFuture as BoxFuture;
#[derive(Debug)]
pub struct Response(
azure_core::http::Response<models::TestHistoryQuery, azure_core::http::JsonFormat>,
);
impl Response {
pub fn into_body(self) -> azure_core::Result<models::TestHistoryQuery> {
self.0.into_model()
}
pub fn into_raw_response(self) -> azure_core::http::RawResponse {
self.0.into()
}
}
#[derive(Clone)]
#[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."]
#[doc = r""]
#[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"]
#[doc = r" parameters can be chained."]
#[doc = r""]
#[doc = r" To finalize and submit the request, invoke `.await`, which"]
#[doc = r" converts the [`RequestBuilder`] into a future,"]
#[doc = r" executes the request and returns a `Result` with the parsed"]
#[doc = r" response."]
#[doc = r""]
#[doc = r" If you need lower-level access to the raw response details"]
#[doc = r" (e.g. to inspect response headers or raw body data) then you"]
#[doc = r" can finalize the request using the"]
#[doc = r" [`RequestBuilder::send()`] method which returns a future"]
#[doc = r" that resolves to a lower-level [`Response`] value."]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) organization: String,
pub(crate) body: models::TestHistoryQuery,
pub(crate) project: String,
}
impl RequestBuilder {
#[doc = "Returns a future that sends the request and returns a [`Response`] object that provides low-level access to full response details."]
#[doc = ""]
#[doc = "You should typically use `.await` (which implicitly calls `IntoFuture::into_future()`) to finalize and send requests rather than `send()`."]
#[doc = "However, this function can provide more flexibility when required."]
pub fn send(self) -> BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = this.url()?;
let mut req =
azure_core::http::Request::new(url, azure_core::http::Method::Post);
if let Some(auth_header) = this
.client
.token_credential()
.http_authorization_header(&this.client.scopes())
.await?
{
req.insert_header(
azure_core::http::headers::AUTHORIZATION,
auth_header,
);
}
req.insert_header("content-type", "application/json");
let req_body = azure_core::json::to_json(&this.body)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?.into()))
}
})
}
fn url(&self) -> azure_core::Result<azure_core::http::Url> {
let mut url = azure_core::http::Url::parse(&format!(
"{}/{}/{}/_apis/testresults/results/testhistory",
self.client.endpoint(),
&self.organization,
&self.project
))?;
let has_api_version_already = url.query_pairs().any(|(k, _)| k == "api-version");
if !has_api_version_already {
url.query_pairs_mut()
.append_pair("api-version", "7.1-preview");
}
Ok(url)
}
}
impl std::future::IntoFuture for RequestBuilder {
type Output = azure_core::Result<models::TestHistoryQuery>;
type IntoFuture = BoxFuture<'static, azure_core::Result<models::TestHistoryQuery>>;
#[doc = "Returns a future that sends the request and returns the parsed response body."]
#[doc = ""]
#[doc = "You should not normally call this method directly, simply invoke `.await` which implicitly calls `IntoFuture::into_future`."]
#[doc = ""]
#[doc = "See [IntoFuture documentation](https://doc.rust-lang.org/std/future/trait.IntoFuture.html) for more details."]
fn into_future(self) -> Self::IntoFuture {
Box::pin(async move { self.send().await?.into_body() })
}
}
}
}
pub mod resultsbybuild {
use super::models;
#[cfg(not(target_arch = "wasm32"))]
use futures::future::BoxFuture;
#[cfg(target_arch = "wasm32")]
use futures::future::LocalBoxFuture as BoxFuture;
pub struct Client(pub(crate) super::Client);
impl Client {
#[doc = "Arguments:"]
#[doc = "* `organization`: The name of the Azure DevOps organization."]
#[doc = "* `project`: Project ID or project name"]
pub fn list(
&self,
organization: impl Into<String>,
project: impl Into<String>,
build_id: i32,
) -> list::RequestBuilder {
list::RequestBuilder {
client: self.0.clone(),
organization: organization.into(),
project: project.into(),
build_id,
publish_context: None,
outcomes: None,
top: None,
continuation_token: None,
}
}
}
pub mod list {
use super::models;
#[cfg(not(target_arch = "wasm32"))]
use futures::future::BoxFuture;
#[cfg(target_arch = "wasm32")]
use futures::future::LocalBoxFuture as BoxFuture;
#[derive(Debug)]
pub struct Response(
azure_core::http::Response<
models::ShallowTestCaseResultList,
azure_core::http::JsonFormat,
>,
);
impl Response {
pub fn into_body(self) -> azure_core::Result<models::ShallowTestCaseResultList> {
self.0.into_model()
}
pub fn into_raw_response(self) -> azure_core::http::RawResponse {
self.0.into()
}
}
#[derive(Clone)]
#[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."]
#[doc = r""]
#[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"]
#[doc = r" parameters can be chained."]
#[doc = r""]
#[doc = r" To finalize and submit the request, invoke `.await`, which"]
#[doc = r" converts the [`RequestBuilder`] into a future,"]
#[doc = r" executes the request and returns a `Result` with the parsed"]
#[doc = r" response."]
#[doc = r""]
#[doc = r" If you need lower-level access to the raw response details"]
#[doc = r" (e.g. to inspect response headers or raw body data) then you"]
#[doc = r" can finalize the request using the"]
#[doc = r" [`RequestBuilder::send()`] method which returns a future"]
#[doc = r" that resolves to a lower-level [`Response`] value."]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) organization: String,
pub(crate) project: String,
pub(crate) build_id: i32,
pub(crate) publish_context: Option<String>,
pub(crate) outcomes: Option<String>,
pub(crate) top: Option<i32>,
pub(crate) continuation_token: Option<String>,
}
impl RequestBuilder {
pub fn publish_context(mut self, publish_context: impl Into<String>) -> Self {
self.publish_context = Some(publish_context.into());
self
}
pub fn outcomes(mut self, outcomes: impl Into<String>) -> Self {
self.outcomes = Some(outcomes.into());
self
}
pub fn top(mut self, top: i32) -> Self {
self.top = Some(top);
self
}
pub fn continuation_token(mut self, continuation_token: impl Into<String>) -> Self {
self.continuation_token = Some(continuation_token.into());
self
}
#[doc = "Returns a future that sends the request and returns a [`Response`] object that provides low-level access to full response details."]
#[doc = ""]
#[doc = "You should typically use `.await` (which implicitly calls `IntoFuture::into_future()`) to finalize and send requests rather than `send()`."]
#[doc = "However, this function can provide more flexibility when required."]
pub fn send(self) -> BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = this.url()?;
let mut req =
azure_core::http::Request::new(url, azure_core::http::Method::Get);
if let Some(auth_header) = this
.client
.token_credential()
.http_authorization_header(&this.client.scopes())
.await?
{
req.insert_header(
azure_core::http::headers::AUTHORIZATION,
auth_header,
);
}
let build_id = &this.build_id;
req.url_mut()
.query_pairs_mut()
.append_pair("buildId", &build_id.to_string());
if let Some(publish_context) = &this.publish_context {
req.url_mut()
.query_pairs_mut()
.append_pair("publishContext", publish_context);
}
if let Some(outcomes) = &this.outcomes {
req.url_mut()
.query_pairs_mut()
.append_pair("outcomes", outcomes);
}
if let Some(top) = &this.top {
req.url_mut()
.query_pairs_mut()
.append_pair("$top", &top.to_string());
}
if let Some(continuation_token) = &this.continuation_token {
req.url_mut()
.query_pairs_mut()
.append_pair("continuationToken", continuation_token);
}
let req_body = azure_core::Bytes::new();
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?.into()))
}
})
}
fn url(&self) -> azure_core::Result<azure_core::http::Url> {
let mut url = azure_core::http::Url::parse(&format!(
"{}/{}/{}/_apis/testresults/resultsbybuild",
self.client.endpoint(),
&self.organization,
&self.project
))?;
let has_api_version_already = url.query_pairs().any(|(k, _)| k == "api-version");
if !has_api_version_already {
url.query_pairs_mut()
.append_pair("api-version", "7.1-preview");
}
Ok(url)
}
}
impl std::future::IntoFuture for RequestBuilder {
type Output = azure_core::Result<models::ShallowTestCaseResultList>;
type IntoFuture =
BoxFuture<'static, azure_core::Result<models::ShallowTestCaseResultList>>;
#[doc = "Returns a future that sends the request and returns the parsed response body."]
#[doc = ""]
#[doc = "You should not normally call this method directly, simply invoke `.await` which implicitly calls `IntoFuture::into_future`."]
#[doc = ""]
#[doc = "See [IntoFuture documentation](https://doc.rust-lang.org/std/future/trait.IntoFuture.html) for more details."]
fn into_future(self) -> Self::IntoFuture {
Box::pin(async move { self.send().await?.into_body() })
}
}
}
}
pub mod resultsbypipeline {
use super::models;
#[cfg(not(target_arch = "wasm32"))]
use futures::future::BoxFuture;
#[cfg(target_arch = "wasm32")]
use futures::future::LocalBoxFuture as BoxFuture;
pub struct Client(pub(crate) super::Client);
impl Client {
#[doc = "Get a list of results."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `organization`: The name of the Azure DevOps organization."]
#[doc = "* `project`: Project ID or project name"]
#[doc = "* `pipeline_id`: Pipeline Id. This is same as build Id."]
pub fn list(
&self,
organization: impl Into<String>,
project: impl Into<String>,
pipeline_id: i32,
) -> list::RequestBuilder {
list::RequestBuilder {
client: self.0.clone(),
organization: organization.into(),
project: project.into(),
pipeline_id,
stage_name: None,
phase_name: None,
job_name: None,
outcomes: None,
top: None,
continuation_token: None,
}
}
}
pub mod list {
use super::models;
#[cfg(not(target_arch = "wasm32"))]
use futures::future::BoxFuture;
#[cfg(target_arch = "wasm32")]
use futures::future::LocalBoxFuture as BoxFuture;
#[derive(Debug)]
pub struct Response(
azure_core::http::Response<
models::ShallowTestCaseResultList,
azure_core::http::JsonFormat,
>,
);
impl Response {
pub fn into_body(self) -> azure_core::Result<models::ShallowTestCaseResultList> {
self.0.into_model()
}
pub fn into_raw_response(self) -> azure_core::http::RawResponse {
self.0.into()
}
}
#[derive(Clone)]
#[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."]
#[doc = r""]
#[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"]
#[doc = r" parameters can be chained."]
#[doc = r""]
#[doc = r" To finalize and submit the request, invoke `.await`, which"]
#[doc = r" converts the [`RequestBuilder`] into a future,"]
#[doc = r" executes the request and returns a `Result` with the parsed"]
#[doc = r" response."]
#[doc = r""]
#[doc = r" If you need lower-level access to the raw response details"]
#[doc = r" (e.g. to inspect response headers or raw body data) then you"]
#[doc = r" can finalize the request using the"]
#[doc = r" [`RequestBuilder::send()`] method which returns a future"]
#[doc = r" that resolves to a lower-level [`Response`] value."]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) organization: String,
pub(crate) project: String,
pub(crate) pipeline_id: i32,
pub(crate) stage_name: Option<String>,
pub(crate) phase_name: Option<String>,
pub(crate) job_name: Option<String>,
pub(crate) outcomes: Option<String>,
pub(crate) top: Option<i32>,
pub(crate) continuation_token: Option<String>,
}
impl RequestBuilder {
#[doc = "Name of the stage. Maximum supported length for name is 256 character."]
pub fn stage_name(mut self, stage_name: impl Into<String>) -> Self {
self.stage_name = Some(stage_name.into());
self
}
#[doc = "Name of the phase. Maximum supported length for name is 256 character."]
pub fn phase_name(mut self, phase_name: impl Into<String>) -> Self {
self.phase_name = Some(phase_name.into());
self
}
#[doc = "Matrixing in YAML generates copies of a job with different inputs in matrix. JobName is the name of those input. Maximum supported length for name is 256 character."]
pub fn job_name(mut self, job_name: impl Into<String>) -> Self {
self.job_name = Some(job_name.into());
self
}
#[doc = "List of outcome of results"]
pub fn outcomes(mut self, outcomes: impl Into<String>) -> Self {
self.outcomes = Some(outcomes.into());
self
}
#[doc = "Maximum number of results to return"]
pub fn top(mut self, top: i32) -> Self {
self.top = Some(top);
self
}
#[doc = "Header to pass the continuation token"]
pub fn continuation_token(mut self, continuation_token: impl Into<String>) -> Self {
self.continuation_token = Some(continuation_token.into());
self
}
#[doc = "Returns a future that sends the request and returns a [`Response`] object that provides low-level access to full response details."]
#[doc = ""]
#[doc = "You should typically use `.await` (which implicitly calls `IntoFuture::into_future()`) to finalize and send requests rather than `send()`."]
#[doc = "However, this function can provide more flexibility when required."]
pub fn send(self) -> BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = this.url()?;
let mut req =
azure_core::http::Request::new(url, azure_core::http::Method::Get);
if let Some(auth_header) = this
.client
.token_credential()
.http_authorization_header(&this.client.scopes())
.await?
{
req.insert_header(
azure_core::http::headers::AUTHORIZATION,
auth_header,
);
}
let pipeline_id = &this.pipeline_id;
req.url_mut()
.query_pairs_mut()
.append_pair("pipelineId", &pipeline_id.to_string());
if let Some(stage_name) = &this.stage_name {
req.url_mut()
.query_pairs_mut()
.append_pair("stageName", stage_name);
}
if let Some(phase_name) = &this.phase_name {
req.url_mut()
.query_pairs_mut()
.append_pair("phaseName", phase_name);
}
if let Some(job_name) = &this.job_name {
req.url_mut()
.query_pairs_mut()
.append_pair("jobName", job_name);
}
if let Some(outcomes) = &this.outcomes {
req.url_mut()
.query_pairs_mut()
.append_pair("outcomes", outcomes);
}
if let Some(top) = &this.top {
req.url_mut()
.query_pairs_mut()
.append_pair("$top", &top.to_string());
}
if let Some(continuation_token) = &this.continuation_token {
req.insert_header("continuationtoken", continuation_token);
}
let req_body = azure_core::Bytes::new();
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?.into()))
}
})
}
fn url(&self) -> azure_core::Result<azure_core::http::Url> {
let mut url = azure_core::http::Url::parse(&format!(
"{}/{}/{}/_apis/testresults/resultsbypipeline",
self.client.endpoint(),
&self.organization,
&self.project
))?;
let has_api_version_already = url.query_pairs().any(|(k, _)| k == "api-version");
if !has_api_version_already {
url.query_pairs_mut()
.append_pair("api-version", "7.1-preview");
}
Ok(url)
}
}
impl std::future::IntoFuture for RequestBuilder {
type Output = azure_core::Result<models::ShallowTestCaseResultList>;
type IntoFuture =
BoxFuture<'static, azure_core::Result<models::ShallowTestCaseResultList>>;
#[doc = "Returns a future that sends the request and returns the parsed response body."]
#[doc = ""]
#[doc = "You should not normally call this method directly, simply invoke `.await` which implicitly calls `IntoFuture::into_future`."]
#[doc = ""]
#[doc = "See [IntoFuture documentation](https://doc.rust-lang.org/std/future/trait.IntoFuture.html) for more details."]
fn into_future(self) -> Self::IntoFuture {
Box::pin(async move { self.send().await?.into_body() })
}
}
}
}
pub mod resultsbyrelease {
use super::models;
#[cfg(not(target_arch = "wasm32"))]
use futures::future::BoxFuture;
#[cfg(target_arch = "wasm32")]
use futures::future::LocalBoxFuture as BoxFuture;
pub struct Client(pub(crate) super::Client);
impl Client {
#[doc = "Arguments:"]
#[doc = "* `organization`: The name of the Azure DevOps organization."]
#[doc = "* `project`: Project ID or project name"]
pub fn list(
&self,
organization: impl Into<String>,
project: impl Into<String>,
release_id: i32,
) -> list::RequestBuilder {
list::RequestBuilder {
client: self.0.clone(),
organization: organization.into(),
project: project.into(),
release_id,
release_envid: None,
publish_context: None,
outcomes: None,
top: None,
continuation_token: None,
}
}
}
pub mod list {
use super::models;
#[cfg(not(target_arch = "wasm32"))]
use futures::future::BoxFuture;
#[cfg(target_arch = "wasm32")]
use futures::future::LocalBoxFuture as BoxFuture;
#[derive(Debug)]
pub struct Response(
azure_core::http::Response<
models::ShallowTestCaseResultList,
azure_core::http::JsonFormat,
>,
);
impl Response {
pub fn into_body(self) -> azure_core::Result<models::ShallowTestCaseResultList> {
self.0.into_model()
}
pub fn into_raw_response(self) -> azure_core::http::RawResponse {
self.0.into()
}
}
#[derive(Clone)]
#[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."]
#[doc = r""]
#[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"]
#[doc = r" parameters can be chained."]
#[doc = r""]
#[doc = r" To finalize and submit the request, invoke `.await`, which"]
#[doc = r" converts the [`RequestBuilder`] into a future,"]
#[doc = r" executes the request and returns a `Result` with the parsed"]
#[doc = r" response."]
#[doc = r""]
#[doc = r" If you need lower-level access to the raw response details"]
#[doc = r" (e.g. to inspect response headers or raw body data) then you"]
#[doc = r" can finalize the request using the"]
#[doc = r" [`RequestBuilder::send()`] method which returns a future"]
#[doc = r" that resolves to a lower-level [`Response`] value."]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) organization: String,
pub(crate) project: String,
pub(crate) release_id: i32,
pub(crate) release_envid: Option<i32>,
pub(crate) publish_context: Option<String>,
pub(crate) outcomes: Option<String>,
pub(crate) top: Option<i32>,
pub(crate) continuation_token: Option<String>,
}
impl RequestBuilder {
pub fn release_envid(mut self, release_envid: i32) -> Self {
self.release_envid = Some(release_envid);
self
}
pub fn publish_context(mut self, publish_context: impl Into<String>) -> Self {
self.publish_context = Some(publish_context.into());
self
}
pub fn outcomes(mut self, outcomes: impl Into<String>) -> Self {
self.outcomes = Some(outcomes.into());
self
}
pub fn top(mut self, top: i32) -> Self {
self.top = Some(top);
self
}
pub fn continuation_token(mut self, continuation_token: impl Into<String>) -> Self {
self.continuation_token = Some(continuation_token.into());
self
}
#[doc = "Returns a future that sends the request and returns a [`Response`] object that provides low-level access to full response details."]
#[doc = ""]
#[doc = "You should typically use `.await` (which implicitly calls `IntoFuture::into_future()`) to finalize and send requests rather than `send()`."]
#[doc = "However, this function can provide more flexibility when required."]
pub fn send(self) -> BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = this.url()?;
let mut req =
azure_core::http::Request::new(url, azure_core::http::Method::Get);
if let Some(auth_header) = this
.client
.token_credential()
.http_authorization_header(&this.client.scopes())
.await?
{
req.insert_header(
azure_core::http::headers::AUTHORIZATION,
auth_header,
);
}
let release_id = &this.release_id;
req.url_mut()
.query_pairs_mut()
.append_pair("releaseId", &release_id.to_string());
if let Some(release_envid) = &this.release_envid {
req.url_mut()
.query_pairs_mut()
.append_pair("releaseEnvid", &release_envid.to_string());
}
if let Some(publish_context) = &this.publish_context {
req.url_mut()
.query_pairs_mut()
.append_pair("publishContext", publish_context);
}
if let Some(outcomes) = &this.outcomes {
req.url_mut()
.query_pairs_mut()
.append_pair("outcomes", outcomes);
}
if let Some(top) = &this.top {
req.url_mut()
.query_pairs_mut()
.append_pair("$top", &top.to_string());
}
if let Some(continuation_token) = &this.continuation_token {
req.url_mut()
.query_pairs_mut()
.append_pair("continuationToken", continuation_token);
}
let req_body = azure_core::Bytes::new();
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?.into()))
}
})
}
fn url(&self) -> azure_core::Result<azure_core::http::Url> {
let mut url = azure_core::http::Url::parse(&format!(
"{}/{}/{}/_apis/testresults/resultsbyrelease",
self.client.endpoint(),
&self.organization,
&self.project
))?;
let has_api_version_already = url.query_pairs().any(|(k, _)| k == "api-version");
if !has_api_version_already {
url.query_pairs_mut()
.append_pair("api-version", "7.1-preview");
}
Ok(url)
}
}
impl std::future::IntoFuture for RequestBuilder {
type Output = azure_core::Result<models::ShallowTestCaseResultList>;
type IntoFuture =
BoxFuture<'static, azure_core::Result<models::ShallowTestCaseResultList>>;
#[doc = "Returns a future that sends the request and returns the parsed response body."]
#[doc = ""]
#[doc = "You should not normally call this method directly, simply invoke `.await` which implicitly calls `IntoFuture::into_future`."]
#[doc = ""]
#[doc = "See [IntoFuture documentation](https://doc.rust-lang.org/std/future/trait.IntoFuture.html) for more details."]
fn into_future(self) -> Self::IntoFuture {
Box::pin(async move { self.send().await?.into_body() })
}
}
}
}
pub mod resultsgroup_details {
use super::models;
#[cfg(not(target_arch = "wasm32"))]
use futures::future::BoxFuture;
#[cfg(target_arch = "wasm32")]
use futures::future::LocalBoxFuture as BoxFuture;
pub struct Client(pub(crate) super::Client);
impl Client {
#[doc = "Get all the available groups details and for these groups get failed and aborted results."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `organization`: The name of the Azure DevOps organization."]
#[doc = "* `project`: Project ID or project name"]
#[doc = "* `pipeline_id`: Pipeline Id. This is same as build Id."]
pub fn test_results_group_details(
&self,
organization: impl Into<String>,
project: impl Into<String>,
pipeline_id: i32,
) -> test_results_group_details::RequestBuilder {
test_results_group_details::RequestBuilder {
client: self.0.clone(),
organization: organization.into(),
project: project.into(),
pipeline_id,
stage_name: None,
phase_name: None,
job_name: None,
should_include_failed_and_aborted_results: None,
query_group_summary_for_in_progress: None,
}
}
}
pub mod test_results_group_details {
use super::models;
#[cfg(not(target_arch = "wasm32"))]
use futures::future::BoxFuture;
#[cfg(target_arch = "wasm32")]
use futures::future::LocalBoxFuture as BoxFuture;
#[derive(Debug)]
pub struct Response(
azure_core::http::Response<models::TestResultsDetails, azure_core::http::JsonFormat>,
);
impl Response {
pub fn into_body(self) -> azure_core::Result<models::TestResultsDetails> {
self.0.into_model()
}
pub fn into_raw_response(self) -> azure_core::http::RawResponse {
self.0.into()
}
}
#[derive(Clone)]
#[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."]
#[doc = r""]
#[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"]
#[doc = r" parameters can be chained."]
#[doc = r""]
#[doc = r" To finalize and submit the request, invoke `.await`, which"]
#[doc = r" converts the [`RequestBuilder`] into a future,"]
#[doc = r" executes the request and returns a `Result` with the parsed"]
#[doc = r" response."]
#[doc = r""]
#[doc = r" If you need lower-level access to the raw response details"]
#[doc = r" (e.g. to inspect response headers or raw body data) then you"]
#[doc = r" can finalize the request using the"]
#[doc = r" [`RequestBuilder::send()`] method which returns a future"]
#[doc = r" that resolves to a lower-level [`Response`] value."]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) organization: String,
pub(crate) project: String,
pub(crate) pipeline_id: i32,
pub(crate) stage_name: Option<String>,
pub(crate) phase_name: Option<String>,
pub(crate) job_name: Option<String>,
pub(crate) should_include_failed_and_aborted_results: Option<bool>,
pub(crate) query_group_summary_for_in_progress: Option<bool>,
}
impl RequestBuilder {
#[doc = "Name of the stage. Maximum supported length for name is 256 character."]
pub fn stage_name(mut self, stage_name: impl Into<String>) -> Self {
self.stage_name = Some(stage_name.into());
self
}
#[doc = "Name of the phase. Maximum supported length for name is 256 character."]
pub fn phase_name(mut self, phase_name: impl Into<String>) -> Self {
self.phase_name = Some(phase_name.into());
self
}
#[doc = "Matrixing in YAML generates copies of a job with different inputs in matrix. JobName is the name of those input. Maximum supported length for name is 256 character."]
pub fn job_name(mut self, job_name: impl Into<String>) -> Self {
self.job_name = Some(job_name.into());
self
}
#[doc = "If true, it will return Ids of failed and aborted results for each test group"]
pub fn should_include_failed_and_aborted_results(
mut self,
should_include_failed_and_aborted_results: bool,
) -> Self {
self.should_include_failed_and_aborted_results =
Some(should_include_failed_and_aborted_results);
self
}
#[doc = "If true, it will calculate summary for InProgress runs as well."]
pub fn query_group_summary_for_in_progress(
mut self,
query_group_summary_for_in_progress: bool,
) -> Self {
self.query_group_summary_for_in_progress =
Some(query_group_summary_for_in_progress);
self
}
#[doc = "Returns a future that sends the request and returns a [`Response`] object that provides low-level access to full response details."]
#[doc = ""]
#[doc = "You should typically use `.await` (which implicitly calls `IntoFuture::into_future()`) to finalize and send requests rather than `send()`."]
#[doc = "However, this function can provide more flexibility when required."]
pub fn send(self) -> BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = this.url()?;
let mut req =
azure_core::http::Request::new(url, azure_core::http::Method::Get);
if let Some(auth_header) = this
.client
.token_credential()
.http_authorization_header(&this.client.scopes())
.await?
{
req.insert_header(
azure_core::http::headers::AUTHORIZATION,
auth_header,
);
}
let pipeline_id = &this.pipeline_id;
req.url_mut()
.query_pairs_mut()
.append_pair("pipelineId", &pipeline_id.to_string());
if let Some(stage_name) = &this.stage_name {
req.url_mut()
.query_pairs_mut()
.append_pair("stageName", stage_name);
}
if let Some(phase_name) = &this.phase_name {
req.url_mut()
.query_pairs_mut()
.append_pair("phaseName", phase_name);
}
if let Some(job_name) = &this.job_name {
req.url_mut()
.query_pairs_mut()
.append_pair("jobName", job_name);
}
if let Some(should_include_failed_and_aborted_results) =
&this.should_include_failed_and_aborted_results
{
req.url_mut().query_pairs_mut().append_pair(
"shouldIncludeFailedAndAbortedResults",
&should_include_failed_and_aborted_results.to_string(),
);
}
if let Some(query_group_summary_for_in_progress) =
&this.query_group_summary_for_in_progress
{
req.url_mut().query_pairs_mut().append_pair(
"queryGroupSummaryForInProgress",
&query_group_summary_for_in_progress.to_string(),
);
}
let req_body = azure_core::Bytes::new();
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?.into()))
}
})
}
fn url(&self) -> azure_core::Result<azure_core::http::Url> {
let mut url = azure_core::http::Url::parse(&format!(
"{}/{}/{}/_apis/testresults/resultsgroupdetails",
self.client.endpoint(),
&self.organization,
&self.project
))?;
let has_api_version_already = url.query_pairs().any(|(k, _)| k == "api-version");
if !has_api_version_already {
url.query_pairs_mut()
.append_pair("api-version", "7.1-preview");
}
Ok(url)
}
}
impl std::future::IntoFuture for RequestBuilder {
type Output = azure_core::Result<models::TestResultsDetails>;
type IntoFuture = BoxFuture<'static, azure_core::Result<models::TestResultsDetails>>;
#[doc = "Returns a future that sends the request and returns the parsed response body."]
#[doc = ""]
#[doc = "You should not normally call this method directly, simply invoke `.await` which implicitly calls `IntoFuture::into_future`."]
#[doc = ""]
#[doc = "See [IntoFuture documentation](https://doc.rust-lang.org/std/future/trait.IntoFuture.html) for more details."]
fn into_future(self) -> Self::IntoFuture {
Box::pin(async move { self.send().await?.into_body() })
}
}
}
}
pub mod resultsummarybybuild {
use super::models;
#[cfg(not(target_arch = "wasm32"))]
use futures::future::BoxFuture;
#[cfg(target_arch = "wasm32")]
use futures::future::LocalBoxFuture as BoxFuture;
pub struct Client(pub(crate) super::Client);
impl Client {
#[doc = "Arguments:"]
#[doc = "* `organization`: The name of the Azure DevOps organization."]
#[doc = "* `project`: Project ID or project name"]
pub fn query(
&self,
organization: impl Into<String>,
project: impl Into<String>,
build_id: i32,
) -> query::RequestBuilder {
query::RequestBuilder {
client: self.0.clone(),
organization: organization.into(),
project: project.into(),
build_id,
publish_context: None,
include_failure_details: None,
build_to_compare_branch_name: None,
build_to_compare_build_system: None,
build_to_compare_definition_id: None,
build_to_compare_id: None,
build_to_compare_number: None,
build_to_compare_repository_id: None,
build_to_compare_uri: None,
}
}
}
pub mod query {
use super::models;
#[cfg(not(target_arch = "wasm32"))]
use futures::future::BoxFuture;
#[cfg(target_arch = "wasm32")]
use futures::future::LocalBoxFuture as BoxFuture;
#[derive(Debug)]
pub struct Response(
azure_core::http::Response<models::TestResultSummary, azure_core::http::JsonFormat>,
);
impl Response {
pub fn into_body(self) -> azure_core::Result<models::TestResultSummary> {
self.0.into_model()
}
pub fn into_raw_response(self) -> azure_core::http::RawResponse {
self.0.into()
}
}
#[derive(Clone)]
#[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."]
#[doc = r""]
#[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"]
#[doc = r" parameters can be chained."]
#[doc = r""]
#[doc = r" To finalize and submit the request, invoke `.await`, which"]
#[doc = r" converts the [`RequestBuilder`] into a future,"]
#[doc = r" executes the request and returns a `Result` with the parsed"]
#[doc = r" response."]
#[doc = r""]
#[doc = r" If you need lower-level access to the raw response details"]
#[doc = r" (e.g. to inspect response headers or raw body data) then you"]
#[doc = r" can finalize the request using the"]
#[doc = r" [`RequestBuilder::send()`] method which returns a future"]
#[doc = r" that resolves to a lower-level [`Response`] value."]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) organization: String,
pub(crate) project: String,
pub(crate) build_id: i32,
pub(crate) publish_context: Option<String>,
pub(crate) include_failure_details: Option<bool>,
pub(crate) build_to_compare_branch_name: Option<String>,
pub(crate) build_to_compare_build_system: Option<String>,
pub(crate) build_to_compare_definition_id: Option<i32>,
pub(crate) build_to_compare_id: Option<i32>,
pub(crate) build_to_compare_number: Option<String>,
pub(crate) build_to_compare_repository_id: Option<String>,
pub(crate) build_to_compare_uri: Option<String>,
}
impl RequestBuilder {
pub fn publish_context(mut self, publish_context: impl Into<String>) -> Self {
self.publish_context = Some(publish_context.into());
self
}
pub fn include_failure_details(mut self, include_failure_details: bool) -> Self {
self.include_failure_details = Some(include_failure_details);
self
}
#[doc = "Branch name."]
pub fn build_to_compare_branch_name(
mut self,
build_to_compare_branch_name: impl Into<String>,
) -> Self {
self.build_to_compare_branch_name = Some(build_to_compare_branch_name.into());
self
}
#[doc = "Build system."]
pub fn build_to_compare_build_system(
mut self,
build_to_compare_build_system: impl Into<String>,
) -> Self {
self.build_to_compare_build_system = Some(build_to_compare_build_system.into());
self
}
#[doc = "Build Definition ID."]
pub fn build_to_compare_definition_id(
mut self,
build_to_compare_definition_id: i32,
) -> Self {
self.build_to_compare_definition_id = Some(build_to_compare_definition_id);
self
}
#[doc = "Build ID."]
pub fn build_to_compare_id(mut self, build_to_compare_id: i32) -> Self {
self.build_to_compare_id = Some(build_to_compare_id);
self
}
#[doc = "Build Number."]
pub fn build_to_compare_number(
mut self,
build_to_compare_number: impl Into<String>,
) -> Self {
self.build_to_compare_number = Some(build_to_compare_number.into());
self
}
#[doc = "Repository ID."]
pub fn build_to_compare_repository_id(
mut self,
build_to_compare_repository_id: impl Into<String>,
) -> Self {
self.build_to_compare_repository_id = Some(build_to_compare_repository_id.into());
self
}
#[doc = "Build URI."]
pub fn build_to_compare_uri(mut self, build_to_compare_uri: impl Into<String>) -> Self {
self.build_to_compare_uri = Some(build_to_compare_uri.into());
self
}
#[doc = "Returns a future that sends the request and returns a [`Response`] object that provides low-level access to full response details."]
#[doc = ""]
#[doc = "You should typically use `.await` (which implicitly calls `IntoFuture::into_future()`) to finalize and send requests rather than `send()`."]
#[doc = "However, this function can provide more flexibility when required."]
pub fn send(self) -> BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = this.url()?;
let mut req =
azure_core::http::Request::new(url, azure_core::http::Method::Get);
if let Some(auth_header) = this
.client
.token_credential()
.http_authorization_header(&this.client.scopes())
.await?
{
req.insert_header(
azure_core::http::headers::AUTHORIZATION,
auth_header,
);
}
let build_id = &this.build_id;
req.url_mut()
.query_pairs_mut()
.append_pair("buildId", &build_id.to_string());
if let Some(publish_context) = &this.publish_context {
req.url_mut()
.query_pairs_mut()
.append_pair("publishContext", publish_context);
}
if let Some(include_failure_details) = &this.include_failure_details {
req.url_mut().query_pairs_mut().append_pair(
"includeFailureDetails",
&include_failure_details.to_string(),
);
}
if let Some(build_to_compare_branch_name) =
&this.build_to_compare_branch_name
{
req.url_mut().query_pairs_mut().append_pair(
"buildToCompare.branchName",
build_to_compare_branch_name,
);
}
if let Some(build_to_compare_build_system) =
&this.build_to_compare_build_system
{
req.url_mut().query_pairs_mut().append_pair(
"buildToCompare.buildSystem",
build_to_compare_build_system,
);
}
if let Some(build_to_compare_definition_id) =
&this.build_to_compare_definition_id
{
req.url_mut().query_pairs_mut().append_pair(
"buildToCompare.definitionId",
&build_to_compare_definition_id.to_string(),
);
}
if let Some(build_to_compare_id) = &this.build_to_compare_id {
req.url_mut()
.query_pairs_mut()
.append_pair("buildToCompare.id", &build_to_compare_id.to_string());
}
if let Some(build_to_compare_number) = &this.build_to_compare_number {
req.url_mut()
.query_pairs_mut()
.append_pair("buildToCompare.number", build_to_compare_number);
}
if let Some(build_to_compare_repository_id) =
&this.build_to_compare_repository_id
{
req.url_mut().query_pairs_mut().append_pair(
"buildToCompare.repositoryId",
build_to_compare_repository_id,
);
}
if let Some(build_to_compare_uri) = &this.build_to_compare_uri {
req.url_mut()
.query_pairs_mut()
.append_pair("buildToCompare.uri", build_to_compare_uri);
}
let req_body = azure_core::Bytes::new();
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?.into()))
}
})
}
fn url(&self) -> azure_core::Result<azure_core::http::Url> {
let mut url = azure_core::http::Url::parse(&format!(
"{}/{}/{}/_apis/testresults/resultsummarybybuild",
self.client.endpoint(),
&self.organization,
&self.project
))?;
let has_api_version_already = url.query_pairs().any(|(k, _)| k == "api-version");
if !has_api_version_already {
url.query_pairs_mut()
.append_pair("api-version", "7.1-preview");
}
Ok(url)
}
}
impl std::future::IntoFuture for RequestBuilder {
type Output = azure_core::Result<models::TestResultSummary>;
type IntoFuture = BoxFuture<'static, azure_core::Result<models::TestResultSummary>>;
#[doc = "Returns a future that sends the request and returns the parsed response body."]
#[doc = ""]
#[doc = "You should not normally call this method directly, simply invoke `.await` which implicitly calls `IntoFuture::into_future`."]
#[doc = ""]
#[doc = "See [IntoFuture documentation](https://doc.rust-lang.org/std/future/trait.IntoFuture.html) for more details."]
fn into_future(self) -> Self::IntoFuture {
Box::pin(async move { self.send().await?.into_body() })
}
}
}
}
pub mod resultsummarybypipeline {
use super::models;
#[cfg(not(target_arch = "wasm32"))]
use futures::future::BoxFuture;
#[cfg(target_arch = "wasm32")]
use futures::future::LocalBoxFuture as BoxFuture;
pub struct Client(pub(crate) super::Client);
impl Client {
#[doc = "Get summary of test results."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `organization`: The name of the Azure DevOps organization."]
#[doc = "* `project`: Project ID or project name"]
#[doc = "* `pipeline_id`: Pipeline Id. This is same as build Id."]
pub fn query(
&self,
organization: impl Into<String>,
project: impl Into<String>,
pipeline_id: i32,
) -> query::RequestBuilder {
query::RequestBuilder {
client: self.0.clone(),
organization: organization.into(),
project: project.into(),
pipeline_id,
stage_name: None,
phase_name: None,
job_name: None,
include_failure_details: None,
}
}
}
pub mod query {
use super::models;
#[cfg(not(target_arch = "wasm32"))]
use futures::future::BoxFuture;
#[cfg(target_arch = "wasm32")]
use futures::future::LocalBoxFuture as BoxFuture;
#[derive(Debug)]
pub struct Response(
azure_core::http::Response<models::TestResultSummary, azure_core::http::JsonFormat>,
);
impl Response {
pub fn into_body(self) -> azure_core::Result<models::TestResultSummary> {
self.0.into_model()
}
pub fn into_raw_response(self) -> azure_core::http::RawResponse {
self.0.into()
}
}
#[derive(Clone)]
#[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."]
#[doc = r""]
#[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"]
#[doc = r" parameters can be chained."]
#[doc = r""]
#[doc = r" To finalize and submit the request, invoke `.await`, which"]
#[doc = r" converts the [`RequestBuilder`] into a future,"]
#[doc = r" executes the request and returns a `Result` with the parsed"]
#[doc = r" response."]
#[doc = r""]
#[doc = r" If you need lower-level access to the raw response details"]
#[doc = r" (e.g. to inspect response headers or raw body data) then you"]
#[doc = r" can finalize the request using the"]
#[doc = r" [`RequestBuilder::send()`] method which returns a future"]
#[doc = r" that resolves to a lower-level [`Response`] value."]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) organization: String,
pub(crate) project: String,
pub(crate) pipeline_id: i32,
pub(crate) stage_name: Option<String>,
pub(crate) phase_name: Option<String>,
pub(crate) job_name: Option<String>,
pub(crate) include_failure_details: Option<bool>,
}
impl RequestBuilder {
#[doc = "Name of the stage. Maximum supported length for name is 256 character."]
pub fn stage_name(mut self, stage_name: impl Into<String>) -> Self {
self.stage_name = Some(stage_name.into());
self
}
#[doc = "Name of the phase. Maximum supported length for name is 256 character."]
pub fn phase_name(mut self, phase_name: impl Into<String>) -> Self {
self.phase_name = Some(phase_name.into());
self
}
#[doc = "Matrixing in YAML generates copies of a job with different inputs in matrix. JobName is the name of those input. Maximum supported length for name is 256 character."]
pub fn job_name(mut self, job_name: impl Into<String>) -> Self {
self.job_name = Some(job_name.into());
self
}
#[doc = "If true returns failure insights"]
pub fn include_failure_details(mut self, include_failure_details: bool) -> Self {
self.include_failure_details = Some(include_failure_details);
self
}
#[doc = "Returns a future that sends the request and returns a [`Response`] object that provides low-level access to full response details."]
#[doc = ""]
#[doc = "You should typically use `.await` (which implicitly calls `IntoFuture::into_future()`) to finalize and send requests rather than `send()`."]
#[doc = "However, this function can provide more flexibility when required."]
pub fn send(self) -> BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = this.url()?;
let mut req =
azure_core::http::Request::new(url, azure_core::http::Method::Get);
if let Some(auth_header) = this
.client
.token_credential()
.http_authorization_header(&this.client.scopes())
.await?
{
req.insert_header(
azure_core::http::headers::AUTHORIZATION,
auth_header,
);
}
let pipeline_id = &this.pipeline_id;
req.url_mut()
.query_pairs_mut()
.append_pair("pipelineId", &pipeline_id.to_string());
if let Some(stage_name) = &this.stage_name {
req.url_mut()
.query_pairs_mut()
.append_pair("stageName", stage_name);
}
if let Some(phase_name) = &this.phase_name {
req.url_mut()
.query_pairs_mut()
.append_pair("phaseName", phase_name);
}
if let Some(job_name) = &this.job_name {
req.url_mut()
.query_pairs_mut()
.append_pair("jobName", job_name);
}
if let Some(include_failure_details) = &this.include_failure_details {
req.url_mut().query_pairs_mut().append_pair(
"includeFailureDetails",
&include_failure_details.to_string(),
);
}
let req_body = azure_core::Bytes::new();
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?.into()))
}
})
}
fn url(&self) -> azure_core::Result<azure_core::http::Url> {
let mut url = azure_core::http::Url::parse(&format!(
"{}/{}/{}/_apis/testresults/resultsummarybypipeline",
self.client.endpoint(),
&self.organization,
&self.project
))?;
let has_api_version_already = url.query_pairs().any(|(k, _)| k == "api-version");
if !has_api_version_already {
url.query_pairs_mut()
.append_pair("api-version", "7.1-preview");
}
Ok(url)
}
}
impl std::future::IntoFuture for RequestBuilder {
type Output = azure_core::Result<models::TestResultSummary>;
type IntoFuture = BoxFuture<'static, azure_core::Result<models::TestResultSummary>>;
#[doc = "Returns a future that sends the request and returns the parsed response body."]
#[doc = ""]
#[doc = "You should not normally call this method directly, simply invoke `.await` which implicitly calls `IntoFuture::into_future`."]
#[doc = ""]
#[doc = "See [IntoFuture documentation](https://doc.rust-lang.org/std/future/trait.IntoFuture.html) for more details."]
fn into_future(self) -> Self::IntoFuture {
Box::pin(async move { self.send().await?.into_body() })
}
}
}
}
pub mod resultsummarybyrelease {
use super::models;
#[cfg(not(target_arch = "wasm32"))]
use futures::future::BoxFuture;
#[cfg(target_arch = "wasm32")]
use futures::future::LocalBoxFuture as BoxFuture;
pub struct Client(pub(crate) super::Client);
impl Client {
#[doc = "Arguments:"]
#[doc = "* `organization`: The name of the Azure DevOps organization."]
#[doc = "* `project`: Project ID or project name"]
pub fn query_test_results_report_for_release(
&self,
organization: impl Into<String>,
project: impl Into<String>,
release_id: i32,
release_env_id: i32,
) -> query_test_results_report_for_release::RequestBuilder {
query_test_results_report_for_release::RequestBuilder {
client: self.0.clone(),
organization: organization.into(),
project: project.into(),
release_id,
release_env_id,
publish_context: None,
include_failure_details: None,
release_to_compare_attempt: None,
release_to_compare_creation_date: None,
release_to_compare_definition_id: None,
release_to_compare_environment_creation_date: None,
release_to_compare_environment_definition_id: None,
release_to_compare_environment_definition_name: None,
release_to_compare_environment_id: None,
release_to_compare_environment_name: None,
release_to_compare_id: None,
release_to_compare_name: None,
}
}
#[doc = "Arguments:"]
#[doc = "* `organization`: The name of the Azure DevOps organization."]
#[doc = "* `project`: Project ID or project name"]
pub fn query_test_results_summary_for_releases(
&self,
organization: impl Into<String>,
body: Vec<models::ReleaseReference>,
project: impl Into<String>,
) -> query_test_results_summary_for_releases::RequestBuilder {
query_test_results_summary_for_releases::RequestBuilder {
client: self.0.clone(),
organization: organization.into(),
body,
project: project.into(),
}
}
}
pub mod query_test_results_report_for_release {
use super::models;
#[cfg(not(target_arch = "wasm32"))]
use futures::future::BoxFuture;
#[cfg(target_arch = "wasm32")]
use futures::future::LocalBoxFuture as BoxFuture;
#[derive(Debug)]
pub struct Response(
azure_core::http::Response<models::TestResultSummary, azure_core::http::JsonFormat>,
);
impl Response {
pub fn into_body(self) -> azure_core::Result<models::TestResultSummary> {
self.0.into_model()
}
pub fn into_raw_response(self) -> azure_core::http::RawResponse {
self.0.into()
}
}
#[derive(Clone)]
#[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."]
#[doc = r""]
#[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"]
#[doc = r" parameters can be chained."]
#[doc = r""]
#[doc = r" To finalize and submit the request, invoke `.await`, which"]
#[doc = r" converts the [`RequestBuilder`] into a future,"]
#[doc = r" executes the request and returns a `Result` with the parsed"]
#[doc = r" response."]
#[doc = r""]
#[doc = r" If you need lower-level access to the raw response details"]
#[doc = r" (e.g. to inspect response headers or raw body data) then you"]
#[doc = r" can finalize the request using the"]
#[doc = r" [`RequestBuilder::send()`] method which returns a future"]
#[doc = r" that resolves to a lower-level [`Response`] value."]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) organization: String,
pub(crate) project: String,
pub(crate) release_id: i32,
pub(crate) release_env_id: i32,
pub(crate) publish_context: Option<String>,
pub(crate) include_failure_details: Option<bool>,
pub(crate) release_to_compare_attempt: Option<i32>,
pub(crate) release_to_compare_creation_date: Option<time::OffsetDateTime>,
pub(crate) release_to_compare_definition_id: Option<i32>,
pub(crate) release_to_compare_environment_creation_date: Option<time::OffsetDateTime>,
pub(crate) release_to_compare_environment_definition_id: Option<i32>,
pub(crate) release_to_compare_environment_definition_name: Option<String>,
pub(crate) release_to_compare_environment_id: Option<i32>,
pub(crate) release_to_compare_environment_name: Option<String>,
pub(crate) release_to_compare_id: Option<i32>,
pub(crate) release_to_compare_name: Option<String>,
}
impl RequestBuilder {
pub fn publish_context(mut self, publish_context: impl Into<String>) -> Self {
self.publish_context = Some(publish_context.into());
self
}
pub fn include_failure_details(mut self, include_failure_details: bool) -> Self {
self.include_failure_details = Some(include_failure_details);
self
}
#[doc = "Number of Release Attempt."]
pub fn release_to_compare_attempt(mut self, release_to_compare_attempt: i32) -> Self {
self.release_to_compare_attempt = Some(release_to_compare_attempt);
self
}
#[doc = "Release Creation Date(UTC)."]
pub fn release_to_compare_creation_date(
mut self,
release_to_compare_creation_date: impl Into<time::OffsetDateTime>,
) -> Self {
self.release_to_compare_creation_date =
Some(release_to_compare_creation_date.into());
self
}
#[doc = "Release definition ID."]
pub fn release_to_compare_definition_id(
mut self,
release_to_compare_definition_id: i32,
) -> Self {
self.release_to_compare_definition_id = Some(release_to_compare_definition_id);
self
}
#[doc = "Environment creation Date(UTC)."]
pub fn release_to_compare_environment_creation_date(
mut self,
release_to_compare_environment_creation_date: impl Into<time::OffsetDateTime>,
) -> Self {
self.release_to_compare_environment_creation_date =
Some(release_to_compare_environment_creation_date.into());
self
}
#[doc = "Release environment definition ID."]
pub fn release_to_compare_environment_definition_id(
mut self,
release_to_compare_environment_definition_id: i32,
) -> Self {
self.release_to_compare_environment_definition_id =
Some(release_to_compare_environment_definition_id);
self
}
#[doc = "Release environment definition name."]
pub fn release_to_compare_environment_definition_name(
mut self,
release_to_compare_environment_definition_name: impl Into<String>,
) -> Self {
self.release_to_compare_environment_definition_name =
Some(release_to_compare_environment_definition_name.into());
self
}
#[doc = "Release environment ID."]
pub fn release_to_compare_environment_id(
mut self,
release_to_compare_environment_id: i32,
) -> Self {
self.release_to_compare_environment_id = Some(release_to_compare_environment_id);
self
}
#[doc = "Release environment name."]
pub fn release_to_compare_environment_name(
mut self,
release_to_compare_environment_name: impl Into<String>,
) -> Self {
self.release_to_compare_environment_name =
Some(release_to_compare_environment_name.into());
self
}
#[doc = "Release ID."]
pub fn release_to_compare_id(mut self, release_to_compare_id: i32) -> Self {
self.release_to_compare_id = Some(release_to_compare_id);
self
}
#[doc = "Release name."]
pub fn release_to_compare_name(
mut self,
release_to_compare_name: impl Into<String>,
) -> Self {
self.release_to_compare_name = Some(release_to_compare_name.into());
self
}
#[doc = "Returns a future that sends the request and returns a [`Response`] object that provides low-level access to full response details."]
#[doc = ""]
#[doc = "You should typically use `.await` (which implicitly calls `IntoFuture::into_future()`) to finalize and send requests rather than `send()`."]
#[doc = "However, this function can provide more flexibility when required."]
pub fn send(self) -> BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = this.url()?;
let mut req =
azure_core::http::Request::new(url, azure_core::http::Method::Get);
if let Some(auth_header) = this
.client
.token_credential()
.http_authorization_header(&this.client.scopes())
.await?
{
req.insert_header(
azure_core::http::headers::AUTHORIZATION,
auth_header,
);
}
let release_id = &this.release_id;
req.url_mut()
.query_pairs_mut()
.append_pair("releaseId", &release_id.to_string());
let release_env_id = &this.release_env_id;
req.url_mut()
.query_pairs_mut()
.append_pair("releaseEnvId", &release_env_id.to_string());
if let Some(publish_context) = &this.publish_context {
req.url_mut()
.query_pairs_mut()
.append_pair("publishContext", publish_context);
}
if let Some(include_failure_details) = &this.include_failure_details {
req.url_mut().query_pairs_mut().append_pair(
"includeFailureDetails",
&include_failure_details.to_string(),
);
}
if let Some(release_to_compare_attempt) = &this.release_to_compare_attempt {
req.url_mut().query_pairs_mut().append_pair(
"releaseToCompare.attempt",
&release_to_compare_attempt.to_string(),
);
}
if let Some(release_to_compare_creation_date) =
&this.release_to_compare_creation_date
{
let formatted_date_time = crate::date_time::format_date_time(
release_to_compare_creation_date,
)?;
req.url_mut()
.query_pairs_mut()
.append_pair("releaseToCompare.creationDate", &formatted_date_time);
}
if let Some(release_to_compare_definition_id) =
&this.release_to_compare_definition_id
{
req.url_mut().query_pairs_mut().append_pair(
"releaseToCompare.definitionId",
&release_to_compare_definition_id.to_string(),
);
}
if let Some(release_to_compare_environment_creation_date) =
&this.release_to_compare_environment_creation_date
{
let formatted_date_time = crate::date_time::format_date_time(
release_to_compare_environment_creation_date,
)?;
req.url_mut().query_pairs_mut().append_pair(
"releaseToCompare.environmentCreationDate",
&formatted_date_time,
);
}
if let Some(release_to_compare_environment_definition_id) =
&this.release_to_compare_environment_definition_id
{
req.url_mut().query_pairs_mut().append_pair(
"releaseToCompare.environmentDefinitionId",
&release_to_compare_environment_definition_id.to_string(),
);
}
if let Some(release_to_compare_environment_definition_name) =
&this.release_to_compare_environment_definition_name
{
req.url_mut().query_pairs_mut().append_pair(
"releaseToCompare.environmentDefinitionName",
release_to_compare_environment_definition_name,
);
}
if let Some(release_to_compare_environment_id) =
&this.release_to_compare_environment_id
{
req.url_mut().query_pairs_mut().append_pair(
"releaseToCompare.environmentId",
&release_to_compare_environment_id.to_string(),
);
}
if let Some(release_to_compare_environment_name) =
&this.release_to_compare_environment_name
{
req.url_mut().query_pairs_mut().append_pair(
"releaseToCompare.environmentName",
release_to_compare_environment_name,
);
}
if let Some(release_to_compare_id) = &this.release_to_compare_id {
req.url_mut().query_pairs_mut().append_pair(
"releaseToCompare.id",
&release_to_compare_id.to_string(),
);
}
if let Some(release_to_compare_name) = &this.release_to_compare_name {
req.url_mut()
.query_pairs_mut()
.append_pair("releaseToCompare.name", release_to_compare_name);
}
let req_body = azure_core::Bytes::new();
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?.into()))
}
})
}
fn url(&self) -> azure_core::Result<azure_core::http::Url> {
let mut url = azure_core::http::Url::parse(&format!(
"{}/{}/{}/_apis/testresults/resultsummarybyrelease",
self.client.endpoint(),
&self.organization,
&self.project
))?;
let has_api_version_already = url.query_pairs().any(|(k, _)| k == "api-version");
if !has_api_version_already {
url.query_pairs_mut()
.append_pair("api-version", "7.1-preview");
}
Ok(url)
}
}
impl std::future::IntoFuture for RequestBuilder {
type Output = azure_core::Result<models::TestResultSummary>;
type IntoFuture = BoxFuture<'static, azure_core::Result<models::TestResultSummary>>;
#[doc = "Returns a future that sends the request and returns the parsed response body."]
#[doc = ""]
#[doc = "You should not normally call this method directly, simply invoke `.await` which implicitly calls `IntoFuture::into_future`."]
#[doc = ""]
#[doc = "See [IntoFuture documentation](https://doc.rust-lang.org/std/future/trait.IntoFuture.html) for more details."]
fn into_future(self) -> Self::IntoFuture {
Box::pin(async move { self.send().await?.into_body() })
}
}
}
pub mod query_test_results_summary_for_releases {
use super::models;
#[cfg(not(target_arch = "wasm32"))]
use futures::future::BoxFuture;
#[cfg(target_arch = "wasm32")]
use futures::future::LocalBoxFuture as BoxFuture;
#[derive(Debug)]
pub struct Response(
azure_core::http::Response<models::TestResultSummaryList, azure_core::http::JsonFormat>,
);
impl Response {
pub fn into_body(self) -> azure_core::Result<models::TestResultSummaryList> {
self.0.into_model()
}
pub fn into_raw_response(self) -> azure_core::http::RawResponse {
self.0.into()
}
}
#[derive(Clone)]
#[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."]
#[doc = r""]
#[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"]
#[doc = r" parameters can be chained."]
#[doc = r""]
#[doc = r" To finalize and submit the request, invoke `.await`, which"]
#[doc = r" converts the [`RequestBuilder`] into a future,"]
#[doc = r" executes the request and returns a `Result` with the parsed"]
#[doc = r" response."]
#[doc = r""]
#[doc = r" If you need lower-level access to the raw response details"]
#[doc = r" (e.g. to inspect response headers or raw body data) then you"]
#[doc = r" can finalize the request using the"]
#[doc = r" [`RequestBuilder::send()`] method which returns a future"]
#[doc = r" that resolves to a lower-level [`Response`] value."]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) organization: String,
pub(crate) body: Vec<models::ReleaseReference>,
pub(crate) project: String,
}
impl RequestBuilder {
#[doc = "Returns a future that sends the request and returns a [`Response`] object that provides low-level access to full response details."]
#[doc = ""]
#[doc = "You should typically use `.await` (which implicitly calls `IntoFuture::into_future()`) to finalize and send requests rather than `send()`."]
#[doc = "However, this function can provide more flexibility when required."]
pub fn send(self) -> BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = this.url()?;
let mut req =
azure_core::http::Request::new(url, azure_core::http::Method::Post);
if let Some(auth_header) = this
.client
.token_credential()
.http_authorization_header(&this.client.scopes())
.await?
{
req.insert_header(
azure_core::http::headers::AUTHORIZATION,
auth_header,
);
}
req.insert_header("content-type", "application/json");
let req_body = azure_core::json::to_json(&this.body)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?.into()))
}
})
}
fn url(&self) -> azure_core::Result<azure_core::http::Url> {
let mut url = azure_core::http::Url::parse(&format!(
"{}/{}/{}/_apis/testresults/resultsummarybyrelease",
self.client.endpoint(),
&self.organization,
&self.project
))?;
let has_api_version_already = url.query_pairs().any(|(k, _)| k == "api-version");
if !has_api_version_already {
url.query_pairs_mut()
.append_pair("api-version", "7.1-preview");
}
Ok(url)
}
}
impl std::future::IntoFuture for RequestBuilder {
type Output = azure_core::Result<models::TestResultSummaryList>;
type IntoFuture = BoxFuture<'static, azure_core::Result<models::TestResultSummaryList>>;
#[doc = "Returns a future that sends the request and returns the parsed response body."]
#[doc = ""]
#[doc = "You should not normally call this method directly, simply invoke `.await` which implicitly calls `IntoFuture::into_future`."]
#[doc = ""]
#[doc = "See [IntoFuture documentation](https://doc.rust-lang.org/std/future/trait.IntoFuture.html) for more details."]
fn into_future(self) -> Self::IntoFuture {
Box::pin(async move { self.send().await?.into_body() })
}
}
}
}
pub mod resultsummarybyrequirement {
use super::models;
#[cfg(not(target_arch = "wasm32"))]
use futures::future::BoxFuture;
#[cfg(target_arch = "wasm32")]
use futures::future::LocalBoxFuture as BoxFuture;
pub struct Client(pub(crate) super::Client);
impl Client {
#[doc = "Arguments:"]
#[doc = "* `organization`: The name of the Azure DevOps organization."]
#[doc = "* `project`: Project ID or project name"]
pub fn query(
&self,
organization: impl Into<String>,
body: impl Into<models::TestResultsContext>,
project: impl Into<String>,
) -> query::RequestBuilder {
query::RequestBuilder {
client: self.0.clone(),
organization: organization.into(),
body: body.into(),
project: project.into(),
work_item_ids: None,
}
}
}
pub mod query {
use super::models;
#[cfg(not(target_arch = "wasm32"))]
use futures::future::BoxFuture;
#[cfg(target_arch = "wasm32")]
use futures::future::LocalBoxFuture as BoxFuture;
#[derive(Debug)]
pub struct Response(
azure_core::http::Response<
models::TestSummaryForWorkItemList,
azure_core::http::JsonFormat,
>,
);
impl Response {
pub fn into_body(self) -> azure_core::Result<models::TestSummaryForWorkItemList> {
self.0.into_model()
}
pub fn into_raw_response(self) -> azure_core::http::RawResponse {
self.0.into()
}
}
#[derive(Clone)]
#[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."]
#[doc = r""]
#[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"]
#[doc = r" parameters can be chained."]
#[doc = r""]
#[doc = r" To finalize and submit the request, invoke `.await`, which"]
#[doc = r" converts the [`RequestBuilder`] into a future,"]
#[doc = r" executes the request and returns a `Result` with the parsed"]
#[doc = r" response."]
#[doc = r""]
#[doc = r" If you need lower-level access to the raw response details"]
#[doc = r" (e.g. to inspect response headers or raw body data) then you"]
#[doc = r" can finalize the request using the"]
#[doc = r" [`RequestBuilder::send()`] method which returns a future"]
#[doc = r" that resolves to a lower-level [`Response`] value."]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) organization: String,
pub(crate) body: models::TestResultsContext,
pub(crate) project: String,
pub(crate) work_item_ids: Option<String>,
}
impl RequestBuilder {
pub fn work_item_ids(mut self, work_item_ids: impl Into<String>) -> Self {
self.work_item_ids = Some(work_item_ids.into());
self
}
#[doc = "Returns a future that sends the request and returns a [`Response`] object that provides low-level access to full response details."]
#[doc = ""]
#[doc = "You should typically use `.await` (which implicitly calls `IntoFuture::into_future()`) to finalize and send requests rather than `send()`."]
#[doc = "However, this function can provide more flexibility when required."]
pub fn send(self) -> BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = this.url()?;
let mut req =
azure_core::http::Request::new(url, azure_core::http::Method::Post);
if let Some(auth_header) = this
.client
.token_credential()
.http_authorization_header(&this.client.scopes())
.await?
{
req.insert_header(
azure_core::http::headers::AUTHORIZATION,
auth_header,
);
}
req.insert_header("content-type", "application/json");
let req_body = azure_core::json::to_json(&this.body)?;
if let Some(work_item_ids) = &this.work_item_ids {
req.url_mut()
.query_pairs_mut()
.append_pair("workItemIds", work_item_ids);
}
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?.into()))
}
})
}
fn url(&self) -> azure_core::Result<azure_core::http::Url> {
let mut url = azure_core::http::Url::parse(&format!(
"{}/{}/{}/_apis/testresults/resultsummarybyrequirement",
self.client.endpoint(),
&self.organization,
&self.project
))?;
let has_api_version_already = url.query_pairs().any(|(k, _)| k == "api-version");
if !has_api_version_already {
url.query_pairs_mut()
.append_pair("api-version", "7.1-preview");
}
Ok(url)
}
}
impl std::future::IntoFuture for RequestBuilder {
type Output = azure_core::Result<models::TestSummaryForWorkItemList>;
type IntoFuture =
BoxFuture<'static, azure_core::Result<models::TestSummaryForWorkItemList>>;
#[doc = "Returns a future that sends the request and returns the parsed response body."]
#[doc = ""]
#[doc = "You should not normally call this method directly, simply invoke `.await` which implicitly calls `IntoFuture::into_future`."]
#[doc = ""]
#[doc = "See [IntoFuture documentation](https://doc.rust-lang.org/std/future/trait.IntoFuture.html) for more details."]
fn into_future(self) -> Self::IntoFuture {
Box::pin(async move { self.send().await?.into_body() })
}
}
}
}
pub mod result_trend_by_build {
use super::models;
#[cfg(not(target_arch = "wasm32"))]
use futures::future::BoxFuture;
#[cfg(target_arch = "wasm32")]
use futures::future::LocalBoxFuture as BoxFuture;
pub struct Client(pub(crate) super::Client);
impl Client {
#[doc = "Arguments:"]
#[doc = "* `organization`: The name of the Azure DevOps organization."]
#[doc = "* `project`: Project ID or project name"]
pub fn query(
&self,
organization: impl Into<String>,
body: impl Into<models::TestResultTrendFilter>,
project: impl Into<String>,
) -> query::RequestBuilder {
query::RequestBuilder {
client: self.0.clone(),
organization: organization.into(),
body: body.into(),
project: project.into(),
}
}
}
pub mod query {
use super::models;
#[cfg(not(target_arch = "wasm32"))]
use futures::future::BoxFuture;
#[cfg(target_arch = "wasm32")]
use futures::future::LocalBoxFuture as BoxFuture;
#[derive(Debug)]
pub struct Response(
azure_core::http::Response<
models::AggregatedDataForResultTrendList,
azure_core::http::JsonFormat,
>,
);
impl Response {
pub fn into_body(self) -> azure_core::Result<models::AggregatedDataForResultTrendList> {
self.0.into_model()
}
pub fn into_raw_response(self) -> azure_core::http::RawResponse {
self.0.into()
}
}
#[derive(Clone)]
#[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."]
#[doc = r""]
#[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"]
#[doc = r" parameters can be chained."]
#[doc = r""]
#[doc = r" To finalize and submit the request, invoke `.await`, which"]
#[doc = r" converts the [`RequestBuilder`] into a future,"]
#[doc = r" executes the request and returns a `Result` with the parsed"]
#[doc = r" response."]
#[doc = r""]
#[doc = r" If you need lower-level access to the raw response details"]
#[doc = r" (e.g. to inspect response headers or raw body data) then you"]
#[doc = r" can finalize the request using the"]
#[doc = r" [`RequestBuilder::send()`] method which returns a future"]
#[doc = r" that resolves to a lower-level [`Response`] value."]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) organization: String,
pub(crate) body: models::TestResultTrendFilter,
pub(crate) project: String,
}
impl RequestBuilder {
#[doc = "Returns a future that sends the request and returns a [`Response`] object that provides low-level access to full response details."]
#[doc = ""]
#[doc = "You should typically use `.await` (which implicitly calls `IntoFuture::into_future()`) to finalize and send requests rather than `send()`."]
#[doc = "However, this function can provide more flexibility when required."]
pub fn send(self) -> BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = this.url()?;
let mut req =
azure_core::http::Request::new(url, azure_core::http::Method::Post);
if let Some(auth_header) = this
.client
.token_credential()
.http_authorization_header(&this.client.scopes())
.await?
{
req.insert_header(
azure_core::http::headers::AUTHORIZATION,
auth_header,
);
}
req.insert_header("content-type", "application/json");
let req_body = azure_core::json::to_json(&this.body)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?.into()))
}
})
}
fn url(&self) -> azure_core::Result<azure_core::http::Url> {
let mut url = azure_core::http::Url::parse(&format!(
"{}/{}/{}/_apis/testresults/resulttrendbybuild",
self.client.endpoint(),
&self.organization,
&self.project
))?;
let has_api_version_already = url.query_pairs().any(|(k, _)| k == "api-version");
if !has_api_version_already {
url.query_pairs_mut()
.append_pair("api-version", "7.1-preview");
}
Ok(url)
}
}
impl std::future::IntoFuture for RequestBuilder {
type Output = azure_core::Result<models::AggregatedDataForResultTrendList>;
type IntoFuture =
BoxFuture<'static, azure_core::Result<models::AggregatedDataForResultTrendList>>;
#[doc = "Returns a future that sends the request and returns the parsed response body."]
#[doc = ""]
#[doc = "You should not normally call this method directly, simply invoke `.await` which implicitly calls `IntoFuture::into_future`."]
#[doc = ""]
#[doc = "See [IntoFuture documentation](https://doc.rust-lang.org/std/future/trait.IntoFuture.html) for more details."]
fn into_future(self) -> Self::IntoFuture {
Box::pin(async move { self.send().await?.into_body() })
}
}
}
}
pub mod result_trend_by_release {
use super::models;
#[cfg(not(target_arch = "wasm32"))]
use futures::future::BoxFuture;
#[cfg(target_arch = "wasm32")]
use futures::future::LocalBoxFuture as BoxFuture;
pub struct Client(pub(crate) super::Client);
impl Client {
#[doc = "Arguments:"]
#[doc = "* `organization`: The name of the Azure DevOps organization."]
#[doc = "* `project`: Project ID or project name"]
pub fn query(
&self,
organization: impl Into<String>,
body: impl Into<models::TestResultTrendFilter>,
project: impl Into<String>,
) -> query::RequestBuilder {
query::RequestBuilder {
client: self.0.clone(),
organization: organization.into(),
body: body.into(),
project: project.into(),
}
}
}
pub mod query {
use super::models;
#[cfg(not(target_arch = "wasm32"))]
use futures::future::BoxFuture;
#[cfg(target_arch = "wasm32")]
use futures::future::LocalBoxFuture as BoxFuture;
#[derive(Debug)]
pub struct Response(
azure_core::http::Response<
models::AggregatedDataForResultTrendList,
azure_core::http::JsonFormat,
>,
);
impl Response {
pub fn into_body(self) -> azure_core::Result<models::AggregatedDataForResultTrendList> {
self.0.into_model()
}
pub fn into_raw_response(self) -> azure_core::http::RawResponse {
self.0.into()
}
}
#[derive(Clone)]
#[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."]
#[doc = r""]
#[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"]
#[doc = r" parameters can be chained."]
#[doc = r""]
#[doc = r" To finalize and submit the request, invoke `.await`, which"]
#[doc = r" converts the [`RequestBuilder`] into a future,"]
#[doc = r" executes the request and returns a `Result` with the parsed"]
#[doc = r" response."]
#[doc = r""]
#[doc = r" If you need lower-level access to the raw response details"]
#[doc = r" (e.g. to inspect response headers or raw body data) then you"]
#[doc = r" can finalize the request using the"]
#[doc = r" [`RequestBuilder::send()`] method which returns a future"]
#[doc = r" that resolves to a lower-level [`Response`] value."]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) organization: String,
pub(crate) body: models::TestResultTrendFilter,
pub(crate) project: String,
}
impl RequestBuilder {
#[doc = "Returns a future that sends the request and returns a [`Response`] object that provides low-level access to full response details."]
#[doc = ""]
#[doc = "You should typically use `.await` (which implicitly calls `IntoFuture::into_future()`) to finalize and send requests rather than `send()`."]
#[doc = "However, this function can provide more flexibility when required."]
pub fn send(self) -> BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = this.url()?;
let mut req =
azure_core::http::Request::new(url, azure_core::http::Method::Post);
if let Some(auth_header) = this
.client
.token_credential()
.http_authorization_header(&this.client.scopes())
.await?
{
req.insert_header(
azure_core::http::headers::AUTHORIZATION,
auth_header,
);
}
req.insert_header("content-type", "application/json");
let req_body = azure_core::json::to_json(&this.body)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?.into()))
}
})
}
fn url(&self) -> azure_core::Result<azure_core::http::Url> {
let mut url = azure_core::http::Url::parse(&format!(
"{}/{}/{}/_apis/testresults/resulttrendbyrelease",
self.client.endpoint(),
&self.organization,
&self.project
))?;
let has_api_version_already = url.query_pairs().any(|(k, _)| k == "api-version");
if !has_api_version_already {
url.query_pairs_mut()
.append_pair("api-version", "7.1-preview");
}
Ok(url)
}
}
impl std::future::IntoFuture for RequestBuilder {
type Output = azure_core::Result<models::AggregatedDataForResultTrendList>;
type IntoFuture =
BoxFuture<'static, azure_core::Result<models::AggregatedDataForResultTrendList>>;
#[doc = "Returns a future that sends the request and returns the parsed response body."]
#[doc = ""]
#[doc = "You should not normally call this method directly, simply invoke `.await` which implicitly calls `IntoFuture::into_future`."]
#[doc = ""]
#[doc = "See [IntoFuture documentation](https://doc.rust-lang.org/std/future/trait.IntoFuture.html) for more details."]
fn into_future(self) -> Self::IntoFuture {
Box::pin(async move { self.send().await?.into_body() })
}
}
}
}
pub mod message_logs {
use super::models;
#[cfg(not(target_arch = "wasm32"))]
use futures::future::BoxFuture;
#[cfg(target_arch = "wasm32")]
use futures::future::LocalBoxFuture as BoxFuture;
pub struct Client(pub(crate) super::Client);
impl Client {
#[doc = "Get test run message logs"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `organization`: The name of the Azure DevOps organization."]
#[doc = "* `project`: Project ID or project name"]
#[doc = "* `run_id`: ID of the run to get."]
pub fn list(
&self,
organization: impl Into<String>,
project: impl Into<String>,
run_id: i32,
) -> list::RequestBuilder {
list::RequestBuilder {
client: self.0.clone(),
organization: organization.into(),
project: project.into(),
run_id,
}
}
}
pub mod list {
use super::models;
#[cfg(not(target_arch = "wasm32"))]
use futures::future::BoxFuture;
#[cfg(target_arch = "wasm32")]
use futures::future::LocalBoxFuture as BoxFuture;
#[derive(Debug)]
pub struct Response(
azure_core::http::Response<
models::TestMessageLogDetailsList,
azure_core::http::JsonFormat,
>,
);
impl Response {
pub fn into_body(self) -> azure_core::Result<models::TestMessageLogDetailsList> {
self.0.into_model()
}
pub fn into_raw_response(self) -> azure_core::http::RawResponse {
self.0.into()
}
}
#[derive(Clone)]
#[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."]
#[doc = r""]
#[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"]
#[doc = r" parameters can be chained."]
#[doc = r""]
#[doc = r" To finalize and submit the request, invoke `.await`, which"]
#[doc = r" converts the [`RequestBuilder`] into a future,"]
#[doc = r" executes the request and returns a `Result` with the parsed"]
#[doc = r" response."]
#[doc = r""]
#[doc = r" If you need lower-level access to the raw response details"]
#[doc = r" (e.g. to inspect response headers or raw body data) then you"]
#[doc = r" can finalize the request using the"]
#[doc = r" [`RequestBuilder::send()`] method which returns a future"]
#[doc = r" that resolves to a lower-level [`Response`] value."]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) organization: String,
pub(crate) project: String,
pub(crate) run_id: i32,
}
impl RequestBuilder {
#[doc = "Returns a future that sends the request and returns a [`Response`] object that provides low-level access to full response details."]
#[doc = ""]
#[doc = "You should typically use `.await` (which implicitly calls `IntoFuture::into_future()`) to finalize and send requests rather than `send()`."]
#[doc = "However, this function can provide more flexibility when required."]
pub fn send(self) -> BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = this.url()?;
let mut req =
azure_core::http::Request::new(url, azure_core::http::Method::Get);
if let Some(auth_header) = this
.client
.token_credential()
.http_authorization_header(&this.client.scopes())
.await?
{
req.insert_header(
azure_core::http::headers::AUTHORIZATION,
auth_header,
);
}
let req_body = azure_core::Bytes::new();
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?.into()))
}
})
}
fn url(&self) -> azure_core::Result<azure_core::http::Url> {
let mut url = azure_core::http::Url::parse(&format!(
"{}/{}/{}/_apis/testresults/runs/{}/messagelogs",
self.client.endpoint(),
&self.organization,
&self.project,
&self.run_id
))?;
let has_api_version_already = url.query_pairs().any(|(k, _)| k == "api-version");
if !has_api_version_already {
url.query_pairs_mut()
.append_pair("api-version", "7.1-preview");
}
Ok(url)
}
}
impl std::future::IntoFuture for RequestBuilder {
type Output = azure_core::Result<models::TestMessageLogDetailsList>;
type IntoFuture =
BoxFuture<'static, azure_core::Result<models::TestMessageLogDetailsList>>;
#[doc = "Returns a future that sends the request and returns the parsed response body."]
#[doc = ""]
#[doc = "You should not normally call this method directly, simply invoke `.await` which implicitly calls `IntoFuture::into_future`."]
#[doc = ""]
#[doc = "See [IntoFuture documentation](https://doc.rust-lang.org/std/future/trait.IntoFuture.html) for more details."]
fn into_future(self) -> Self::IntoFuture {
Box::pin(async move { self.send().await?.into_body() })
}
}
}
}
pub mod result_document {
use super::models;
#[cfg(not(target_arch = "wasm32"))]
use futures::future::BoxFuture;
#[cfg(target_arch = "wasm32")]
use futures::future::LocalBoxFuture as BoxFuture;
pub struct Client(pub(crate) super::Client);
impl Client {
#[doc = "Arguments:"]
#[doc = "* `organization`: The name of the Azure DevOps organization."]
#[doc = "* `project`: Project ID or project name"]
pub fn publish_test_result_document(
&self,
organization: impl Into<String>,
body: impl Into<models::TestResultDocument>,
project: impl Into<String>,
run_id: i32,
) -> publish_test_result_document::RequestBuilder {
publish_test_result_document::RequestBuilder {
client: self.0.clone(),
organization: organization.into(),
body: body.into(),
project: project.into(),
run_id,
}
}
}
pub mod publish_test_result_document {
use super::models;
#[cfg(not(target_arch = "wasm32"))]
use futures::future::BoxFuture;
#[cfg(target_arch = "wasm32")]
use futures::future::LocalBoxFuture as BoxFuture;
#[derive(Debug)]
pub struct Response(
azure_core::http::Response<models::TestResultDocument, azure_core::http::JsonFormat>,
);
impl Response {
pub fn into_body(self) -> azure_core::Result<models::TestResultDocument> {
self.0.into_model()
}
pub fn into_raw_response(self) -> azure_core::http::RawResponse {
self.0.into()
}
}
#[derive(Clone)]
#[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."]
#[doc = r""]
#[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"]
#[doc = r" parameters can be chained."]
#[doc = r""]
#[doc = r" To finalize and submit the request, invoke `.await`, which"]
#[doc = r" converts the [`RequestBuilder`] into a future,"]
#[doc = r" executes the request and returns a `Result` with the parsed"]
#[doc = r" response."]
#[doc = r""]
#[doc = r" If you need lower-level access to the raw response details"]
#[doc = r" (e.g. to inspect response headers or raw body data) then you"]
#[doc = r" can finalize the request using the"]
#[doc = r" [`RequestBuilder::send()`] method which returns a future"]
#[doc = r" that resolves to a lower-level [`Response`] value."]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) organization: String,
pub(crate) body: models::TestResultDocument,
pub(crate) project: String,
pub(crate) run_id: i32,
}
impl RequestBuilder {
#[doc = "Returns a future that sends the request and returns a [`Response`] object that provides low-level access to full response details."]
#[doc = ""]
#[doc = "You should typically use `.await` (which implicitly calls `IntoFuture::into_future()`) to finalize and send requests rather than `send()`."]
#[doc = "However, this function can provide more flexibility when required."]
pub fn send(self) -> BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = this.url()?;
let mut req =
azure_core::http::Request::new(url, azure_core::http::Method::Post);
if let Some(auth_header) = this
.client
.token_credential()
.http_authorization_header(&this.client.scopes())
.await?
{
req.insert_header(
azure_core::http::headers::AUTHORIZATION,
auth_header,
);
}
req.insert_header("content-type", "application/json");
let req_body = azure_core::json::to_json(&this.body)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?.into()))
}
})
}
fn url(&self) -> azure_core::Result<azure_core::http::Url> {
let mut url = azure_core::http::Url::parse(&format!(
"{}/{}/{}/_apis/testresults/runs/{}/resultdocument",
self.client.endpoint(),
&self.organization,
&self.project,
&self.run_id
))?;
let has_api_version_already = url.query_pairs().any(|(k, _)| k == "api-version");
if !has_api_version_already {
url.query_pairs_mut()
.append_pair("api-version", "7.1-preview");
}
Ok(url)
}
}
impl std::future::IntoFuture for RequestBuilder {
type Output = azure_core::Result<models::TestResultDocument>;
type IntoFuture = BoxFuture<'static, azure_core::Result<models::TestResultDocument>>;
#[doc = "Returns a future that sends the request and returns the parsed response body."]
#[doc = ""]
#[doc = "You should not normally call this method directly, simply invoke `.await` which implicitly calls `IntoFuture::into_future`."]
#[doc = ""]
#[doc = "See [IntoFuture documentation](https://doc.rust-lang.org/std/future/trait.IntoFuture.html) for more details."]
fn into_future(self) -> Self::IntoFuture {
Box::pin(async move { self.send().await?.into_body() })
}
}
}
}
pub mod bugs {
use super::models;
#[cfg(not(target_arch = "wasm32"))]
use futures::future::BoxFuture;
#[cfg(target_arch = "wasm32")]
use futures::future::LocalBoxFuture as BoxFuture;
pub struct Client(pub(crate) super::Client);
impl Client {
#[doc = "Arguments:"]
#[doc = "* `organization`: The name of the Azure DevOps organization."]
#[doc = "* `project`: Project ID or project name"]
pub fn list(
&self,
organization: impl Into<String>,
project: impl Into<String>,
run_id: i32,
test_case_result_id: i32,
) -> list::RequestBuilder {
list::RequestBuilder {
client: self.0.clone(),
organization: organization.into(),
project: project.into(),
run_id,
test_case_result_id,
}
}
}
pub mod list {
use super::models;
#[cfg(not(target_arch = "wasm32"))]
use futures::future::BoxFuture;
#[cfg(target_arch = "wasm32")]
use futures::future::LocalBoxFuture as BoxFuture;
#[derive(Debug)]
pub struct Response(
azure_core::http::Response<models::WorkItemReferenceList, azure_core::http::JsonFormat>,
);
impl Response {
pub fn into_body(self) -> azure_core::Result<models::WorkItemReferenceList> {
self.0.into_model()
}
pub fn into_raw_response(self) -> azure_core::http::RawResponse {
self.0.into()
}
}
#[derive(Clone)]
#[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."]
#[doc = r""]
#[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"]
#[doc = r" parameters can be chained."]
#[doc = r""]
#[doc = r" To finalize and submit the request, invoke `.await`, which"]
#[doc = r" converts the [`RequestBuilder`] into a future,"]
#[doc = r" executes the request and returns a `Result` with the parsed"]
#[doc = r" response."]
#[doc = r""]
#[doc = r" If you need lower-level access to the raw response details"]
#[doc = r" (e.g. to inspect response headers or raw body data) then you"]
#[doc = r" can finalize the request using the"]
#[doc = r" [`RequestBuilder::send()`] method which returns a future"]
#[doc = r" that resolves to a lower-level [`Response`] value."]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) organization: String,
pub(crate) project: String,
pub(crate) run_id: i32,
pub(crate) test_case_result_id: i32,
}
impl RequestBuilder {
#[doc = "Returns a future that sends the request and returns a [`Response`] object that provides low-level access to full response details."]
#[doc = ""]
#[doc = "You should typically use `.await` (which implicitly calls `IntoFuture::into_future()`) to finalize and send requests rather than `send()`."]
#[doc = "However, this function can provide more flexibility when required."]
pub fn send(self) -> BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = this.url()?;
let mut req =
azure_core::http::Request::new(url, azure_core::http::Method::Get);
if let Some(auth_header) = this
.client
.token_credential()
.http_authorization_header(&this.client.scopes())
.await?
{
req.insert_header(
azure_core::http::headers::AUTHORIZATION,
auth_header,
);
}
let req_body = azure_core::Bytes::new();
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?.into()))
}
})
}
fn url(&self) -> azure_core::Result<azure_core::http::Url> {
let mut url = azure_core::http::Url::parse(&format!(
"{}/{}/{}/_apis/testresults/runs/{}/results/{}/bugs",
self.client.endpoint(),
&self.organization,
&self.project,
&self.run_id,
&self.test_case_result_id
))?;
let has_api_version_already = url.query_pairs().any(|(k, _)| k == "api-version");
if !has_api_version_already {
url.query_pairs_mut()
.append_pair("api-version", "7.1-preview");
}
Ok(url)
}
}
impl std::future::IntoFuture for RequestBuilder {
type Output = azure_core::Result<models::WorkItemReferenceList>;
type IntoFuture = BoxFuture<'static, azure_core::Result<models::WorkItemReferenceList>>;
#[doc = "Returns a future that sends the request and returns the parsed response body."]
#[doc = ""]
#[doc = "You should not normally call this method directly, simply invoke `.await` which implicitly calls `IntoFuture::into_future`."]
#[doc = ""]
#[doc = "See [IntoFuture documentation](https://doc.rust-lang.org/std/future/trait.IntoFuture.html) for more details."]
fn into_future(self) -> Self::IntoFuture {
Box::pin(async move { self.send().await?.into_body() })
}
}
}
}
pub mod similar_test_results {
use super::models;
#[cfg(not(target_arch = "wasm32"))]
use futures::future::BoxFuture;
#[cfg(target_arch = "wasm32")]
use futures::future::LocalBoxFuture as BoxFuture;
pub struct Client(pub(crate) super::Client);
impl Client {
#[doc = "Gets the list of results whose failure matches with the provided one."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `organization`: The name of the Azure DevOps organization."]
#[doc = "* `project`: Project ID or project name"]
#[doc = "* `run_id`: id of test run"]
#[doc = "* `test_result_id`: id of test result inside a test run"]
#[doc = "* `test_sub_result_id`: id of subresult inside a test result"]
pub fn list(
&self,
organization: impl Into<String>,
project: impl Into<String>,
run_id: i32,
test_result_id: i32,
test_sub_result_id: i32,
) -> list::RequestBuilder {
list::RequestBuilder {
client: self.0.clone(),
organization: organization.into(),
project: project.into(),
run_id,
test_result_id,
test_sub_result_id,
top: None,
continuation_token: None,
}
}
}
pub mod list {
use super::models;
#[cfg(not(target_arch = "wasm32"))]
use futures::future::BoxFuture;
#[cfg(target_arch = "wasm32")]
use futures::future::LocalBoxFuture as BoxFuture;
#[derive(Debug)]
pub struct Response(
azure_core::http::Response<models::TestCaseResultList, azure_core::http::JsonFormat>,
);
impl Response {
pub fn into_body(self) -> azure_core::Result<models::TestCaseResultList> {
self.0.into_model()
}
pub fn into_raw_response(self) -> azure_core::http::RawResponse {
self.0.into()
}
}
#[derive(Clone)]
#[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."]
#[doc = r""]
#[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"]
#[doc = r" parameters can be chained."]
#[doc = r""]
#[doc = r" To finalize and submit the request, invoke `.await`, which"]
#[doc = r" converts the [`RequestBuilder`] into a future,"]
#[doc = r" executes the request and returns a `Result` with the parsed"]
#[doc = r" response."]
#[doc = r""]
#[doc = r" If you need lower-level access to the raw response details"]
#[doc = r" (e.g. to inspect response headers or raw body data) then you"]
#[doc = r" can finalize the request using the"]
#[doc = r" [`RequestBuilder::send()`] method which returns a future"]
#[doc = r" that resolves to a lower-level [`Response`] value."]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) organization: String,
pub(crate) project: String,
pub(crate) run_id: i32,
pub(crate) test_result_id: i32,
pub(crate) test_sub_result_id: i32,
pub(crate) top: Option<i32>,
pub(crate) continuation_token: Option<String>,
}
impl RequestBuilder {
#[doc = "Maximum number of results to return"]
pub fn top(mut self, top: i32) -> Self {
self.top = Some(top);
self
}
#[doc = "Header to pass the continuation token"]
pub fn continuation_token(mut self, continuation_token: impl Into<String>) -> Self {
self.continuation_token = Some(continuation_token.into());
self
}
#[doc = "Returns a future that sends the request and returns a [`Response`] object that provides low-level access to full response details."]
#[doc = ""]
#[doc = "You should typically use `.await` (which implicitly calls `IntoFuture::into_future()`) to finalize and send requests rather than `send()`."]
#[doc = "However, this function can provide more flexibility when required."]
pub fn send(self) -> BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = this.url()?;
let mut req =
azure_core::http::Request::new(url, azure_core::http::Method::Get);
if let Some(auth_header) = this
.client
.token_credential()
.http_authorization_header(&this.client.scopes())
.await?
{
req.insert_header(
azure_core::http::headers::AUTHORIZATION,
auth_header,
);
}
let test_sub_result_id = &this.test_sub_result_id;
req.url_mut()
.query_pairs_mut()
.append_pair("testSubResultId", &test_sub_result_id.to_string());
if let Some(top) = &this.top {
req.url_mut()
.query_pairs_mut()
.append_pair("$top", &top.to_string());
}
if let Some(continuation_token) = &this.continuation_token {
req.insert_header("continuationtoken", continuation_token);
}
let req_body = azure_core::Bytes::new();
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?.into()))
}
})
}
fn url(&self) -> azure_core::Result<azure_core::http::Url> {
let mut url = azure_core::http::Url::parse(&format!(
"{}/{}/{}/_apis/testresults/runs/{}/results/{}/similartestresults",
self.client.endpoint(),
&self.organization,
&self.project,
&self.run_id,
&self.test_result_id
))?;
let has_api_version_already = url.query_pairs().any(|(k, _)| k == "api-version");
if !has_api_version_already {
url.query_pairs_mut()
.append_pair("api-version", "7.1-preview");
}
Ok(url)
}
}
impl std::future::IntoFuture for RequestBuilder {
type Output = azure_core::Result<models::TestCaseResultList>;
type IntoFuture = BoxFuture<'static, azure_core::Result<models::TestCaseResultList>>;
#[doc = "Returns a future that sends the request and returns the parsed response body."]
#[doc = ""]
#[doc = "You should not normally call this method directly, simply invoke `.await` which implicitly calls `IntoFuture::into_future`."]
#[doc = ""]
#[doc = "See [IntoFuture documentation](https://doc.rust-lang.org/std/future/trait.IntoFuture.html) for more details."]
fn into_future(self) -> Self::IntoFuture {
Box::pin(async move { self.send().await?.into_body() })
}
}
}
}
pub mod runsummary {
use super::models;
#[cfg(not(target_arch = "wasm32"))]
use futures::future::BoxFuture;
#[cfg(target_arch = "wasm32")]
use futures::future::LocalBoxFuture as BoxFuture;
pub struct Client(pub(crate) super::Client);
impl Client {
#[doc = "Get test run summary, used when we want to get summary of a run by outcome. Test run should be in completed state."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `organization`: The name of the Azure DevOps organization."]
#[doc = "* `project`: Project ID or project name"]
#[doc = "* `run_id`: ID of the run to get."]
pub fn get(
&self,
organization: impl Into<String>,
project: impl Into<String>,
run_id: i32,
) -> get::RequestBuilder {
get::RequestBuilder {
client: self.0.clone(),
organization: organization.into(),
project: project.into(),
run_id,
}
}
}
pub mod get {
use super::models;
#[cfg(not(target_arch = "wasm32"))]
use futures::future::BoxFuture;
#[cfg(target_arch = "wasm32")]
use futures::future::LocalBoxFuture as BoxFuture;
#[derive(Debug)]
pub struct Response(
azure_core::http::Response<models::TestRunStatistic, azure_core::http::JsonFormat>,
);
impl Response {
pub fn into_body(self) -> azure_core::Result<models::TestRunStatistic> {
self.0.into_model()
}
pub fn into_raw_response(self) -> azure_core::http::RawResponse {
self.0.into()
}
}
#[derive(Clone)]
#[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."]
#[doc = r""]
#[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"]
#[doc = r" parameters can be chained."]
#[doc = r""]
#[doc = r" To finalize and submit the request, invoke `.await`, which"]
#[doc = r" converts the [`RequestBuilder`] into a future,"]
#[doc = r" executes the request and returns a `Result` with the parsed"]
#[doc = r" response."]
#[doc = r""]
#[doc = r" If you need lower-level access to the raw response details"]
#[doc = r" (e.g. to inspect response headers or raw body data) then you"]
#[doc = r" can finalize the request using the"]
#[doc = r" [`RequestBuilder::send()`] method which returns a future"]
#[doc = r" that resolves to a lower-level [`Response`] value."]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) organization: String,
pub(crate) project: String,
pub(crate) run_id: i32,
}
impl RequestBuilder {
#[doc = "Returns a future that sends the request and returns a [`Response`] object that provides low-level access to full response details."]
#[doc = ""]
#[doc = "You should typically use `.await` (which implicitly calls `IntoFuture::into_future()`) to finalize and send requests rather than `send()`."]
#[doc = "However, this function can provide more flexibility when required."]
pub fn send(self) -> BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = this.url()?;
let mut req =
azure_core::http::Request::new(url, azure_core::http::Method::Get);
if let Some(auth_header) = this
.client
.token_credential()
.http_authorization_header(&this.client.scopes())
.await?
{
req.insert_header(
azure_core::http::headers::AUTHORIZATION,
auth_header,
);
}
let req_body = azure_core::Bytes::new();
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?.into()))
}
})
}
fn url(&self) -> azure_core::Result<azure_core::http::Url> {
let mut url = azure_core::http::Url::parse(&format!(
"{}/{}/{}/_apis/testresults/runs/{}/runsummary",
self.client.endpoint(),
&self.organization,
&self.project,
&self.run_id
))?;
let has_api_version_already = url.query_pairs().any(|(k, _)| k == "api-version");
if !has_api_version_already {
url.query_pairs_mut()
.append_pair("api-version", "7.1-preview");
}
Ok(url)
}
}
impl std::future::IntoFuture for RequestBuilder {
type Output = azure_core::Result<models::TestRunStatistic>;
type IntoFuture = BoxFuture<'static, azure_core::Result<models::TestRunStatistic>>;
#[doc = "Returns a future that sends the request and returns the parsed response body."]
#[doc = ""]
#[doc = "You should not normally call this method directly, simply invoke `.await` which implicitly calls `IntoFuture::into_future`."]
#[doc = ""]
#[doc = "See [IntoFuture documentation](https://doc.rust-lang.org/std/future/trait.IntoFuture.html) for more details."]
fn into_future(self) -> Self::IntoFuture {
Box::pin(async move { self.send().await?.into_body() })
}
}
}
}
pub mod statistics {
use super::models;
#[cfg(not(target_arch = "wasm32"))]
use futures::future::BoxFuture;
#[cfg(target_arch = "wasm32")]
use futures::future::LocalBoxFuture as BoxFuture;
pub struct Client(pub(crate) super::Client);
impl Client {
#[doc = "Get test run statistics , used when we want to get summary of a run by outcome."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `organization`: The name of the Azure DevOps organization."]
#[doc = "* `project`: Project ID or project name"]
#[doc = "* `run_id`: ID of the run to get."]
pub fn get(
&self,
organization: impl Into<String>,
project: impl Into<String>,
run_id: i32,
) -> get::RequestBuilder {
get::RequestBuilder {
client: self.0.clone(),
organization: organization.into(),
project: project.into(),
run_id,
}
}
}
pub mod get {
use super::models;
#[cfg(not(target_arch = "wasm32"))]
use futures::future::BoxFuture;
#[cfg(target_arch = "wasm32")]
use futures::future::LocalBoxFuture as BoxFuture;
#[derive(Debug)]
pub struct Response(
azure_core::http::Response<models::TestRunStatistic, azure_core::http::JsonFormat>,
);
impl Response {
pub fn into_body(self) -> azure_core::Result<models::TestRunStatistic> {
self.0.into_model()
}
pub fn into_raw_response(self) -> azure_core::http::RawResponse {
self.0.into()
}
}
#[derive(Clone)]
#[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."]
#[doc = r""]
#[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"]
#[doc = r" parameters can be chained."]
#[doc = r""]
#[doc = r" To finalize and submit the request, invoke `.await`, which"]
#[doc = r" converts the [`RequestBuilder`] into a future,"]
#[doc = r" executes the request and returns a `Result` with the parsed"]
#[doc = r" response."]
#[doc = r""]
#[doc = r" If you need lower-level access to the raw response details"]
#[doc = r" (e.g. to inspect response headers or raw body data) then you"]
#[doc = r" can finalize the request using the"]
#[doc = r" [`RequestBuilder::send()`] method which returns a future"]
#[doc = r" that resolves to a lower-level [`Response`] value."]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) organization: String,
pub(crate) project: String,
pub(crate) run_id: i32,
}
impl RequestBuilder {
#[doc = "Returns a future that sends the request and returns a [`Response`] object that provides low-level access to full response details."]
#[doc = ""]
#[doc = "You should typically use `.await` (which implicitly calls `IntoFuture::into_future()`) to finalize and send requests rather than `send()`."]
#[doc = "However, this function can provide more flexibility when required."]
pub fn send(self) -> BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = this.url()?;
let mut req =
azure_core::http::Request::new(url, azure_core::http::Method::Get);
if let Some(auth_header) = this
.client
.token_credential()
.http_authorization_header(&this.client.scopes())
.await?
{
req.insert_header(
azure_core::http::headers::AUTHORIZATION,
auth_header,
);
}
let req_body = azure_core::Bytes::new();
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?.into()))
}
})
}
fn url(&self) -> azure_core::Result<azure_core::http::Url> {
let mut url = azure_core::http::Url::parse(&format!(
"{}/{}/{}/_apis/testresults/runs/{}/statistics",
self.client.endpoint(),
&self.organization,
&self.project,
&self.run_id
))?;
let has_api_version_already = url.query_pairs().any(|(k, _)| k == "api-version");
if !has_api_version_already {
url.query_pairs_mut()
.append_pair("api-version", "7.1-preview");
}
Ok(url)
}
}
impl std::future::IntoFuture for RequestBuilder {
type Output = azure_core::Result<models::TestRunStatistic>;
type IntoFuture = BoxFuture<'static, azure_core::Result<models::TestRunStatistic>>;
#[doc = "Returns a future that sends the request and returns the parsed response body."]
#[doc = ""]
#[doc = "You should not normally call this method directly, simply invoke `.await` which implicitly calls `IntoFuture::into_future`."]
#[doc = ""]
#[doc = "See [IntoFuture documentation](https://doc.rust-lang.org/std/future/trait.IntoFuture.html) for more details."]
fn into_future(self) -> Self::IntoFuture {
Box::pin(async move { self.send().await?.into_body() })
}
}
}
}
pub mod settings {
use super::models;
#[cfg(not(target_arch = "wasm32"))]
use futures::future::BoxFuture;
#[cfg(target_arch = "wasm32")]
use futures::future::LocalBoxFuture as BoxFuture;
pub struct Client(pub(crate) super::Client);
impl Client {
#[doc = "Get TestResultsSettings data"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `organization`: The name of the Azure DevOps organization."]
#[doc = "* `project`: Project ID or project name"]
pub fn get(
&self,
organization: impl Into<String>,
project: impl Into<String>,
) -> get::RequestBuilder {
get::RequestBuilder {
client: self.0.clone(),
organization: organization.into(),
project: project.into(),
settings_type: None,
}
}
#[doc = "Update project settings of test results"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `organization`: The name of the Azure DevOps organization."]
#[doc = "* `project`: Project ID or project name"]
pub fn update(
&self,
organization: impl Into<String>,
body: impl Into<models::TestResultsUpdateSettings>,
project: impl Into<String>,
) -> update::RequestBuilder {
update::RequestBuilder {
client: self.0.clone(),
organization: organization.into(),
body: body.into(),
project: project.into(),
}
}
}
pub mod get {
use super::models;
#[cfg(not(target_arch = "wasm32"))]
use futures::future::BoxFuture;
#[cfg(target_arch = "wasm32")]
use futures::future::LocalBoxFuture as BoxFuture;
#[derive(Debug)]
pub struct Response(
azure_core::http::Response<models::TestResultsSettings, azure_core::http::JsonFormat>,
);
impl Response {
pub fn into_body(self) -> azure_core::Result<models::TestResultsSettings> {
self.0.into_model()
}
pub fn into_raw_response(self) -> azure_core::http::RawResponse {
self.0.into()
}
}
#[derive(Clone)]
#[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."]
#[doc = r""]
#[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"]
#[doc = r" parameters can be chained."]
#[doc = r""]
#[doc = r" To finalize and submit the request, invoke `.await`, which"]
#[doc = r" converts the [`RequestBuilder`] into a future,"]
#[doc = r" executes the request and returns a `Result` with the parsed"]
#[doc = r" response."]
#[doc = r""]
#[doc = r" If you need lower-level access to the raw response details"]
#[doc = r" (e.g. to inspect response headers or raw body data) then you"]
#[doc = r" can finalize the request using the"]
#[doc = r" [`RequestBuilder::send()`] method which returns a future"]
#[doc = r" that resolves to a lower-level [`Response`] value."]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) organization: String,
pub(crate) project: String,
pub(crate) settings_type: Option<models::TestResultsSettingsType>,
}
impl RequestBuilder {
pub fn settings_type(
mut self,
settings_type: impl Into<models::TestResultsSettingsType>,
) -> Self {
self.settings_type = Some(settings_type.into());
self
}
#[doc = "Returns a future that sends the request and returns a [`Response`] object that provides low-level access to full response details."]
#[doc = ""]
#[doc = "You should typically use `.await` (which implicitly calls `IntoFuture::into_future()`) to finalize and send requests rather than `send()`."]
#[doc = "However, this function can provide more flexibility when required."]
pub fn send(self) -> BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = this.url()?;
let mut req =
azure_core::http::Request::new(url, azure_core::http::Method::Get);
if let Some(auth_header) = this
.client
.token_credential()
.http_authorization_header(&this.client.scopes())
.await?
{
req.insert_header(
azure_core::http::headers::AUTHORIZATION,
auth_header,
);
}
if let Some(settings_type) = &this.settings_type {
req.url_mut()
.query_pairs_mut()
.append_pair("settingsType", &settings_type.to_string());
}
let req_body = azure_core::Bytes::new();
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?.into()))
}
})
}
fn url(&self) -> azure_core::Result<azure_core::http::Url> {
let mut url = azure_core::http::Url::parse(&format!(
"{}/{}/{}/_apis/testresults/settings",
self.client.endpoint(),
&self.organization,
&self.project
))?;
let has_api_version_already = url.query_pairs().any(|(k, _)| k == "api-version");
if !has_api_version_already {
url.query_pairs_mut()
.append_pair("api-version", "7.1-preview");
}
Ok(url)
}
}
impl std::future::IntoFuture for RequestBuilder {
type Output = azure_core::Result<models::TestResultsSettings>;
type IntoFuture = BoxFuture<'static, azure_core::Result<models::TestResultsSettings>>;
#[doc = "Returns a future that sends the request and returns the parsed response body."]
#[doc = ""]
#[doc = "You should not normally call this method directly, simply invoke `.await` which implicitly calls `IntoFuture::into_future`."]
#[doc = ""]
#[doc = "See [IntoFuture documentation](https://doc.rust-lang.org/std/future/trait.IntoFuture.html) for more details."]
fn into_future(self) -> Self::IntoFuture {
Box::pin(async move { self.send().await?.into_body() })
}
}
}
pub mod update {
use super::models;
#[cfg(not(target_arch = "wasm32"))]
use futures::future::BoxFuture;
#[cfg(target_arch = "wasm32")]
use futures::future::LocalBoxFuture as BoxFuture;
#[derive(Debug)]
pub struct Response(
azure_core::http::Response<models::TestResultsSettings, azure_core::http::JsonFormat>,
);
impl Response {
pub fn into_body(self) -> azure_core::Result<models::TestResultsSettings> {
self.0.into_model()
}
pub fn into_raw_response(self) -> azure_core::http::RawResponse {
self.0.into()
}
}
#[derive(Clone)]
#[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."]
#[doc = r""]
#[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"]
#[doc = r" parameters can be chained."]
#[doc = r""]
#[doc = r" To finalize and submit the request, invoke `.await`, which"]
#[doc = r" converts the [`RequestBuilder`] into a future,"]
#[doc = r" executes the request and returns a `Result` with the parsed"]
#[doc = r" response."]
#[doc = r""]
#[doc = r" If you need lower-level access to the raw response details"]
#[doc = r" (e.g. to inspect response headers or raw body data) then you"]
#[doc = r" can finalize the request using the"]
#[doc = r" [`RequestBuilder::send()`] method which returns a future"]
#[doc = r" that resolves to a lower-level [`Response`] value."]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) organization: String,
pub(crate) body: models::TestResultsUpdateSettings,
pub(crate) project: String,
}
impl RequestBuilder {
#[doc = "Returns a future that sends the request and returns a [`Response`] object that provides low-level access to full response details."]
#[doc = ""]
#[doc = "You should typically use `.await` (which implicitly calls `IntoFuture::into_future()`) to finalize and send requests rather than `send()`."]
#[doc = "However, this function can provide more flexibility when required."]
pub fn send(self) -> BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = this.url()?;
let mut req =
azure_core::http::Request::new(url, azure_core::http::Method::Patch);
if let Some(auth_header) = this
.client
.token_credential()
.http_authorization_header(&this.client.scopes())
.await?
{
req.insert_header(
azure_core::http::headers::AUTHORIZATION,
auth_header,
);
}
req.insert_header("content-type", "application/json");
let req_body = azure_core::json::to_json(&this.body)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?.into()))
}
})
}
fn url(&self) -> azure_core::Result<azure_core::http::Url> {
let mut url = azure_core::http::Url::parse(&format!(
"{}/{}/{}/_apis/testresults/settings",
self.client.endpoint(),
&self.organization,
&self.project
))?;
let has_api_version_already = url.query_pairs().any(|(k, _)| k == "api-version");
if !has_api_version_already {
url.query_pairs_mut()
.append_pair("api-version", "7.1-preview");
}
Ok(url)
}
}
impl std::future::IntoFuture for RequestBuilder {
type Output = azure_core::Result<models::TestResultsSettings>;
type IntoFuture = BoxFuture<'static, azure_core::Result<models::TestResultsSettings>>;
#[doc = "Returns a future that sends the request and returns the parsed response body."]
#[doc = ""]
#[doc = "You should not normally call this method directly, simply invoke `.await` which implicitly calls `IntoFuture::into_future`."]
#[doc = ""]
#[doc = "See [IntoFuture documentation](https://doc.rust-lang.org/std/future/trait.IntoFuture.html) for more details."]
fn into_future(self) -> Self::IntoFuture {
Box::pin(async move { self.send().await?.into_body() })
}
}
}
}
pub mod testfailuretype {
use super::models;
#[cfg(not(target_arch = "wasm32"))]
use futures::future::BoxFuture;
#[cfg(target_arch = "wasm32")]
use futures::future::LocalBoxFuture as BoxFuture;
pub struct Client(pub(crate) super::Client);
impl Client {
#[doc = "Returns the list of test failure types."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `organization`: The name of the Azure DevOps organization."]
#[doc = "* `project`: Project ID or project name"]
pub fn list(
&self,
organization: impl Into<String>,
project: impl Into<String>,
) -> list::RequestBuilder {
list::RequestBuilder {
client: self.0.clone(),
organization: organization.into(),
project: project.into(),
}
}
#[doc = "Creates a new test failure type"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `organization`: The name of the Azure DevOps organization."]
#[doc = "* `project`: Project ID or project name"]
pub fn create(
&self,
organization: impl Into<String>,
body: impl Into<models::TestResultFailureTypeRequestModel>,
project: impl Into<String>,
) -> create::RequestBuilder {
create::RequestBuilder {
client: self.0.clone(),
organization: organization.into(),
body: body.into(),
project: project.into(),
}
}
#[doc = "Deletes a test failure type with specified failureTypeId"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `organization`: The name of the Azure DevOps organization."]
#[doc = "* `project`: Project ID or project name"]
pub fn delete(
&self,
organization: impl Into<String>,
project: impl Into<String>,
failure_type_id: i32,
) -> delete::RequestBuilder {
delete::RequestBuilder {
client: self.0.clone(),
organization: organization.into(),
project: project.into(),
failure_type_id,
}
}
}
pub mod list {
use super::models;
#[cfg(not(target_arch = "wasm32"))]
use futures::future::BoxFuture;
#[cfg(target_arch = "wasm32")]
use futures::future::LocalBoxFuture as BoxFuture;
#[derive(Debug)]
pub struct Response(
azure_core::http::Response<
models::TestResultFailureTypeList,
azure_core::http::JsonFormat,
>,
);
impl Response {
pub fn into_body(self) -> azure_core::Result<models::TestResultFailureTypeList> {
self.0.into_model()
}
pub fn into_raw_response(self) -> azure_core::http::RawResponse {
self.0.into()
}
}
#[derive(Clone)]
#[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."]
#[doc = r""]
#[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"]
#[doc = r" parameters can be chained."]
#[doc = r""]
#[doc = r" To finalize and submit the request, invoke `.await`, which"]
#[doc = r" converts the [`RequestBuilder`] into a future,"]
#[doc = r" executes the request and returns a `Result` with the parsed"]
#[doc = r" response."]
#[doc = r""]
#[doc = r" If you need lower-level access to the raw response details"]
#[doc = r" (e.g. to inspect response headers or raw body data) then you"]
#[doc = r" can finalize the request using the"]
#[doc = r" [`RequestBuilder::send()`] method which returns a future"]
#[doc = r" that resolves to a lower-level [`Response`] value."]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) organization: String,
pub(crate) project: String,
}
impl RequestBuilder {
#[doc = "Returns a future that sends the request and returns a [`Response`] object that provides low-level access to full response details."]
#[doc = ""]
#[doc = "You should typically use `.await` (which implicitly calls `IntoFuture::into_future()`) to finalize and send requests rather than `send()`."]
#[doc = "However, this function can provide more flexibility when required."]
pub fn send(self) -> BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = this.url()?;
let mut req =
azure_core::http::Request::new(url, azure_core::http::Method::Get);
if let Some(auth_header) = this
.client
.token_credential()
.http_authorization_header(&this.client.scopes())
.await?
{
req.insert_header(
azure_core::http::headers::AUTHORIZATION,
auth_header,
);
}
let req_body = azure_core::Bytes::new();
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?.into()))
}
})
}
fn url(&self) -> azure_core::Result<azure_core::http::Url> {
let mut url = azure_core::http::Url::parse(&format!(
"{}/{}/{}/_apis/testresults/testfailuretype",
self.client.endpoint(),
&self.organization,
&self.project
))?;
let has_api_version_already = url.query_pairs().any(|(k, _)| k == "api-version");
if !has_api_version_already {
url.query_pairs_mut()
.append_pair("api-version", "7.1-preview");
}
Ok(url)
}
}
impl std::future::IntoFuture for RequestBuilder {
type Output = azure_core::Result<models::TestResultFailureTypeList>;
type IntoFuture =
BoxFuture<'static, azure_core::Result<models::TestResultFailureTypeList>>;
#[doc = "Returns a future that sends the request and returns the parsed response body."]
#[doc = ""]
#[doc = "You should not normally call this method directly, simply invoke `.await` which implicitly calls `IntoFuture::into_future`."]
#[doc = ""]
#[doc = "See [IntoFuture documentation](https://doc.rust-lang.org/std/future/trait.IntoFuture.html) for more details."]
fn into_future(self) -> Self::IntoFuture {
Box::pin(async move { self.send().await?.into_body() })
}
}
}
pub mod create {
use super::models;
#[cfg(not(target_arch = "wasm32"))]
use futures::future::BoxFuture;
#[cfg(target_arch = "wasm32")]
use futures::future::LocalBoxFuture as BoxFuture;
#[derive(Debug)]
pub struct Response(
azure_core::http::Response<models::TestResultFailureType, azure_core::http::JsonFormat>,
);
impl Response {
pub fn into_body(self) -> azure_core::Result<models::TestResultFailureType> {
self.0.into_model()
}
pub fn into_raw_response(self) -> azure_core::http::RawResponse {
self.0.into()
}
}
#[derive(Clone)]
#[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."]
#[doc = r""]
#[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"]
#[doc = r" parameters can be chained."]
#[doc = r""]
#[doc = r" To finalize and submit the request, invoke `.await`, which"]
#[doc = r" converts the [`RequestBuilder`] into a future,"]
#[doc = r" executes the request and returns a `Result` with the parsed"]
#[doc = r" response."]
#[doc = r""]
#[doc = r" If you need lower-level access to the raw response details"]
#[doc = r" (e.g. to inspect response headers or raw body data) then you"]
#[doc = r" can finalize the request using the"]
#[doc = r" [`RequestBuilder::send()`] method which returns a future"]
#[doc = r" that resolves to a lower-level [`Response`] value."]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) organization: String,
pub(crate) body: models::TestResultFailureTypeRequestModel,
pub(crate) project: String,
}
impl RequestBuilder {
#[doc = "Returns a future that sends the request and returns a [`Response`] object that provides low-level access to full response details."]
#[doc = ""]
#[doc = "You should typically use `.await` (which implicitly calls `IntoFuture::into_future()`) to finalize and send requests rather than `send()`."]
#[doc = "However, this function can provide more flexibility when required."]
pub fn send(self) -> BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = this.url()?;
let mut req =
azure_core::http::Request::new(url, azure_core::http::Method::Post);
if let Some(auth_header) = this
.client
.token_credential()
.http_authorization_header(&this.client.scopes())
.await?
{
req.insert_header(
azure_core::http::headers::AUTHORIZATION,
auth_header,
);
}
req.insert_header("content-type", "application/json");
let req_body = azure_core::json::to_json(&this.body)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?.into()))
}
})
}
fn url(&self) -> azure_core::Result<azure_core::http::Url> {
let mut url = azure_core::http::Url::parse(&format!(
"{}/{}/{}/_apis/testresults/testfailuretype",
self.client.endpoint(),
&self.organization,
&self.project
))?;
let has_api_version_already = url.query_pairs().any(|(k, _)| k == "api-version");
if !has_api_version_already {
url.query_pairs_mut()
.append_pair("api-version", "7.1-preview");
}
Ok(url)
}
}
impl std::future::IntoFuture for RequestBuilder {
type Output = azure_core::Result<models::TestResultFailureType>;
type IntoFuture = BoxFuture<'static, azure_core::Result<models::TestResultFailureType>>;
#[doc = "Returns a future that sends the request and returns the parsed response body."]
#[doc = ""]
#[doc = "You should not normally call this method directly, simply invoke `.await` which implicitly calls `IntoFuture::into_future`."]
#[doc = ""]
#[doc = "See [IntoFuture documentation](https://doc.rust-lang.org/std/future/trait.IntoFuture.html) for more details."]
fn into_future(self) -> Self::IntoFuture {
Box::pin(async move { self.send().await?.into_body() })
}
}
}
pub mod delete {
use super::models;
#[cfg(not(target_arch = "wasm32"))]
use futures::future::BoxFuture;
#[cfg(target_arch = "wasm32")]
use futures::future::LocalBoxFuture as BoxFuture;
#[derive(Debug)]
pub struct Response(azure_core::http::Response<(), azure_core::http::NoFormat>);
impl Response {
pub fn into_raw_response(self) -> azure_core::http::RawResponse {
self.0.into()
}
}
#[derive(Clone)]
#[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."]
#[doc = r""]
#[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"]
#[doc = r" parameters can be chained."]
#[doc = r""]
#[doc = r" To finalize and submit the request, invoke `.await`, which"]
#[doc = r" converts the [`RequestBuilder`] into a future,"]
#[doc = r" executes the request and returns a `Result` with the parsed"]
#[doc = r" response."]
#[doc = r""]
#[doc = r" If you need lower-level access to the raw response details"]
#[doc = r" (e.g. to inspect response headers or raw body data) then you"]
#[doc = r" can finalize the request using the"]
#[doc = r" [`RequestBuilder::send()`] method which returns a future"]
#[doc = r" that resolves to a lower-level [`Response`] value."]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) organization: String,
pub(crate) project: String,
pub(crate) failure_type_id: i32,
}
impl RequestBuilder {
#[doc = "Returns a future that sends the request and returns a [`Response`] object that provides low-level access to full response details."]
#[doc = ""]
#[doc = "You should typically use `.await` (which implicitly calls `IntoFuture::into_future()`) to finalize and send requests rather than `send()`."]
#[doc = "However, this function can provide more flexibility when required."]
pub fn send(self) -> BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = this.url()?;
let mut req =
azure_core::http::Request::new(url, azure_core::http::Method::Delete);
if let Some(auth_header) = this
.client
.token_credential()
.http_authorization_header(&this.client.scopes())
.await?
{
req.insert_header(
azure_core::http::headers::AUTHORIZATION,
auth_header,
);
}
let req_body = azure_core::Bytes::new();
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?.into()))
}
})
}
fn url(&self) -> azure_core::Result<azure_core::http::Url> {
let mut url = azure_core::http::Url::parse(&format!(
"{}/{}/{}/_apis/testresults/testfailuretype/{}",
self.client.endpoint(),
&self.organization,
&self.project,
&self.failure_type_id
))?;
let has_api_version_already = url.query_pairs().any(|(k, _)| k == "api-version");
if !has_api_version_already {
url.query_pairs_mut()
.append_pair("api-version", "7.1-preview");
}
Ok(url)
}
}
impl std::future::IntoFuture for RequestBuilder {
type Output = azure_core::Result<()>;
type IntoFuture = BoxFuture<'static, azure_core::Result<()>>;
#[doc = "Returns a future that sends the request and waits for the response."]
#[doc = ""]
#[doc = "You should not normally call this method directly, simply invoke `.await` which implicitly calls `IntoFuture::into_future`."]
#[doc = ""]
#[doc = "See [IntoFuture documentation](https://doc.rust-lang.org/std/future/trait.IntoFuture.html) for more details."]
fn into_future(self) -> Self::IntoFuture {
Box::pin(async move {
let _rsp = self.send().await?;
Ok(())
})
}
}
}
}
pub mod testsettings {
use super::models;
#[cfg(not(target_arch = "wasm32"))]
use futures::future::BoxFuture;
#[cfg(target_arch = "wasm32")]
use futures::future::LocalBoxFuture as BoxFuture;
pub struct Client(pub(crate) super::Client);
impl Client {
#[doc = "Arguments:"]
#[doc = "* `organization`: The name of the Azure DevOps organization."]
#[doc = "* `project`: Project ID or project name"]
pub fn get(
&self,
organization: impl Into<String>,
project: impl Into<String>,
test_settings_id: i32,
) -> get::RequestBuilder {
get::RequestBuilder {
client: self.0.clone(),
organization: organization.into(),
project: project.into(),
test_settings_id,
}
}
#[doc = "Arguments:"]
#[doc = "* `organization`: The name of the Azure DevOps organization."]
#[doc = "* `project`: Project ID or project name"]
pub fn create(
&self,
organization: impl Into<String>,
body: impl Into<models::TestSettings>,
project: impl Into<String>,
) -> create::RequestBuilder {
create::RequestBuilder {
client: self.0.clone(),
organization: organization.into(),
body: body.into(),
project: project.into(),
}
}
#[doc = "Arguments:"]
#[doc = "* `organization`: The name of the Azure DevOps organization."]
#[doc = "* `project`: Project ID or project name"]
pub fn delete(
&self,
organization: impl Into<String>,
project: impl Into<String>,
test_settings_id: i32,
) -> delete::RequestBuilder {
delete::RequestBuilder {
client: self.0.clone(),
organization: organization.into(),
project: project.into(),
test_settings_id,
}
}
}
pub mod get {
use super::models;
#[cfg(not(target_arch = "wasm32"))]
use futures::future::BoxFuture;
#[cfg(target_arch = "wasm32")]
use futures::future::LocalBoxFuture as BoxFuture;
#[derive(Debug)]
pub struct Response(
azure_core::http::Response<models::TestSettings, azure_core::http::JsonFormat>,
);
impl Response {
pub fn into_body(self) -> azure_core::Result<models::TestSettings> {
self.0.into_model()
}
pub fn into_raw_response(self) -> azure_core::http::RawResponse {
self.0.into()
}
}
#[derive(Clone)]
#[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."]
#[doc = r""]
#[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"]
#[doc = r" parameters can be chained."]
#[doc = r""]
#[doc = r" To finalize and submit the request, invoke `.await`, which"]
#[doc = r" converts the [`RequestBuilder`] into a future,"]
#[doc = r" executes the request and returns a `Result` with the parsed"]
#[doc = r" response."]
#[doc = r""]
#[doc = r" If you need lower-level access to the raw response details"]
#[doc = r" (e.g. to inspect response headers or raw body data) then you"]
#[doc = r" can finalize the request using the"]
#[doc = r" [`RequestBuilder::send()`] method which returns a future"]
#[doc = r" that resolves to a lower-level [`Response`] value."]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) organization: String,
pub(crate) project: String,
pub(crate) test_settings_id: i32,
}
impl RequestBuilder {
#[doc = "Returns a future that sends the request and returns a [`Response`] object that provides low-level access to full response details."]
#[doc = ""]
#[doc = "You should typically use `.await` (which implicitly calls `IntoFuture::into_future()`) to finalize and send requests rather than `send()`."]
#[doc = "However, this function can provide more flexibility when required."]
pub fn send(self) -> BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = this.url()?;
let mut req =
azure_core::http::Request::new(url, azure_core::http::Method::Get);
if let Some(auth_header) = this
.client
.token_credential()
.http_authorization_header(&this.client.scopes())
.await?
{
req.insert_header(
azure_core::http::headers::AUTHORIZATION,
auth_header,
);
}
let test_settings_id = &this.test_settings_id;
req.url_mut()
.query_pairs_mut()
.append_pair("testSettingsId", &test_settings_id.to_string());
let req_body = azure_core::Bytes::new();
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?.into()))
}
})
}
fn url(&self) -> azure_core::Result<azure_core::http::Url> {
let mut url = azure_core::http::Url::parse(&format!(
"{}/{}/{}/_apis/testresults/testsettings",
self.client.endpoint(),
&self.organization,
&self.project
))?;
let has_api_version_already = url.query_pairs().any(|(k, _)| k == "api-version");
if !has_api_version_already {
url.query_pairs_mut()
.append_pair("api-version", "7.1-preview");
}
Ok(url)
}
}
impl std::future::IntoFuture for RequestBuilder {
type Output = azure_core::Result<models::TestSettings>;
type IntoFuture = BoxFuture<'static, azure_core::Result<models::TestSettings>>;
#[doc = "Returns a future that sends the request and returns the parsed response body."]
#[doc = ""]
#[doc = "You should not normally call this method directly, simply invoke `.await` which implicitly calls `IntoFuture::into_future`."]
#[doc = ""]
#[doc = "See [IntoFuture documentation](https://doc.rust-lang.org/std/future/trait.IntoFuture.html) for more details."]
fn into_future(self) -> Self::IntoFuture {
Box::pin(async move { self.send().await?.into_body() })
}
}
}
pub mod create {
use super::models;
#[cfg(not(target_arch = "wasm32"))]
use futures::future::BoxFuture;
#[cfg(target_arch = "wasm32")]
use futures::future::LocalBoxFuture as BoxFuture;
#[derive(Debug)]
pub struct Response(azure_core::http::Response<i32, azure_core::http::JsonFormat>);
impl Response {
pub fn into_body(self) -> azure_core::Result<i32> {
self.0.into_model()
}
pub fn into_raw_response(self) -> azure_core::http::RawResponse {
self.0.into()
}
}
#[derive(Clone)]
#[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."]
#[doc = r""]
#[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"]
#[doc = r" parameters can be chained."]
#[doc = r""]
#[doc = r" To finalize and submit the request, invoke `.await`, which"]
#[doc = r" converts the [`RequestBuilder`] into a future,"]
#[doc = r" executes the request and returns a `Result` with the parsed"]
#[doc = r" response."]
#[doc = r""]
#[doc = r" If you need lower-level access to the raw response details"]
#[doc = r" (e.g. to inspect response headers or raw body data) then you"]
#[doc = r" can finalize the request using the"]
#[doc = r" [`RequestBuilder::send()`] method which returns a future"]
#[doc = r" that resolves to a lower-level [`Response`] value."]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) organization: String,
pub(crate) body: models::TestSettings,
pub(crate) project: String,
}
impl RequestBuilder {
#[doc = "Returns a future that sends the request and returns a [`Response`] object that provides low-level access to full response details."]
#[doc = ""]
#[doc = "You should typically use `.await` (which implicitly calls `IntoFuture::into_future()`) to finalize and send requests rather than `send()`."]
#[doc = "However, this function can provide more flexibility when required."]
pub fn send(self) -> BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = this.url()?;
let mut req =
azure_core::http::Request::new(url, azure_core::http::Method::Post);
if let Some(auth_header) = this
.client
.token_credential()
.http_authorization_header(&this.client.scopes())
.await?
{
req.insert_header(
azure_core::http::headers::AUTHORIZATION,
auth_header,
);
}
req.insert_header("content-type", "application/json");
let req_body = azure_core::json::to_json(&this.body)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?.into()))
}
})
}
fn url(&self) -> azure_core::Result<azure_core::http::Url> {
let mut url = azure_core::http::Url::parse(&format!(
"{}/{}/{}/_apis/testresults/testsettings",
self.client.endpoint(),
&self.organization,
&self.project
))?;
let has_api_version_already = url.query_pairs().any(|(k, _)| k == "api-version");
if !has_api_version_already {
url.query_pairs_mut()
.append_pair("api-version", "7.1-preview");
}
Ok(url)
}
}
impl std::future::IntoFuture for RequestBuilder {
type Output = azure_core::Result<i32>;
type IntoFuture = BoxFuture<'static, azure_core::Result<i32>>;
#[doc = "Returns a future that sends the request and returns the parsed response body."]
#[doc = ""]
#[doc = "You should not normally call this method directly, simply invoke `.await` which implicitly calls `IntoFuture::into_future`."]
#[doc = ""]
#[doc = "See [IntoFuture documentation](https://doc.rust-lang.org/std/future/trait.IntoFuture.html) for more details."]
fn into_future(self) -> Self::IntoFuture {
Box::pin(async move { self.send().await?.into_body() })
}
}
}
pub mod delete {
use super::models;
#[cfg(not(target_arch = "wasm32"))]
use futures::future::BoxFuture;
#[cfg(target_arch = "wasm32")]
use futures::future::LocalBoxFuture as BoxFuture;
#[derive(Debug)]
pub struct Response(azure_core::http::Response<(), azure_core::http::NoFormat>);
impl Response {
pub fn into_raw_response(self) -> azure_core::http::RawResponse {
self.0.into()
}
}
#[derive(Clone)]
#[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."]
#[doc = r""]
#[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"]
#[doc = r" parameters can be chained."]
#[doc = r""]
#[doc = r" To finalize and submit the request, invoke `.await`, which"]
#[doc = r" converts the [`RequestBuilder`] into a future,"]
#[doc = r" executes the request and returns a `Result` with the parsed"]
#[doc = r" response."]
#[doc = r""]
#[doc = r" If you need lower-level access to the raw response details"]
#[doc = r" (e.g. to inspect response headers or raw body data) then you"]
#[doc = r" can finalize the request using the"]
#[doc = r" [`RequestBuilder::send()`] method which returns a future"]
#[doc = r" that resolves to a lower-level [`Response`] value."]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) organization: String,
pub(crate) project: String,
pub(crate) test_settings_id: i32,
}
impl RequestBuilder {
#[doc = "Returns a future that sends the request and returns a [`Response`] object that provides low-level access to full response details."]
#[doc = ""]
#[doc = "You should typically use `.await` (which implicitly calls `IntoFuture::into_future()`) to finalize and send requests rather than `send()`."]
#[doc = "However, this function can provide more flexibility when required."]
pub fn send(self) -> BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = this.url()?;
let mut req =
azure_core::http::Request::new(url, azure_core::http::Method::Delete);
if let Some(auth_header) = this
.client
.token_credential()
.http_authorization_header(&this.client.scopes())
.await?
{
req.insert_header(
azure_core::http::headers::AUTHORIZATION,
auth_header,
);
}
let test_settings_id = &this.test_settings_id;
req.url_mut()
.query_pairs_mut()
.append_pair("testSettingsId", &test_settings_id.to_string());
let req_body = azure_core::Bytes::new();
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?.into()))
}
})
}
fn url(&self) -> azure_core::Result<azure_core::http::Url> {
let mut url = azure_core::http::Url::parse(&format!(
"{}/{}/{}/_apis/testresults/testsettings",
self.client.endpoint(),
&self.organization,
&self.project
))?;
let has_api_version_already = url.query_pairs().any(|(k, _)| k == "api-version");
if !has_api_version_already {
url.query_pairs_mut()
.append_pair("api-version", "7.1-preview");
}
Ok(url)
}
}
impl std::future::IntoFuture for RequestBuilder {
type Output = azure_core::Result<()>;
type IntoFuture = BoxFuture<'static, azure_core::Result<()>>;
#[doc = "Returns a future that sends the request and waits for the response."]
#[doc = ""]
#[doc = "You should not normally call this method directly, simply invoke `.await` which implicitly calls `IntoFuture::into_future`."]
#[doc = ""]
#[doc = "See [IntoFuture documentation](https://doc.rust-lang.org/std/future/trait.IntoFuture.html) for more details."]
fn into_future(self) -> Self::IntoFuture {
Box::pin(async move {
let _rsp = self.send().await?;
Ok(())
})
}
}
}
}