icann/icann-rdap
1
0
Fork 0
Code Issues Activity

Adding upstream version 0.0.22.

Browse source 
Signed-off-by: Daniel Baumann <daniel@debian.org>
This commit is contained in:
Daniel Baumann 2025-05-08 18:41:54 +02:00
parent 2f814b513a
commit b06d3acde8
Signed by: daniel
GPG key ID: FBB4F0E80A80222F
190 changed files with 61565 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

2
icann-rdap-srv/tests/integration/bin/mod.rs Normal file
View file

@ -0,0 +1,2 @@
mod rdap_srv_data;
mod rdap_srv_store;

281
icann-rdap-srv/tests/integration/bin/rdap_srv_data.rs Normal file
View file

@ -0,0 +1,281 @@
#![allow(non_snake_case)]
use test_dir::DirBuilder;
use crate::test_jig::RdapSrvDataTestJig;
#[test]
fn GIVEN_data_dir_WHEN_invoked_THEN_data_stored_in_data_dir() {
// GIVEN
let mut test_jig = RdapSrvDataTestJig::new();
// WHEN
test_jig
.cmd
.arg("--data-dir")
.arg(test_jig.source_dir.root())
.arg("entity")
.arg("--handle")
.arg("foo1234")
.arg("--email")
.arg("joe@example.com")
.arg("--full-name")
.arg("Joe User");
// THEN
let assert = test_jig.cmd.assert();
assert.success();
assert!(test_jig
.source_dir
.root()
.read_dir()
.expect("source directory does not exist")
.next()
.is_some());
assert!(test_jig
.data_dir
.root()
.read_dir()
.expect("data directory does not exist")
.next()
.is_none());
}
#[test]
fn GIVEN_no_data_dir_WHEN_invoked_THEN_data_stored_in_data_dir() {
// GIVEN
let mut test_jig = RdapSrvDataTestJig::new();
// WHEN
test_jig
.cmd
.arg("entity")
.arg("--handle")
.arg("foo1234")
.arg("--email")
.arg("joe@example.com")
.arg("--full-name")
.arg("Joe User");
// THEN
let assert = test_jig.cmd.assert();
assert.success();
assert!(test_jig
.source_dir
.root()
.read_dir()
.expect("source directory does not exist")
.next()
.is_none());
assert!(test_jig
.data_dir
.root()
.read_dir()
.expect("data directory does not exist")
.next()
.is_some());
}
#[test]
fn GIVEN_entity_options_WHEN_create_data_THEN_success() {
// GIVEN
let _test_jig = make_foo1234();
// WHEN
// everything done in the helper function above
// THEN
// everything done in the helper function above
}
#[test]
fn GIVEN_nameserver_options_WHEN_create_data_THEN_success() {
// GIVEN
let mut test_jig = make_foo1234();
// WHEN
test_jig
.cmd
.arg("nameserver")
.arg("--ldh")
.arg("ns1.example.com")
.arg("--registrant")
.arg("foo1234");
// THEN
let assert = test_jig.cmd.assert();
assert.success();
}
#[test]
fn GIVEN_domain_options_WHEN_create_data_THEN_success() {
// GIVEN
let mut test_jig = make_foo1234();
test_jig
.cmd
.arg("nameserver")
.arg("--ldh")
.arg("ns1.example.com")
.arg("--registrant")
.arg("foo1234");
// THEN
let assert = test_jig.cmd.assert();
assert.success();
let mut test_jig = test_jig.new_cmd();
// WHEN
test_jig
.cmd
.arg("domain")
.arg("--ldh")
.arg("example.com")
.arg("--registrant")
.arg("foo1234");
// THEN
let assert = test_jig.cmd.assert();
assert.success();
}
#[test]
fn GIVEN_domain_with_idn_WHEN_create_data_THEN_success() {
// GIVEN
let mut test_jig = make_foo1234();
// WHEN
test_jig
.cmd
.arg("domain")
.arg("--ldh")
.arg("example.com")
.arg("--idn")
.arg("example.com")
.arg("--registrant")
.arg("foo1234");
// THEN
let assert = test_jig.cmd.assert();
assert.success();
}
#[test]
fn GIVEN_idn_WHEN_create_data_THEN_success() {
// GIVEN
let mut test_jig = make_foo1234();
// WHEN
test_jig
.cmd
.arg("domain")
.arg("--idn")
.arg("example.com")
.arg("--registrant")
.arg("foo1234");
// THEN
let assert = test_jig.cmd.assert();
assert.success();
}
#[test]
fn GIVEN_autnum_options_WHEN_create_data_THEN_success() {
// GIVEN
let mut test_jig = make_foo1234();
// WHEN
test_jig
.cmd
.arg("autnum")
.arg("--start-autnum")
.arg("700")
.arg("--end-autnum")
.arg("710")
.arg("--registrant")
.arg("foo1234");
// THEN
let assert = test_jig.cmd.assert();
assert.success();
}
#[test]
fn GIVEN_network_options_WHEN_create_data_THEN_success() {
// GIVEN
let mut test_jig = make_foo1234();
// WHEN
test_jig
.cmd
.arg("network")
.arg("--cidr")
.arg("10.0.0.0/24")
.arg("--registrant")
.arg("foo1234");
// THEN
let assert = test_jig.cmd.assert();
assert.success();
}
#[test]
fn GIVEN_srvhelp_with_no_options_WHEN_create_srvhelp_THEN_success() {
// GIVEN
let mut test_jig = RdapSrvDataTestJig::new();
// WHEN
test_jig.cmd.arg("srv-help");
// THEN
let assert = test_jig.cmd.assert();
assert.success();
}
#[test]
fn GIVEN_srvhelp_with_notice_WHEN_create_srvhelp_THEN_success() {
// GIVEN
let mut test_jig = RdapSrvDataTestJig::new();
// WHEN
test_jig
.cmd
.arg("srv-help")
.arg("--notice")
.arg("\"A test notice\"");
// THEN
let assert = test_jig.cmd.assert();
assert.success();
}
#[test]
fn GIVEN_srvhelp_with_host_WHEN_create_srvhelp_THEN_success() {
// GIVEN
let mut test_jig = RdapSrvDataTestJig::new();
// WHEN
test_jig
.cmd
.arg("srv-help")
.arg("--host")
.arg("foo.example.com");
// THEN
let assert = test_jig.cmd.assert();
assert.success();
}
fn make_foo1234() -> RdapSrvDataTestJig {
let mut test_jig = RdapSrvDataTestJig::new();
test_jig
.cmd
.arg("entity")
.arg("--handle")
.arg("foo1234")
.arg("--email")
.arg("joe@example.com")
.arg("--full-name")
.arg("Joe User");
let assert = test_jig.cmd.assert();
assert.success();
test_jig.new_cmd()
}

18
icann-rdap-srv/tests/integration/bin/rdap_srv_store.rs Normal file
View file

@ -0,0 +1,18 @@
#![allow(non_snake_case)]
use test_dir::DirBuilder;
use crate::test_jig::RdapSrvStoreTestJig;
#[test]
fn GIVEN_source_dir_same_as_data_dir_WHEN_invoked_THEN_error() {
// GIVEN
let mut test_jig = RdapSrvStoreTestJig::new();
// WHEN
test_jig.cmd.arg(test_jig.data_dir.root());
// THEN
let assert = test_jig.cmd.assert();
assert.failure();
}

4
icann-rdap-srv/tests/integration/main.rs Normal file
View file

@ -0,0 +1,4 @@
mod bin;
mod srv;
mod storage;
mod test_jig;

383
icann-rdap-srv/tests/integration/srv/bootstrap.rs Normal file
View file

