use std::collections::BTreeSet;
use std::io::{IsTerminal, Write};
use std::str::FromStr;
use serde_json::{json, Value};
use crate::cli::{
AuthSubcommand, Cli, Command, CompaniesSubcommand, ConfigKey, ConfigSubcommand,
DocumentsSubcommand, FinancialFieldArg, ReportingScopeArg, ResolveArgs,
};
use crate::client::{
CompanyFilters, CompanyId, CompanyInclude, CompanyPage, CoragridClient, DocumentId,
ExternalIdentifierSelector, FinancialField, FinancialRange, ReportingScope,
ResolveCompanyRequest, SearchCompaniesRequest,
};
use crate::config::{
clear_effective_credential_reference, list_profiles, set_profile_credential_reference,
set_profile_value, use_profile, Credential, CredentialKind, CredentialSource, EffectiveConfig,
};
use crate::credential_store::{CredentialReference, CredentialStore, OsCredentialStore};
use crate::error::{CgdError, ExitStatus};
use crate::output::Renderer;
pub async fn execute<W: Write, E: Write>(
cli: &Cli,
command: &Command,
config: &EffectiveConfig,
stdout: &mut W,
stderr: &mut E,
) -> Result<ExitStatus, CgdError> {
for warning in &config.warnings {
writeln!(stderr, "warning: {warning}")?;
}
match command {
Command::Config(command) => {
let mut renderer = Renderer::new(stdout, config.output, cli.quiet);
match &command.command {
ConfigSubcommand::List => renderer.config(config)?,
ConfigSubcommand::Get { key } => render_config_value(&mut renderer, config, *key)?,
ConfigSubcommand::Set { key, value } => {
let normalized =
set_profile_value(&config.config_path, &config.profile, *key, value)?;
renderer.config_value(key.as_str(), normalized)?;
}
ConfigSubcommand::Profiles => {
let profiles = list_profiles(&config.config_path)?;
renderer.config_profiles(&profiles)?;
}
ConfigSubcommand::Use { profile } => {
use_profile(&config.config_path, profile)?;
renderer.config_value("current_profile", profile)?;
}
}
Ok(ExitStatus::Success)
}
Command::Auth(command) => match &command.command {
AuthSubcommand::Login => login(config, cli, stdout, stderr).await,
AuthSubcommand::Logout => logout(config, cli, stdout),
AuthSubcommand::Status => {
let client = CoragridClient::new(config)?;
let response = client.caller().await?;
let mut renderer = Renderer::new(stdout, config.output, cli.quiet);
renderer.caller(&response.value.data, &response.raw, config)?;
write_request_diagnostic(stderr, cli.verbose, response.request_id.as_deref())?;
Ok(ExitStatus::Success)
}
},
Command::Resolve(arguments) => {
let client = CoragridClient::new(config)?;
let request = resolve_request(arguments)?;
let response = client.resolve(&request).await?;
let status = response.value.data.status.as_str();
let mut renderer = Renderer::new(stdout, config.output, cli.quiet);
renderer.resolution(&response.value.data, &response.raw)?;
write_request_diagnostic(stderr, cli.verbose, response.request_id.as_deref())?;
if status == "not_found" {
return Ok(ExitStatus::NotFound);
}
if arguments.require_unique
&& (status != "resolved" || response.value.data.result.is_none())
{
return Ok(ExitStatus::NotFound);
}
Ok(ExitStatus::Success)
}
Command::Companies(command) => {
let client = CoragridClient::new(config)?;
match &command.command {
CompaniesSubcommand::Get(arguments) => {
let company_id = CompanyId::from_str(&arguments.company_id)
.map_err(|message| CgdError::Usage(message.to_owned()))?;
let response = client.get_company(&company_id).await?;
let mut renderer = Renderer::new(stdout, config.output, cli.quiet);
renderer.company(&response.value.data, &response.raw)?;
write_request_diagnostic(stderr, cli.verbose, response.request_id.as_deref())?;
Ok(ExitStatus::Success)
}
CompaniesSubcommand::Officers(arguments) => {
let company_id = CompanyId::from_str(&arguments.company_id)
.map_err(|message| CgdError::Usage(message.to_owned()))?;
let response = client
.get_company_officers(&company_id, arguments.limit)
.await?;
let mut renderer = Renderer::new(stdout, config.output, cli.quiet);
renderer.company_officers(&response.value, &response.raw)?;
write_request_diagnostic(stderr, cli.verbose, response.request_id.as_deref())?;
Ok(ExitStatus::Success)
}
CompaniesSubcommand::Search(arguments) => {
let (page, raw, request_ids) = search_companies(&client, arguments).await?;
let mut renderer = Renderer::new(stdout, config.output, cli.quiet);
renderer.company_page(&page, &raw)?;
if cli.verbose > 0 {
for request_id in request_ids {
writeln!(stderr, "request: {request_id}")?;
}
}
Ok(ExitStatus::Success)
}
}
}
Command::Documents(command) => {
let client = CoragridClient::new(config)?;
match &command.command {
DocumentsSubcommand::Get(arguments) => {
if !arguments.metadata {
return Err(CgdError::Usage(
"document get requires --metadata; document bytes are not available"
.to_owned(),
));
}
let document_id = DocumentId::from_str(&arguments.document_id)
.map_err(|message| CgdError::Usage(message.to_owned()))?;
let response = client.get_document_metadata(&document_id).await?;
let mut renderer = Renderer::new(stdout, config.output, cli.quiet);
renderer.document(&response.value.data, &response.raw)?;
write_request_diagnostic(stderr, cli.verbose, response.request_id.as_deref())?;
Ok(ExitStatus::Success)
}
}
}
Command::Completions(_) | Command::Version | Command::Tui(_) => Err(CgdError::Internal(
"local-only command reached the network command dispatcher".to_owned(),
)),
}
}
async fn login<W: Write, E: Write>(
config: &EffectiveConfig,
cli: &Cli,
stdout: &mut W,
stderr: &mut E,
) -> Result<ExitStatus, CgdError> {
if !std::io::stdin().is_terminal() {
return Err(CgdError::Usage(
"auth login requires an interactive terminal; automation should set CORAGRID_API_KEY"
.to_owned(),
));
}
let secret = rpassword::prompt_password("Coragrid API key: ").map_err(|error| {
if error.kind() == std::io::ErrorKind::Interrupted {
CgdError::Interrupted
} else {
CgdError::Unavailable(format!("cannot securely read the API key: {error}"))
}
})?;
let credential = Credential::new(
CredentialKind::ApiKey,
CredentialSource::OsCredentialStore,
secret,
"API key",
)?;
let reference = CredentialReference::for_profile(&config.profile)?;
let store = OsCredentialStore;
login_with_credential(config, cli, stdout, stderr, &store, reference, credential).await
}
async fn login_with_credential<W: Write, E: Write>(
config: &EffectiveConfig,
cli: &Cli,
stdout: &mut W,
stderr: &mut E,
store: &dyn CredentialStore,
reference: CredentialReference,
credential: Credential,
) -> Result<ExitStatus, CgdError> {
let mut verified_config = config.clone();
verified_config.credential = Some(credential.clone());
verified_config.credential_ref = Some(reference.clone());
let response = CoragridClient::new(&verified_config)?.caller().await?;
let previous = store.get(&reference)?;
store.put(&reference, &credential)?;
if let Err(config_error) =
set_profile_credential_reference(&config.config_path, &config.profile, &reference)
{
let rollback = match previous.as_ref() {
Some(previous) => store.put(&reference, previous),
None => store.delete(&reference).map(|_| ()),
};
return match rollback {
Ok(()) => Err(config_error),
Err(rollback_error) => Err(CgdError::Internal(format!(
"cannot persist the credential reference ({config_error}); credential-store rollback also failed ({rollback_error})"
))),
};
}
if config
.credential
.as_ref()
.is_some_and(|credential| credential.source() == CredentialSource::Environment)
{
writeln!(
stderr,
"warning: an environment credential remains higher precedence than the stored profile credential"
)?;
}
let mut renderer = Renderer::new(stdout, config.output, cli.quiet);
renderer.auth_login(
&response.value.data,
&response.raw,
&verified_config,
&reference,
)?;
write_request_diagnostic(stderr, cli.verbose, response.request_id.as_deref())?;
Ok(ExitStatus::Success)
}
fn logout<W: Write>(
config: &EffectiveConfig,
cli: &Cli,
stdout: &mut W,
) -> Result<ExitStatus, CgdError> {
let environment_credential_active = config
.credential
.as_ref()
.is_some_and(|credential| credential.source() == CredentialSource::Environment);
let Some(reference) = config.credential_ref.as_ref() else {
let mut renderer = Renderer::new(stdout, config.output, cli.quiet);
renderer.auth_logout(&config.profile, None, false, environment_credential_active)?;
return Ok(ExitStatus::Success);
};
let removal =
clear_effective_credential_reference(&config.config_path, &config.profile, reference)?;
if !removal.removed {
return Err(CgdError::Conflict(
"the selected profile's credential reference changed; retry logout".to_owned(),
));
}
let deleted = if removal.still_referenced {
false
} else {
let store = OsCredentialStore;
match store.delete(reference) {
Ok(deleted) => deleted,
Err(error) => {
let restore = set_profile_credential_reference(
&config.config_path,
&config.profile,
reference,
);
return match restore {
Ok(()) => Err(error),
Err(restore_error) => Err(CgdError::Internal(format!(
"cannot delete {reference} ({error}); restoring its configuration binding also failed ({restore_error})"
))),
};
}
}
};
let mut renderer = Renderer::new(stdout, config.output, cli.quiet);
renderer.auth_logout(
&config.profile,
Some(reference),
deleted,
environment_credential_active,
)?;
Ok(ExitStatus::Success)
}
fn render_config_value<W: Write>(
renderer: &mut Renderer<'_, W>,
config: &EffectiveConfig,
key: ConfigKey,
) -> Result<(), CgdError> {
let (name, value) = match key {
ConfigKey::Profile => ("profile", config.profile.clone()),
ConfigKey::ApiBaseUrl => ("api_base_url", config.api_base_url.to_string()),
ConfigKey::Workspace => (
"workspace",
config.workspace.clone().unwrap_or_else(|| "n/a".to_owned()),
),
ConfigKey::Output => ("output", config.output.to_string()),
ConfigKey::Timeout => (
"timeout",
humantime::format_duration(config.timeout).to_string(),
),
ConfigKey::NoColor => ("no_color", config.no_color.to_string()),
ConfigKey::CredentialSource => (
"credential_source",
config
.credential
.as_ref()
.map(|credential| credential.source_description())
.unwrap_or_else(|| "none".to_owned()),
),
ConfigKey::CredentialRef => (
"credential_ref",
config
.credential_ref
.as_ref()
.map(ToString::to_string)
.unwrap_or_else(|| "none".to_owned()),
),
ConfigKey::ConfigPath => ("config_path", config.config_path.display().to_string()),
};
renderer.config_value(name, value)
}
fn resolve_request(arguments: &ResolveArgs) -> Result<ResolveCompanyRequest, CgdError> {
let query = arguments.query.trim();
if query.is_empty() || query.len() > 2048 {
return Err(CgdError::Usage(
"resolve query must contain between 1 and 2048 characters".to_owned(),
));
}
if !(1..=25).contains(&arguments.limit) {
return Err(CgdError::Usage(
"resolve limit must be between 1 and 25".to_owned(),
));
}
let jurisdiction = arguments
.country
.as_deref()
.map(normalize_country)
.transpose()?;
let domain = arguments
.domain
.as_deref()
.map(normalize_domain)
.transpose()?;
if query.starts_with("co_") {
let company_id =
CompanyId::from_str(query).map_err(|message| CgdError::Usage(message.to_owned()))?;
if jurisdiction.is_some() || domain.is_some() || !arguments.identifier.is_empty() {
return Err(CgdError::Usage(
"a permanent co_ ID cannot be combined with other resolve selectors".to_owned(),
));
}
return Ok(ResolveCompanyRequest {
id: Some(company_id.to_string()),
name: None,
domain: None,
jurisdiction: None,
identifiers: Vec::new(),
limit: arguments.limit,
});
}
if arguments.identifier.len() > 1 {
return Err(CgdError::Usage(
"the company-only alpha accepts one strong external identifier per resolve request"
.to_owned(),
));
}
if let Some(identifier) = arguments.identifier.first() {
if jurisdiction.is_some() || domain.is_some() {
return Err(CgdError::Usage(
"an external identifier cannot yet be intersected with country or domain"
.to_owned(),
));
}
let selector = parse_external_identifier(identifier)?;
if query != selector.value && query != identifier {
return Err(CgdError::Usage(format!(
"when --identifier is used, the positional query must be {:?} or {:?}",
selector.value, identifier
)));
}
return Ok(ResolveCompanyRequest {
id: None,
name: None,
domain: None,
jurisdiction: None,
identifiers: vec![selector],
limit: arguments.limit,
});
}
if domain.is_none() && jurisdiction.is_none() && looks_like_domain(query) {
return Ok(ResolveCompanyRequest {
id: None,
name: None,
domain: Some(normalize_domain(query)?),
jurisdiction: None,
identifiers: Vec::new(),
limit: arguments.limit,
});
}
Ok(ResolveCompanyRequest {
id: None,
name: Some(query.to_owned()),
domain,
jurisdiction,
identifiers: Vec::new(),
limit: arguments.limit,
})
}
fn parse_external_identifier(value: &str) -> Result<ExternalIdentifierSelector, CgdError> {
let (scheme, identifier) = value
.split_once(':')
.ok_or_else(|| CgdError::Usage("--identifier must use scheme:value syntax".to_owned()))?;
if scheme.is_empty()
|| scheme.len() > 64
|| !scheme
.chars()
.all(|character| character.is_ascii_lowercase() || character == '_')
|| identifier.trim().is_empty()
|| identifier.len() > 256
{
return Err(CgdError::Usage(
"--identifier contains an invalid scheme or value".to_owned(),
));
}
Ok(ExternalIdentifierSelector {
scheme: scheme.to_owned(),
value: identifier.trim().to_owned(),
})
}
async fn search_companies(
client: &CoragridClient,
arguments: &crate::cli::CompanySearchArgs,
) -> Result<(CompanyPage, Value, Vec<String>), CgdError> {
let filters = search_filters(arguments)?;
let query = arguments
.query
.as_deref()
.map(str::trim)
.filter(|query| !query.is_empty())
.map(str::to_owned);
if arguments.query.is_some() && query.is_none() {
return Err(CgdError::Usage("search query cannot be blank".to_owned()));
}
if query.as_ref().is_some_and(|query| query.len() > 4096) {
return Err(CgdError::Usage(
"search query cannot exceed 4096 characters".to_owned(),
));
}
if query.is_none()
&& filters.countries.is_empty()
&& filters.company_status.is_empty()
&& filters.company_types.is_empty()
&& filters.financial.is_none()
{
return Err(CgdError::Usage(
"search requires a query or at least one structured filter".to_owned(),
));
}
if !(1..=200).contains(&arguments.limit) {
return Err(CgdError::Usage(
"search limit must be between 1 and 200".to_owned(),
));
}
if !arguments.all && arguments.max_results.is_some() {
return Err(CgdError::Usage(
"--max-results is valid only with --all".to_owned(),
));
}
let maximum = if arguments.all {
let value = arguments.max_results.expect("clap requires max-results");
if !(1..=10_000).contains(&value) {
return Err(CgdError::Usage(
"--max-results must be between 1 and 10000".to_owned(),
));
}
value
} else {
arguments.limit as usize
};
let mut request = SearchCompaniesRequest {
query,
filters,
include: vec![CompanyInclude::Profile],
cursor: arguments.cursor.clone(),
limit: arguments.limit.min(maximum as u16),
};
let mut data = Vec::new();
let mut raw_data = Vec::new();
let mut request_ids = Vec::new();
let mut seen_cursors = BTreeSet::new();
let mut first_raw = None;
let next_cursor = loop {
let response = client.search(&request).await?;
if let Some(request_id) = response.request_id {
request_ids.push(request_id);
}
if first_raw.is_none() {
first_raw = Some(response.raw.clone());
}
let page_raw = response
.raw
.get("data")
.and_then(Value::as_array)
.ok_or_else(|| {
CgdError::Decode("search response is missing its data array".to_owned())
})?;
if page_raw.len() != response.value.data.len() {
return Err(CgdError::Decode(
"typed and raw search result counts differ".to_owned(),
));
}
let remaining = maximum.saturating_sub(data.len());
let take = remaining.min(response.value.data.len());
data.extend(response.value.data.into_iter().take(take));
raw_data.extend(page_raw.iter().take(take).cloned());
let response_next_cursor = response.value.next_cursor;
if !arguments.all || data.len() >= maximum || response_next_cursor.is_none() {
break response_next_cursor;
}
let cursor = response_next_cursor.expect("checked above");
if !seen_cursors.insert(cursor.clone()) {
return Err(CgdError::Decode(
"API repeated a pagination cursor; refusing an infinite loop".to_owned(),
));
}
request.cursor = Some(cursor);
request.limit = arguments
.limit
.min(maximum.saturating_sub(data.len()).min(200) as u16);
};
let page = CompanyPage {
data,
next_cursor: next_cursor.clone(),
};
let raw = if arguments.all {
json!({
"data": raw_data,
"next_cursor": next_cursor,
})
} else {
first_raw.expect("at least one search request is always executed")
};
Ok((page, raw, request_ids))
}
fn search_filters(arguments: &crate::cli::CompanySearchArgs) -> Result<CompanyFilters, CgdError> {
let countries = arguments
.country
.iter()
.map(|country| normalize_country(country))
.collect::<Result<Vec<_>, _>>()?;
let financial_requested = arguments.financial_field.is_some()
|| arguments.financial_period.is_some()
|| arguments.financial_currency.is_some()
|| arguments.financial_gte.is_some()
|| arguments.financial_lte.is_some();
let financial = if financial_requested {
let field = arguments.financial_field.ok_or_else(|| {
CgdError::Usage("--financial-field is required for a financial filter".to_owned())
})?;
let period = arguments.financial_period.as_deref().ok_or_else(|| {
CgdError::Usage("--financial-period is required for a financial filter".to_owned())
})?;
let currency = arguments.financial_currency.as_deref().ok_or_else(|| {
CgdError::Usage("--financial-currency is required for a financial filter".to_owned())
})?;
if arguments.financial_gte.is_none() && arguments.financial_lte.is_none() {
return Err(CgdError::Usage(
"a financial filter requires --financial-gte or --financial-lte".to_owned(),
));
}
if let (Some(gte), Some(lte)) = (arguments.financial_gte, arguments.financial_lte)
&& gte > lte
{
return Err(CgdError::Usage(
"--financial-gte cannot exceed --financial-lte".to_owned(),
));
}
Some(FinancialRange {
field: match field {
FinancialFieldArg::Revenue => FinancialField::Revenue,
},
gte: arguments.financial_gte,
lte: arguments.financial_lte,
currency: normalize_currency(currency)?,
fiscal_year: parse_fiscal_year(period)?,
reporting_scope: match arguments.financial_scope {
ReportingScopeArg::Company => ReportingScope::Company,
ReportingScopeArg::Group => ReportingScope::Group,
},
})
} else {
None
};
Ok(CompanyFilters {
countries,
company_status: normalize_filter_values(&arguments.status, "status")?,
company_types: normalize_filter_values(&arguments.company_type, "type")?,
financial,
})
}
fn normalize_country(value: &str) -> Result<String, CgdError> {
let value = value.trim().to_ascii_uppercase();
if value.len() != 2
|| !value
.chars()
.all(|character| character.is_ascii_alphabetic())
{
return Err(CgdError::Usage(format!(
"country {value:?} must be a two-letter ISO code"
)));
}
Ok(value)
}
fn normalize_currency(value: &str) -> Result<String, CgdError> {
let value = value.trim().to_ascii_uppercase();
if value.len() != 3
|| !value
.chars()
.all(|character| character.is_ascii_alphabetic())
{
return Err(CgdError::Usage(
"financial currency must be a three-letter ISO 4217 code".to_owned(),
));
}
Ok(value)
}
fn normalize_domain(value: &str) -> Result<String, CgdError> {
let domain = value.trim().trim_end_matches('.').to_ascii_lowercase();
if domain.is_empty()
|| domain.len() > 253
|| !domain.contains('.')
|| domain.chars().any(char::is_whitespace)
|| domain.contains('/')
|| domain.contains(':')
{
return Err(CgdError::Usage(
"domain must be a hostname such as example.com".to_owned(),
));
}
Ok(domain)
}
fn looks_like_domain(value: &str) -> bool {
value.contains('.') && !value.chars().any(char::is_whitespace)
}
fn normalize_filter_values(values: &[String], label: &str) -> Result<Vec<String>, CgdError> {
let mut normalized = BTreeSet::new();
for value in values {
let value = value.trim();
if value.is_empty() || value.len() > 128 {
return Err(CgdError::Usage(format!(
"{label} filters must contain 1-128 characters"
)));
}
normalized.insert(value.to_owned());
}
Ok(normalized.into_iter().collect())
}
fn parse_fiscal_year(value: &str) -> Result<i32, CgdError> {
let year = value
.strip_prefix("FY")
.ok_or_else(|| {
CgdError::Usage("financial period must use FYYYYY, such as FY2025".to_owned())
})?
.parse::<i32>()
.map_err(|_| CgdError::Usage("financial period contains an invalid year".to_owned()))?;
if !(1800..=3000).contains(&year) {
return Err(CgdError::Usage(
"financial fiscal year must be between 1800 and 3000".to_owned(),
));
}
Ok(year)
}
fn write_request_diagnostic<E: Write>(
stderr: &mut E,
verbosity: u8,
request_id: Option<&str>,
) -> Result<(), CgdError> {
if verbosity > 0
&& let Some(request_id) = request_id
{
writeln!(stderr, "request: {request_id}")?;
}
Ok(())
}
#[cfg(test)]
mod tests {
use std::cell::RefCell;
use axum::http::{HeaderMap, StatusCode};
use axum::response::{IntoResponse, Response};
use axum::routing::get;
use axum::{Json, Router};
use clap::Parser;
use serde_json::json;
use url::Url;
use super::*;
#[derive(Default)]
struct MemoryCredentialStore {
credential: RefCell<Option<Credential>>,
}
impl CredentialStore for MemoryCredentialStore {
fn get(&self, _reference: &CredentialReference) -> Result<Option<Credential>, CgdError> {
Ok(self.credential.borrow().clone())
}
fn put(
&self,
_reference: &CredentialReference,
credential: &Credential,
) -> Result<(), CgdError> {
self.credential.replace(Some(credential.clone()));
Ok(())
}
fn delete(&self, _reference: &CredentialReference) -> Result<bool, CgdError> {
Ok(self.credential.take().is_some())
}
}
#[test]
fn public_id_resolution_is_never_mixed_with_mutable_selectors() {
let request = resolve_request(&ResolveArgs {
query: "co_014d2pf2dbsqqg28t5cy4tqkff".to_owned(),
country: None,
domain: None,
identifier: Vec::new(),
limit: 5,
require_unique: false,
})
.unwrap();
assert_eq!(request.id.as_deref(), Some("co_014d2pf2dbsqqg28t5cy4tqkff"));
assert!(request.name.is_none());
}
#[test]
fn financial_filter_requires_a_complete_typed_shape() {
let arguments = crate::cli::CompanySearchArgs {
query: None,
country: vec!["fi".to_owned()],
status: Vec::new(),
company_type: Vec::new(),
limit: 25,
cursor: None,
all: false,
max_results: None,
financial_field: Some(FinancialFieldArg::Revenue),
financial_period: Some("FY2025".to_owned()),
financial_currency: Some("eur".to_owned()),
financial_gte: Some(10_000_000),
financial_lte: Some(100_000_000),
financial_scope: ReportingScopeArg::Company,
};
let filters = search_filters(&arguments).unwrap();
let financial = filters.financial.unwrap();
assert_eq!(financial.currency, "EUR");
assert_eq!(financial.fiscal_year, 2025);
}
#[tokio::test]
async fn login_verifies_before_persisting_the_api_key() {
async fn caller(headers: HeaderMap) -> Response {
let mut response_headers = HeaderMap::new();
response_headers.insert(
"x-request-id",
"req_014d2pf2dbsqqg28t5cy4tqkff".parse().unwrap(),
);
if headers
.get("authorization")
.and_then(|value| value.to_str().ok())
!= Some("Bearer valid-key")
{
return (
StatusCode::UNAUTHORIZED,
response_headers,
Json(json!({
"type": "https://coragrid.com/problems/invalid-credential",
"title": "Invalid credential",
"status": 401,
"detail": "The bearer credential is invalid.",
"instance": "/v1/me",
"request_id": "req_014d2pf2dbsqqg28t5cy4tqkff",
"code": "invalid_credential",
"retryable": false
})),
)
.into_response();
}
(
StatusCode::OK,
response_headers,
Json(json!({
"data": {
"object": "principal",
"credential_id": "key_014d2pf2dbsqqg28t5cy4tqkff",
"organization_id": "org_014d2pf2dbsqqg28t5cy4tqkff",
"principal_type": "service",
"scopes": ["companies:read"],
"limits": {"max_search_results": 100}
}
})),
)
.into_response()
}
let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
let address = listener.local_addr().unwrap();
let server = tokio::spawn(async move {
axum::serve(listener, Router::new().route("/v1/me", get(caller)))
.await
.unwrap();
});
let directory = std::env::temp_dir().join(format!(
"cgd-login-test-{}-{}",
std::process::id(),
rand::random::<u64>()
));
let config = EffectiveConfig {
profile: "team".to_owned(),
api_base_url: Url::parse(&format!("http://{address}/")).unwrap(),
output: crate::config::OutputFormat::Json,
timeout: std::time::Duration::from_secs(5),
no_color: true,
workspace: None,
credential_ref: None,
credential: None,
config_path: directory.join("config.toml"),
warnings: Vec::new(),
};
let cli = Cli::try_parse_from(["cgd", "--output", "json", "auth", "login"]).unwrap();
let reference = CredentialReference::for_profile("team").unwrap();
let store = MemoryCredentialStore::default();
let invalid = Credential::new(
CredentialKind::ApiKey,
CredentialSource::OsCredentialStore,
"invalid-key".to_owned(),
"test API key",
)
.unwrap();
let mut stdout = Vec::new();
let mut stderr = Vec::new();
let error = login_with_credential(
&config,
&cli,
&mut stdout,
&mut stderr,
&store,
reference.clone(),
invalid,
)
.await
.unwrap_err();
assert_eq!(error.exit_status(), ExitStatus::Authentication);
assert!(store.credential.borrow().is_none());
assert!(!config.config_path.exists());
let valid = Credential::new(
CredentialKind::ApiKey,
CredentialSource::OsCredentialStore,
"valid-key".to_owned(),
"test API key",
)
.unwrap();
login_with_credential(
&config,
&cli,
&mut stdout,
&mut stderr,
&store,
reference,
valid,
)
.await
.unwrap();
assert_eq!(
store.credential.borrow().as_ref().unwrap().bearer(),
"valid-key"
);
let written = std::fs::read_to_string(&config.config_path).unwrap();
assert!(written.contains("credential_ref = \"os-keyring:cgd/team\""));
assert!(!written.contains("valid-key"));
let output: Value = serde_json::from_slice(&stdout).unwrap();
assert_eq!(output["status"], "authenticated");
server.abort();
let _ = std::fs::remove_dir_all(directory);
}
}