aboutsummaryrefslogtreecommitdiffstats
path: root/rust
diff options
context:
space:
mode:
Diffstat (limited to 'rust')
-rw-r--r--rust/src/api_entity_crud.rs139
-rw-r--r--rust/src/api_helpers.rs93
-rw-r--r--rust/src/api_server.rs40
-rw-r--r--rust/src/api_wrappers.rs58
-rw-r--r--rust/src/bin/fatcat-export.rs2
-rw-r--r--rust/tests/test_api_server_http.rs16
-rw-r--r--rust/tests/test_old_python_tests.rs4
7 files changed, 242 insertions, 110 deletions
diff --git a/rust/src/api_entity_crud.rs b/rust/src/api_entity_crud.rs
index 80cae471..3a2760c2 100644
--- a/rust/src/api_entity_crud.rs
+++ b/rust/src/api_entity_crud.rs
@@ -41,8 +41,8 @@ where
type RevRow;
// Generic Methods
- fn db_get(conn: &DbConn, ident: FatCatId) -> Result<Self>;
- fn db_get_rev(conn: &DbConn, rev_id: Uuid) -> Result<Self>;
+ fn db_get(conn: &DbConn, ident: FatCatId, hide: HideFlags) -> Result<Self>;
+ fn db_get_rev(conn: &DbConn, rev_id: Uuid, hide: HideFlags) -> Result<Self>;
fn db_expand(&mut self, conn: &DbConn, expand: ExpandFlags) -> Result<()>;
fn db_create(&self, conn: &DbConn, edit_context: &EditContext) -> Result<Self::EditRow>;
fn db_create_batch(
@@ -73,6 +73,7 @@ where
conn: &DbConn,
rev_row: Self::RevRow,
ident_row: Option<Self::IdentRow>,
+ hide: HideFlags,
) -> Result<Self>;
fn db_insert_rev(&self, conn: &DbConn) -> Result<Uuid>;
fn db_insert_revs(conn: &DbConn, models: &[&Self]) -> Result<Vec<Uuid>>;
@@ -80,23 +81,23 @@ where
macro_rules! generic_db_get {
($ident_table:ident, $rev_table:ident) => {
- fn db_get(conn: &DbConn, ident: FatCatId) -> Result<Self> {
+ fn db_get(conn: &DbConn, ident: FatCatId, hide: HideFlags) -> Result<Self> {
let (ident, rev): (Self::IdentRow, Self::RevRow) = $ident_table::table
.find(ident.to_uuid())
.inner_join($rev_table::table)
.first(conn)?;
- Self::db_from_row(conn, rev, Some(ident))
+ Self::db_from_row(conn, rev, Some(ident), hide)
}
};
}
macro_rules! generic_db_get_rev {
($rev_table:ident) => {
- fn db_get_rev(conn: &DbConn, rev_id: Uuid) -> Result<Self> {
+ fn db_get_rev(conn: &DbConn, rev_id: Uuid, hide: HideFlags) -> Result<Self> {
let rev = $rev_table::table.find(rev_id).first(conn)?;
- Self::db_from_row(conn, rev, None)
+ Self::db_from_row(conn, rev, None, hide)
}
};
}
@@ -388,6 +389,7 @@ impl EntityCrud for ContainerEntity {
_conn: &DbConn,
rev_row: Self::RevRow,
ident_row: Option<Self::IdentRow>,
+ _hide: HideFlags,
) -> Result<Self> {
let (state, ident_id, redirect_id) = match ident_row {
Some(i) => (
@@ -466,6 +468,7 @@ impl EntityCrud for CreatorEntity {
_conn: &DbConn,
rev_row: Self::RevRow,
ident_row: Option<Self::IdentRow>,
+ _hide: HideFlags,
) -> Result<Self> {
let (state, ident_id, redirect_id) = match ident_row {
Some(i) => (
@@ -541,6 +544,7 @@ impl EntityCrud for FileEntity {
conn: &DbConn,
rev_row: Self::RevRow,
ident_row: Option<Self::IdentRow>,
+ _hide: HideFlags,
) -> Result<Self> {
let (state, ident_id, redirect_id) = match ident_row {
Some(i) => (
@@ -660,8 +664,6 @@ impl EntityCrud for ReleaseEntity {
generic_db_get!(release_ident, release_rev);
generic_db_get_rev!(release_rev);
- //generic_db_create!(release_ident, release_edit);
- //generic_db_create_batch!(release_ident, release_edit);
generic_db_update!(release_ident, release_edit);
generic_db_delete!(release_ident, release_edit);
generic_db_get_history!(release_edit);
@@ -674,11 +676,11 @@ impl EntityCrud for ReleaseEntity {
None => bail!("Can't expand files on a non-concrete entity"),
Some(s) => FatCatId::from_str(&s)?,
};
- self.files = Some(get_release_files(ident, conn)?);
+ self.files = Some(get_release_files(ident, HideFlags::none(), conn)?);
}
if expand.container {
if let Some(ref cid) = self.container_id {
- self.container = Some(ContainerEntity::db_get(conn, FatCatId::from_str(&cid)?)?);
+ self.container = Some(ContainerEntity::db_get(conn, FatCatId::from_str(&cid)?, HideFlags::none())?);
}
}
Ok(())
@@ -768,6 +770,7 @@ impl EntityCrud for ReleaseEntity {
conn: &DbConn,
rev_row: Self::RevRow,
ident_row: Option<Self::IdentRow>,
+ hide: HideFlags,
) -> Result<Self> {
let (state, ident_id, redirect_id) = match ident_row {
Some(i) => (
@@ -778,55 +781,70 @@ impl EntityCrud for ReleaseEntity {
None => (None, None, None),
};
- let refs: Vec<ReleaseRef> = release_ref::table
- .filter(release_ref::release_rev.eq(rev_row.id))
- .order(release_ref::index_val.asc())
- .get_results(conn)?
- .into_iter()
- .map(|r: ReleaseRefRow| ReleaseRef {
- index: r.index_val.map(|v| v as i64),
- key: r.key,
- extra: r.extra_json,
- container_name: r.container_name,
- year: r.year.map(|v| v as i64),
- title: r.title,
- locator: r.locator,
- target_release_id: r
- .target_release_ident_id
- .map(|v| FatCatId::from_uuid(&v).to_string()),
- }).collect();
+ let refs: Option<Vec<ReleaseRef>> = match hide.refs {
+ true => None,
+ false => Some(
+ release_ref::table
+ .filter(release_ref::release_rev.eq(rev_row.id))
+ .order(release_ref::index_val.asc())
+ .get_results(conn)?
+ .into_iter()
+ .map(|r: ReleaseRefRow| ReleaseRef {
+ index: r.index_val.map(|v| v as i64),
+ key: r.key,
+ extra: r.extra_json,
+ container_name: r.container_name,
+ year: r.year.map(|v| v as i64),
+ title: r.title,
+ locator: r.locator,
+ target_release_id: r
+ .target_release_ident_id
+ .map(|v| FatCatId::from_uuid(&v).to_string()),
+ }).collect(),
+ ),
+ };
- let contribs: Vec<ReleaseContrib> = release_contrib::table
- .filter(release_contrib::release_rev.eq(rev_row.id))
- .order((
- release_contrib::role.asc(),
- release_contrib::index_val.asc(),
- )).get_results(conn)?
- .into_iter()
- .map(|c: ReleaseContribRow| ReleaseContrib {
- index: c.index_val.map(|v| v as i64),
- raw_name: c.raw_name,
- role: c.role,
- extra: c.extra_json,
- creator_id: c
- .creator_ident_id
- .map(|v| FatCatId::from_uuid(&v).to_string()),
- creator: None,
- }).collect();
+ let contribs: Option<Vec<ReleaseContrib>> = match hide.contribs {
+ true => None,
+ false => Some(
+ release_contrib::table
+ .filter(release_contrib::release_rev.eq(rev_row.id))
+ .order((
+ release_contrib::role.asc(),
+ release_contrib::index_val.asc(),
+ )).get_results(conn)?
+ .into_iter()
+ .map(|c: ReleaseContribRow| ReleaseContrib {
+ index: c.index_val.map(|v| v as i64),
+ raw_name: c.raw_name,
+ role: c.role,
+ extra: c.extra_json,
+ creator_id: c
+ .creator_ident_id
+ .map(|v| FatCatId::from_uuid(&v).to_string()),
+ creator: None,
+ }).collect(),
+ ),
+ };
- let abstracts: Vec<ReleaseEntityAbstracts> = release_rev_abstract::table
- .inner_join(abstracts::table)
- .filter(release_rev_abstract::release_rev.eq(rev_row.id))
- .get_results(conn)?
- .into_iter()
- .map(
- |r: (ReleaseRevAbstractRow, AbstractsRow)| ReleaseEntityAbstracts {
- sha1: Some(r.0.abstract_sha1),
- mimetype: r.0.mimetype,
- lang: r.0.lang,
- content: Some(r.1.content),
- },
- ).collect();
+ let abstracts: Option<Vec<ReleaseEntityAbstracts>> = match hide.abstracts {
+ true => None,
+ false => Some(
+ release_rev_abstract::table
+ .inner_join(abstracts::table)
+ .filter(release_rev_abstract::release_rev.eq(rev_row.id))
+ .get_results(conn)?
+ .into_iter()
+ .map(
+ |r: (ReleaseRevAbstractRow, AbstractsRow)| ReleaseEntityAbstracts {
+ sha1: Some(r.0.abstract_sha1),
+ mimetype: r.0.mimetype,
+ lang: r.0.lang,
+ content: Some(r.1.content),
+ },
+ ).collect(),
+ ),
+ };
Ok(ReleaseEntity {
title: rev_row.title,
@@ -850,9 +868,9 @@ impl EntityCrud for ReleaseEntity {
publisher: rev_row.publisher,
language: rev_row.language,
work_id: Some(FatCatId::from_uuid(&rev_row.work_ident_id).to_string()),
- refs: Some(refs),
- contribs: Some(contribs),
- abstracts: Some(abstracts),
+ refs: refs,
+ contribs: contribs,
+ abstracts: abstracts,
state: state,
ident: ident_id,
revision: Some(rev_row.id.to_string()),
@@ -1060,6 +1078,7 @@ impl EntityCrud for WorkEntity {
_conn: &DbConn,
rev_row: Self::RevRow,
ident_row: Option<Self::IdentRow>,
+ _hide: HideFlags,
) -> Result<Self> {
let (state, ident_id, redirect_id) = match ident_row {
Some(i) => (
diff --git a/rust/src/api_helpers.rs b/rust/src/api_helpers.rs
index 4b3f573b..952cb9cd 100644
--- a/rust/src/api_helpers.rs
+++ b/rust/src/api_helpers.rs
@@ -39,25 +39,11 @@ impl FromStr for ExpandFlags {
impl ExpandFlags {
pub fn from_str_list(list: &[&str]) -> ExpandFlags {
- if list.contains(&"none") {
- ExpandFlags::none()
- } else if list.contains(&"all") {
- ExpandFlags::all()
- } else {
- ExpandFlags {
- files: list.contains(&"files"),
- container: list.contains(&"container"),
- releases: list.contains(&"releases"),
- creators: list.contains(&"creators"),
- }
- }
- }
- pub fn all() -> ExpandFlags {
ExpandFlags {
- files: true,
- container: true,
- releases: true,
- creators: true,
+ files: list.contains(&"files"),
+ container: list.contains(&"container"),
+ releases: list.contains(&"releases"),
+ creators: list.contains(&"creators"),
}
}
pub fn none() -> ExpandFlags {
@@ -103,7 +89,70 @@ fn test_expand_flags() {
creators: true
}
);
- assert!(all == ExpandFlags::all());
+}
+
+#[derive(Clone, Copy, PartialEq)]
+pub struct HideFlags {
+ pub abstracts: bool,
+ pub refs: bool,
+ pub contribs: bool,
+}
+
+impl FromStr for HideFlags {
+ type Err = Error;
+ fn from_str(param: &str) -> Result<HideFlags> {
+ let list: Vec<&str> = param.split_terminator(",").collect();
+ Ok(HideFlags::from_str_list(&list))
+ }
+}
+
+impl HideFlags {
+ pub fn from_str_list(list: &[&str]) -> HideFlags {
+ HideFlags {
+ abstracts: list.contains(&"abstracts"),
+ refs: list.contains(&"refs"),
+ contribs: list.contains(&"contribs"),
+ }
+ }
+ pub fn none() -> HideFlags {
+ HideFlags {
+ abstracts: false,
+ refs: false,
+ contribs: false,
+ }
+ }
+}
+
+#[test]
+fn test_hide_flags() {
+ assert!(HideFlags::from_str_list(&vec![]).abstracts == false);
+ assert!(HideFlags::from_str_list(&vec!["abstracts"]).abstracts == true);
+ assert!(HideFlags::from_str_list(&vec!["abstract"]).abstracts == false);
+ let all = HideFlags::from_str_list(&vec!["abstracts", "refs", "other_thing", "contribs"]);
+ assert!(
+ all == HideFlags {
+ abstracts: true,
+ refs: true,
+ contribs: true,
+ }
+ );
+ assert!(HideFlags::from_str("").unwrap().abstracts == false);
+ assert!(HideFlags::from_str("abstracts").unwrap().abstracts == true);
+ assert!(
+ HideFlags::from_str("something,,abstracts")
+ .unwrap()
+ .abstracts
+ == true
+ );
+ assert!(HideFlags::from_str("file").unwrap().abstracts == false);
+ let all = HideFlags::from_str("abstracts,refs,other_thing,contribs").unwrap();
+ assert!(
+ all == HideFlags {
+ abstracts: true,
+ refs: true,
+ contribs: true,
+ }
+ );
}
pub fn make_edit_context(
@@ -320,7 +369,6 @@ fn test_check_orcid() {
}
pub fn check_release_type(raw: &str) -> Result<()> {
-
let valid_types = vec![
// Citation Style Language official types
"article",
@@ -365,7 +413,7 @@ pub fn check_release_type(raw: &str) -> Result<()> {
];
for good in valid_types {
if raw == good {
- return Ok(())
+ return Ok(());
}
}
Err(ErrorKind::NotInControlledVocabulary(format!(
@@ -385,7 +433,6 @@ fn test_check_release_type() {
}
pub fn check_contrib_role(raw: &str) -> Result<()> {
-
let valid_types = vec![
// Citation Style Language official role types
"author",
@@ -407,7 +454,7 @@ pub fn check_contrib_role(raw: &str) -> Result<()> {
];
for good in valid_types {
if raw == good {
- return Ok(())
+ return Ok(());
}
}
Err(ErrorKind::NotInControlledVocabulary(format!(
diff --git a/rust/src/api_server.rs b/rust/src/api_server.rs
index 9562a0f2..2bcd4a7f 100644
--- a/rust/src/api_server.rs
+++ b/rust/src/api_server.rs
@@ -53,7 +53,7 @@ pub struct Server {
pub db_pool: ConnectionPool,
}
-pub fn get_release_files(id: FatCatId, conn: &DbConn) -> Result<Vec<FileEntity>> {
+pub fn get_release_files(id: FatCatId, hide: HideFlags, conn: &DbConn) -> Result<Vec<FileEntity>> {
let rows: Vec<(FileRevRow, FileIdentRow, FileReleaseRow)> = file_rev::table
.inner_join(file_ident::table)
.inner_join(file_release::table)
@@ -63,12 +63,13 @@ pub fn get_release_files(id: FatCatId, conn: &DbConn) -> Result<Vec<FileEntity>>
.load(conn)?;
rows.into_iter()
- .map(|(rev, ident, _)| FileEntity::db_from_row(conn, rev, Some(ident)))
- .collect()
+ .map(
+ |(rev, ident, _)| FileEntity::db_from_row(conn, rev, Some(ident), hide),
+ ).collect()
}
impl Server {
- pub fn lookup_container_handler(&self, issnl: &str, conn: &DbConn) -> Result<ContainerEntity> {
+ pub fn lookup_container_handler(&self, issnl: &str, hide: HideFlags, conn: &DbConn) -> Result<ContainerEntity> {
check_issn(issnl)?;
let (ident, rev): (ContainerIdentRow, ContainerRevRow) = container_ident::table
.inner_join(container_rev::table)
@@ -77,10 +78,10 @@ impl Server {
.filter(container_ident::redirect_id.is_null())
.first(conn)?;
- ContainerEntity::db_from_row(conn, rev, Some(ident))
+ ContainerEntity::db_from_row(conn, rev, Some(ident), hide)
}
- pub fn lookup_creator_handler(&self, orcid: &str, conn: &DbConn) -> Result<CreatorEntity> {
+ pub fn lookup_creator_handler(&self, orcid: &str, hide: HideFlags, conn: &DbConn) -> Result<CreatorEntity> {
check_orcid(orcid)?;
let (ident, rev): (CreatorIdentRow, CreatorRevRow) = creator_ident::table
.inner_join(creator_rev::table)
@@ -89,12 +90,13 @@ impl Server {
.filter(creator_ident::redirect_id.is_null())
.first(conn)?;
- CreatorEntity::db_from_row(conn, rev, Some(ident))
+ CreatorEntity::db_from_row(conn, rev, Some(ident), hide)
}
pub fn get_creator_releases_handler(
&self,
id: FatCatId,
+ hide: HideFlags,
conn: &DbConn,
) -> Result<Vec<ReleaseEntity>> {
// TODO: some kind of unique or group-by?
@@ -108,11 +110,11 @@ impl Server {
// TODO: from_rows, not from_row?
rows.into_iter()
- .map(|(rev, ident, _)| ReleaseEntity::db_from_row(conn, rev, Some(ident)))
+ .map(|(rev, ident, _)| ReleaseEntity::db_from_row(conn, rev, Some(ident), hide))
.collect()
}
- pub fn lookup_file_handler(&self, sha1: &str, conn: &DbConn) -> Result<FileEntity> {
+ pub fn lookup_file_handler(&self, sha1: &str, hide: HideFlags, conn: &DbConn) -> Result<FileEntity> {
let (ident, rev): (FileIdentRow, FileRevRow) = file_ident::table
.inner_join(file_rev::table)
.filter(file_rev::sha1.eq(sha1))
@@ -120,10 +122,15 @@ impl Server {
.filter(file_ident::redirect_id.is_null())
.first(conn)?;
- FileEntity::db_from_row(conn, rev, Some(ident))
+ FileEntity::db_from_row(conn, rev, Some(ident), hide)
}
- pub fn lookup_release_handler(&self, doi: &str, conn: &DbConn) -> Result<ReleaseEntity> {
+ pub fn lookup_release_handler(
+ &self,
+ doi: &str,
+ hide: HideFlags,
+ conn: &DbConn,
+ ) -> Result<ReleaseEntity> {
check_doi(doi)?;
let (ident, rev): (ReleaseIdentRow, ReleaseRevRow) = release_ident::table
.inner_join(release_rev::table)
@@ -132,20 +139,22 @@ impl Server {
.filter(release_ident::redirect_id.is_null())
.first(conn)?;
- ReleaseEntity::db_from_row(conn, rev, Some(ident))
+ ReleaseEntity::db_from_row(conn, rev, Some(ident), hide)
}
pub fn get_release_files_handler(
&self,
id: FatCatId,
+ hide: HideFlags,
conn: &DbConn,
) -> Result<Vec<FileEntity>> {
- get_release_files(id, conn)
+ get_release_files(id, hide, conn)
}
pub fn get_work_releases_handler(
&self,
id: FatCatId,
+ hide: HideFlags,
conn: &DbConn,
) -> Result<Vec<ReleaseEntity>> {
let rows: Vec<(ReleaseRevRow, ReleaseIdentRow)> = release_rev::table
@@ -156,8 +165,9 @@ impl Server {
.load(conn)?;
rows.into_iter()
- .map(|(rev, ident)| ReleaseEntity::db_from_row(conn, rev, Some(ident)))
- .collect()
+ .map(|(rev, ident)| {
+ ReleaseEntity::db_from_row(conn, rev, Some(ident), hide)
+ }).collect()
}
pub fn accept_editgroup_handler(&self, id: FatCatId, conn: &DbConn) -> Result<()> {
diff --git a/rust/src/api_wrappers.rs b/rust/src/api_wrappers.rs
index 098ea0b9..e5176ac6 100644
--- a/rust/src/api_wrappers.rs
+++ b/rust/src/api_wrappers.rs
@@ -30,17 +30,22 @@ macro_rules! wrap_entity_handlers {
&self,
id: String,
expand: Option<String>,
+ hide: Option<String>,
_context: &Context,
) -> Box<Future<Item = $get_resp, Error = ApiError> + Send> {
let conn = self.db_pool.get().expect("db_pool error");
// No transaction for GET
let ret = match conn.transaction(|| {
let entity_id = FatCatId::from_str(&id)?;
+ let hide_flags = match hide {
+ None => HideFlags::none(),
+ Some(param) => HideFlags::from_str(&param)?,
+ };
match expand {
- None => $model::db_get(&conn, entity_id),
+ None => $model::db_get(&conn, entity_id, hide_flags),
Some(param) => {
let expand_flags = ExpandFlags::from_str(&param)?;
- let mut entity = $model::db_get(&conn, entity_id)?;
+ let mut entity = $model::db_get(&conn, entity_id, hide_flags)?;
entity.db_expand(&conn, expand_flags)?;
Ok(entity)
},
@@ -247,11 +252,16 @@ macro_rules! wrap_lookup_handler {
fn $get_fn(
&self,
$idname: $idtype,
+ hide: Option<String>,
_context: &Context,
) -> Box<Future<Item = $get_resp, Error = ApiError> + Send> {
let conn = self.db_pool.get().expect("db_pool error");
+ let hide_flags = match hide {
+ None => HideFlags::none(),
+ Some(param) => HideFlags::from_str(&param).unwrap(),
+ };
// No transaction for GET
- let ret = match self.$get_handler(&$idname, &conn) {
+ let ret = match self.$get_handler(&$idname, hide_flags, &conn) {
Ok(entity) =>
$get_resp::FoundEntity(entity),
Err(Error(ErrorKind::Diesel(::diesel::result::Error::NotFound), _)) =>
@@ -299,6 +309,42 @@ macro_rules! wrap_fcid_handler {
}
}
+macro_rules! wrap_fcid_hide_handler {
+ ($get_fn:ident, $get_handler:ident, $get_resp:ident) => {
+ fn $get_fn(
+ &self,
+ id: String,
+ hide: Option<String>,
+ _context: &Context,
+ ) -> Box<Future<Item = $get_resp, Error = ApiError> + Send> {
+ let conn = self.db_pool.get().expect("db_pool error");
+ // No transaction for GET
+ let ret = match (|| {
+ let fcid = FatCatId::from_str(&id)?;
+ let hide_flags = match hide {
+ None => HideFlags::none(),
+ Some(param) => HideFlags::from_str(&param)?,
+ };
+ self.$get_handler(fcid, hide_flags, &conn)
+ })() {
+ Ok(entity) =>
+ $get_resp::Found(entity),
+ Err(Error(ErrorKind::Diesel(::diesel::result::Error::NotFound), _)) =>
+ $get_resp::NotFound(ErrorResponse { message: format!("Not found: {}", id) }),
+ Err(Error(ErrorKind::MalformedExternalId(e), _)) =>
+ $get_resp::BadRequest(ErrorResponse { message: e.to_string() }),
+ Err(Error(ErrorKind::NotInControlledVocabulary(e), _)) =>
+ $get_resp::BadRequest(ErrorResponse { message: e.to_string() }),
+ Err(e) => {
+ error!("{}", e);
+ $get_resp::BadRequest(ErrorResponse { message: e.to_string() })
+ },
+ };
+ Box::new(futures::done(Ok(ret)))
+ }
+ }
+}
+
impl Api for Server {
wrap_entity_handlers!(
get_container,
@@ -411,17 +457,17 @@ impl Api for Server {
String
);
- wrap_fcid_handler!(
+ wrap_fcid_hide_handler!(
get_release_files,
get_release_files_handler,
GetReleaseFilesResponse
);
- wrap_fcid_handler!(
+ wrap_fcid_hide_handler!(
get_work_releases,
get_work_releases_handler,
GetWorkReleasesResponse
);
- wrap_fcid_handler!(
+ wrap_fcid_hide_handler!(
get_creator_releases,
get_creator_releases_handler,
GetCreatorReleasesResponse
diff --git a/rust/src/bin/fatcat-export.rs b/rust/src/bin/fatcat-export.rs
index 0d6d69b1..9dd5138e 100644
--- a/rust/src/bin/fatcat-export.rs
+++ b/rust/src/bin/fatcat-export.rs
@@ -73,7 +73,7 @@ macro_rules! generic_loop_work {
fn $fn_name(row_receiver: channel::Receiver<IdentRow>, output_sender: channel::Sender<String>, db_conn: &DbConn, expand: Option<ExpandFlags>) {
let result: Result<()> = (|| {
for row in row_receiver {
- let mut entity = $entity_model::db_get_rev(db_conn, row.rev_id.expect("valid, non-deleted row"))
+ let mut entity = $entity_model::db_get_rev(db_conn, row.rev_id.expect("valid, non-deleted row"), HideFlags::none())
.chain_err(|| "reading entity from database")?;
//let mut entity = ReleaseEntity::db_get_rev(db_conn, row.rev_id.expect("valid, non-deleted row"))?;
entity.state = Some("active".to_string()); // XXX
diff --git a/rust/tests/test_api_server_http.rs b/rust/tests/test_api_server_http.rs
index c179637c..614e6b65 100644
--- a/rust/tests/test_api_server_http.rs
+++ b/rust/tests/test_api_server_http.rs
@@ -81,7 +81,7 @@ fn test_entity_gets() {
// expand keyword
check_http_response(
request::get(
- "http://localhost:9411/v0/release/aaaaaaaaaaaaarceaaaaaaaaai?expand=all",
+ "http://localhost:9411/v0/release/aaaaaaaaaaaaarceaaaaaaaaai?expand=container",
headers.clone(),
&router,
),
@@ -89,6 +89,17 @@ fn test_entity_gets() {
Some("MySpace Blog"),
);
+ // hide keyword
+ check_http_response(
+ request::get(
+ "http://localhost:9411/v0/release/aaaaaaaaaaaaarceaaaaaaaaai?hide=refs,container",
+ headers.clone(),
+ &router,
+ ),
+ status::Ok,
+ Some("bigger example"),
+ );
+
check_http_response(
request::get(
"http://localhost:9411/v0/work/aaaaaaaaaaaaavkvaaaaaaaaai",
@@ -463,8 +474,7 @@ fn test_post_release() {
status::BadRequest,
None,
);
- */
-}
+ */}
#[test]
fn test_post_work() {
diff --git a/rust/tests/test_old_python_tests.rs b/rust/tests/test_old_python_tests.rs
index 1b496328..5e33a7f6 100644
--- a/rust/tests/test_old_python_tests.rs
+++ b/rust/tests/test_old_python_tests.rs
@@ -148,7 +148,7 @@ fn test_api_rich_create() {
};
// test that foreign key relations worked
- let re = match client.get_release(release_id.clone(), None).wait().unwrap() {
+ let re = match client.get_release(release_id.clone(), None, None).wait().unwrap() {
GetReleaseResponse::FoundEntity(e) => e,
_ => unreachable!(),
};
@@ -166,7 +166,7 @@ fn test_api_rich_create() {
stub_release_id
);
- let fe = match client.get_file(file_id, None).wait().unwrap() {
+ let fe = match client.get_file(file_id, None, None).wait().unwrap() {
GetFileResponse::FoundEntity(e) => e,
_ => unreachable!(),
};