@ -0,0 +1,383 @@
#![allow(non_snake_case)]
use {
icann_rdap_client::{
http::{create_client, ClientConfig},
rdap::{rdap_request, QueryType},
},
icann_rdap_common::response::Rfc9083Error,
icann_rdap_srv::storage::{
data::{AutnumId, DomainId, EntityId, NetworkId, NetworkIdType},
StoreOps,
},
};
use crate::test_jig::SrvTestJig;
#[tokio::test]
async fn GIVEN_bootstrap_with_less_specific_domain_WHEN_query_domain_THEN_status_code_is_redirect()
{
// GIVEN
let test_srv = SrvTestJig::new_bootstrap().await;
let mut tx = test_srv.mem.new_tx().await.expect("new transaction");
tx.add_domain_err(
&DomainId::builder().ldh_name("example").build(),
&Rfc9083Error::redirect().url("https://example.net/").build(),
)
.await
.expect("add domain redirect");
tx.commit().await.expect("tx commit");
// WHEN
let client_config = ClientConfig::builder()
.https_only(false)
.follow_redirects(false)
.build();
let client = create_client(&client_config).expect("creating client");
let query = QueryType::domain("foo.example").expect("invalid domain name");
let response = rdap_request(&test_srv.rdap_base, &query, &client)
.await
.expect("quering server");
// THEN
assert!(response.rdap.is_redirect());
assert_eq!(
response
.http_data
.location
.as_ref()
.expect("no location header information"),
"https://example.net/domain/foo.example"
);
}
#[tokio::test]
#[should_panic]
async fn GIVEN_bootstrap_with_no_less_specific_domain_WHEN_query_domain_THEN_should_panic() {
// GIVEN
let test_srv = SrvTestJig::new_bootstrap().await;
let mut tx = test_srv.mem.new_tx().await.expect("new transaction");
tx.add_domain_err(
&DomainId::builder().ldh_name("no_example").build(),
&Rfc9083Error::redirect().url("https://example.net").build(),
)
.await
.expect("add domain redirect");
tx.commit().await.expect("tx commit");
// WHEN
let client_config = ClientConfig::builder()
.https_only(false)
.follow_redirects(false)
.build();
let client = create_client(&client_config).expect("creating client");
let query = QueryType::domain("foo.example").expect("invalid domain name");
let response = rdap_request(&test_srv.rdap_base, &query, &client).await;
// THEN
response.expect("this should be a 404"); // SHOULD PANIC
}
#[tokio::test]
async fn GIVEN_bootstrap_with_less_specific_ns_WHEN_query_ns_THEN_status_code_is_redirect() {
// GIVEN
let test_srv = SrvTestJig::new_bootstrap().await;
let mut tx = test_srv.mem.new_tx().await.expect("new transaction");
tx.add_domain_err(
&DomainId::builder().ldh_name("example").build(),
&Rfc9083Error::redirect().url("https://example.net/").build(),
)
.await
.expect("add domain redirect");
tx.commit().await.expect("tx commit");
// WHEN
let client_config = ClientConfig::builder()
.https_only(false)
.follow_redirects(false)
.build();
let client = create_client(&client_config).expect("creating client");
let query = QueryType::ns("ns.foo.example").expect("invalid nameserver");
let response = rdap_request(&test_srv.rdap_base, &query, &client)
.await
.expect("quering server");
// THEN
assert!(response.rdap.is_redirect());
assert_eq!(
response
.http_data
.location
.as_ref()
.expect("no location header information"),
"https://example.net/nameserver/ns.foo.example"
);
}
#[tokio::test]
#[should_panic]
async fn GIVEN_bootstrap_with_no_less_specific_ns_WHEN_query_ns_THEN_should_panic() {
// GIVEN
let test_srv = SrvTestJig::new_bootstrap().await;
let mut tx = test_srv.mem.new_tx().await.expect("new transaction");
tx.add_domain_err(
&DomainId::builder().ldh_name("no_example").build(),
&Rfc9083Error::redirect().url("https://example.net").build(),
)
.await
.expect("add domain redirect");
tx.commit().await.expect("tx commit");
// WHEN
let client_config = ClientConfig::builder()
.https_only(false)
.follow_redirects(false)
.build();
let client = create_client(&client_config).expect("creating client");
let query = QueryType::ns("ns.foo.example").expect("invalid nameserver");
let response = rdap_request(&test_srv.rdap_base, &query, &client).await;
// THEN
response.expect("this should be a 404"); // SHOULD PANIC
}
#[tokio::test]
async fn GIVEN_bootstrap_with_less_specific_ip_WHEN_query_ip_THEN_status_code_is_redirect() {
// GIVEN
let test_srv = SrvTestJig::new_bootstrap().await;
let mut tx = test_srv.mem.new_tx().await.expect("new transaction");
tx.add_network_err(
&NetworkId::builder()
.network_id(NetworkIdType::Cidr(ipnet::IpNet::V4(
"10.0.0.0/8".parse().expect("parsing ipnet"),
)))
.build(),
&Rfc9083Error::redirect().url("https://example.net/").build(),
)
.await
.expect("adding network redirect");
tx.commit().await.expect("tx commit");
// WHEN
let client_config = ClientConfig::builder()
.https_only(false)
.follow_redirects(false)
.build();
let client = create_client(&client_config).expect("creating client");
let query = QueryType::ipv4cidr("10.0.0.0/24").expect("invalid CIDR");
let response = rdap_request(&test_srv.rdap_base, &query, &client)
.await
.expect("quering server");
// THEN
assert!(response.rdap.is_redirect());
assert_eq!(
response
.http_data
.location
.as_ref()
.expect("no location header information"),
"https://example.net/ip/10.0.0.0/24"
);
}
#[tokio::test]
#[should_panic]
async fn GIVEN_bootstrap_with_no_less_specific_ip_WHEN_query_ip_THEN_should_panic() {
// GIVEN
let test_srv = SrvTestJig::new_bootstrap().await;
let mut tx = test_srv.mem.new_tx().await.expect("new transaction");
tx.add_network_err(
&NetworkId::builder()
.network_id(NetworkIdType::Cidr(ipnet::IpNet::V4(
"10.0.0.0/8".parse().expect("parsing ipnet"),
)))
.build(),
&Rfc9083Error::redirect().url("https://example.net").build(),
)
.await
.expect("adding network redirect");
tx.commit().await.expect("tx commit");
// WHEN
let client_config = ClientConfig::builder()
.https_only(false)
.follow_redirects(false)
.build();
let client = create_client(&client_config).expect("creating client");
let query = QueryType::ipv4cidr("11.0.0.0/24").expect("invalid CIDR");
let response = rdap_request(&test_srv.rdap_base, &query, &client).await;
// THEN
response.expect("this should be 404"); // SHOLD PANIC
}
#[tokio::test]
async fn GIVEN_bootstrap_with_less_specific_autnum_WHEN_query_autnum_THEN_status_code_is_redirect()
{
// GIVEN
let test_srv = SrvTestJig::new_bootstrap().await;
let mut tx = test_srv.mem.new_tx().await.expect("new transaction");
tx.add_autnum_err(
&AutnumId::builder()
.start_autnum(700)
.end_autnum(800)
.build(),
&Rfc9083Error::redirect().url("https://example.net/").build(),
)
.await
.expect("adding autnum redirect");
tx.commit().await.expect("tx commit");
// WHEN
let client_config = ClientConfig::builder()
.https_only(false)
.follow_redirects(false)
.build();
let client = create_client(&client_config).expect("creating client");
let query = QueryType::autnum("AS710").expect("invalid autnum");
let response = rdap_request(&test_srv.rdap_base, &query, &client)
.await
.expect("quering server");
// THEN
assert!(response.rdap.is_redirect());
assert_eq!(
response
.http_data
.location
.as_ref()
.expect("no location header information"),
"https://example.net/autnum/710"
);
}
#[tokio::test]
#[should_panic]
async fn GIVEN_bootstrap_with_no_less_specific_autnum_WHEN_query_autnum_THEN_should_panic() {
// GIVEN
let test_srv = SrvTestJig::new_bootstrap().await;
let mut tx = test_srv.mem.new_tx().await.expect("new transaction");
tx.add_autnum_err(
&AutnumId::builder()
.start_autnum(700)
.end_autnum(800)
.build(),
&Rfc9083Error::redirect().url("https://example.net").build(),
)
.await
.expect("adding autnum redirect");
tx.commit().await.expect("tx commit");
// WHEN
let client_config = ClientConfig::builder()
.https_only(false)
.follow_redirects(false)
.build();
let client = create_client(&client_config).expect("creating client");
let query = QueryType::autnum("AS1000").expect("invalid autnum");
let response = rdap_request(&test_srv.rdap_base, &query, &client).await;
// THEN
response.expect("this should be 404"); // SHOLD PANIC
}
#[tokio::test]
async fn GIVEN_bootstrap_with_specific_tag_WHEN_query_entity_THEN_status_code_is_redirect() {
// GIVEN
let test_srv = SrvTestJig::new_bootstrap().await;
let mut tx = test_srv.mem.new_tx().await.expect("new transaction");
tx.add_entity_err(
&EntityId::builder().handle("-ARIN").build(),
&Rfc9083Error::redirect().url("https://example.net/").build(),
)
.await
.expect("adding entity redirect");
tx.commit().await.expect("tx commit");
// WHEN
let client_config = ClientConfig::builder()
.https_only(false)
.follow_redirects(false)
.build();
let client = create_client(&client_config).expect("creating client");
let query = QueryType::Entity("foo-ARIN".to_string());
let response = rdap_request(&test_srv.rdap_base, &query, &client)
.await
.expect("quering server");
// THEN
assert!(response.rdap.is_redirect());
assert_eq!(
response
.http_data
.location
.as_ref()
.expect("no location header information"),
"https://example.net/entity/foo-ARIN"
);
}
#[tokio::test]
async fn GIVEN_bootstrap_with_specific_tag_lowercase_WHEN_query_entity_THEN_status_code_is_redirect(
) {
// GIVEN
let test_srv = SrvTestJig::new_bootstrap().await;
let mut tx = test_srv.mem.new_tx().await.expect("new transaction");
tx.add_entity_err(
&EntityId::builder().handle("-ARIN").build(),
&Rfc9083Error::redirect().url("https://example.net/").build(),
)
.await
.expect("adding entity redirect");
tx.commit().await.expect("tx commit");
// WHEN
let client_config = ClientConfig::builder()
.https_only(false)
.follow_redirects(false)
.build();
let client = create_client(&client_config).expect("creating client");
let query = QueryType::Entity("foo-arin".to_string());
let response = rdap_request(&test_srv.rdap_base, &query, &client)
.await
.expect("quering server");
// THEN
assert!(response.rdap.is_redirect());
assert_eq!(
response
.http_data
.location
.as_ref()
.expect("no location header information"),
"https://example.net/entity/foo-arin"
);
}
#[tokio::test]
#[should_panic]
async fn GIVEN_bootstrap_with_no_specific_tag_WHEN_query_entity_THEN_should_panic() {
// GIVEN
let test_srv = SrvTestJig::new_bootstrap().await;
let mut tx = test_srv.mem.new_tx().await.expect("new transaction");
tx.add_entity_err(
&EntityId::builder().handle("-CLAUCA").build(),
&Rfc9083Error::redirect().url("https://example.net").build(),
)
.await
.expect("adding entity redirect");
tx.commit().await.expect("tx commit");
// WHEN
let client_config = ClientConfig::builder()
.https_only(false)
.follow_redirects(false)
.build();
let client = create_client(&client_config).expect("creating client");
let query = QueryType::Entity("foo-arin".to_string());
let response = rdap_request(&test_srv.rdap_base, &query, &client).await;
// THEN
response.expect("this should be 404"); // SHOLD PANIC
}

