use super::vcl::extract_entities_vcl_with_offset;
use crate::models::{EntityKind, ParsedEntity, ReferenceIntent};
struct VtcContext<'a> {
lines: &'a [&'a str],
file_path: &'a str,
repo_name: &'a str,
server_names: &'a [(String, usize)],
entities: Vec<ParsedEntity>,
}
impl VtcContext<'_> {
fn dispatch(&mut self, i: usize, trimmed: &str) -> usize {
if trimmed.starts_with("varnishtest ") || trimmed.starts_with("vtest ") {
self.handle_test_case(i, trimmed)
} else if trimmed.starts_with("server ") {
self.handle_server(i, trimmed)
} else if trimmed.starts_with("client ") {
self.handle_client(i, trimmed)
} else if trimmed.starts_with("varnish ") {
self.handle_varnish(i, trimmed)
} else if trimmed.starts_with("logexpect ") {
self.handle_logexpect(i, trimmed)
} else if trimmed.starts_with("barrier ") {
self.handle_barrier(i, trimmed)
} else {
i + 1
}
}
fn handle_test_case(&mut self, i: usize, trimmed: &str) -> usize {
let desc = parse_quoted_or_rest(trimmed);
let mut entity = ParsedEntity::new(
desc.clone(),
EntityKind::VtcTestCase,
format!("vtc:{}:{}:testcase", self.repo_name, self.file_path),
Some(format!("varnishtest \"{}\"", desc)),
None,
"vtc",
self.file_path,
i + 1,
i + 1,
None,
self.repo_name,
);
entity.is_test_context = true;
self.entities.push(entity);
i + 1
}
fn handle_server(&mut self, i: usize, trimmed: &str) -> usize {
let Some(name) = parse_instance_name(trimmed, "server ") else {
return i + 1;
};
let start_line = i + 1;
let (body, next_i) = extract_brace_block(self.lines, i, trimmed);
let mut refs: Vec<ReferenceIntent> = Vec::new();
for (sname, sline) in self.server_names {
if sname.as_str() == "s1" {
continue;
}
if body.contains(&format!("-connect ${{{}}}", sname))
|| body.contains(&format!("${{{}}}", sname))
{
refs.push(ReferenceIntent::ValueReference {
value_name: format!("vtc:server:{}", sname),
line: *sline,
});
}
}
let mut entity = ParsedEntity::new(
name.clone(),
EntityKind::VtcServer,
format!("vtc:{}:{}:{}", self.repo_name, self.file_path, name),
Some(format!("server {} {{ ... }}", name)),
None,
"vtc",
self.file_path,
start_line,
start_line,
None,
self.repo_name,
);
entity.is_test_context = true;
entity.reference_intents = refs;
self.entities.push(entity);
next_i
}
fn handle_client(&mut self, i: usize, trimmed: &str) -> usize {
let Some(name) = parse_instance_name(trimmed, "client ") else {
return i + 1;
};
let start_line = i + 1;
let (_, next_i) = extract_brace_block(self.lines, i, trimmed);
let mut entity = ParsedEntity::new(
name.clone(),
EntityKind::VtcClient,
format!("vtc:{}:{}:{}", self.repo_name, self.file_path, name),
Some(format!("client {} {{ ... }}", name)),
None,
"vtc",
self.file_path,
start_line,
start_line,
None,
self.repo_name,
);
entity.is_test_context = true;
self.entities.push(entity);
next_i
}
fn handle_varnish(&mut self, i: usize, trimmed: &str) -> usize {
let Some(name) = parse_instance_name(trimmed, "varnish ") else {
return i + 1;
};
let start_line = i + 1;
let next_i = parse_varnish_command(
self.lines,
i,
trimmed,
&name,
self.file_path,
self.repo_name,
self.server_names,
&mut self.entities,
);
next_i.max(start_line)
}
fn handle_logexpect(&mut self, i: usize, trimmed: &str) -> usize {
let Some(name) = parse_instance_name(trimmed, "logexpect ") else {
return i + 1;
};
let start_line = i + 1;
let (_, next_i) = extract_brace_block(self.lines, i, trimmed);
let mut entity = ParsedEntity::new(
name.clone(),
EntityKind::VtcLogexpect,
format!("vtc:{}:{}:{}", self.repo_name, self.file_path, name),
Some(format!("logexpect {} {{ ... }}", name)),
None,
"vtc",
self.file_path,
start_line,
start_line,
None,
self.repo_name,
);
entity.is_test_context = true;
self.entities.push(entity);
next_i
}
fn handle_barrier(&mut self, i: usize, trimmed: &str) -> usize {
if let Some(name) = parse_instance_name(trimmed, "barrier ") {
let start_line = i + 1;
let mut entity = ParsedEntity::new(
name.clone(),
EntityKind::VtcBarrier,
format!("vtc:{}:{}:{}", self.repo_name, self.file_path, name),
Some(format!("barrier {} ...", name)),
None,
"vtc",
self.file_path,
start_line,
start_line,
None,
self.repo_name,
);
entity.is_test_context = true;
self.entities.push(entity);
}
i + 1
}
}
fn collect_instance_names(
lines: &[&str],
server_names: &mut Vec<(String, usize)>,
varnish_names: &mut Vec<(String, usize)>,
) {
for (i, line) in lines.iter().enumerate() {
let trimmed = line.trim();
if trimmed.starts_with("server ") {
if let Some(name) = parse_instance_name(trimmed, "server ") {
server_names.push((name, i + 1));
}
} else if trimmed.starts_with("varnish ")
&& let Some(name) = parse_instance_name(trimmed, "varnish ")
{
varnish_names.push((name, i + 1));
}
}
}
pub(crate) fn extract_entities_vtc(
source: &str,
file_path: &str,
repo_name: &str,
) -> Vec<ParsedEntity> {
let lines: Vec<&str> = source.lines().collect();
let mut server_names: Vec<(String, usize)> = Vec::new();
let mut varnish_names: Vec<(String, usize)> = Vec::new();
collect_instance_names(&lines, &mut server_names, &mut varnish_names);
let mut ctx = VtcContext {
lines: &lines,
file_path,
repo_name,
server_names: &server_names,
entities: Vec::new(),
};
let mut i = 0;
while i < lines.len() {
let trimmed = lines[i].trim();
if trimmed.is_empty() || trimmed.starts_with('#') {
i += 1;
continue;
}
i = ctx.dispatch(i, trimmed);
}
ctx.entities
}
fn parse_instance_name(line: &str, prefix: &str) -> Option<String> {
let rest = line.strip_prefix(prefix)?;
let rest = rest.trim();
rest.split_whitespace().next().map(|s| s.to_string())
}
fn parse_quoted_or_rest(line: &str) -> String {
let rest = line.split_once(' ').map(|(_, r)| r).unwrap_or("");
let rest = rest.trim();
if rest.starts_with('"') {
let inside = rest.strip_prefix('"').unwrap_or(rest);
if let Some(end) = inside.rfind('"') {
inside[..end].to_string()
} else {
inside.to_string()
}
} else {
rest.to_string()
}
}
fn scan_block_line(line: &str, depth: &mut usize, is_first_line: bool) -> (String, bool) {
let mut content = String::new();
let mut in_str = false;
let mut started = false;
for ch in line.chars() {
if ch == '"' {
in_str = !in_str;
}
if !in_str && ch == '{' {
*depth += 1;
started = true;
if is_first_line && *depth == 1 {
continue;
}
}
if !in_str && ch == '}' && *depth > 0 {
*depth -= 1;
if *depth == 0 {
break;
}
}
if *depth > 0 {
content.push(ch);
}
}
(content, started)
}
fn resume_block_on_next_line(lines: &[&str], i: usize, first_line: &str) -> (String, usize) {
if first_line.contains("-vcl+backend") && i + 1 < lines.len() {
let trimmed_next = lines[i + 1].trim();
if trimmed_next.starts_with('{') {
return extract_brace_block(lines, i + 1, lines[i + 1]);
}
}
(String::new(), i + 1)
}
fn extract_brace_block(lines: &[&str], start: usize, first_line: &str) -> (String, usize) {
let mut body = String::new();
let mut i = start;
let mut depth = 0;
let (first_content, started) = scan_block_line(first_line, &mut depth, true);
if started {
if !first_content.trim().is_empty() {
body.push_str(&first_content);
body.push('\n');
}
i += 1;
while i < lines.len() && depth > 0 {
let line = lines[i];
let (line_content, _) = scan_block_line(line, &mut depth, false);
if depth > 0 || !line_content.trim().is_empty() {
body.push_str(&line_content);
body.push('\n');
}
i += 1;
}
(body, i)
} else {
resume_block_on_next_line(lines, i, first_line)
}
}
#[expect(
clippy::too_many_arguments,
reason = "VTC command parsing requires line buffer, position, and context parameters"
)]
fn parse_varnish_command(
lines: &[&str],
i: usize,
first_line: &str,
name: &str,
file_path: &str,
repo_name: &str,
server_names: &[(String, usize)],
entities: &mut Vec<ParsedEntity>,
) -> usize {
let _ = repo_name;
let start_line = i + 1;
let has_errvcl = first_line.contains("-errvcl");
let has_vcl_plus_backend = first_line.contains("-vcl+backend");
let (vcl_body, next_i) = extract_brace_block(lines, i, first_line);
if !has_errvcl && !vcl_body.is_empty() {
let mut vcl_entities =
extract_entities_vcl_with_offset(&vcl_body, file_path, repo_name, start_line);
for mut e in vcl_entities.drain(..) {
e.is_test_context = true;
entities.push(e);
}
if has_vcl_plus_backend {
for (sname, sline) in server_names {
let mut be = ParsedEntity::new(
sname.clone(),
EntityKind::VclBackend,
format!("vcl:{}:{}:{}", repo_name, file_path, sname),
Some(format!(
"backend {} {{ .host = \"${{{}_addr}}\"; .port = \"${{{}_port}}\"; }}",
sname, sname, sname
)),
Some(String::from("Synthesised by -vcl+backend")),
"vcl",
file_path,
*sline,
*sline,
None,
repo_name,
);
be.is_test_context = true;
be.reference_intents.push(ReferenceIntent::ValueReference {
value_name: format!("vtc:server:{}", sname),
line: *sline,
});
entities.push(be);
}
}
}
let mut entity = ParsedEntity::new(
name.to_string(),
EntityKind::VtcVarnishInstance,
format!("vtc:{}:{}:{}", repo_name, file_path, name),
Some(format!("varnish {} {{ ... }}", name)),
None,
"vtc",
file_path,
start_line,
start_line,
None,
repo_name,
);
entity.is_test_context = true;
entities.push(entity);
next_i
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_extract_vtc_test_case() {
let src = r#"varnishtest "Basic test"
server s1 {
rxreq
txresp -body "ok"
} -start"#;
let entities = extract_entities_vtc(src, "test.vtc", "test-repo");
let testcases: Vec<_> = entities
.iter()
.filter(|e| e.kind == EntityKind::VtcTestCase)
.collect();
assert_eq!(testcases.len(), 1);
assert_eq!(testcases[0].name, "Basic test");
}
#[test]
fn test_extract_vtc_vtest() {
let entities = extract_entities_vtc(
r#"vtest "my test"
server s1 { } -start"#,
"test.vtc",
"test-repo",
);
let testcases: Vec<_> = entities
.iter()
.filter(|e| e.kind == EntityKind::VtcTestCase)
.collect();
assert_eq!(testcases.len(), 1);
assert_eq!(testcases[0].name, "my test");
}
#[test]
fn test_extract_vtc_server() {
let src = r#"varnishtest "test"
server s1 {
rxreq
txresp
} -start"#;
let entities = extract_entities_vtc(src, "test.vtc", "test-repo");
let servers: Vec<_> = entities
.iter()
.filter(|e| e.kind == EntityKind::VtcServer)
.collect();
assert_eq!(servers.len(), 1);
assert_eq!(servers[0].name, "s1");
assert!(servers[0].is_test_context);
}
#[test]
fn test_extract_vtc_client() {
let src = r#"varnishtest "test"
client c1 {
txreq -url "/"
rxresp
} -run"#;
let entities = extract_entities_vtc(src, "test.vtc", "test-repo");
let clients: Vec<_> = entities
.iter()
.filter(|e| e.kind == EntityKind::VtcClient)
.collect();
assert_eq!(clients.len(), 1);
assert_eq!(clients[0].name, "c1");
}
#[test]
fn test_extract_vtc_varnish_instance() {
let src = r#"varnishtest "test"
varnish v1 -vcl+backend {
sub vcl_recv { return (hash); }
} -start"#;
let entities = extract_entities_vtc(src, "test.vtc", "test-repo");
let instances: Vec<_> = entities
.iter()
.filter(|e| e.kind == EntityKind::VtcVarnishInstance)
.collect();
assert_eq!(instances.len(), 1);
assert_eq!(instances[0].name, "v1");
}
#[test]
fn test_extract_vtc_logexpect() {
let src = r#"varnishtest "test"
logexpect l1 -v v1 {
expect * = ReqURL "^/foo$"
expect * = End
} -run"#;
let entities = extract_entities_vtc(src, "test.vtc", "test-repo");
let logexpects: Vec<_> = entities
.iter()
.filter(|e| e.kind == EntityKind::VtcLogexpect)
.collect();
assert_eq!(logexpects.len(), 1);
assert_eq!(logexpects[0].name, "l1");
}
#[test]
fn test_extract_vtc_barrier() {
let src = r#"varnishtest "test"
barrier b1 cond 2"#;
let entities = extract_entities_vtc(src, "test.vtc", "test-repo");
let barriers: Vec<_> = entities
.iter()
.filter(|e| e.kind == EntityKind::VtcBarrier)
.collect();
assert_eq!(barriers.len(), 1);
assert_eq!(barriers[0].name, "b1");
}
#[test]
fn test_vtc_backend_synthesis_vcl_plus_backend() {
let src = r#"varnishtest "test"
server s1 {
rxreq
txresp
} -start
varnish v1 -vcl+backend {
sub vcl_recv { set req.backend_hint = s1; }
} -start"#;
let entities = extract_entities_vtc(src, "test.vtc", "test-repo");
let backends: Vec<_> = entities
.iter()
.filter(|e| e.kind == EntityKind::VclBackend)
.collect();
assert_eq!(backends.len(), 1);
assert_eq!(backends[0].name, "s1");
}
#[test]
fn test_vtc_errvcl_skipped() {
let src = r#"varnishtest "test"
varnish v1 -errvcl "expected msg" {
invalid vcl that should fail
}"#;
let entities = extract_entities_vtc(src, "test.vtc", "test-repo");
let vcl_entities: Vec<_> = entities.iter().filter(|e| e.language == "vcl").collect();
assert!(vcl_entities.is_empty());
}
#[test]
fn test_vtc_all_entities_test_context() {
let src = r#"varnishtest "test"
server s1 { } -start
client c1 { } -run
varnish v1 -vcl+backend { sub vcl_recv { } } -start"#;
let entities = extract_entities_vtc(src, "test.vtc", "test-repo");
for e in &entities {
if e.kind != EntityKind::VclVersion {
assert!(
e.is_test_context,
"entity {} should have is_test_context",
e.name
);
}
}
}
#[test]
fn test_extract_brace_block_embedded_vcl_string() {
let lines = vec![
"varnish v1 -vcl {",
" sub vcl_recv {",
" if (req.url ~ \"foo{bar}\") { set req.http.x = \"}\"; }",
" }",
"} -start",
];
let (body, end_idx) = extract_brace_block(&lines, 0, lines[0]);
assert_eq!(end_idx, 5);
assert!(body.contains("vcl_recv"));
assert!(body.contains("foo{bar}"));
}
#[test]
fn test_extract_brace_block_vcl_backend_next_line() {
let lines = vec!["varnish v1 -vcl+backend", "{", " sub vcl_recv { }", "}"];
let (body, end_idx) = extract_brace_block(&lines, 0, lines[0]);
assert_eq!(end_idx, 4);
assert!(body.contains("vcl_recv"));
}
}