use std::path::Path;
use super::error::NetrcError;
use super::parser::NetrcParser;
use super::types::NetrcEntry;
#[test]
fn test_parse_basic_machine() {
let content = "machine ftp.example.com\nlogin myuser\npassword mypass\n";
let parser = NetrcParser::parse(content).expect("parse should succeed");
assert_eq!(parser.len(), 1);
assert!(!parser.is_empty());
let entry = parser.find("ftp.example.com").expect("entry should exist");
assert_eq!(entry.machine, "ftp.example.com");
assert_eq!(entry.login.as_deref(), Some("myuser"));
assert_eq!(entry.password.as_deref(), Some("mypass"));
assert!(entry.account.is_none());
}
#[test]
fn test_parse_with_account() {
let content = "machine host.example.com\nlogin user1\npassword pass1\naccount acct123\n";
let parser = NetrcParser::parse(content).expect("parse should succeed");
let entry = parser.find("host.example.com").expect("entry should exist");
assert_eq!(entry.account.as_deref(), Some("acct123"));
}
#[test]
fn test_parse_default_entry() {
let content = "default\nlogin anonymous\npassword guest@\n";
let parser = NetrcParser::parse(content).expect("parse should succeed");
assert!(parser.find("anything.example.com").is_none());
let def = parser.find_default().expect("default should exist");
assert!(def.is_default());
assert_eq!(def.login.as_deref(), Some("anonymous"));
assert_eq!(def.password.as_deref(), Some("guest@"));
}
#[test]
fn test_parse_machine_and_default() {
let content = "\
machine ftp.example.com\n\
login myuser\n\
password mypass\n\
default\n\
login anon\n\
password guest@\n";
let parser = NetrcParser::parse(content).expect("parse should succeed");
assert_eq!(parser.len(), 2);
let entry = parser.find("ftp.example.com").expect("entry should exist");
assert_eq!(entry.login.as_deref(), Some("myuser"));
let fallback = parser
.find_with_fallback("unknown.host.com")
.expect("fallback should exist");
assert!(fallback.is_default());
assert_eq!(fallback.login.as_deref(), Some("anon"));
}
#[test]
fn test_parse_multiple_machines() {
let content = "\
machine ftp.example.com\n\
login user1\n\
password pass1\n\
\n\
machine ssh.example.com\n\
login user2\n\
password pass2\n";
let parser = NetrcParser::parse(content).expect("parse should succeed");
assert_eq!(parser.entries().len(), 2);
assert_eq!(
parser
.find("ftp.example.com")
.expect("ftp entry")
.login
.as_deref(),
Some("user1")
);
assert_eq!(
parser
.find("ssh.example.com")
.expect("ssh entry")
.login
.as_deref(),
Some("user2")
);
}
#[test]
fn test_find_unknown_returns_none() {
let content = "machine ftp.example.com\nlogin user\npassword pass\n";
let parser = NetrcParser::parse(content).expect("parse should succeed");
assert!(parser.find("unknown.com").is_none());
assert!(parser.find_with_fallback("unknown.com").is_none());
}
#[test]
fn test_leading_dot_machine_matches_subdomains_only() {
let content = "machine .example.com\nlogin user\npassword pass\n";
let parser = NetrcParser::parse(content).expect("parse should succeed");
assert_eq!(
parser
.find("ftp.example.com")
.and_then(|entry| entry.login.as_deref()),
Some("user")
);
assert!(parser.find("example.com").is_none());
}
#[test]
fn test_leading_dot_machine_does_not_match_numeric_host() {
let content = "machine .example.com\nlogin suffix-user\npassword suffix-pass\n\
machine 192.0.0.1\nlogin exact-user\npassword exact-pass\n";
let parser = NetrcParser::parse(content).expect("parse should succeed");
assert!(parser.find("192.0.0.1").is_some());
assert_eq!(
parser.find("192.0.0.1").map(|entry| entry.login.as_deref()),
Some(Some("exact-user"))
);
assert!(parser.find("10.0.0.1").is_none());
}
#[test]
fn test_comments_and_blank_lines() {
let content = "\
# This is a comment\n\
machine example.com\n\
# Another comment\n\
login user\n\
password pass\n";
let parser = NetrcParser::parse(content).expect("parse should succeed");
assert_eq!(parser.len(), 1);
let entry = &parser.entries()[0];
assert_eq!(entry.login.as_deref(), Some("user"));
assert_eq!(entry.password.as_deref(), Some("pass"));
}
#[test]
fn test_case_insensitive_keywords() {
let content = "MACHINE example.com\nLOGIN user\nPASSWORD pass\n";
let parser = NetrcParser::parse(content).expect("parse should succeed");
assert_eq!(parser.entries()[0].login.as_deref(), Some("user"));
}
#[test]
fn test_passwd_alias() {
let content = "machine example.com\nlogin user\npasswd secret\n";
let parser = NetrcParser::parse(content).expect("parse should succeed");
assert_eq!(parser.entries()[0].password.as_deref(), Some("secret"));
}
#[test]
fn test_inline_tokens() {
let content = "machine example.com login user password pass\n";
let parser = NetrcParser::parse(content).expect("parse should succeed");
assert_eq!(parser.len(), 1);
let entry = &parser.entries()[0];
assert_eq!(entry.machine, "example.com");
assert_eq!(entry.login.as_deref(), Some("user"));
assert_eq!(entry.password.as_deref(), Some("pass"));
}
#[test]
fn test_macdef_skipped() {
let content = "\
machine example.com\n\
login user\n\
password pass\n\
macdef mymacro\n\
this is macro body\n\
\n\
machine other.com\n\
login otheruser\n\
password otherpass\n";
let parser = NetrcParser::parse(content).expect("parse should succeed");
assert_eq!(parser.entries().len(), 2);
assert_eq!(
parser
.find("example.com")
.expect("example entry")
.login
.as_deref(),
Some("user")
);
assert_eq!(
parser
.find("other.com")
.expect("other entry")
.login
.as_deref(),
Some("otheruser")
);
}
#[test]
fn test_error_token_before_machine() {
let content = "login user\n";
let result = NetrcParser::parse(content);
assert!(result.is_err());
let err = result.unwrap_err();
match err {
NetrcError::ParseError(msg) => {
assert!(msg.contains("'login'"));
assert!(msg.contains("machine") || msg.contains("default"));
}
_ => panic!("expected ParseError, got {:?}", err),
}
}
#[test]
fn test_error_premature_eof() {
let content = "machine\n";
let result = NetrcParser::parse(content);
assert!(result.is_err());
match result.unwrap_err() {
NetrcError::ParseError(msg) => {
assert!(msg.contains("EOF") || msg.contains("token"));
}
_ => panic!("expected ParseError"),
}
}
#[test]
fn test_error_login_without_value() {
let content = "machine example.com\nlogin\n";
let result = NetrcParser::parse(content);
assert!(result.is_err());
}
#[test]
fn test_empty_input() {
let parser = NetrcParser::parse("").expect("empty input should parse");
assert!(parser.is_empty());
assert_eq!(parser.len(), 0);
}
#[test]
fn test_only_comments() {
let content = "# just a comment\n# another comment\n";
let parser = NetrcParser::parse(content).expect("comments only should parse");
assert!(parser.is_empty());
}
#[test]
fn test_entry_has_credentials() {
let mut entry = NetrcEntry::new("host".to_string());
assert!(!entry.has_credentials());
entry.login = Some("user".to_string());
assert!(!entry.has_credentials());
entry.password = Some("pass".to_string());
assert!(entry.has_credentials());
}
#[test]
fn test_entry_is_default() {
let machine_entry = NetrcEntry::new("host".to_string());
assert!(!machine_entry.is_default());
let default_entry = NetrcEntry::new_default();
assert!(default_entry.is_default());
}
#[test]
fn test_error_display() {
let err = NetrcError::FileNotFound("/missing/.netrc".into());
assert!(err.to_string().contains("/missing/.netrc"));
let err2 = NetrcError::ParseError("bad token".into());
assert!(err2.to_string().contains("parse error"));
let err3 = NetrcError::IoError("read failed".into());
assert!(err3.to_string().contains("I/O"));
}
#[test]
fn test_parse_file_not_found() {
let result = NetrcParser::parse_file(Path::new("/nonexistent/.netrc"));
assert!(result.is_err());
match result.unwrap_err() {
NetrcError::FileNotFound(_) => {}
other => panic!("expected FileNotFound, got {:?}", other),
}
}
#[test]
fn test_convert_to_netrc_store() {
let content = "\
machine ftp.example.com\n\
login myuser\n\
password mypass\n\
default\n\
login anon\n\
password guest@\n";
let parser = NetrcParser::parse(content).expect("parse should succeed");
let store: super::super::NetrcStore = parser.into();
let entry = store
.find("ftp.example.com")
.expect("store entry should exist");
assert_eq!(entry.login, "myuser");
assert_eq!(entry.password, "mypass");
let default = store.default_entry();
assert!(default.is_some());
assert_eq!(default.unwrap().login, "anon");
let fallback = store
.find_with_fallback("unknown.host.com")
.expect("fallback should exist");
assert_eq!(fallback.login, "anon");
}
#[test]
fn test_convert_skips_entries_without_credentials() {
let content = "machine incomplete.com\nlogin user\n";
let parser = NetrcParser::parse(content).expect("parse should succeed");
let store: super::super::NetrcStore = parser.into();
assert!(store.is_empty());
}
#[test]
fn test_real_world_netrc_format() {
let content = "\
# ~/.netrc\n\
machine ftp.example.com\n\
login myuser\n\
password mypass\n\
\n\
machine api.example.com\n\
login apiuser\n\
password apipass\n\
account prod\n\
\n\
default\n\
login anonymous\n\
password guest@\n";
let parser = NetrcParser::parse(content).expect("parse should succeed");
assert_eq!(parser.entries().len(), 2);
assert!(parser.default_entry().is_some());
let ftp = parser.find("ftp.example.com").expect("ftp entry");
assert_eq!(ftp.login.as_deref(), Some("myuser"));
assert!(ftp.account.is_none());
let api = parser.find("api.example.com").expect("api entry");
assert_eq!(api.login.as_deref(), Some("apiuser"));
assert_eq!(api.account.as_deref(), Some("prod"));
let fallback = parser.find_with_fallback("unknown.com").expect("fallback");
assert_eq!(fallback.login.as_deref(), Some("anonymous"));
}
#[test]
fn test_tabs_as_whitespace() {
let content = "machine\texample.com\tlogin\tuser\tpassword\tpass\n";
let parser = NetrcParser::parse(content).expect("parse should succeed");
let entry = parser.find("example.com").expect("entry should exist");
assert_eq!(entry.login.as_deref(), Some("user"));
assert_eq!(entry.password.as_deref(), Some("pass"));
}
#[test]
fn test_mixed_whitespace_and_comments() {
let content = " machine example.com # inline comment\n login user\n password pass\n";
let parser = NetrcParser::parse(content).expect("parse should succeed");
assert_eq!(parser.entries()[0].machine, "example.com");
}