125
icann-rdap-srv/tests/integration/srv/domain.rs Normal file
View file

@ -0,0 +1,125 @@
#![allow(non_snake_case)]
use {
icann_rdap_client::{
http::{create_client, ClientConfig},
rdap::{rdap_request, QueryType},
RdapClientError,
},
icann_rdap_common::response::Domain,
icann_rdap_srv::storage::{CommonConfig, StoreOps},
};
use crate::test_jig::SrvTestJig;
#[tokio::test]
async fn GIVEN_server_with_domain_WHEN_query_domain_THEN_status_code_200() {
// GIVEN
let test_srv = SrvTestJig::new().await;
let mut tx = test_srv.mem.new_tx().await.expect("new transaction");
tx.add_domain(&Domain::builder().ldh_name("foo.example").build())
.await
.expect("add domain in tx");
tx.commit().await.expect("tx commit");
// WHEN
let client_config = ClientConfig::builder()
.https_only(false)
.follow_redirects(false)
.build();
let client = create_client(&client_config).expect("creating client");
let query = QueryType::domain("foo.example").expect("invalid domain name");
let response = rdap_request(&test_srv.rdap_base, &query, &client)
.await
.expect("quering server");
// THEN
assert_eq!(response.http_data.status_code, 200);
}
#[tokio::test]
async fn GIVEN_server_with_idn_WHEN_query_domain_THEN_status_code_200() {
// GIVEN
let test_srv = SrvTestJig::new().await;
let mut tx = test_srv.mem.new_tx().await.expect("new transaction");
tx.add_domain(
&Domain::idn()
.unicode_name("café.example")
.ldh_name("cafe.example")
.build(),
)
.await
.expect("add domain in tx");
tx.commit().await.expect("tx commit");
// WHEN
let client_config = ClientConfig::builder()
.https_only(false)
.follow_redirects(false)
.build();
let client = create_client(&client_config).expect("creating client");
let query = QueryType::domain("café.example").expect("invalid domain name");
let response = rdap_request(&test_srv.rdap_base, &query, &client)
.await
.expect("quering server");
// THEN
assert_eq!(response.http_data.status_code, 200);
}
#[tokio::test]
async fn GIVEN_server_with_domain_and_search_disabled_WHEN_query_domain_THEN_status_code_501() {
// GIVEN
let common_config = CommonConfig::builder()
.domain_search_by_name_enable(false)
.build();
let test_srv = SrvTestJig::new_common_config(common_config).await;
let mut tx = test_srv.mem.new_tx().await.expect("new transaction");
tx.add_domain(&Domain::builder().ldh_name("foo.example").build())
.await
.expect("add domain in tx");
tx.commit().await.expect("tx commit");
// WHEN
let client_config = ClientConfig::builder()
.https_only(false)
.follow_redirects(false)
.build();
let client = create_client(&client_config).expect("creating client");
let query = QueryType::DomainNameSearch("foo.*".to_string());
let response = rdap_request(&test_srv.rdap_base, &query, &client).await;
// THEN
let RdapClientError::Client(error) = response.expect_err("not an error response") else {
panic!("the error was not an HTTP error")
};
assert_eq!(error.status().expect("no status code"), 501);
}
#[tokio::test]
async fn GIVEN_server_with_domain_and_search_enabled_WHEN_query_domain_THEN_status_code_200() {
// GIVEN
let common_config = CommonConfig::builder()
.domain_search_by_name_enable(true)
.build();
let test_srv = SrvTestJig::new_common_config(common_config).await;
let mut tx = test_srv.mem.new_tx().await.expect("new transaction");
tx.add_domain(&Domain::builder().ldh_name("foo.example").build())
.await
.expect("add domain in tx");
tx.commit().await.expect("tx commit");
// WHEN
let client_config = ClientConfig::builder()
.https_only(false)
.follow_redirects(false)
.build();
let client = create_client(&client_config).expect("creating client");
let query = QueryType::DomainNameSearch("foo.*".to_string());
let response = rdap_request(&test_srv.rdap_base, &query, &client)
.await
.expect("quering server");
// THEN
assert_eq!(response.http_data.status_code, 200);
}

4
icann-rdap-srv/tests/integration/srv/mod.rs Normal file
View file

@ -0,0 +1,4 @@
mod bootstrap;
mod domain;
mod redirect;
mod srvhelp;

315
icann-rdap-srv/tests/integration/srv/redirect.rs Normal file
View file

