use crossterm::event::{KeyCode, KeyEvent, KeyModifiers, MouseEvent, MouseEventKind};
use unicode_segmentation::UnicodeSegmentation;
use crate::client::{
CallerResource, CompanyFilters, CompanyId, CompanyInclude, CompanyOfficerPage, CompanyResource,
DocumentId, DocumentResource, ResolveCompanyRequest, SearchCompaniesRequest,
};
use crate::tui::effect::{Effect, EffectResult};
pub const DOCUMENT_FIELD_COUNT: usize = 16;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Route {
Search,
Detail,
Officers,
Document,
Auth,
}
impl Route {
pub const fn label(self) -> &'static str {
match self {
Self::Search => "search",
Self::Detail => "company",
Self::Officers => "officers",
Self::Document => "document",
Self::Auth => "auth",
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Overlay {
Help,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum QueryMode {
Search,
Resolve,
Document,
}
impl QueryMode {
pub const fn label(self) -> &'static str {
match self {
Self::Search => "search",
Self::Resolve => "resolve",
Self::Document => "document",
}
}
pub const fn placeholder(self) -> &'static str {
match self {
Self::Search => "describe a company or private-market thesis",
Self::Resolve => "enter a company name, domain, or co_ ID",
Self::Document => "enter a permanent doc_ ID",
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Focus {
Query,
Results,
}
#[derive(Debug, Clone)]
pub struct CompanyListItem {
pub id: CompanyId,
pub name: Option<String>,
pub country: Option<String>,
pub status: Option<String>,
pub relevance: Option<f32>,
pub match_reasons: Vec<String>,
}
#[derive(Debug)]
pub struct App {
pub route: Route,
pub overlay: Option<Overlay>,
pub query_mode: QueryMode,
pub focus: Focus,
pub query: String,
pub query_cursor: usize,
pub results: Vec<CompanyListItem>,
pub selection: usize,
pub detail: Option<CompanyResource>,
pub officers: Option<CompanyOfficerPage>,
pub officer_selection: usize,
pub document: Option<DocumentResource>,
pub document_selection: usize,
pub caller: Option<CallerResource>,
pub loading: bool,
pub generation: u64,
pub request_id: Option<String>,
pub notice: Option<String>,
pub animation_frame: usize,
pub terminal_focused: bool,
pub should_quit: bool,
}
#[derive(Debug)]
pub enum AppAction {
None,
Start(Box<Effect>),
Cancel,
}
impl App {
pub fn new(warnings: &[String]) -> Self {
Self {
route: Route::Search,
overlay: None,
query_mode: QueryMode::Search,
focus: Focus::Query,
query: String::new(),
query_cursor: 0,
results: Vec::new(),
selection: 0,
detail: None,
officers: None,
officer_selection: 0,
document: None,
document_selection: 0,
caller: None,
loading: false,
generation: 0,
request_id: None,
notice: (!warnings.is_empty()).then(|| warnings.join(" · ")),
animation_frame: 0,
terminal_focused: true,
should_quit: false,
}
}
pub fn selected(&self) -> Option<&CompanyListItem> {
self.results.get(self.selection)
}
#[cfg(test)]
pub fn set_query(&mut self, value: impl Into<String>) {
self.query = value.into();
self.query_cursor = self.query.len();
}
pub fn tick(&mut self) {
if self.loading {
self.animation_frame = self.animation_frame.wrapping_add(1);
}
}
pub fn set_terminal_focus(&mut self, focused: bool) {
self.terminal_focused = focused;
}
pub const fn spinner(&self) -> &'static str {
const FRAMES: [&str; 8] = ["â ‹", "â ™", "â ¹", "â ¸", "â ¼", "â ´", "â ¦", "â §"];
FRAMES[self.animation_frame % FRAMES.len()]
}
pub fn handle_key(&mut self, event: KeyEvent) -> AppAction {
let event = normalize_navigation_key(event);
if event.modifiers.contains(KeyModifiers::CONTROL)
&& matches!(event.code, KeyCode::Char('c'))
{
if self.loading {
self.loading = false;
self.notice = Some("request cancelled".to_owned());
return AppAction::Cancel;
}
self.should_quit = true;
return AppAction::None;
}
if event.modifiers.contains(KeyModifiers::CONTROL)
&& matches!(event.code, KeyCode::Char('q'))
{
self.should_quit = true;
return AppAction::None;
}
if self.overlay == Some(Overlay::Help) {
return match event.code {
KeyCode::Esc | KeyCode::F(1) | KeyCode::Char('q') | KeyCode::Char('?') => {
self.overlay = None;
AppAction::None
}
_ => AppAction::None,
};
}
if event.code == KeyCode::F(1) {
self.overlay = Some(Overlay::Help);
return AppAction::None;
}
if event.code == KeyCode::Esc {
return if self.loading {
self.loading = false;
self.notice = Some("request cancelled".to_owned());
AppAction::Cancel
} else if self.route == Route::Officers {
self.route = Route::Detail;
AppAction::None
} else if self.route != Route::Search {
self.route = Route::Search;
AppAction::None
} else if self.focus == Focus::Results {
self.focus = Focus::Query;
self.query_cursor = self.query.len();
AppAction::None
} else {
self.query.clear();
self.query_cursor = 0;
AppAction::None
};
}
if self.route == Route::Search && self.focus == Focus::Query {
return self.handle_query_key(event);
}
match event.code {
KeyCode::Char('?') => {
self.overlay = Some(Overlay::Help);
AppAction::None
}
KeyCode::Char('q') => {
match self.route {
Route::Search => self.should_quit = true,
Route::Officers => self.route = Route::Detail,
Route::Detail | Route::Document | Route::Auth => self.route = Route::Search,
}
AppAction::None
}
KeyCode::Char('a') => {
self.route = Route::Auth;
self.start(Effect::Caller { generation: 0 })
}
KeyCode::Char('/') => {
self.route = Route::Search;
self.focus = Focus::Query;
self.query_cursor = self.query.len();
AppAction::None
}
KeyCode::Enter if self.route == Route::Search && self.focus == Focus::Results => {
self.open_selected()
}
KeyCode::Down | KeyCode::Char('j')
if self.route == Route::Search && !self.results.is_empty() =>
{
self.focus = Focus::Results;
self.selection = (self.selection + 1).min(self.results.len() - 1);
AppAction::None
}
KeyCode::Up | KeyCode::Char('k')
if self.route == Route::Search && !self.results.is_empty() =>
{
self.focus = Focus::Results;
self.selection = self.selection.saturating_sub(1);
AppAction::None
}
KeyCode::Home | KeyCode::Char('g')
if self.route == Route::Search && !self.results.is_empty() =>
{
self.focus = Focus::Results;
self.selection = 0;
AppAction::None
}
KeyCode::End | KeyCode::Char('G')
if self.route == Route::Search && !self.results.is_empty() =>
{
self.focus = Focus::Results;
self.selection = self.results.len() - 1;
AppAction::None
}
KeyCode::PageDown if self.route == Route::Search && !self.results.is_empty() => {
self.selection = (self.selection + 10).min(self.results.len() - 1);
AppAction::None
}
KeyCode::PageUp if self.route == Route::Search && !self.results.is_empty() => {
self.selection = self.selection.saturating_sub(10);
AppAction::None
}
KeyCode::Down | KeyCode::Char('j') if self.has_officers() => {
self.officer_selection =
(self.officer_selection + 1).min(self.officer_count().saturating_sub(1));
AppAction::None
}
KeyCode::Up | KeyCode::Char('k') if self.has_officers() => {
self.officer_selection = self.officer_selection.saturating_sub(1);
AppAction::None
}
KeyCode::Home | KeyCode::Char('g') if self.has_officers() => {
self.officer_selection = 0;
AppAction::None
}
KeyCode::End | KeyCode::Char('G') if self.has_officers() => {
self.officer_selection = self.officer_count().saturating_sub(1);
AppAction::None
}
KeyCode::PageDown if self.has_officers() => {
self.officer_selection =
(self.officer_selection + 10).min(self.officer_count().saturating_sub(1));
AppAction::None
}
KeyCode::PageUp if self.has_officers() => {
self.officer_selection = self.officer_selection.saturating_sub(10);
AppAction::None
}
KeyCode::Down | KeyCode::Char('j') if self.has_document() => {
self.document_selection =
(self.document_selection + 1).min(DOCUMENT_FIELD_COUNT - 1);
AppAction::None
}
KeyCode::Up | KeyCode::Char('k') if self.has_document() => {
self.document_selection = self.document_selection.saturating_sub(1);
AppAction::None
}
KeyCode::Home | KeyCode::Char('g') if self.has_document() => {
self.document_selection = 0;
AppAction::None
}
KeyCode::End | KeyCode::Char('G') if self.has_document() => {
self.document_selection = DOCUMENT_FIELD_COUNT - 1;
AppAction::None
}
KeyCode::PageDown if self.has_document() => {
self.document_selection =
(self.document_selection + 10).min(DOCUMENT_FIELD_COUNT - 1);
AppAction::None
}
KeyCode::PageUp if self.has_document() => {
self.document_selection = self.document_selection.saturating_sub(10);
AppAction::None
}
KeyCode::Char('r') if self.route == Route::Detail => self.refresh_detail(),
KeyCode::Char('r') if self.route == Route::Officers => self.refresh_officers(),
KeyCode::Char('r') if self.route == Route::Document => self.refresh_document(),
KeyCode::Char('o') if self.route == Route::Detail => self.open_officers(),
KeyCode::Char('r') if self.route == Route::Search => self.submit_query(),
_ => AppAction::None,
}
}
fn handle_query_key(&mut self, event: KeyEvent) -> AppAction {
match event.code {
KeyCode::Tab | KeyCode::BackTab => {
self.query_mode = match self.query_mode {
QueryMode::Search => QueryMode::Resolve,
QueryMode::Resolve => QueryMode::Document,
QueryMode::Document => QueryMode::Search,
};
if self.query_mode == QueryMode::Document {
self.focus = Focus::Query;
}
}
KeyCode::Enter => return self.submit_query(),
KeyCode::Down if self.query_mode != QueryMode::Document && !self.results.is_empty() => {
self.focus = Focus::Results;
}
KeyCode::Left => self.query_cursor = previous_grapheme(&self.query, self.query_cursor),
KeyCode::Right => self.query_cursor = next_grapheme(&self.query, self.query_cursor),
KeyCode::Home => self.query_cursor = 0,
KeyCode::End => self.query_cursor = self.query.len(),
KeyCode::Backspace => self.delete_previous_grapheme(),
KeyCode::Delete => self.delete_next_grapheme(),
KeyCode::Char('u') if event.modifiers.contains(KeyModifiers::CONTROL) => {
self.query.clear();
self.query_cursor = 0;
}
KeyCode::Char('w') if event.modifiers.contains(KeyModifiers::CONTROL) => {
self.delete_previous_word();
}
KeyCode::Char(character)
if !event
.modifiers
.intersects(KeyModifiers::CONTROL | KeyModifiers::ALT)
&& !character.is_control() =>
{
self.insert_character(character);
}
_ => {}
}
AppAction::None
}
pub fn handle_paste(&mut self, value: &str) {
if self.overlay.is_some() || self.route != Route::Search || self.focus != Focus::Query {
return;
}
let remaining = 4096usize.saturating_sub(self.query.chars().count());
let inserted = value
.chars()
.filter(|character| !character.is_control())
.take(remaining)
.collect::<String>();
self.query.insert_str(self.query_cursor, &inserted);
self.query_cursor += inserted.len();
}
fn delete_previous_grapheme(&mut self) {
let start = previous_grapheme(&self.query, self.query_cursor);
if start < self.query_cursor {
self.query.drain(start..self.query_cursor);
self.query_cursor = start;
}
}
fn insert_character(&mut self, character: char) {
if self.query.chars().count() < 4096 {
self.query.insert(self.query_cursor, character);
self.query_cursor += character.len_utf8();
}
}
fn delete_next_grapheme(&mut self) {
let end = next_grapheme(&self.query, self.query_cursor);
if self.query_cursor < end {
self.query.drain(self.query_cursor..end);
}
}
fn delete_previous_word(&mut self) {
let mut start = self.query_cursor;
while start > 0 {
let previous = previous_grapheme(&self.query, start);
if !self.query[previous..start].chars().all(char::is_whitespace) {
break;
}
start = previous;
}
while start > 0 {
let previous = previous_grapheme(&self.query, start);
if self.query[previous..start].chars().all(char::is_whitespace) {
break;
}
start = previous;
}
if start < self.query_cursor {
self.query.drain(start..self.query_cursor);
self.query_cursor = start;
}
}
pub fn handle_mouse(&mut self, event: MouseEvent) {
if self.overlay.is_some() {
return;
}
match (self.route, event.kind) {
(Route::Search, MouseEventKind::ScrollDown) if !self.results.is_empty() => {
self.focus = Focus::Results;
self.selection = (self.selection + 1).min(self.results.len() - 1);
}
(Route::Search, MouseEventKind::ScrollUp) if !self.results.is_empty() => {
self.focus = Focus::Results;
self.selection = self.selection.saturating_sub(1);
}
(Route::Officers, MouseEventKind::ScrollDown) if self.has_officers() => {
self.officer_selection =
(self.officer_selection + 1).min(self.officer_count().saturating_sub(1));
}
(Route::Officers, MouseEventKind::ScrollUp) if self.has_officers() => {
self.officer_selection = self.officer_selection.saturating_sub(1);
}
(Route::Document, MouseEventKind::ScrollDown) if self.has_document() => {
self.document_selection =
(self.document_selection + 1).min(DOCUMENT_FIELD_COUNT - 1);
}
(Route::Document, MouseEventKind::ScrollUp) if self.has_document() => {
self.document_selection = self.document_selection.saturating_sub(1);
}
_ => {}
}
}
pub fn apply(&mut self, result: EffectResult) {
if result.generation() != self.generation {
return;
}
self.loading = false;
self.request_id = result.request_id().map(str::to_owned);
match result {
EffectResult::Search {
response: Ok(response),
..
} => {
self.results = response
.value
.data
.into_iter()
.map(|item| CompanyListItem {
id: item.company.id,
name: item.company.name,
country: item.company.country_code,
status: item.company.company_status,
relevance: item.relevance_score,
match_reasons: Vec::new(),
})
.collect();
self.selection = 0;
self.focus = if self.results.is_empty() {
Focus::Query
} else {
Focus::Results
};
self.notice = Some(format!("{} companies", self.results.len()));
}
EffectResult::Resolve {
response: Ok(response),
..
} => {
let resolution = response.value.data;
let candidates = resolution
.result
.into_iter()
.chain(resolution.candidates)
.map(|candidate| CompanyListItem {
id: candidate.id,
name: candidate.name,
country: candidate.jurisdiction,
status: Some(resolution.status.clone()),
relevance: None,
match_reasons: candidate.match_reasons,
})
.collect::<Vec<_>>();
self.results = candidates;
self.selection = 0;
self.focus = if self.results.is_empty() {
Focus::Query
} else {
Focus::Results
};
self.notice = Some(format!(
"{} · {} candidate(s)",
resolution.status,
self.results.len()
));
}
EffectResult::Company {
response: Ok(response),
..
} => {
self.detail = Some(response.value.data);
self.officers = None;
self.route = Route::Detail;
self.notice = None;
}
EffectResult::Officers {
response: Ok(response),
..
} => {
let count = response.value.data.len();
self.officers = Some(response.value);
self.officer_selection = 0;
self.route = Route::Officers;
self.notice = Some(format!("{count} current officer(s)"));
}
EffectResult::Document {
response: Ok(response),
..
} => {
self.document = Some(response.value.data);
self.document_selection = 0;
self.route = Route::Document;
self.notice = Some("rights-qualified metadata only".to_owned());
}
EffectResult::Caller {
response: Ok(response),
..
} => {
self.caller = Some(response.value.data);
self.route = Route::Auth;
self.notice = None;
}
EffectResult::Search {
response: Err(error),
..
}
| EffectResult::Resolve {
response: Err(error),
..
}
| EffectResult::Company {
response: Err(error),
..
}
| EffectResult::Officers {
response: Err(error),
..
}
| EffectResult::Document {
response: Err(error),
..
}
| EffectResult::Caller {
response: Err(error),
..
} => {
self.request_id = error.request_id.clone();
self.notice = Some(format!("failed: {}", error.message));
}
}
}
fn submit_query(&mut self) -> AppAction {
let query = self.query.trim();
if query.is_empty() {
self.notice = Some(
match self.query_mode {
QueryMode::Search => "enter a company thesis",
QueryMode::Resolve => "enter a company name, domain, or co_ ID",
QueryMode::Document => "enter a permanent doc_ ID",
}
.to_owned(),
);
return AppAction::None;
}
match self.query_mode {
QueryMode::Search => self.start(Effect::Search {
generation: 0,
request: SearchCompaniesRequest {
query: Some(query.to_owned()),
filters: CompanyFilters::default(),
include: vec![CompanyInclude::Profile],
cursor: None,
limit: 50,
},
}),
QueryMode::Resolve => {
let (id, name, domain) = if query.starts_with("co_") {
match query.parse::<CompanyId>() {
Ok(id) => (Some(id.to_string()), None, None),
Err(error) => {
self.notice = Some(error.to_owned());
return AppAction::None;
}
}
} else if query.contains('.') && !query.chars().any(char::is_whitespace) {
(None, None, Some(query.to_ascii_lowercase()))
} else {
(None, Some(query.to_owned()), None)
};
self.start(Effect::Resolve {
generation: 0,
request: ResolveCompanyRequest {
id,
name,
domain,
jurisdiction: None,
identifiers: Vec::new(),
limit: 25,
},
})
}
QueryMode::Document => match query.parse::<DocumentId>() {
Ok(document_id) => self.start(Effect::Document {
generation: 0,
document_id,
}),
Err(error) => {
self.notice = Some(error.to_owned());
AppAction::None
}
},
}
}
fn open_selected(&mut self) -> AppAction {
let Some(company_id) = self.selected().map(|item| item.id.clone()) else {
return AppAction::None;
};
self.start(Effect::Company {
generation: 0,
company_id,
})
}
fn refresh_detail(&mut self) -> AppAction {
let Some(company_id) = self.detail.as_ref().map(|detail| detail.id.clone()) else {
return AppAction::None;
};
self.start(Effect::Company {
generation: 0,
company_id,
})
}
fn open_officers(&mut self) -> AppAction {
let Some(company_id) = self.detail.as_ref().map(|detail| detail.id.clone()) else {
return AppAction::None;
};
self.start(Effect::Officers {
generation: 0,
company_id,
limit: 100,
})
}
fn refresh_officers(&mut self) -> AppAction {
let Some(company_id) = self
.officers
.as_ref()
.map(|officers| officers.requested_company_id.clone())
else {
return AppAction::None;
};
self.start(Effect::Officers {
generation: 0,
company_id,
limit: 100,
})
}
fn refresh_document(&mut self) -> AppAction {
let Some(document_id) = self.document.as_ref().map(|document| document.id.clone()) else {
return AppAction::None;
};
self.start(Effect::Document {
generation: 0,
document_id,
})
}
fn officer_count(&self) -> usize {
self.officers
.as_ref()
.map_or(0, |officers| officers.data.len())
}
fn has_officers(&self) -> bool {
self.route == Route::Officers && self.officer_count() > 0
}
fn has_document(&self) -> bool {
self.route == Route::Document && self.document.is_some()
}
fn start(&mut self, mut effect: Effect) -> AppAction {
self.generation = self.generation.wrapping_add(1);
effect.set_generation(self.generation);
self.loading = true;
self.notice = Some(effect.running_label().to_owned());
AppAction::Start(Box::new(effect))
}
}
fn normalize_navigation_key(event: KeyEvent) -> KeyEvent {
if event.modifiers != KeyModifiers::CONTROL {
return event;
}
let code = match event.code {
KeyCode::Char('n') => KeyCode::Down,
KeyCode::Char('p') => KeyCode::Up,
_ => return event,
};
KeyEvent { code, ..event }
}
fn previous_grapheme(value: &str, cursor: usize) -> usize {
value[..cursor]
.grapheme_indices(true)
.next_back()
.map_or(0, |(index, _)| index)
}
fn next_grapheme(value: &str, cursor: usize) -> usize {
value[cursor..]
.graphemes(true)
.next()
.map_or(value.len(), |grapheme| cursor + grapheme.len())
}
#[cfg(test)]
mod tests {
use crossterm::event::KeyEvent;
use super::*;
#[test]
fn newer_generation_rejects_a_stale_effect_result() {
let mut app = App::new(&[]);
app.generation = 2;
app.notice = Some("new request".to_owned());
app.apply(EffectResult::Search {
generation: 1,
response: Err(crate::tui::effect::UiFailure {
message: "stale".to_owned(),
request_id: None,
}),
});
assert_eq!(app.notice.as_deref(), Some("new request"));
}
#[test]
fn ctrl_c_cancels_once_then_quits() {
let mut app = App::new(&[]);
app.loading = true;
let event = KeyEvent::new(KeyCode::Char('c'), KeyModifiers::CONTROL);
assert!(matches!(app.handle_key(event), AppAction::Cancel));
assert!(!app.should_quit);
assert!(matches!(app.handle_key(event), AppAction::None));
assert!(app.should_quit);
}
#[test]
fn query_editor_preserves_printable_shortcuts_and_graphemes() {
let mut app = App::new(&[]);
app.set_query("A🙂B");
app.handle_key(KeyEvent::new(KeyCode::Left, KeyModifiers::NONE));
app.handle_key(KeyEvent::new(KeyCode::Backspace, KeyModifiers::NONE));
app.handle_key(KeyEvent::new(KeyCode::Home, KeyModifiers::NONE));
app.handle_key(KeyEvent::new(KeyCode::Char('q'), KeyModifiers::NONE));
app.handle_key(KeyEvent::new(KeyCode::Char('?'), KeyModifiers::NONE));
assert_eq!(app.query, "q?AB");
assert!(!app.should_quit);
assert_eq!(app.overlay, None);
}
#[test]
fn ctrl_n_and_ctrl_p_follow_down_and_up_navigation() {
let mut app = App::new(&[]);
app.results = [
"co_014d2pf2dbsqqg28t5cy4tqkff",
"co_114d2pf2dbsqqg28t5cy4tqkff",
]
.into_iter()
.map(|id| CompanyListItem {
id: id.parse().unwrap(),
name: None,
country: None,
status: None,
relevance: None,
match_reasons: Vec::new(),
})
.collect();
let down = KeyEvent::new(KeyCode::Char('n'), KeyModifiers::CONTROL);
let up = KeyEvent::new(KeyCode::Char('p'), KeyModifiers::CONTROL);
app.handle_key(down);
assert_eq!(app.focus, Focus::Results);
assert_eq!(app.selection, 0);
app.handle_key(down);
assert_eq!(app.selection, 1);
app.handle_key(up);
assert_eq!(app.selection, 0);
}
#[test]
fn help_overlay_preserves_the_active_route() {
let mut app = App::new(&[]);
app.route = Route::Detail;
app.handle_key(KeyEvent::new(KeyCode::F(1), KeyModifiers::NONE));
assert_eq!(app.overlay, Some(Overlay::Help));
app.handle_key(KeyEvent::new(KeyCode::Esc, KeyModifiers::NONE));
assert_eq!(app.overlay, None);
assert_eq!(app.route, Route::Detail);
}
#[test]
fn officer_result_opens_a_reversible_company_subview() {
let company_id = "co_014d2pf2dbsqqg28t5cy4tqkff"
.parse::<CompanyId>()
.unwrap();
let mut app = App::new(&[]);
app.apply(EffectResult::Officers {
generation: 0,
response: Ok(crate::client::ApiResponse {
value: CompanyOfficerPage {
object: "company_officer_list".to_owned(),
requested_company_id: company_id.clone(),
company_id,
data: vec![crate::client::CompanyOfficerResource {
object: "company_officer".to_owned(),
name: "Anna Virtanen".to_owned(),
roles: vec!["Chief executive officer".to_owned()],
appointed_on: None,
resigned_on: None,
source: crate::client::OfficerSource {
system: "official_company_register".to_owned(),
url: None,
title: None,
published_at: None,
observed_at: None,
},
}],
has_more: false,
},
raw: serde_json::json!({}),
request_id: None,
}),
});
assert_eq!(app.route, Route::Officers);
app.handle_key(KeyEvent::new(KeyCode::Esc, KeyModifiers::NONE));
assert_eq!(app.route, Route::Detail);
}
#[test]
fn document_mode_uses_the_public_metadata_resource() {
let mut app = App::new(&[]);
app.results.push(CompanyListItem {
id: "co_014d2pf2dbsqqg28t5cy4tqkff".parse().unwrap(),
name: Some("Stale company result".to_owned()),
country: None,
status: None,
relevance: None,
match_reasons: Vec::new(),
});
app.query_mode = QueryMode::Document;
app.set_query("doc_014d2pf2dbsqqg28t5cy4tqkff");
app.handle_key(KeyEvent::new(KeyCode::Down, KeyModifiers::NONE));
assert_eq!(app.focus, Focus::Query);
let AppAction::Start(effect) =
app.handle_key(KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE))
else {
panic!("document submission did not start a request");
};
assert!(matches!(*effect, Effect::Document { .. }));
let response: crate::client::Envelope<crate::client::DocumentResource> =
serde_json::from_str(crate::client::TEST_DOCUMENT_METADATA).unwrap();
app.apply(EffectResult::Document {
generation: app.generation,
response: Ok(crate::client::ApiResponse {
value: response,
raw: serde_json::json!({}),
request_id: Some("req_document".to_owned()),
}),
});
assert_eq!(app.route, Route::Document);
assert!(!app.document.as_ref().unwrap().access.bytes);
app.handle_key(KeyEvent::new(KeyCode::End, KeyModifiers::NONE));
assert_eq!(app.document_selection, DOCUMENT_FIELD_COUNT - 1);
app.handle_key(KeyEvent::new(KeyCode::Esc, KeyModifiers::NONE));
assert_eq!(app.route, Route::Search);
}
}