use std::{borrow::Cow, collections::BTreeSet, iter};
use chrono::{DateTime, Utc};
use derive_builder::Builder;
use http::Method;
use crate::api::{
common::{CommaSeparatedList, NameOrId, SortOrder},
helpers::{Labels, ReactionEmoji},
Endpoint, Pageable, QueryParams,
};
use super::{
Assignee, IssueDueDateFilter, IssueEpic, IssueHealthStatus, IssueIteration, IssueMilestone,
IssueOrderBy, IssueScope, IssueSearchScope, IssueState, IssueType, IssueWeight,
};
#[derive(Debug, Builder, Clone)]
#[builder(setter(strip_option))]
pub struct GroupIssues<'a> {
#[builder(setter(into))]
group: NameOrId<'a>,
#[builder(setter(name = "_iids"), default, private)]
iids: BTreeSet<u64>,
#[builder(default)]
state: Option<IssueState>,
#[builder(setter(name = "_labels"), default, private)]
labels: Option<Labels<'a>>,
#[builder(default)]
with_labels_details: Option<bool>,
#[builder(default)]
iteration: Option<IssueIteration<'a>>,
#[builder(default)]
milestone_id: Option<IssueMilestone<'a>>,
#[builder(default)]
scope: Option<IssueScope>,
#[builder(setter(into), default)]
author: Option<NameOrId<'a>>,
#[builder(setter(name = "_assignee"), default, private)]
assignee: Option<Assignee<'a>>,
#[builder(setter(name = "_my_reaction_emoji"), default, private)]
my_reaction_emoji: Option<ReactionEmoji<'a>>,
#[builder(default)]
non_archived: Option<bool>,
#[builder(default)]
weight: Option<IssueWeight>,
#[builder(setter(into), default)]
search: Option<Cow<'a, str>>,
#[builder(setter(name = "_search_in"), default, private)]
search_in: Option<CommaSeparatedList<IssueSearchScope>>,
#[builder(default)]
created_after: Option<DateTime<Utc>>,
#[builder(default)]
created_before: Option<DateTime<Utc>>,
#[builder(default)]
updated_after: Option<DateTime<Utc>>,
#[builder(default)]
updated_before: Option<DateTime<Utc>>,
#[builder(default)]
confidential: Option<bool>,
#[builder(default)]
due_date: Option<IssueDueDateFilter>,
#[builder(default)]
epic_id: Option<IssueEpic>,
#[builder(default)]
issue_type: Option<IssueType>,
#[builder(default)]
health_status: Option<IssueHealthStatus>,
#[builder(default)]
order_by: Option<IssueOrderBy>,
#[builder(default)]
sort: Option<SortOrder>,
}
impl<'a> GroupIssues<'a> {
pub fn builder() -> GroupIssuesBuilder<'a> {
GroupIssuesBuilder::default()
}
}
impl<'a> GroupIssuesBuilder<'a> {
pub fn iid(&mut self, iid: u64) -> &mut Self {
self.iids.get_or_insert_with(BTreeSet::new).insert(iid);
self
}
pub fn iids<I>(&mut self, iter: I) -> &mut Self
where
I: Iterator<Item = u64>,
{
self.iids.get_or_insert_with(BTreeSet::new).extend(iter);
self
}
pub fn unlabeled(&mut self) -> &mut Self {
self.labels = Some(Some(Labels::None));
self
}
pub fn with_any_label(&mut self) -> &mut Self {
self.labels = Some(Some(Labels::Any));
self
}
pub fn label<L>(&mut self, label: L) -> &mut Self
where
L: Into<Cow<'a, str>>,
{
let label = label.into();
let labels = if let Some(Some(Labels::AllOf(mut set))) = self.labels.take() {
set.push(label);
set
} else {
iter::once(label).collect()
};
self.labels = Some(Some(Labels::AllOf(labels)));
self
}
pub fn labels<I, L>(&mut self, iter: I) -> &mut Self
where
I: IntoIterator<Item = L>,
L: Into<Cow<'a, str>>,
{
let iter = iter.into_iter().map(Into::into);
let labels = if let Some(Some(Labels::AllOf(mut set))) = self.labels.take() {
set.extend(iter);
set
} else {
iter.collect()
};
self.labels = Some(Some(Labels::AllOf(labels)));
self
}
pub fn without_milestone(&mut self) -> &mut Self {
self.milestone_id = Some(Some(IssueMilestone::None));
self
}
pub fn any_milestone(&mut self) -> &mut Self {
self.milestone_id = Some(Some(IssueMilestone::Any));
self
}
pub fn milestone<M>(&mut self, milestone: M) -> &mut Self
where
M: Into<Cow<'a, str>>,
{
self.milestone_id = Some(Some(IssueMilestone::Named(milestone.into())));
self
}
pub fn unassigned(&mut self) -> &mut Self {
self.assignee = Some(Some(Assignee::Unassigned));
self
}
pub fn assigned(&mut self) -> &mut Self {
self.assignee = Some(Some(Assignee::Assigned));
self
}
pub fn assignee_id(&mut self, assignee: u64) -> &mut Self {
self.assignee = Some(Some(Assignee::Id(assignee)));
self
}
pub fn assignee<A>(&mut self, assignee: A) -> &mut Self
where
A: Into<Cow<'a, str>>,
{
let assignee = assignee.into();
let assignees = if let Some(Some(Assignee::Usernames(mut set))) = self.assignee.take() {
set.insert(assignee);
set
} else {
let mut set = BTreeSet::new();
set.insert(assignee);
set
};
self.assignee = Some(Some(Assignee::Usernames(assignees)));
self
}
pub fn assignees<I, A>(&mut self, iter: I) -> &mut Self
where
I: IntoIterator<Item = A>,
A: Into<Cow<'a, str>>,
{
let iter = iter.into_iter().map(Into::into);
let assignees = if let Some(Some(Assignee::Usernames(mut set))) = self.assignee.take() {
set.extend(iter);
set
} else {
iter.collect()
};
self.assignee = Some(Some(Assignee::Usernames(assignees)));
self
}
pub fn no_reaction(&mut self) -> &mut Self {
self.my_reaction_emoji = Some(Some(ReactionEmoji::None));
self
}
pub fn any_reaction(&mut self) -> &mut Self {
self.my_reaction_emoji = Some(Some(ReactionEmoji::Any));
self
}
pub fn my_reaction<E>(&mut self, emoji: E) -> &mut Self
where
E: Into<Cow<'a, str>>,
{
self.my_reaction_emoji = Some(Some(ReactionEmoji::Emoji(emoji.into())));
self
}
pub fn search_in(&mut self, scope: IssueSearchScope) -> &mut Self {
self.search_in
.get_or_insert(None)
.get_or_insert_with(CommaSeparatedList::new)
.push(scope);
self
}
}
impl<'a> Endpoint for GroupIssues<'a> {
fn method(&self) -> Method {
Method::GET
}
fn endpoint(&self) -> Cow<'static, str> {
format!("groups/{}/issues", self.group).into()
}
fn parameters(&self) -> QueryParams {
let mut params = QueryParams::default();
params
.extend(self.iids.iter().map(|&value| ("iids[]", value)))
.push_opt("state", self.state)
.push_opt("labels", self.labels.as_ref())
.push_opt("with_labels_details", self.with_labels_details)
.push_opt("milestone_id", self.milestone_id.as_ref())
.push_opt("scope", self.scope)
.push_opt("my_reaction_emoji", self.my_reaction_emoji.as_ref())
.push_opt("non_archived", self.non_archived)
.push_opt("weight", self.weight)
.push_opt("search", self.search.as_ref())
.push_opt("in", self.search_in.as_ref())
.push_opt("created_after", self.created_after)
.push_opt("created_before", self.created_before)
.push_opt("updated_after", self.updated_after)
.push_opt("updated_before", self.updated_before)
.push_opt("confidential", self.confidential)
.push_opt("due_date", self.due_date)
.push_opt("epic_id", self.epic_id)
.push_opt("issue_type", self.issue_type)
.push_opt("health_status", self.health_status)
.push_opt("order_by", self.order_by)
.push_opt("sort", self.sort);
if let Some(author) = self.author.as_ref() {
match author {
NameOrId::Name(name) => {
params.push("author_username", name);
},
NameOrId::Id(id) => {
params.push("author_id", *id);
},
}
}
if let Some(iteration) = self.iteration.as_ref() {
iteration.add_params(&mut params);
}
if let Some(assignee) = self.assignee.as_ref() {
assignee.add_params(&mut params);
}
params
}
}
impl<'a> Pageable for GroupIssues<'a> {}
#[cfg(test)]
mod tests {
use chrono::{TimeZone, Utc};
use crate::api::common::SortOrder;
use crate::api::issues::{
groups::GroupIssues, groups::GroupIssuesBuilderError, IssueDueDateFilter, IssueEpic,
IssueHealthStatus, IssueIteration, IssueMilestone, IssueOrderBy, IssueScope,
IssueSearchScope, IssueState, IssueType, IssueWeight,
};
use crate::api::{self, Query};
use crate::test::client::{ExpectedUrl, SingleTestClient};
#[test]
fn group_is_needed() {
let err = GroupIssues::builder().build().unwrap_err();
crate::test::assert_missing_field!(err, GroupIssuesBuilderError, "group");
}
#[test]
fn group_is_sufficient() {
GroupIssues::builder().group(1).build().unwrap();
}
#[test]
fn endpoint() {
let endpoint = ExpectedUrl::builder()
.endpoint("groups/simple%2Fgroup/issues")
.build()
.unwrap();
let client = SingleTestClient::new_raw(endpoint, "");
let endpoint = GroupIssues::builder()
.group("simple/group")
.build()
.unwrap();
api::ignore(endpoint).query(&client).unwrap();
}
#[test]
fn endpoint_iids() {
let endpoint = ExpectedUrl::builder()
.endpoint("groups/simple%2Fgroup/issues")
.add_query_params(&[("iids[]", "1"), ("iids[]", "2")])
.build()
.unwrap();
let client = SingleTestClient::new_raw(endpoint, "");
let endpoint = GroupIssues::builder()
.group("simple/group")
.iid(1)
.iids([1, 2].iter().copied())
.build()
.unwrap();
api::ignore(endpoint).query(&client).unwrap();
}
#[test]
fn endpoint_state() {
let endpoint = ExpectedUrl::builder()
.endpoint("groups/simple%2Fgroup/issues")
.add_query_params(&[("state", "closed")])
.build()
.unwrap();
let client = SingleTestClient::new_raw(endpoint, "");
let endpoint = GroupIssues::builder()
.group("simple/group")
.state(IssueState::Closed)
.build()
.unwrap();
api::ignore(endpoint).query(&client).unwrap();
}
#[test]
fn endpoint_labels() {
let endpoint = ExpectedUrl::builder()
.endpoint("groups/simple%2Fgroup/issues")
.add_query_params(&[("labels", "label,label1,label2")])
.build()
.unwrap();
let client = SingleTestClient::new_raw(endpoint, "");
let endpoint = GroupIssues::builder()
.group("simple/group")
.label("label")
.labels(["label1", "label2"].iter().cloned())
.build()
.unwrap();
api::ignore(endpoint).query(&client).unwrap();
}
#[test]
fn endpoint_labels_unlabeled() {
let endpoint = ExpectedUrl::builder()
.endpoint("groups/simple%2Fgroup/issues")
.add_query_params(&[("labels", "None")])
.build()
.unwrap();
let client = SingleTestClient::new_raw(endpoint, "");
let endpoint = GroupIssues::builder()
.group("simple/group")
.unlabeled()
.build()
.unwrap();
api::ignore(endpoint).query(&client).unwrap();
}
#[test]
fn endpoint_labels_any() {
let endpoint = ExpectedUrl::builder()
.endpoint("groups/simple%2Fgroup/issues")
.add_query_params(&[("labels", "Any")])
.build()
.unwrap();
let client = SingleTestClient::new_raw(endpoint, "");
let endpoint = GroupIssues::builder()
.group("simple/group")
.with_any_label()
.build()
.unwrap();
api::ignore(endpoint).query(&client).unwrap();
}
#[test]
fn endpoint_with_labels_details() {
let endpoint = ExpectedUrl::builder()
.endpoint("groups/simple%2Fgroup/issues")
.add_query_params(&[("with_labels_details", "true")])
.build()
.unwrap();
let client = SingleTestClient::new_raw(endpoint, "");
let endpoint = GroupIssues::builder()
.group("simple/group")
.with_labels_details(true)
.build()
.unwrap();
api::ignore(endpoint).query(&client).unwrap();
}
#[test]
fn endpoint_epic_id() {
let endpoint = ExpectedUrl::builder()
.endpoint("groups/simple%2Fgroup/issues")
.add_query_params(&[("epic_id", "4")])
.build()
.unwrap();
let client = SingleTestClient::new_raw(endpoint, "");
let endpoint = GroupIssues::builder()
.group("simple/group")
.epic_id(IssueEpic::Id(4))
.build()
.unwrap();
api::ignore(endpoint).query(&client).unwrap();
}
#[test]
fn endpoint_issue_type() {
let endpoint = ExpectedUrl::builder()
.endpoint("groups/simple%2Fgroup/issues")
.add_query_params(&[("issue_type", "incident")])
.build()
.unwrap();
let client = SingleTestClient::new_raw(endpoint, "");
let endpoint = GroupIssues::builder()
.group("simple/group")
.issue_type(IssueType::Incident)
.build()
.unwrap();
api::ignore(endpoint).query(&client).unwrap();
}
#[test]
fn endpoint_health_status() {
let endpoint = ExpectedUrl::builder()
.endpoint("groups/simple%2Fgroup/issues")
.add_query_params(&[("health_status", "at_risk")])
.build()
.unwrap();
let client = SingleTestClient::new_raw(endpoint, "");
let endpoint = GroupIssues::builder()
.group("simple/group")
.health_status(IssueHealthStatus::AtRisk)
.build()
.unwrap();
api::ignore(endpoint).query(&client).unwrap();
}
#[test]
fn endpoint_iteration_none() {
let endpoint = ExpectedUrl::builder()
.endpoint("groups/simple%2Fgroup/issues")
.add_query_params(&[("iteration_id", "None")])
.build()
.unwrap();
let client = SingleTestClient::new_raw(endpoint, "");
let endpoint = GroupIssues::builder()
.group("simple/group")
.iteration(IssueIteration::None)
.build()
.unwrap();
api::ignore(endpoint).query(&client).unwrap();
}
#[test]
fn endpoint_iteration_any() {
let endpoint = ExpectedUrl::builder()
.endpoint("groups/simple%2Fgroup/issues")
.add_query_params(&[("iteration_id", "Any")])
.build()
.unwrap();
let client = SingleTestClient::new_raw(endpoint, "");
let endpoint = GroupIssues::builder()
.group("simple/group")
.iteration(IssueIteration::Any)
.build()
.unwrap();
api::ignore(endpoint).query(&client).unwrap();
}
#[test]
fn endpoint_iteration_id() {
let endpoint = ExpectedUrl::builder()
.endpoint("groups/simple%2Fgroup/issues")
.add_query_params(&[("iteration_id", "1")])
.build()
.unwrap();
let client = SingleTestClient::new_raw(endpoint, "");
let endpoint = GroupIssues::builder()
.group("simple/group")
.iteration(IssueIteration::Id(1))
.build()
.unwrap();
api::ignore(endpoint).query(&client).unwrap();
}
#[test]
fn endpoint_iteration_title() {
let endpoint = ExpectedUrl::builder()
.endpoint("groups/simple%2Fgroup/issues")
.add_query_params(&[("iteration_title", "title")])
.build()
.unwrap();
let client = SingleTestClient::new_raw(endpoint, "");
let endpoint = GroupIssues::builder()
.group("simple/group")
.iteration(IssueIteration::Title("title".into()))
.build()
.unwrap();
api::ignore(endpoint).query(&client).unwrap();
}
#[test]
fn endpoint_milestone_id() {
let endpoint = ExpectedUrl::builder()
.endpoint("groups/simple%2Fgroup/issues")
.add_query_params(&[("milestone_id", "1.0")])
.build()
.unwrap();
let client = SingleTestClient::new_raw(endpoint, "");
let endpoint = GroupIssues::builder()
.group("simple/group")
.milestone_id(IssueMilestone::Named("1.0".into()))
.build()
.unwrap();
api::ignore(endpoint).query(&client).unwrap();
}
#[test]
fn endpoint_scope() {
let endpoint = ExpectedUrl::builder()
.endpoint("groups/simple%2Fgroup/issues")
.add_query_params(&[("scope", "all")])
.build()
.unwrap();
let client = SingleTestClient::new_raw(endpoint, "");
let endpoint = GroupIssues::builder()
.group("simple/group")
.scope(IssueScope::All)
.build()
.unwrap();
api::ignore(endpoint).query(&client).unwrap();
}
#[test]
fn endpoint_author_id() {
let endpoint = ExpectedUrl::builder()
.endpoint("groups/simple%2Fgroup/issues")
.add_query_params(&[("author_id", "1")])
.build()
.unwrap();
let client = SingleTestClient::new_raw(endpoint, "");
let endpoint = GroupIssues::builder()
.group("simple/group")
.author(1)
.build()
.unwrap();
api::ignore(endpoint).query(&client).unwrap();
}
#[test]
fn endpoint_author_name() {
let endpoint = ExpectedUrl::builder()
.endpoint("groups/simple%2Fgroup/issues")
.add_query_params(&[("author_username", "name")])
.build()
.unwrap();
let client = SingleTestClient::new_raw(endpoint, "");
let endpoint = GroupIssues::builder()
.group("simple/group")
.author("name")
.build()
.unwrap();
api::ignore(endpoint).query(&client).unwrap();
}
#[test]
fn endpoint_assignee_unassigned() {
let endpoint = ExpectedUrl::builder()
.endpoint("groups/simple%2Fgroup/issues")
.add_query_params(&[("assignee_id", "None")])
.build()
.unwrap();
let client = SingleTestClient::new_raw(endpoint, "");
let endpoint = GroupIssues::builder()
.group("simple/group")
.unassigned()
.build()
.unwrap();
api::ignore(endpoint).query(&client).unwrap();
}
#[test]
fn endpoint_assignee_assigned() {
let endpoint = ExpectedUrl::builder()
.endpoint("groups/simple%2Fgroup/issues")
.add_query_params(&[("assignee_id", "Any")])
.build()
.unwrap();
let client = SingleTestClient::new_raw(endpoint, "");
let endpoint = GroupIssues::builder()
.group("simple/group")
.assigned()
.build()
.unwrap();
api::ignore(endpoint).query(&client).unwrap();
}
#[test]
fn endpoint_assignee_id() {
let endpoint = ExpectedUrl::builder()
.endpoint("groups/simple%2Fgroup/issues")
.add_query_params(&[("assignee_id", "1")])
.build()
.unwrap();
let client = SingleTestClient::new_raw(endpoint, "");
let endpoint = GroupIssues::builder()
.group("simple/group")
.assignee_id(1)
.build()
.unwrap();
api::ignore(endpoint).query(&client).unwrap();
}
#[test]
fn endpoint_assignee_user() {
let endpoint = ExpectedUrl::builder()
.endpoint("groups/simple%2Fgroup/issues")
.add_query_params(&[
("assignee_username[]", "name1"),
("assignee_username[]", "name2"),
])
.build()
.unwrap();
let client = SingleTestClient::new_raw(endpoint, "");
let endpoint = GroupIssues::builder()
.group("simple/group")
.assignee("name1")
.assignees(["name1", "name2"].iter().copied())
.build()
.unwrap();
api::ignore(endpoint).query(&client).unwrap();
}
#[test]
fn endpoint_my_reaction_emoji() {
let endpoint = ExpectedUrl::builder()
.endpoint("groups/simple%2Fgroup/issues")
.add_query_params(&[("my_reaction_emoji", "tada")])
.build()
.unwrap();
let client = SingleTestClient::new_raw(endpoint, "");
let endpoint = GroupIssues::builder()
.group("simple/group")
.my_reaction("tada")
.build()
.unwrap();
api::ignore(endpoint).query(&client).unwrap();
}
#[test]
fn endpoint_my_reaction_emoji_no_reaction() {
let endpoint = ExpectedUrl::builder()
.endpoint("groups/simple%2Fgroup/issues")
.add_query_params(&[("my_reaction_emoji", "None")])
.build()
.unwrap();
let client = SingleTestClient::new_raw(endpoint, "");
let endpoint = GroupIssues::builder()
.group("simple/group")
.no_reaction()
.build()
.unwrap();
api::ignore(endpoint).query(&client).unwrap();
}
#[test]
fn endpoint_my_reaction_emoji_any_reaction() {
let endpoint = ExpectedUrl::builder()
.endpoint("groups/simple%2Fgroup/issues")
.add_query_params(&[("my_reaction_emoji", "Any")])
.build()
.unwrap();
let client = SingleTestClient::new_raw(endpoint, "");
let endpoint = GroupIssues::builder()
.group("simple/group")
.any_reaction()
.build()
.unwrap();
api::ignore(endpoint).query(&client).unwrap();
}
#[test]
fn endpoint_non_archived() {
let endpoint = ExpectedUrl::builder()
.endpoint("groups/simple%2Fgroup/issues")
.add_query_params(&[("non_archived", "true")])
.build()
.unwrap();
let client = SingleTestClient::new_raw(endpoint, "");
let endpoint = GroupIssues::builder()
.group("simple/group")
.non_archived(true)
.build()
.unwrap();
api::ignore(endpoint).query(&client).unwrap();
}
#[test]
fn endpoint_weight() {
let endpoint = ExpectedUrl::builder()
.endpoint("groups/simple%2Fgroup/issues")
.add_query_params(&[("weight", "Any")])
.build()
.unwrap();
let client = SingleTestClient::new_raw(endpoint, "");
let endpoint = GroupIssues::builder()
.group("simple/group")
.weight(IssueWeight::Any)
.build()
.unwrap();
api::ignore(endpoint).query(&client).unwrap();
}
#[test]
fn endpoint_search() {
let endpoint = ExpectedUrl::builder()
.endpoint("groups/simple%2Fgroup/issues")
.add_query_params(&[("search", "query")])
.build()
.unwrap();
let client = SingleTestClient::new_raw(endpoint, "");
let endpoint = GroupIssues::builder()
.group("simple/group")
.search("query")
.build()
.unwrap();
api::ignore(endpoint).query(&client).unwrap();
}
#[test]
fn endpoint_search_in() {
let endpoint = ExpectedUrl::builder()
.endpoint("groups/simple%2Fgroup/issues")
.add_query_params(&[("in", "title,description")])
.build()
.unwrap();
let client = SingleTestClient::new_raw(endpoint, "");
let endpoint = GroupIssues::builder()
.group("simple/group")
.search_in(IssueSearchScope::Title)
.search_in(IssueSearchScope::Description)
.build()
.unwrap();
api::ignore(endpoint).query(&client).unwrap();
}
#[test]
fn endpoint_created_after() {
let endpoint = ExpectedUrl::builder()
.endpoint("groups/simple%2Fgroup/issues")
.add_query_params(&[("created_after", "2020-01-01T00:00:00Z")])
.build()
.unwrap();
let client = SingleTestClient::new_raw(endpoint, "");
let endpoint = GroupIssues::builder()
.group("simple/group")
.created_after(Utc.with_ymd_and_hms(2020, 1, 1, 0, 0, 0).unwrap())
.build()
.unwrap();
api::ignore(endpoint).query(&client).unwrap();
}
#[test]
fn endpoint_created_before() {
let endpoint = ExpectedUrl::builder()
.endpoint("groups/simple%2Fgroup/issues")
.add_query_params(&[("created_before", "2020-01-01T00:00:00Z")])
.build()
.unwrap();
let client = SingleTestClient::new_raw(endpoint, "");
let endpoint = GroupIssues::builder()
.group("simple/group")
.created_before(Utc.with_ymd_and_hms(2020, 1, 1, 0, 0, 0).unwrap())
.build()
.unwrap();
api::ignore(endpoint).query(&client).unwrap();
}
#[test]
fn endpoint_updated_after() {
let endpoint = ExpectedUrl::builder()
.endpoint("groups/simple%2Fgroup/issues")
.add_query_params(&[("updated_after", "2020-01-01T00:00:00Z")])
.build()
.unwrap();
let client = SingleTestClient::new_raw(endpoint, "");
let endpoint = GroupIssues::builder()
.group("simple/group")
.updated_after(Utc.with_ymd_and_hms(2020, 1, 1, 0, 0, 0).unwrap())
.build()
.unwrap();
api::ignore(endpoint).query(&client).unwrap();
}
#[test]
fn endpoint_updated_before() {
let endpoint = ExpectedUrl::builder()
.endpoint("groups/simple%2Fgroup/issues")
.add_query_params(&[("updated_before", "2020-01-01T00:00:00Z")])
.build()
.unwrap();
let client = SingleTestClient::new_raw(endpoint, "");
let endpoint = GroupIssues::builder()
.group("simple/group")
.updated_before(Utc.with_ymd_and_hms(2020, 1, 1, 0, 0, 0).unwrap())
.build()
.unwrap();
api::ignore(endpoint).query(&client).unwrap();
}
#[test]
fn endpoint_confidential() {
let endpoint = ExpectedUrl::builder()
.endpoint("groups/simple%2Fgroup/issues")
.add_query_params(&[("confidential", "true")])
.build()
.unwrap();
let client = SingleTestClient::new_raw(endpoint, "");
let endpoint = GroupIssues::builder()
.group("simple/group")
.confidential(true)
.build()
.unwrap();
api::ignore(endpoint).query(&client).unwrap();
}
#[test]
fn endpoint_due_date() {
let endpoint = ExpectedUrl::builder()
.endpoint("groups/simple%2Fgroup/issues")
.add_query_params(&[("due_date", "week")])
.build()
.unwrap();
let client = SingleTestClient::new_raw(endpoint, "");
let endpoint = GroupIssues::builder()
.group("simple/group")
.due_date(IssueDueDateFilter::ThisWeek)
.build()
.unwrap();
api::ignore(endpoint).query(&client).unwrap();
}
#[test]
fn endpoint_order_by() {
let endpoint = ExpectedUrl::builder()
.endpoint("groups/simple%2Fgroup/issues")
.add_query_params(&[("order_by", "due_date")])
.build()
.unwrap();
let client = SingleTestClient::new_raw(endpoint, "");
let endpoint = GroupIssues::builder()
.group("simple/group")
.order_by(IssueOrderBy::DueDate)
.build()
.unwrap();
api::ignore(endpoint).query(&client).unwrap();
}
#[test]
fn endpoint_sort() {
let endpoint = ExpectedUrl::builder()
.endpoint("groups/simple%2Fgroup/issues")
.add_query_params(&[("sort", "desc")])
.build()
.unwrap();
let client = SingleTestClient::new_raw(endpoint, "");
let endpoint = GroupIssues::builder()
.group("simple/group")
.sort(SortOrder::Descending)
.build()
.unwrap();
api::ignore(endpoint).query(&client).unwrap();
}
}