@ -0,0 +1,315 @@
#![allow(non_snake_case)]
use {
icann_rdap_client::{
http::{create_client, ClientConfig},
rdap::{rdap_request, QueryType},
},
icann_rdap_common::response::{Link, Notice, NoticeOrRemark, Rfc9083Error},
icann_rdap_srv::storage::{
data::{AutnumId, DomainId, EntityId, NameserverId, NetworkId, NetworkIdType},
StoreOps,
},
};
use crate::test_jig::SrvTestJig;
#[tokio::test]
async fn GIVEN_domain_error_with_first_link_href_WHEN_query_THEN_status_code_is_redirect() {
// GIVEN
let test_srv = SrvTestJig::new().await;
let mut tx = test_srv.mem.new_tx().await.expect("new transaction");
tx.add_domain_err(
&DomainId {
ldh_name: "foo.example".to_string(),
unicode_name: None,
},
&Rfc9083Error::builder()
.error_code(307)
.notice(Notice(
NoticeOrRemark::builder()
.links(vec![Link::builder()
.href("https://other.example.com")
.value("https://other.example.com")
.rel("about")
.build()])
.build(),
))
.build(),
)
.await
.expect("add redirect in tx");
tx.commit().await.expect("tx commit");
// WHEN
let client_config = ClientConfig::builder()
.https_only(false)
.follow_redirects(false)
.build();
let client = create_client(&client_config).expect("creating client");
let query = QueryType::domain("foo.example").expect("invalid domain name");
let response = rdap_request(&test_srv.rdap_base, &query, &client)
.await
.expect("quering server");
// THEN
assert_eq!(response.http_data.status_code, 307);
assert_eq!(
response
.http_data
.location
.as_ref()
.expect("no location header information"),
"https://other.example.com"
);
}
#[tokio::test]
async fn GIVEN_nameserver_error_with_first_link_href_WHEN_query_THEN_status_code_is_redirect() {
// GIVEN
let test_srv = SrvTestJig::new().await;
let mut tx = test_srv.mem.new_tx().await.expect("new transaction");
tx.add_nameserver_err(
&NameserverId {
ldh_name: "ns.foo.example".to_string(),
unicode_name: None,
},
&Rfc9083Error::builder()
.error_code(307)
.notice(Notice(
NoticeOrRemark::builder()
.links(vec![Link::builder()
.href("https://other.example.com")
.value("https://other.example.com")
.rel("about")
.build()])
.build(),
))
.build(),
)
.await
.expect("add redirect in tx");
tx.commit().await.expect("tx commit");
// WHEN
let client_config = ClientConfig::builder()
.https_only(false)
.follow_redirects(false)
.build();
let client = create_client(&client_config).expect("creating client");
let query = QueryType::ns("ns.foo.example").expect("invalid nameserver");
let response = rdap_request(&test_srv.rdap_base, &query, &client)
.await
.expect("quering server");
// THEN
assert_eq!(response.http_data.status_code, 307);
assert_eq!(
response
.http_data
.location
.as_ref()
.expect("no location header information"),
"https://other.example.com"
);
}
#[tokio::test]
async fn GIVEN_entity_error_with_first_link_href_WHEN_query_THEN_status_code_is_redirect() {
// GIVEN
let test_srv = SrvTestJig::new().await;
let mut tx = test_srv.mem.new_tx().await.expect("new transaction");
tx.add_entity_err(
&EntityId {
handle: "foo".to_string(),
},
&Rfc9083Error::builder()
.error_code(307)
.notice(Notice(
NoticeOrRemark::builder()
.links(vec![Link::builder()
.href("https://other.example.com")
.value("https://other.example.com")
.rel("about")
.build()])
.build(),
))
.build(),
)
.await
.expect("add redirect in tx");
tx.commit().await.expect("tx commit");
// WHEN
let client_config = ClientConfig::builder()
.https_only(false)
.follow_redirects(false)
.build();
let client = create_client(&client_config).expect("creating client");
let query = QueryType::Entity("foo".to_string());
let response = rdap_request(&test_srv.rdap_base, &query, &client)
.await
.expect("quering server");
// THEN
assert_eq!(response.http_data.status_code, 307);
assert_eq!(
response
.http_data
.location
.as_ref()
.expect("no location header information"),
"https://other.example.com"
);
}
#[tokio::test]
async fn GIVEN_autnum_error_with_first_link_href_WHEN_query_THEN_status_code_is_redirect() {
// GIVEN
let test_srv = SrvTestJig::new().await;
let mut tx = test_srv.mem.new_tx().await.expect("new transaction");
tx.add_autnum_err(
&AutnumId {
start_autnum: 700,
end_autnum: 710,
},
&Rfc9083Error::builder()
.error_code(307)
.notice(Notice(
NoticeOrRemark::builder()
.links(vec![Link::builder()
.href("https://other.example.com")
.value("https://other.example.com")
.rel("about")
.build()])
.build(),
))
.build(),
)
.await
.expect("add redirect in tx");
tx.commit().await.expect("tx commit");
// WHEN
let client_config = ClientConfig::builder()
.https_only(false)
.follow_redirects(false)
.build();
let client = create_client(&client_config).expect("creating client");
let query = QueryType::autnum("700").expect("invalid autnum");
let response = rdap_request(&test_srv.rdap_base, &query, &client)
.await
.expect("quering server");
// THEN
assert_eq!(response.http_data.status_code, 307);
assert_eq!(
response
.http_data
.location
.as_ref()
.expect("no location header information"),
"https://other.example.com"
);
}
#[tokio::test]
async fn GIVEN_network_cidr_error_with_first_link_href_WHEN_query_THEN_status_code_is_redirect() {
// GIVEN
let test_srv = SrvTestJig::new().await;
let mut tx = test_srv.mem.new_tx().await.expect("new transaction");
tx.add_network_err(
&NetworkId {
network_id: NetworkIdType::Cidr("10.0.0.0/16".parse().expect("parsing cidr")),
},
&Rfc9083Error::builder()
.error_code(307)
.notice(Notice(
NoticeOrRemark::builder()
.links(vec![Link::builder()
.href("https://other.example.com")
.value("https://other.example.com")
.rel("about")
.build()])
.build(),
))
.build(),
)
.await
.expect("add redirect in tx");
tx.commit().await.expect("tx commit");
// WHEN
let client_config = ClientConfig::builder()
.https_only(false)
.follow_redirects(false)
.build();
let client = create_client(&client_config).expect("creating client");
let query = QueryType::ipv4("10.0.0.1").expect("invalid IP address");
let response = rdap_request(&test_srv.rdap_base, &query, &client)
.await
.expect("quering server");
// THEN
assert_eq!(response.http_data.status_code, 307);
assert_eq!(
response
.http_data
.location
.as_ref()
.expect("no location header information"),
"https://other.example.com"
);
}
#[tokio::test]
async fn GIVEN_network_addrs_error_with_first_link_href_WHEN_query_THEN_status_code_is_redirect() {
// GIVEN
let test_srv = SrvTestJig::new().await;
let mut tx = test_srv.mem.new_tx().await.expect("new transaction");
tx.add_network_err(
&NetworkId {
network_id: NetworkIdType::Range {
start_address: "10.0.0.0".to_string(),
end_address: "10.0.0.255".to_string(),
},
},
&Rfc9083Error::builder()
.error_code(307)
.notice(Notice(
NoticeOrRemark::builder()
.links(vec![Link::builder()
.href("https://other.example.com")
.value("https://other.example.com")
.rel("about")
.build()])
.build(),
))
.build(),
)
.await
.expect("add redirect in tx");
tx.commit().await.expect("tx commit");
// WHEN
let client_config = ClientConfig::builder()
.https_only(false)
.follow_redirects(false)
.build();
let client = create_client(&client_config).expect("creating client");
let query = QueryType::ipv4("10.0.0.1").expect("invalid IP address");
let response = rdap_request(&test_srv.rdap_base, &query, &client)
.await
.expect("quering server");
// THEN
assert_eq!(response.http_data.status_code, 307);
assert_eq!(
response
.http_data
.location
.as_ref()
.expect("no location header information"),
"https://other.example.com"
);
}

77
icann-rdap-srv/tests/integration/srv/srvhelp.rs Normal file
View file

@ -0,0 +1,77 @@
#![allow(non_snake_case)]
use {
icann_rdap_client::{
http::{create_client, ClientConfig},
rdap::{rdap_request, QueryType},
},
icann_rdap_common::response::{Help, Notice, NoticeOrRemark},
icann_rdap_srv::storage::StoreOps,
};
use crate::test_jig::SrvTestJig;
#[tokio::test]
async fn GIVEN_server_with_default_help_WHEN_query_help_THEN_status_code_200() {
// GIVEN
let test_srv = SrvTestJig::new().await;
let mut tx = test_srv.mem.new_tx().await.expect("new transaction");
let srvhelp = Help::builder()
.notice(Notice(
NoticeOrRemark::builder()
.description_entry("foo".to_string())
.build(),
))
.build();
tx.add_srv_help(&srvhelp, None)
.await
.expect("adding srv help");
tx.commit().await.expect("tx commit");
// WHEN
let client_config = ClientConfig::builder()
.https_only(false)
.follow_redirects(false)
.build();
let client = create_client(&client_config).expect("creating client");
let query = QueryType::Help;
let response = rdap_request(&test_srv.rdap_base, &query, &client)
.await
.expect("quering server");
// THEN
assert_eq!(response.http_data.status_code, 200);
}
#[tokio::test]
async fn GIVEN_server_with_host_help_WHEN_query_help_THEN_status_code_200() {
// GIVEN
let test_srv = SrvTestJig::new().await;
let mut tx = test_srv.mem.new_tx().await.expect("new transaction");
let srvhelp = Help::builder()
.notice(Notice(
NoticeOrRemark::builder()
.description_entry("foo".to_string())
.build(),
))
.build();
tx.add_srv_help(&srvhelp, Some("foo.example.com"))
.await
.expect("adding srv help");
tx.commit().await.expect("tx commit");
// WHEN
let client_config = ClientConfig::builder()
.https_only(false)
.follow_redirects(false)
.host(reqwest::header::HeaderValue::from_static("foo.example.com"))
.build();
let client = create_client(&client_config).expect("creating client");
let query = QueryType::Help;
let response = rdap_request(&test_srv.rdap_base, &query, &client)
.await
.expect("quering server");
// THEN
assert_eq!(response.http_data.status_code, 200);
}

585
icann-rdap-srv/tests/integration/storage/data.rs Normal file
View file

