#[cfg(test)]
mod tests {
use std::{env, vec};
use strum::IntoEnumIterator;
use tfl_api_wrapper::models::{self};
use tfl_api_wrapper::{linemodels, Client, RequestBuilder};
fn get_client() -> Client {
Client::new(env::var("APP_KEY").unwrap())
}
#[tokio::test]
async fn it_is_expected_version() {
let client = get_client();
let ver = client.api_version().fetch().await.unwrap();
assert_eq!(ver.version, "master.5909\r\n");
}
#[tokio::test]
async fn it_fetches_routes() {
let client = get_client();
let routes = client
.routes()
.service_type(models::ServiceTypes::Regular)
.fetch()
.await
.unwrap();
assert!(!routes.is_empty());
}
#[tokio::test]
async fn it_fetches_routes_by_line() {
let client = get_client();
let lines: Vec<linemodels::LineID> = vec![linemodels::LineID::Bakerloo];
let route = client.routes_by_line().line(lines).fetch().await.unwrap();
assert_eq!(route.name, "Bakerloo");
}
#[tokio::test]
async fn it_fetches_routes_by_and_line() {
let client = get_client();
let lines: Vec<linemodels::LineID> = vec![linemodels::LineID::HammersmithAndCity];
let route = client.routes_by_line().line(lines).fetch().await.unwrap();
assert_eq!(route.name, "Hammersmith & City");
}
#[tokio::test]
async fn it_fetches_routes_for_all_overridden_lines() {
let client = get_client();
for l in linemodels::LineID::iter() {
let l_str = Into::<&'static str>::into(l);
if l_str != l.line() {
println!("Testing LineID: {} -> {}", l.line(), l_str);
let lines: Vec<linemodels::LineID> = vec![l];
let route = client.routes_by_line().line(lines).fetch().await.expect(
format!("Failed whilst testing LineID: {} -> {}", l.line(), l_str).as_str(),
);
assert_eq!(route.name, l_str);
}
}
}
#[tokio::test]
async fn it_fetches_disruptions_by_mode() {
let client = get_client();
let modes: Vec<models::Mode> = vec![models::Mode::Bus, models::Mode::Tube];
let disruptions = client
.disruptions_by_mode()
.mode(modes)
.fetch()
.await
.unwrap();
if disruptions.len() == 0 {
assert!(disruptions.is_empty());
} else {
assert!(!disruptions.is_empty());
}
}
#[tokio::test]
async fn it_fetches_disruptions_by_line() {
let client = get_client();
let lines: Vec<linemodels::LineID> =
vec![linemodels::LineID::Bakerloo, linemodels::LineID::Jubilee];
let disruptions = client
.disruptions_by_line()
.line(lines)
.fetch()
.await
.unwrap();
if disruptions.len() == 0 {
assert!(disruptions.is_empty());
} else {
assert!(!disruptions.is_empty());
}
}
#[tokio::test]
async fn it_predicts_arrivals_by_line() {
let client = get_client();
let lines: Vec<linemodels::LineID> =
vec![linemodels::LineID::Bakerloo, linemodels::LineID::Jubilee];
let arrivals = client
.arrival_predictions_by_lines()
.line(lines)
.fetch()
.await
.unwrap();
if arrivals.len() == 0 {
assert!(arrivals.is_empty());
} else {
assert!(!arrivals.is_empty());
}
}
#[tokio::test]
async fn it_predicts_arrivals_by_line_with_stoppoint_id() {
let client = get_client();
let lines: Vec<linemodels::LineID> = vec![linemodels::LineID::Bakerloo];
let predicted_arrivals = client
.arrival_predictions_by_lines_with_stoppoint()
.line(lines)
.stop_point("940GZZLUPAH")
.direction(models::Directions::Inbound)
.fetch()
.await
.unwrap();
println!("{:?}", predicted_arrivals);
if predicted_arrivals.len() == 0 {
assert!(predicted_arrivals.is_empty());
} else {
assert!(!predicted_arrivals.is_empty())
}
}
#[tokio::test]
async fn it_lists_stations_by_lines() {
let client = get_client();
let lines: Vec<linemodels::LineID> = vec![linemodels::LineID::Bakerloo];
let stations = client
.list_stations_by_lines()
.line(lines)
.fetch()
.await
.unwrap();
println!("{:?}", stations);
assert!(!stations.is_empty())
}
#[tokio::test]
async fn it_lists_disruption_categories() {
let client = get_client();
let disruption_categories = client.list_disruption_categories().fetch().await.unwrap();
assert!(!disruption_categories.is_empty())
}
#[tokio::test]
async fn it_lists_valid_modes() {
let client = get_client();
let valid_modes = client.list_modes().fetch().await.unwrap();
assert!(!valid_modes.is_empty())
}
#[tokio::test]
async fn it_lists_service_types() {
let client = get_client();
let service_types = client.list_service_types().fetch().await.unwrap();
assert!(!service_types.is_empty())
}
#[tokio::test]
async fn it_lists_severity_types() {
let client = get_client();
let severity_types = client.list_severity_types().fetch().await.unwrap();
assert!(!severity_types.is_empty());
}
#[tokio::test]
async fn it_lists_routes_by_modes() {
let client = get_client();
let modes: Vec<models::Mode> = vec![models::Mode::Bus, models::Mode::Tube];
let routes = client
.list_lines_routes_by_modes()
.mode(modes)
.fetch()
.await
.unwrap();
assert!(!routes.is_empty())
}
#[tokio::test]
async fn it_lists_routes_by_line_with_sequence() {
let client = get_client();
let routes = client
.list_routes_by_line_with_sequence()
.line(linemodels::LineID::Victoria)
.direction(models::Directions::Inbound)
.service_type(models::ServiceTypes::Regular)
.exclude_crowding(true)
.fetch()
.await
.unwrap();
assert_eq!(routes.line_name, "Victoria")
}
#[tokio::test]
async fn it_lists_lines_by_id() {
let client = get_client();
let lines: Vec<linemodels::LineID> = vec![linemodels::LineID::Bakerloo];
let lines = client.list_lines_by_id().line(lines).fetch().await.unwrap();
assert!(!lines.is_empty())
}
#[tokio::test]
async fn it_lists_lines_by_modes() {
let client = get_client();
let modes: Vec<models::Mode> = vec![models::Mode::Tube, models::Mode::Bus];
let lines = client
.list_lines_by_modes()
.mode(modes)
.fetch()
.await
.unwrap();
assert!(!lines.is_empty())
}
#[tokio::test]
async fn it_fetches_line_status_by_severity() {
let client = get_client();
let line_statuses = client
.line_status_by_severity()
.level(0)
.fetch()
.await
.unwrap();
if line_statuses.len() == 0 {
assert!(line_statuses.is_empty())
} else {
assert!(!line_statuses.is_empty())
}
}
#[tokio::test]
async fn it_fetches_line_statuses_between_dates() {
let client = get_client();
let lines: Vec<linemodels::LineID> = vec![linemodels::LineID::Bakerloo];
let line_statuses = client
.line_status_between_dates()
.line(lines)
.start_date("2023-07-19T10:11:12")
.end_date("2023-07-20T10:11:12")
.detail(true)
.fetch()
.await
.unwrap();
if line_statuses.len() == 0 {
assert!(line_statuses.is_empty())
} else {
assert!(!line_statuses.is_empty())
}
}
#[tokio::test]
async fn it_fetches_line_statuses_for_modes() {
let client = get_client();
let modes: Vec<models::Mode> = vec![models::Mode::Tube];
let line_statuses = client
.line_status_by_modes()
.mode(modes)
.detail(true)
.fetch()
.await
.unwrap();
if line_statuses.len() == 0 {
assert!(line_statuses.is_empty())
} else {
assert!(!line_statuses.is_empty())
}
}
#[tokio::test]
async fn it_fetches_line_statuses_by_id() {
let client = get_client();
let lines: Vec<linemodels::LineID> = vec![linemodels::LineID::Bakerloo];
let line_statuses = client
.line_status_by_ids()
.line(lines)
.detail(true)
.fetch()
.await
.unwrap();
if line_statuses.len() == 0 {
assert!(line_statuses.is_empty())
} else {
assert!(!line_statuses.is_empty())
}
}
#[tokio::test]
async fn it_fetches_timetable_for_station_by_line_id() {
let client = get_client();
let timetable = client
.station_timetable_by_line()
.line(linemodels::LineID::Bakerloo)
.from_stop_point_id("940GZZLUERB")
.fetch()
.await
.unwrap();
assert!(!timetable.disambiguation.disambiguation_options.is_empty())
}
#[tokio::test]
async fn it_fetches_timetable_for_station_with_destination_by_line_id() {
let client = get_client();
let timetable = client
.station_timetable_with_destination_by_line()
.line(linemodels::LineID::Bakerloo)
.from_stop_point_id("940GZZLUERB")
.to_stop_point_id("940GZZLUERB")
.fetch()
.await
.unwrap();
assert_eq!(timetable.line_name, "Bakerloo")
}
#[tokio::test]
async fn it_fetches_lines_routes_by_query() {
let client = get_client();
let modes: Vec<models::Mode> = vec![models::Mode::Tube];
let results = client
.search_line_routes_by_query()
.query(linemodels::LineID::Victoria)
.mode(modes)
.service_type(models::ServiceTypes::Regular)
.fetch()
.await
.unwrap();
assert!(!results.search_matches.is_empty())
}
}