@ -0,0 +1,585 @@
#![allow(non_snake_case)]
use {
icann_rdap_common::{
prelude::Numberish,
response::{
Autnum, Domain, Entity, Help, Nameserver, Network, Notice, NoticeOrRemark, RdapResponse,
},
},
icann_rdap_srv::{
config::{ServiceConfig, StorageType},
storage::{
data::{
load_data, AutnumId, AutnumOrError::AutnumObject, DomainId, DomainOrError,
EntityId, EntityOrError::EntityObject, NameserverId,
NameserverOrError::NameserverObject, NetworkId, NetworkIdType,
NetworkOrError::NetworkObject, Template,
},
mem::{config::MemConfig, ops::Mem},
CommonConfig, StoreOps,
},
},
test_dir::{DirBuilder, TestDir},
};
async fn new_and_init_mem(data_dir: String) -> Mem {
let mem_config = MemConfig::builder()
.common_config(CommonConfig::default())
.build();
let mem = Mem::new(mem_config.clone());
mem.init().await.expect("initialzing memeory");
load_data(
&ServiceConfig::non_server()
.data_dir(data_dir)
.storage_type(StorageType::Memory(mem_config))
.build()
.expect("building service config"),
&mem,
false,
)
.await
.expect("loading data");
mem
}
#[tokio::test]
async fn GIVEN_data_dir_with_domain_WHEN_mem_init_THEN_domain_is_loaded() {
// GIVEN
let ldh_name = "foo.example";
let temp = TestDir::temp();
let domain = Domain::builder().ldh_name(ldh_name).build();
let domain_file = temp.path("foo_example.json");
std::fs::write(
domain_file,
serde_json::to_string(&domain).expect("serializing domain"),
)
.expect("writing file");
// WHEN
let mem = new_and_init_mem(temp.root().to_string_lossy().to_string()).await;
// THEN
let actual = mem
.get_domain_by_ldh(ldh_name)
.await
.expect("getting domain by ldh");
assert!(matches!(actual, RdapResponse::Domain(_)));
let RdapResponse::Domain(domain) = actual else {
panic!()
};
assert_eq!(domain.ldh_name.as_ref().expect("ldhName is none"), ldh_name)
}
#[tokio::test]
async fn GIVEN_data_dir_with_domain_template_WHEN_mem_init_THEN_domains_are_loaded() {
// GIVEN
let ldh1 = "foo.example";
let ldh2 = "bar.example";
let temp = TestDir::temp();
let template = Template::Domain {
domain: DomainOrError::DomainObject(Box::new(
Domain::builder().ldh_name("example").build(),
)),
ids: vec![
DomainId::builder().ldh_name(ldh1).build(),
DomainId::builder().ldh_name(ldh2).build(),
],
};
let template_file = temp.path("example.template");
std::fs::write(
template_file,
serde_json::to_string(&template).expect("serializing template"),
)
.expect("writing file");
// WHEN
let mem = new_and_init_mem(temp.root().to_string_lossy().to_string()).await;
// THEN
for ldh in [ldh1, ldh2] {
let actual = mem
.get_domain_by_ldh(ldh)
.await
.expect("getting domain by ldh");
assert!(matches!(actual, RdapResponse::Domain(_)));
let RdapResponse::Domain(domain) = actual else {
panic!()
};
assert_eq!(domain.ldh_name.as_ref().expect("ldhName is none"), ldh)
}
}
#[tokio::test]
async fn GIVEN_data_dir_with_entity_WHEN_mem_init_THEN_entity_is_loaded() {
// GIVEN
let handle = "foo.example";
let temp = TestDir::temp();
let entity = Entity::builder().handle(handle).build();
let domain_file = temp.path("foo_example.json");
std::fs::write(
domain_file,
serde_json::to_string(&entity).expect("serializing entity"),
)
.expect("writing file");
// WHEN
let mem = new_and_init_mem(temp.root().to_string_lossy().to_string()).await;
// THEN
let actual = mem
.get_entity_by_handle(handle)
.await
.expect("getting entity by ldh");
assert!(matches!(actual, RdapResponse::Entity(_)));
let RdapResponse::Entity(entity) = actual else {
panic!()
};
assert_eq!(
entity
.object_common
.handle
.as_ref()
.expect("handle is none"),
handle
)
}
#[tokio::test]
async fn GIVEN_data_dir_with_entity_template_WHEN_mem_init_THEN_entities_are_loaded() {
// GIVEN
let handle1 = "foo";
let handle2 = "bar";
let temp = TestDir::temp();
let template = Template::Entity {
entity: EntityObject(Box::new(Entity::builder().handle("example").build())),
ids: vec![
EntityId::builder().handle(handle1).build(),
EntityId::builder().handle(handle2).build(),
],
};
let template_file = temp.path("example.template");
std::fs::write(
template_file,
serde_json::to_string(&template).expect("serializing template"),
)
.expect("writing file");
// WHEN
let mem = new_and_init_mem(temp.root().to_string_lossy().to_string()).await;
// THEN
for handle in [handle1, handle2] {
let actual = mem
.get_entity_by_handle(handle)
.await
.expect("getting entity by handle");
assert!(matches!(actual, RdapResponse::Entity(_)));
let RdapResponse::Entity(entity) = actual else {
panic!()
};
assert_eq!(
entity
.object_common
.handle
.as_ref()
.expect("handle is none"),
handle
)
}
}
#[tokio::test]
async fn GIVEN_data_dir_with_nameserver_WHEN_mem_init_THEN_nameserver_is_loaded() {
// GIVEN
let ldh_name = "ns.foo.example";
let temp = TestDir::temp();
let nameserver = Nameserver::builder().ldh_name(ldh_name).build().unwrap();
let nameserver_file = temp.path("ns_foo_example.json");
std::fs::write(
nameserver_file,
serde_json::to_string(&nameserver).expect("serializing nameserver"),
)
.expect("writing file");
// WHEN
let mem = new_and_init_mem(temp.root().to_string_lossy().to_string()).await;
// THEN
let actual = mem
.get_nameserver_by_ldh(ldh_name)
.await
.expect("getting nameserver by ldh");
assert!(matches!(actual, RdapResponse::Nameserver(_)));
let RdapResponse::Nameserver(nameserver) = actual else {
panic!()
};
assert_eq!(
nameserver.ldh_name.as_ref().expect("ldhName is none"),
ldh_name
)
}
#[tokio::test]
async fn GIVEN_data_dir_with_nameserver_template_WHEN_mem_init_THEN_nameservers_are_loaded() {
// GIVEN
let ldh1 = "ns.foo.example";
let ldh2 = "ns.bar.example";
let temp = TestDir::temp();
let template = Template::Nameserver {
nameserver: NameserverObject(Box::new(
Nameserver::builder().ldh_name("example").build().unwrap(),
)),
ids: vec![
NameserverId::builder().ldh_name(ldh1).build(),
NameserverId::builder().ldh_name(ldh2).build(),
],
};
let template_file = temp.path("example.template");
std::fs::write(
template_file,
serde_json::to_string(&template).expect("serializing template"),
)
.expect("writing file");
// WHEN
let mem = new_and_init_mem(temp.root().to_string_lossy().to_string()).await;
// THEN
for ldh in [ldh1, ldh2] {
let actual = mem
.get_nameserver_by_ldh(ldh)
.await
.expect("getting nameserver by ldh");
assert!(matches!(actual, RdapResponse::Nameserver(_)));
let RdapResponse::Nameserver(nameserver) = actual else {
panic!()
};
assert_eq!(nameserver.ldh_name.as_ref().expect("ldhName is none"), ldh)
}
}
#[tokio::test]
async fn GIVEN_data_dir_with_autnum_WHEN_mem_init_THEN_autnum_is_loaded() {
// GIVEN
let num = 700u32;
let temp = TestDir::temp();
let autnum = Autnum::builder().autnum_range(num..num).build();
let autnum_file = temp.path("700.json");
std::fs::write(
autnum_file,
serde_json::to_string(&autnum).expect("serializing autnum"),
)
.expect("writing file");
// WHEN
let mem = new_and_init_mem(temp.root().to_string_lossy().to_string()).await;
// THEN
let actual = mem
.get_autnum_by_num(num)
.await
.expect("getting autnum by num");
assert!(matches!(actual, RdapResponse::Autnum(_)));
let RdapResponse::Autnum(autnum) = actual else {
panic!()
};
assert_eq!(
*autnum.start_autnum.as_ref().expect("startAutnum is none"),
Numberish::<u32>::from(num)
)
}
#[tokio::test]
async fn GIVEN_data_dir_with_autnum_template_WHEN_mem_init_THEN_autnums_are_loaded() {
// GIVEN
let num1 = 700u32;
let num2 = 800u32;
let temp = TestDir::temp();
let template = Template::Autnum {
autnum: AutnumObject(Box::new(Autnum::builder().autnum_range(0..0).build())),
ids: vec![
AutnumId::builder()
.start_autnum(num1)
.end_autnum(num1)
.build(),
AutnumId::builder()
.start_autnum(num2)
.end_autnum(num2)
.build(),
],
};
let template_file = temp.path("example.template");
std::fs::write(
template_file,
serde_json::to_string(&template).expect("serializing template"),
)
.expect("writing file");
// WHEN
let mem = new_and_init_mem(temp.root().to_string_lossy().to_string()).await;
// THEN
for num in [num1, num2] {
let actual = mem
.get_autnum_by_num(num)
.await
.expect("getting autnum by num");
assert!(matches!(actual, RdapResponse::Autnum(_)));
let RdapResponse::Autnum(autnum) = actual else {
panic!()
};
assert_eq!(
*autnum.start_autnum.as_ref().expect("startAutnum is none"),
Numberish::<u32>::from(num)
)
}
}
#[tokio::test]
async fn GIVEN_data_dir_with_network_WHEN_mem_init_THEN_network_is_loaded() {
// GIVEN
let temp = TestDir::temp();
let network = Network::builder()
.cidr("10.0.0.0/24")
.build()
.expect("cidr parsing");
let net_file = temp.path("ten_net.json");
std::fs::write(
net_file,
serde_json::to_string(&network).expect("serializing network"),
)
.expect("writing file");
// WHEN
let mem = new_and_init_mem(temp.root().to_string_lossy().to_string()).await;
// THEN
let actual = mem
.get_network_by_ipaddr("10.0.0.0")
.await
.expect("getting autnum by num");
assert!(matches!(actual, RdapResponse::Network(_)));
let RdapResponse::Network(network) = actual else {
panic!()
};
assert_eq!(
*network
.start_address
.as_ref()
.expect("startAddress is none"),
"10.0.0.0"
)
}
#[tokio::test]
async fn GIVEN_data_dir_with_network_template_with_cidr_WHEN_mem_init_THEN_networks_are_loaded() {
// GIVEN
let cidr1 = "10.0.0.0/24";
let cidr2 = "10.0.1.0/24";
let start1 = "10.0.0.0";
let start2 = "10.0.1.0";
let temp = TestDir::temp();
let template = Template::Network {
network: NetworkObject(Box::new(
Network::builder()
.cidr("1.1.1.1/32")
.build()
.expect("parsing cidr"),
)),
ids: vec![
NetworkId::builder()
.network_id(NetworkIdType::Cidr(cidr1.parse().expect("parsing cidr")))
.build(),
NetworkId::builder()
.network_id(NetworkIdType::Cidr(cidr2.parse().expect("parsing cidr")))
.build(),
],
};
let template_file = temp.path("example.template");
std::fs::write(
template_file,
serde_json::to_string(&template).expect("serializing template"),
)
.expect("writing file");
// WHEN
let mem = new_and_init_mem(temp.root().to_string_lossy().to_string()).await;
// THEN
for (cidr, start) in [(cidr1, start1), (cidr2, start2)] {
let actual = mem
.get_network_by_cidr(cidr)
.await
.expect("getting cidr by num");
assert!(matches!(actual, RdapResponse::Network(_)));
let RdapResponse::Network(network) = actual else {
panic!()
};
assert_eq!(
*network
.start_address
.as_ref()
.expect("startAddress is none"),
start
)
}
}
#[tokio::test]
async fn GIVEN_data_dir_with_network_template_with_range_WHEN_mem_init_THEN_networks_are_loaded() {
// GIVEN
let start1 = "10.0.0.0";
let start2 = "10.0.1.0";
let end1 = "10.0.0.255";
let end2 = "10.0.1.255";
let temp = TestDir::temp();
let template = Template::Network {
network: NetworkObject(Box::new(
Network::builder()
.cidr("1.1.1.1/32")
.build()
.expect("parsing cidr"),
)),
ids: vec![
NetworkId::builder()
.network_id(NetworkIdType::Range {
start_address: start1.to_string(),
end_address: end1.to_string(),
})
.build(),
NetworkId::builder()
.network_id(NetworkIdType::Range {
start_address: start2.to_string(),
end_address: end2.to_string(),
})
.build(),
],
};
let template_file = temp.path("example.template");
std::fs::write(
template_file,
serde_json::to_string(&template).expect("serializing template"),
)
.expect("writing file");
// WHEN
let mem = new_and_init_mem(temp.root().to_string_lossy().to_string()).await;
// THEN
for (start, end) in [(start1, end1), (start2, end2)] {
let actual = mem
.get_network_by_ipaddr(end)
.await
.expect("getting cidr by addr");
assert!(matches!(actual, RdapResponse::Network(_)));
let RdapResponse::Network(network) = actual else {
panic!()
};
assert_eq!(
*network
.start_address
.as_ref()
.expect("startAddress is none"),
start
)
}
}
#[tokio::test]
async fn GIVEN_data_dir_with_default_help_WHEN_mem_init_THEN_default_help_is_loaded() {
// GIVEN
let temp = TestDir::temp();
let srvhelp = Help::builder()
.notice(Notice(
NoticeOrRemark::builder()
.description_entry("foo".to_string())
.build(),
))
.build();
let srvhelp_file = temp.path("__default.help");
std::fs::write(
srvhelp_file,
serde_json::to_string(&srvhelp).expect("serializing srvhelp"),
)
.expect("writing file");
// WHEN
let mem = new_and_init_mem(temp.root().to_string_lossy().to_string()).await;
// THEN
let actual = mem
.get_srv_help(None)
.await
.expect("getting default srvhelp");
assert!(matches!(actual, RdapResponse::Help(_)));
let RdapResponse::Help(srvhelp) = actual else {
panic!()
};
let notice = srvhelp
.common
.notices
.expect("no notices in srvhelp")
.first()
.expect("notices empty")
.to_owned();
assert_eq!(
notice
.description
.as_ref()
.expect("no description!")
.vec()
.first()
.expect("no description in notice"),
"foo"
);
}
#[tokio::test]
async fn GIVEN_data_dir_with_host_help_WHEN_mem_init_THEN_host_help_is_loaded() {
// GIVEN
let temp = TestDir::temp();
let srvhelp = Help::builder()
.notice(Notice(
NoticeOrRemark::builder()
.description_entry("bar".to_string())
.build(),
))
.build();
let srvhelp_file = temp.path("foo_example_com.help");
std::fs::write(
srvhelp_file,
serde_json::to_string(&srvhelp).expect("serializing srvhelp"),
)
.expect("writing file");
// WHEN
let mem = new_and_init_mem(temp.root().to_string_lossy().to_string()).await;
// THEN
let actual = mem
.get_srv_help(Some("foo.example.com"))
.await
.expect("getting default srvhelp");
assert!(matches!(actual, RdapResponse::Help(_)));
let RdapResponse::Help(srvhelp) = actual else {
panic!()
};
let notice = srvhelp
.common
.notices
.expect("no notices in srvhelp")
.first()
.expect("notices empty")
.to_owned();
assert_eq!(
notice
.description
.as_ref()
.expect("no description!")
.vec()
.first()
.expect("no description in notice"),
"bar"
);
}

743
icann-rdap-srv/tests/integration/storage/mem/mod.rs Normal file
View file

@ -0,0 +1,743 @@
#![allow(non_snake_case)]
use {
icann_rdap_common::{
prelude::Numberish,
response::{
Autnum, Common, Domain, Entity, Help, Nameserver, Network, Notice, NoticeOrRemark,
ObjectCommon, RdapResponse,
},
},
icann_rdap_srv::storage::{
mem::{config::MemConfig, ops::Mem},
CommonConfig, StoreOps,
},
rstest::rstest,
};
#[tokio::test]
async fn GIVEN_domain_in_mem_WHEN_new_truncate_tx_THEN_no_domain_in_mem() {
// GIVEN
let mem = Mem::default();
let mut tx = mem.new_tx().await.expect("new transaction");
tx.add_domain(&Domain::builder().ldh_name("foo.example").build())
.await
.expect("add domain in tx");
tx.commit().await.expect("tx commit");
// WHEN
let tx = mem.new_truncate_tx().await.expect("new truncate tx");
tx.commit().await.expect("tx commit");
// THEN
let actual = mem
.get_domain_by_ldh("foo.example")
.await
.expect("getting domain by ldh");
let RdapResponse::ErrorResponse(error) = actual else {
panic!()
};
assert_eq!(error.error_code, 404)
}
#[tokio::test]
async fn GIVEN_domain_in_mem_WHEN_lookup_domain_by_ldh_THEN_domain_returned() {
// GIVEN
let mem = Mem::default();
let mut tx = mem.new_tx().await.expect("new transaction");
tx.add_domain(&Domain::builder().ldh_name("foo.example").build())
.await
.expect("add domain in tx");
tx.commit().await.expect("tx commit");
// WHEN
let actual = mem
.get_domain_by_ldh("foo.example")
.await
.expect("getting domain by ldh");
// THEN
let RdapResponse::Domain(domain) = actual else {
panic!()
};
assert_eq!(
domain.ldh_name.as_ref().expect("ldhName is none"),
"foo.example"
)
}
#[tokio::test]
async fn GIVEN_domain_in_mem_WHEN_lookup_domain_by_unicode_THEN_domain_returned() {
// GIVEN
let mem = Mem::default();
let mut tx = mem.new_tx().await.expect("new transaction");
tx.add_domain(
&Domain::idn()
.unicode_name("foo.example")
.ldh_name("foo.example")
.build(),
)
.await
.expect("add domain in tx");
tx.commit().await.expect("tx commit");
// WHEN
let actual = mem
.get_domain_by_unicode("foo.example")
.await
.expect("getting domain by unicode");
// THEN
let RdapResponse::Domain(domain) = actual else {
panic!()
};
assert_eq!(
domain.unicode_name.as_ref().expect("unicodeName is none"),
"foo.example"
)
}
#[tokio::test]
async fn GIVEN_domain_in_mem_WHEN_search_domain_by_name_THEN_domain_returned() {
// GIVEN
let mem = Mem::default();
let mut tx = mem.new_tx().await.expect("new transaction");
tx.add_domain(
&Domain::idn()
.unicode_name("foo.example.com")
.ldh_name("foo.example.com")
.build(),
)
.await
.expect("add domain in tx");
tx.commit().await.expect("tx commit");
// WHEN
let actual = mem
.search_domains_by_name("foo.example.*")
.await
.expect("getting domain by unicode");
// THEN
let RdapResponse::DomainSearchResults(domains) = actual else {
panic!()
};
assert_eq!(domains.clone().results.len(), 1);
assert_eq!(
domains
.results
.first()
.expect("at least one")
.unicode_name
.as_ref()
.expect("unicodeName is none"),
"foo.example.com"
)
}
#[tokio::test]
async fn GIVEN_domain_in_mem_but_search_not_enabled_WHEN_search_domain_by_name_THEN_not_implemented(
) {
// GIVEN
let mem_config = MemConfig::builder()
.common_config(
CommonConfig::builder()
.domain_search_by_name_enable(false)
.build(),
)
.build();
let mem = Mem::new(mem_config);
let mut tx = mem.new_tx().await.expect("new transaction");
tx.add_domain(
&Domain::idn()
.unicode_name("foo.example.com")
.ldh_name("foo.example.com")
.build(),
)
.await
.expect("add domain in tx");
tx.commit().await.expect("tx commit");
// WHEN
let actual = mem
.search_domains_by_name("foo.example.*")
.await
.expect("getting domain by unicode");
// THEN
let RdapResponse::ErrorResponse(_e) = actual else {
panic!()
};
}
#[tokio::test]
async fn GIVEN_no_domain_in_mem_WHEN_lookup_domain_by_ldh_THEN_404_returned() {
// GIVEN
let mem = Mem::default();
// WHEN
let actual = mem
.get_domain_by_ldh("foo.example")
.await
.expect("getting domain by ldh");
// THEN
let RdapResponse::ErrorResponse(error) = actual else {
panic!()
};
assert_eq!(error.error_code, 404)
}
#[tokio::test]
async fn GIVEN_entity_in_mem_WHEN_lookup_entity_by_handle_THEN_entity_returned() {
// GIVEN
let mem = Mem::default();
let mut tx = mem.new_tx().await.expect("new transaction");
tx.add_entity(&Entity::builder().handle("foo").build())
.await
.expect("add entity in tx");
tx.commit().await.expect("entity tx commit");
// WHEN
let actual = mem
.get_entity_by_handle("foo")
.await
.expect("getting entity by handle");
// THEN
let RdapResponse::Entity(entity) = actual else {
panic!()
};
assert_eq!(
entity
.object_common
.handle
.as_ref()
.expect("handle is none"),
"foo"
)
}
#[tokio::test]
async fn GIVEN_no_entity_in_mem_WHEN_lookup_entity_by_handle_THEN_404_returned() {
// GIVEN
let mem = Mem::default();
// WHEN
let actual = mem
.get_entity_by_handle("foo")
.await
.expect("getting entity by handle");
// THEN
let RdapResponse::ErrorResponse(error) = actual else {
panic!()
};
assert_eq!(error.error_code, 404)
}
#[tokio::test]
async fn GIVEN_nameserver_in_mem_WHEN_lookup_nameserver_by_ldh_THEN_nameserver_returned() {
// GIVEN
let mem = Mem::default();
let mut tx = mem.new_tx().await.expect("new transaction");
tx.add_nameserver(
&Nameserver::builder()
.ldh_name("ns.foo.example")
.build()
.unwrap(),
)
.await
.expect("add nameserver in tx");
tx.commit().await.expect("tx commit");
// WHEN
let actual = mem
.get_nameserver_by_ldh("ns.foo.example")
.await
.expect("getting nameserver by ldh");
// THEN
let RdapResponse::Nameserver(nameserver) = actual else {
panic!()
};
assert_eq!(
nameserver.ldh_name.as_ref().expect("ldhName is none"),
"ns.foo.example"
)
}
#[tokio::test]
async fn GIVEN_no_nameserver_in_mem_WHEN_lookup_nameserver_by_ldh_THEN_404_returned() {
// GIVEN
let mem = Mem::default();
// WHEN
let actual = mem
.get_nameserver_by_ldh("ns.foo.example")
.await
.expect("getting nameserver by ldh");
// THEN
let RdapResponse::ErrorResponse(error) = actual else {
panic!()
};
assert_eq!(error.error_code, 404)
}
#[tokio::test]
async fn GIVEN_autnum_in_mem_WHEN_lookup_autnum_by_start_autnum_THEN_autnum_returned() {
// GIVEN
let mem = Mem::default();
let mut tx = mem.new_tx().await.expect("new transaction");
tx.add_autnum(&Autnum::builder().autnum_range(700..710).build())
.await
.expect("add autnum in tx");
tx.commit().await.expect("tx commit");
// WHEN
let actual = mem
.get_autnum_by_num(700)
.await
.expect("getting autnum by num");
// THEN
let RdapResponse::Autnum(autnum) = actual else {
panic!()
};
assert_eq!(
*autnum.start_autnum.as_ref().expect("startNum is none"),
Numberish::<u32>::from(700)
);
assert_eq!(
*autnum.end_autnum.as_ref().expect("startNum is none"),
Numberish::<u32>::from(710)
);
}
#[tokio::test]
async fn GIVEN_autnum_in_mem_WHEN_lookup_autnum_by_end_autnum_THEN_autnum_returned() {
// GIVEN
let mem = Mem::default();
let mut tx = mem.new_tx().await.expect("new transaction");
tx.add_autnum(&Autnum::builder().autnum_range(700..710).build())
.await
.expect("add autnum in tx");
tx.commit().await.expect("tx commit");
// WHEN
let actual = mem
.get_autnum_by_num(710)
.await
.expect("getting autnum by num");
// THEN
let RdapResponse::Autnum(autnum) = actual else {
panic!()
};
assert_eq!(
*autnum.start_autnum.as_ref().expect("startNum is none"),
Numberish::<u32>::from(700)
);
assert_eq!(
*autnum.end_autnum.as_ref().expect("startNum is none"),
Numberish::<u32>::from(710)
);
}
#[tokio::test]
async fn GIVEN_no_autnum_in_mem_WHEN_lookup_autnum_by_num_THEN_404_returned() {
// GIVEN
let mem = Mem::default();
// WHEN
let actual = mem
.get_autnum_by_num(700)
.await
.expect("getting autnum by num");
// THEN
let RdapResponse::ErrorResponse(error) = actual else {
panic!()
};
assert_eq!(error.error_code, 404)
}
#[rstest]
#[case("192.168.0.0/24", "192.168.0.1", "192.168.0.0", "192.168.0.255")]
#[case("192.168.0.0/24", "192.168.0.0", "192.168.0.0", "192.168.0.255")]
#[case("192.168.0.0/24", "192.168.0.254", "192.168.0.0", "192.168.0.255")]
#[case("192.168.0.0/24", "192.168.0.255", "192.168.0.0", "192.168.0.255")]
#[tokio::test]
async fn GIVEN_network_in_mem_WHEN_lookup_network_by_address_THEN_network_returned(
#[case] cidr: &str,
#[case] addr: &str,
#[case] start: &str,
#[case] end: &str,
) {
// GIVEN
let mem = Mem::default();
let mut tx = mem.new_tx().await.expect("new transaction");
tx.add_network(&Network::builder().cidr(cidr).build().expect("cidr parsing"))
.await
.expect("add network in tx");
tx.commit().await.expect("tx commit");
// WHEN
let actual = mem
.get_network_by_ipaddr(addr)
.await
.expect("getting network by num");
// THEN
let RdapResponse::Network(network) = actual else {
panic!()
};
assert_eq!(
*network
.start_address
.as_ref()
.expect("startAddress is none"),
start
);
assert_eq!(
*network.end_address.as_ref().expect("endAddress is none"),
end
);
}
#[tokio::test]
async fn GIVEN_no_network_in_mem_WHEN_lookup_network_by_address_THEN_404_returned() {
// GIVEN
let mem = Mem::default();
// WHEN
let actual = mem
.get_network_by_ipaddr("192.168.0.1")
.await
.expect("getting network by address");
// THEN
let RdapResponse::ErrorResponse(error) = actual else {
panic!()
};
assert_eq!(error.error_code, 404)
}
#[rstest]
#[case(&["192.168.0.0/16", "192.168.0.0/8", "192.168.0.0/24"], "192.168.0.1", "192.168.0.0", "192.168.0.255")]
#[case(&["2001::/64", "2001::/56", "2001::/20"], "2001::1", "2001::", "2001::ffff:ffff:ffff:ffff")]
#[tokio::test]
async fn GIVEN_contained_networks_in_mem_WHEN_lookup_network_by_address_THEN_most_specific_network_returned(
#[case] cidrs: &[&str],
#[case] addr: &str,
#[case] start: &str,
#[case] end: &str,
) {
// GIVEN
let mem = Mem::default();
let mut tx = mem.new_tx().await.expect("new transaction");
for cidr in cidrs {
tx.add_network(
&Network::builder()
.cidr(*cidr)
.build()
.expect("cidr parsing"),
)
.await
.expect("add network in tx");
}
tx.commit().await.expect("tx commit");
// WHEN
let actual = mem
.get_network_by_ipaddr(addr)
.await
.expect("getting network by num");
// THEN
let RdapResponse::Network(network) = actual else {
panic!()
};
assert_eq!(
*network
.start_address
.as_ref()
.expect("startAddress is none"),
start
);
assert_eq!(
*network.end_address.as_ref().expect("endAddress is none"),
end
);
}
#[tokio::test]
async fn GIVEN_offbit_network_in_mem_WHEN_lookup_network_by_first_address_THEN_network_returned() {
// GIVEN
let start = "10.0.0.0";
let end = "10.0.1.255";
let mem = Mem::default();
let mut tx = mem.new_tx().await.expect("new transaction");
tx.add_network(&Network {
common: Common {
rdap_conformance: None,
notices: None,
},
object_common: ObjectCommon {
object_class_name: "ip network".to_string(),
handle: None,
remarks: None,
links: None,
events: None,
status: None,
port_43: None,
entities: None,
redacted: None,
},
start_address: Some(start.to_string()),
end_address: Some(end.to_string()),
ip_version: Some("v4".to_string()),
name: None,
network_type: None,
parent_handle: None,
country: None,
cidr0_cidrs: None,
})
.await
.expect("add network in tx");
tx.commit().await.expect("tx commit");
// WHEN
let actual = mem
.get_network_by_ipaddr(start)
.await
.expect("getting network by num");
// THEN
let RdapResponse::Network(network) = actual else {
panic!()
};
assert_eq!(
*network
.start_address
.as_ref()
.expect("startAddress is none"),
start
);
assert_eq!(
*network.end_address.as_ref().expect("endAddress is none"),
end
);
}
#[tokio::test]
async fn GIVEN_offbit_network_in_mem_WHEN_lookup_network_by_last_address_THEN_network_returned() {
// GIVEN
let start = "10.0.0.0";
let end = "10.0.1.255";
let mem = Mem::default();
let mut tx = mem.new_tx().await.expect("new transaction");
tx.add_network(&Network {
common: Common {
rdap_conformance: None,
notices: None,
},
object_common: ObjectCommon {
object_class_name: "ip network".to_string(),
handle: None,
remarks: None,
links: None,
events: None,
status: None,
port_43: None,
entities: None,
redacted: None,
},
start_address: Some(start.to_string()),
end_address: Some(end.to_string()),
ip_version: Some("v4".to_string()),
name: None,
network_type: None,
parent_handle: None,
country: None,
cidr0_cidrs: None,
})
.await
.expect("add network in tx");
tx.commit().await.expect("tx commit");
// WHEN
let actual = mem
.get_network_by_ipaddr(end)
.await
.expect("getting network by num");
// THEN
let RdapResponse::Network(network) = actual else {
panic!()
};
assert_eq!(
*network
.start_address
.as_ref()
.expect("startAddress is none"),
start
);
assert_eq!(
*network.end_address.as_ref().expect("endAddress is none"),
end
);
}
#[rstest]
#[case("192.168.0.0/16", "192.168.0.0/24", "192.168.0.0", "192.168.255.255")]
#[case("192.168.0.0/16", "192.168.0.0/16", "192.168.0.0", "192.168.255.255")]
#[tokio::test]
async fn GIVEN_network_in_mem_WHEN_lookup_network_by_cidr_THEN_network_returned(
#[case] cidr: &str,
#[case] lookup: &str,
#[case] start: &str,
#[case] end: &str,
) {
// GIVEN
let mem = Mem::default();
let mut tx = mem.new_tx().await.expect("new transaction");
tx.add_network(&Network::builder().cidr(cidr).build().expect("cidr parsing"))
.await
.expect("add network in tx");
tx.commit().await.expect("tx commit");
// WHEN
let actual = mem
.get_network_by_cidr(lookup)
.await
.expect("getting network by cidr");
// THEN
let RdapResponse::Network(network) = actual else {
panic!()
};
assert_eq!(
*network
.start_address
.as_ref()
.expect("startAddress is none"),
start
);
assert_eq!(
*network.end_address.as_ref().expect("endAddress is none"),
end
);
}
#[tokio::test]
async fn GIVEN_no_network_in_mem_WHEN_lookup_network_by_cidr_THEN_404_returned() {
// GIVEN
let mem = Mem::default();
// WHEN
let actual = mem
.get_network_by_cidr("192.168.0.0/24")
.await
.expect("getting network by address");
// THEN
let RdapResponse::ErrorResponse(error) = actual else {
panic!()
};
assert_eq!(error.error_code, 404)
}
#[tokio::test]
async fn GIVEN_default_help_in_mem_WHEN_lookup_help_with_no_host_THEN_get_default_help() {
// GIVEN
let mem = Mem::default();
let mut tx = mem.new_tx().await.expect("new transaction");
tx.add_srv_help(
&Help::builder()
.notice(Notice(
NoticeOrRemark::builder()
.description_entry("foo".to_string())
.build(),
))
.build(),
None,
)
.await
.expect("adding srv help");
tx.commit().await.expect("tx commit");
// WHEN
let actual = mem.get_srv_help(None).await.expect("getting srv helf");
// THEN
let RdapResponse::Help(srvhelp) = actual else {
panic!()
};
let notice = srvhelp
.common
.notices
.expect("no notices in srvhelp")
.first()
.expect("notices empty")
.to_owned();
assert_eq!(
notice
.description
.as_ref()
.expect("no description!")
.vec()
.first()
.expect("no description in notice"),
"foo"
);
}
#[tokio::test]
async fn GIVEN_help_in_mem_WHEN_lookup_help_with_host_THEN_get_host_help() {
// GIVEN
let mem = Mem::default();
let mut tx = mem.new_tx().await.expect("new transaction");
tx.add_srv_help(
&Help::builder()
.notice(Notice(
NoticeOrRemark::builder()
.description_entry("bar".to_string())
.build(),
))
.build(),
Some("bar.example.com"),
)
.await
.expect("adding srv help");
tx.commit().await.expect("tx commit");
// WHEN
let actual = mem
.get_srv_help(Some("bar.example.com"))
.await
.expect("getting srv helf");
// THEN
let RdapResponse::Help(srvhelp) = actual else {
panic!()
};
let notice = srvhelp
.common
.notices
.expect("no notices in srvhelp")
.first()
.expect("notices empty")
.to_owned();
assert_eq!(
notice
.description
.as_ref()
.expect("no description")
.vec()
.first()
.expect("no description in notice"),
"bar"
);
}

2
icann-rdap-srv/tests/integration/storage/mod.rs Normal file
View file

@ -0,0 +1,2 @@
mod data;
mod mem;

144
icann-rdap-srv/tests/integration/test_jig.rs Normal file
View file

@ -0,0 +1,144 @@
use {
assert_cmd::Command,
icann_rdap_srv::{
config::ListenConfig,
server::{AppState, Listener},
storage::{
mem::{config::MemConfig, ops::Mem},
CommonConfig,
},
},
std::time::Duration,
test_dir::{DirBuilder, TestDir},
};
pub struct RdapSrvStoreTestJig {
pub cmd: Command,
#[allow(dead_code)]
pub source_dir: TestDir,
pub data_dir: TestDir,
}
impl RdapSrvStoreTestJig {
pub fn new() -> RdapSrvStoreTestJig {
let source_dir = TestDir::temp();
let data_dir = TestDir::temp();
let mut cmd = Command::cargo_bin("rdap-srv-store").expect("cannot find rdap-srv-store cmd");
cmd.env_clear()
.timeout(Duration::from_secs(2))
.env("RDAP_BASE_URL", "http://localhost:3000/rdap")
.env("RDAP_SRV_LOG", "debug")
.env("RDAP_SRV_DATA_DIR", data_dir.root());
Self {
cmd,
source_dir,
data_dir,
}
}
}
pub struct RdapSrvDataTestJig {
pub cmd: Command,
pub source_dir: TestDir,
pub data_dir: TestDir,
}
impl RdapSrvDataTestJig {
pub fn new() -> Self {
let source_dir = TestDir::temp();
let data_dir = TestDir::temp();
let mut cmd = Command::cargo_bin("rdap-srv-data").expect("cannot find rdap-srv-data cmd");
cmd.env_clear()
.timeout(Duration::from_secs(2))
.env("RDAP_BASE_URL", "http://localhost:3000/rdap")
.env("RDAP_SRV_LOG", "debug")
.env("RDAP_SRV_DATA_DIR", data_dir.root());
Self {
cmd,
source_dir,
data_dir,
}
}
pub fn new_cmd(self) -> Self {
let mut cmd = Command::cargo_bin("rdap-srv-data").expect("cannot find rdap-srv-data cmd");
cmd.env_clear()
.timeout(Duration::from_secs(2))
.env("RDAP_BASE_URL", "http://localhost:3000/rdap")
.env("RDAP_SRV_LOG", "debug")
.env("RDAP_SRV_DATA_DIR", self.data_dir.root());
Self {
cmd,
source_dir: self.source_dir,
data_dir: self.data_dir,
}
}
}
pub struct SrvTestJig {
pub mem: Mem,
pub rdap_base: String,
}
impl SrvTestJig {
pub async fn new() -> Self {
let mem = Mem::default();
let app_state = AppState {
storage: mem.clone(),
bootstrap: false,
};
let _ = tracing_subscriber::fmt().with_test_writer().try_init();
let listener = Listener::listen(&ListenConfig::default())
.await
.expect("listening on interface");
let rdap_base = listener.rdap_base();
tokio::spawn(async move {
listener
.start_with_state(app_state)
.await
.expect("starting server");
});
Self { mem, rdap_base }
}
pub async fn new_common_config(common_config: CommonConfig) -> Self {
let mem_config = MemConfig::builder().common_config(common_config).build();
let mem = Mem::new(mem_config);
let app_state = AppState {
storage: mem.clone(),
bootstrap: false,
};
let _ = tracing_subscriber::fmt().with_test_writer().try_init();
let listener = Listener::listen(&ListenConfig::default())
.await
.expect("listening on interface");
let rdap_base = listener.rdap_base();
tokio::spawn(async move {
listener
.start_with_state(app_state)
.await
.expect("starting server");
});
Self { mem, rdap_base }
}
pub async fn new_bootstrap() -> Self {
let mem = Mem::default();
let app_state = AppState {
storage: mem.clone(),
bootstrap: true,
};
let _ = tracing_subscriber::fmt().with_test_writer().try_init();
let listener = Listener::listen(&ListenConfig::default())
.await
.expect("listening on interface");
let rdap_base = listener.rdap_base();
tokio::spawn(async move {
listener
.start_with_state(app_state)
.await
.expect("starting server");
});
Self { mem, rdap_base }
}
}