Complete source 6 engineering workflows and preserve release validation evidence
This commit is contained in:
Codex
@@ -0,0 +1,119 @@
|
||||
//! HTTP admission limits must reject endpoint decisions before transition planning.
|
||||
use super::*;
|
||||
use oa_core::{semantic::SemanticTransitionRequest, transitions::*};
|
||||
|
||||
async fn post(
|
||||
server: &TestServer,
|
||||
id: Id,
|
||||
route: &str,
|
||||
etag: &str,
|
||||
body: &Value,
|
||||
) -> reqwest::Response {
|
||||
server
|
||||
.client
|
||||
.post(server.url(&format!("/projects/{id}/{route}")))
|
||||
.header("if-match", etag)
|
||||
.json(body)
|
||||
.send()
|
||||
.await
|
||||
.unwrap()
|
||||
}
|
||||
|
||||
async fn unchanged(server: &TestServer, before: &StoredProject, disk: &Path, bytes: &[u8]) {
|
||||
let after = server.get(before.resource_id).await;
|
||||
assert_eq!(after.revision, before.revision);
|
||||
assert_eq!(after.etag(), before.etag());
|
||||
assert_eq!(after.model, before.model);
|
||||
assert_eq!(after.source_project, before.source_project);
|
||||
assert_eq!(std::fs::read(disk).unwrap(), bytes);
|
||||
}
|
||||
|
||||
async fn endpoint_limit(semantic: bool) {
|
||||
let directory = tempfile::tempdir().unwrap();
|
||||
let server = TestServer::start(directory.path(), None).await;
|
||||
let mut model = Project::empty();
|
||||
let source = model
|
||||
.add_element(Kind::Activity, Layer::Oa, "Inspect service", None)
|
||||
.unwrap();
|
||||
let (id, etag) = server.import(&model).await;
|
||||
let before = server.get(id).await;
|
||||
let disk = directory.path().join(format!("{id}.json"));
|
||||
let bytes = std::fs::read(&disk).unwrap();
|
||||
let transition = TransitionRequest::new(TransitionDirection::OaToSa, vec![source]);
|
||||
let (route, mut request, decision_path, applied_decision_path) = if semantic {
|
||||
(
|
||||
"semantic-transitions",
|
||||
serde_json::to_value(SemanticTransitionRequest::new(transition)).unwrap(),
|
||||
"/transition/communication_endpoints",
|
||||
"/plan/request/transition/communication_endpoints",
|
||||
)
|
||||
} else {
|
||||
(
|
||||
"transitions",
|
||||
serde_json::to_value(transition).unwrap(),
|
||||
"/communication_endpoints",
|
||||
"/plan/request/communication_endpoints",
|
||||
)
|
||||
};
|
||||
// Obtain a real prepared envelope first: apply must enforce the same bound,
|
||||
// even when a client modifies a previously valid plan's embedded request.
|
||||
let response = post(&server, id, &format!("{route}/preview"), &etag, &request).await;
|
||||
let status = response.status();
|
||||
let mut plan: Value = response.json().await.unwrap();
|
||||
assert_eq!(status, StatusCode::OK, "{plan}");
|
||||
assert_eq!(plan["plan"]["conflicts"], json!([]));
|
||||
unchanged(&server, &before, &disk, &bytes).await;
|
||||
|
||||
// Syntactically typed but semantically inapplicable decisions deliberately
|
||||
// distinguish capacity admission (400) from core semantic rejection (422 or
|
||||
// a preview containing conflicts). The bound counts entries, not unique IDs.
|
||||
let decision = CommunicationEndpointDecision {
|
||||
source,
|
||||
source_port: CommunicationPortChoice::Reuse { port: source },
|
||||
target_port: CommunicationPortChoice::Reuse { port: source },
|
||||
};
|
||||
*request.pointer_mut(decision_path).unwrap() = json!(vec![decision.clone(); 200]);
|
||||
let response = post(&server, id, &format!("{route}/preview"), &etag, &request).await;
|
||||
let status = response.status();
|
||||
let body: Value = response.json().await.unwrap();
|
||||
assert!(
|
||||
matches!(status, StatusCode::OK | StatusCode::UNPROCESSABLE_ENTITY),
|
||||
"Exactly 200 decisions must pass capacity admission: {status} {body}"
|
||||
);
|
||||
unchanged(&server, &before, &disk, &bytes).await;
|
||||
|
||||
let over_limit = json!(vec![decision; 201]);
|
||||
*request.pointer_mut(decision_path).unwrap() = over_limit.clone();
|
||||
*plan.pointer_mut(applied_decision_path).unwrap() = over_limit;
|
||||
for (operation, body) in [("preview", request), ("apply", plan)] {
|
||||
let response = post(&server, id, &format!("{route}/{operation}"), &etag, &body).await;
|
||||
let status = response.status();
|
||||
let error: Value = response.json().await.unwrap();
|
||||
assert_eq!(
|
||||
status,
|
||||
StatusCode::BAD_REQUEST,
|
||||
"{route}/{operation}: {error}"
|
||||
);
|
||||
assert_eq!(error["code"], "invalid_request", "{error}");
|
||||
let detail = error["detail"].as_str().unwrap().to_lowercase();
|
||||
assert!(
|
||||
detail.contains("200") && detail.contains("endpoint"),
|
||||
"Capacity rejection must identify endpoint decisions: {error}"
|
||||
);
|
||||
unchanged(&server, &before, &disk, &bytes).await;
|
||||
}
|
||||
server.stop().await;
|
||||
let server = TestServer::start(directory.path(), None).await;
|
||||
unchanged(&server, &before, &disk, &bytes).await;
|
||||
server.stop().await;
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn ordinary_transition_endpoint_decision_limit_rejects_201_without_mutation() {
|
||||
endpoint_limit(false).await;
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn semantic_transition_endpoint_decision_limit_rejects_201_without_mutation() {
|
||||
endpoint_limit(true).await;
|
||||
}
|
||||
@@ -185,7 +185,7 @@ async fn published_data_contract_queries_atomic_edits_identity_and_restart() {
|
||||
.text()
|
||||
.await
|
||||
.unwrap();
|
||||
assert!(source.starts_with("arcadia 5;"));
|
||||
assert!(source.starts_with("arcadia 6;"));
|
||||
assert_eq!(oa_core::language::parse(&source).unwrap(), removed.model);
|
||||
server.stop().await;
|
||||
let server = TestServer::start(directory.path(), None).await;
|
||||
@@ -218,7 +218,10 @@ async fn authored_schema3_bundle_upgrade_reports_data_defaults_and_preserves_fil
|
||||
let resource = summary["resource_id"].as_str().unwrap().parse().unwrap();
|
||||
let stored = server.get(resource).await;
|
||||
let report = stored.migration.as_ref().unwrap();
|
||||
assert_eq!((report.from_schema, report.to_schema), (3, 5));
|
||||
assert_eq!(
|
||||
(report.from_schema, report.to_schema),
|
||||
(3, oa_core::SCHEMA_VERSION)
|
||||
);
|
||||
assert_eq!(report.generated_interface_allocations.len(), 1);
|
||||
assert!(!report.semantic_defaults.is_empty());
|
||||
let validated: Value = server
|
||||
@@ -241,7 +244,7 @@ async fn authored_schema3_bundle_upgrade_reports_data_defaults_and_preserves_fil
|
||||
1
|
||||
);
|
||||
assert_eq!(stored.source_project.files.len(), 2);
|
||||
assert!(stored.source_project.files["legacy.arcadia"].contains("arcadia 5;"));
|
||||
assert!(stored.source_project.files["legacy.arcadia"].contains("arcadia 6;"));
|
||||
for text in [
|
||||
"// Event rationale",
|
||||
"// Interface rationale",
|
||||
@@ -283,9 +286,9 @@ async fn existing_schema3_coupled_envelope_upgrades_in_memory_until_explicit_sav
|
||||
let server = TestServer::start(directory.path(), None).await;
|
||||
let opened = server.get(resource).await;
|
||||
assert_eq!(opened.revision, 17);
|
||||
assert_eq!(opened.model.schema_version, 5);
|
||||
assert_eq!(opened.model.schema_version, oa_core::SCHEMA_VERSION);
|
||||
assert_eq!(opened.migration.as_ref().unwrap().from_schema, 3);
|
||||
assert!(opened.source_project.files["project.arcadia"].contains("arcadia 5;"));
|
||||
assert!(opened.source_project.files["project.arcadia"].contains("arcadia 6;"));
|
||||
assert_pair(&opened);
|
||||
assert_eq!(std::fs::read(&filename).unwrap(), original);
|
||||
assert_eq!(
|
||||
@@ -717,7 +720,7 @@ async fn qualified_call_reply_values_reject_invalid_edits_and_survive_identity_s
|
||||
.text()
|
||||
.await
|
||||
.unwrap();
|
||||
assert!(source.starts_with("arcadia 5;"));
|
||||
assert!(source.starts_with("arcadia 6;"));
|
||||
assert_eq!(oa_core::language::parse(&source).unwrap(), changed.model);
|
||||
let saved = std::fs::read(&filename).unwrap();
|
||||
server.stop().await;
|
||||
|
||||
@@ -0,0 +1,374 @@
|
||||
use super::*;
|
||||
use oa_core::{
|
||||
ComponentPortKind, ComponentPortOrientation, Position, ProjectionKind, RelationBody,
|
||||
SharedBody,
|
||||
source_project::{ProjectLimits, SourceBundle, compile_bundle},
|
||||
transitions::{
|
||||
CommunicationEndpointDecision, CommunicationPortChoice, TransitionDirection,
|
||||
TransitionMapping, TransitionRequest,
|
||||
},
|
||||
view_options::{
|
||||
CategorySelection, EdgeKind, ExchangeFamily, ExchangeLabels, RelationKinds, ViewOptions,
|
||||
},
|
||||
};
|
||||
use std::collections::BTreeMap;
|
||||
|
||||
struct Fixture {
|
||||
bundle: SourceBundle,
|
||||
mean: Id,
|
||||
category: Id,
|
||||
diagram: Id,
|
||||
item: Id,
|
||||
oa: [Id; 2],
|
||||
sa: [Id; 2],
|
||||
}
|
||||
|
||||
fn fixture() -> Fixture {
|
||||
let mut model = Project::empty();
|
||||
let a = model
|
||||
.add_element(Kind::Entity, Layer::Oa, "Rescue team", None)
|
||||
.unwrap();
|
||||
let b = model
|
||||
.add_element(Kind::Actor, Layer::Oa, "Control centre", None)
|
||||
.unwrap();
|
||||
let sa = model
|
||||
.add_element(Kind::System, Layer::Sa, "Radio", None)
|
||||
.unwrap();
|
||||
let sb = model
|
||||
.add_element(Kind::SystemActor, Layer::Sa, "External radio", None)
|
||||
.unwrap();
|
||||
let item = model
|
||||
.add_element(Kind::ExchangeItem, Layer::Oa, "Position & status", None)
|
||||
.unwrap();
|
||||
let mean = model.relate(RelationKind::CommunicationMean, "Radio <channel>", a, b);
|
||||
let category = model
|
||||
.add_element(Kind::ExchangeCategory, Layer::Oa, "Radio channels", None)
|
||||
.unwrap();
|
||||
*model
|
||||
.elements
|
||||
.get_mut(&category)
|
||||
.unwrap()
|
||||
.shared_mut()
|
||||
.unwrap() = SharedBody::ExchangeCategory {
|
||||
family: ExchangeFamily::Participant,
|
||||
exchanges: vec![mean],
|
||||
};
|
||||
let diagram = model.ensure_diagram(Layer::Oa);
|
||||
model.place(diagram, a, Position { x: 0., y: 0. });
|
||||
model.place(diagram, b, Position { x: 400., y: 0. });
|
||||
let view = model.diagrams.get_mut(&diagram).unwrap();
|
||||
view.projection = ProjectionKind::Allocation;
|
||||
view.view_options = ViewOptions {
|
||||
relation_kinds: RelationKinds::Only(vec![EdgeKind::Relation(
|
||||
RelationKind::CommunicationMean,
|
||||
)]),
|
||||
participant_categories: CategorySelection::Any(vec![category]),
|
||||
exchange_labels: ExchangeLabels::NameAndItems,
|
||||
..Default::default()
|
||||
};
|
||||
let source = format!(
|
||||
"// Authored source-6 engineering rationale\n{}",
|
||||
oa_core::language::format(&model).replacen("{\n", "{\n include \"notes.arcadia\";\n", 1)
|
||||
);
|
||||
let bundle = SourceBundle {
|
||||
entry: "radio.arcadia".into(),
|
||||
files: BTreeMap::from([
|
||||
("radio.arcadia".into(), source),
|
||||
(
|
||||
"notes.arcadia".into(),
|
||||
"// Retain this exact included note, including CRLF.\r\n".into(),
|
||||
),
|
||||
]),
|
||||
};
|
||||
let compiled = compile_bundle(&bundle, ProjectLimits::default()).unwrap();
|
||||
assert_eq!(compiled.decoded.project, model);
|
||||
Fixture {
|
||||
bundle: compiled.bundle,
|
||||
mean,
|
||||
category,
|
||||
diagram,
|
||||
item,
|
||||
oa: [a, b],
|
||||
sa: [sa, sb],
|
||||
}
|
||||
}
|
||||
|
||||
async fn import(server: &TestServer, bundle: &SourceBundle) -> StoredProject {
|
||||
let response = server
|
||||
.client
|
||||
.post(server.url("/projects/import-source-project"))
|
||||
.json(bundle)
|
||||
.send()
|
||||
.await
|
||||
.unwrap();
|
||||
let status = response.status();
|
||||
let result: Value = response.json().await.unwrap();
|
||||
assert_eq!(status, StatusCode::CREATED, "{result}");
|
||||
server
|
||||
.get(result["resource_id"].as_str().unwrap().parse().unwrap())
|
||||
.await
|
||||
}
|
||||
|
||||
fn assert_pair(stored: &StoredProject) {
|
||||
let compiled = compile_bundle(&stored.source_project, ProjectLimits::default()).unwrap();
|
||||
assert_eq!(compiled.bundle, stored.source_project);
|
||||
assert_eq!(compiled.decoded.project, stored.model);
|
||||
assert_eq!(stored.model.schema_version, 6);
|
||||
}
|
||||
|
||||
async fn transact(
|
||||
server: &TestServer,
|
||||
current: &StoredProject,
|
||||
commands: Vec<Command>,
|
||||
) -> reqwest::Response {
|
||||
server
|
||||
.client
|
||||
.post(server.url(&format!("/projects/{}/transactions", current.resource_id)))
|
||||
.header("if-match", current.etag())
|
||||
.json(&json!({"commands":commands}))
|
||||
.send()
|
||||
.await
|
||||
.unwrap()
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn source6_http_views_categories_and_means_preserve_source_and_reject_invalid_batch_after_restart()
|
||||
{
|
||||
let f = fixture();
|
||||
let directory = tempfile::tempdir().unwrap();
|
||||
let server = TestServer::start(directory.path(), None).await;
|
||||
let original = import(&server, &f.bundle).await;
|
||||
let resource = original.resource_id;
|
||||
assert_eq!(original.source_project, f.bundle);
|
||||
assert_pair(&original);
|
||||
let model: Value = server
|
||||
.client
|
||||
.get(server.url(&format!("/projects/{resource}/model")))
|
||||
.send()
|
||||
.await
|
||||
.unwrap()
|
||||
.error_for_status()
|
||||
.unwrap()
|
||||
.json()
|
||||
.await
|
||||
.unwrap();
|
||||
assert_eq!(
|
||||
model["relations"][f.mean.to_string()]["body"]["CommunicationMean"]["oriented"],
|
||||
false
|
||||
);
|
||||
assert_eq!(
|
||||
model["diagrams"][f.diagram.to_string()]["view_options"]["exchange_labels"],
|
||||
"NameAndItems"
|
||||
);
|
||||
for (route, expected) in [
|
||||
("relations?kind=CommunicationMean", f.mean),
|
||||
("elements?kind=ExchangeCategory", f.category),
|
||||
] {
|
||||
let result: Value = server
|
||||
.client
|
||||
.get(server.url(&format!("/projects/{resource}/{route}")))
|
||||
.send()
|
||||
.await
|
||||
.unwrap()
|
||||
.error_for_status()
|
||||
.unwrap()
|
||||
.json()
|
||||
.await
|
||||
.unwrap();
|
||||
assert_eq!(result["items"].as_array().unwrap().len(), 1);
|
||||
assert_eq!(result["items"][0]["id"], expected.to_string());
|
||||
}
|
||||
// There is no projection HTTP route. The actual returned model supplies the
|
||||
// shared desktop projection; saved filters must not alter queried relations.
|
||||
assert!(
|
||||
oa_core::projection::project_view(&original.model, f.diagram)
|
||||
.edges
|
||||
.iter()
|
||||
.any(|e| e.id == f.mean)
|
||||
);
|
||||
let mut relation = original.model.relations[&f.mean].clone();
|
||||
if let RelationBody::CommunicationMean {
|
||||
oriented, items, ..
|
||||
} = &mut relation.body
|
||||
{
|
||||
*oriented = true;
|
||||
*items = vec![f.item];
|
||||
}
|
||||
let mut diagram = original.model.diagrams[&f.diagram].clone();
|
||||
diagram.view_options.hidden_edges = vec![f.mean];
|
||||
diagram.view_options.exchange_labels = ExchangeLabels::Items;
|
||||
let response = transact(
|
||||
&server,
|
||||
&original,
|
||||
vec![
|
||||
Command::EditRelation(f.mean, relation.clone()),
|
||||
Command::EditDiagram(f.diagram, diagram.clone()),
|
||||
],
|
||||
)
|
||||
.await;
|
||||
let status = response.status();
|
||||
let result: Value = response.json().await.unwrap();
|
||||
assert_eq!(status, StatusCode::OK, "{result}");
|
||||
let changed = server.get(resource).await;
|
||||
assert_eq!(changed.revision, original.revision + 1);
|
||||
assert_eq!(changed.model.relations[&f.mean], relation);
|
||||
assert_eq!(changed.model.diagrams[&f.diagram], diagram);
|
||||
assert!(
|
||||
oa_core::projection::project_view(&changed.model, f.diagram)
|
||||
.edges
|
||||
.is_empty()
|
||||
);
|
||||
assert_eq!(
|
||||
changed.source_project.files["notes.arcadia"],
|
||||
f.bundle.files["notes.arcadia"]
|
||||
);
|
||||
assert!(
|
||||
changed.source_project.files["radio.arcadia"]
|
||||
.starts_with("// Authored source-6 engineering rationale\n")
|
||||
);
|
||||
assert_pair(&changed);
|
||||
let disk = directory.path().join(format!("{resource}.json"));
|
||||
let accepted_bytes = std::fs::read(&disk).unwrap();
|
||||
let mut invalid = changed.model.elements[&f.category].clone();
|
||||
if let Some(SharedBody::ExchangeCategory { family, .. }) = invalid.shared_mut() {
|
||||
*family = ExchangeFamily::Work; // A communication means cannot join this family.
|
||||
}
|
||||
relation.name = "Must not leak from rejected batch".into();
|
||||
let rejected = transact(
|
||||
&server,
|
||||
&changed,
|
||||
vec![
|
||||
Command::EditRelation(f.mean, relation),
|
||||
Command::EditElement(f.category, invalid),
|
||||
],
|
||||
)
|
||||
.await;
|
||||
assert_eq!(rejected.status(), StatusCode::UNPROCESSABLE_ENTITY);
|
||||
let retained = server.get(resource).await;
|
||||
assert_eq!(retained.model, changed.model);
|
||||
assert_eq!(retained.source_project, changed.source_project);
|
||||
assert_eq!(retained.etag(), changed.etag());
|
||||
assert_eq!(std::fs::read(&disk).unwrap(), accepted_bytes);
|
||||
server.stop().await;
|
||||
let server = TestServer::start(directory.path(), None).await;
|
||||
let reopened = server.get(resource).await;
|
||||
assert_eq!(reopened.model, changed.model);
|
||||
assert_eq!(reopened.source_project, changed.source_project);
|
||||
assert_eq!(reopened.etag(), changed.etag());
|
||||
assert_pair(&reopened);
|
||||
server.stop().await;
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn source6_http_explicit_communication_ports_preview_apply_and_restart_preserve_decisions() {
|
||||
let f = fixture();
|
||||
let directory = tempfile::tempdir().unwrap();
|
||||
let server = TestServer::start(directory.path(), None).await;
|
||||
let original = import(&server, &f.bundle).await;
|
||||
let resource = original.resource_id;
|
||||
let mut request = TransitionRequest::new(TransitionDirection::OaToSa, vec![f.mean]);
|
||||
request.mappings =
|
||||
f.oa.into_iter()
|
||||
.zip(f.sa)
|
||||
.map(|(source, target)| TransitionMapping {
|
||||
source,
|
||||
target: Some(target),
|
||||
target_kind: None,
|
||||
})
|
||||
.collect();
|
||||
let ports = [Id::new_v4(), Id::new_v4()];
|
||||
let create = |id, alias: &str| CommunicationPortChoice::Create {
|
||||
id,
|
||||
alias: alias.into(),
|
||||
name: alias.into(),
|
||||
description: "Explicit HTTP endpoint choice".into(),
|
||||
kind: ComponentPortKind::Standard,
|
||||
orientation: ComponentPortOrientation::Unset,
|
||||
};
|
||||
request
|
||||
.communication_endpoints
|
||||
.push(CommunicationEndpointDecision {
|
||||
source: f.mean,
|
||||
source_port: create(ports[0], "http_radio_source"),
|
||||
target_port: create(ports[1], "http_radio_target"),
|
||||
});
|
||||
let accepted_bytes = std::fs::read(directory.path().join(format!("{resource}.json"))).unwrap();
|
||||
let response = server
|
||||
.client
|
||||
.post(server.url(&format!("/projects/{resource}/transitions/preview")))
|
||||
.header("if-match", original.etag())
|
||||
.json(&request)
|
||||
.send()
|
||||
.await
|
||||
.unwrap();
|
||||
let status = response.status();
|
||||
let preview: Value = response.json().await.unwrap();
|
||||
assert_eq!(status, StatusCode::OK, "{preview}");
|
||||
assert!(
|
||||
preview["plan"]["conflicts"].as_array().unwrap().is_empty(),
|
||||
"{preview}"
|
||||
);
|
||||
assert_eq!(
|
||||
preview["plan"]["request"]["communication_endpoints"],
|
||||
serde_json::to_value(&request.communication_endpoints).unwrap()
|
||||
);
|
||||
assert_eq!(
|
||||
server.get(resource).await.source_project,
|
||||
original.source_project
|
||||
);
|
||||
assert_eq!(
|
||||
std::fs::read(directory.path().join(format!("{resource}.json"))).unwrap(),
|
||||
accepted_bytes
|
||||
);
|
||||
let response = server
|
||||
.client
|
||||
.post(server.url(&format!("/projects/{resource}/transitions/apply")))
|
||||
.header("if-match", original.etag())
|
||||
.json(&preview)
|
||||
.send()
|
||||
.await
|
||||
.unwrap();
|
||||
let status = response.status();
|
||||
let result: Value = response.json().await.unwrap();
|
||||
assert_eq!(status, StatusCode::OK, "{result}");
|
||||
let changed = server.get(resource).await;
|
||||
assert_eq!(changed.revision, original.revision + 1);
|
||||
assert_pair(&changed);
|
||||
let target = changed
|
||||
.model
|
||||
.traces
|
||||
.values()
|
||||
.find(|t| t.oa == f.mean)
|
||||
.unwrap()
|
||||
.sa;
|
||||
assert!(
|
||||
matches!(changed.model.relations[&target].body, RelationBody::BoundaryExchange { source, target, oriented:false, .. } if [source,target] == ports)
|
||||
);
|
||||
for (port, owner) in ports.into_iter().zip(f.sa) {
|
||||
assert_eq!(changed.model.elements[&port].parent, Some(owner));
|
||||
}
|
||||
assert_eq!(
|
||||
changed.model.relations[&f.mean],
|
||||
original.model.relations[&f.mean]
|
||||
);
|
||||
assert_eq!(
|
||||
changed.model.elements[&f.category],
|
||||
original.model.elements[&f.category]
|
||||
);
|
||||
assert_eq!(
|
||||
changed.model.diagrams[&f.diagram],
|
||||
original.model.diagrams[&f.diagram]
|
||||
);
|
||||
assert_eq!(
|
||||
changed.source_project.files["notes.arcadia"],
|
||||
original.source_project.files["notes.arcadia"]
|
||||
);
|
||||
server.stop().await;
|
||||
let server = TestServer::start(directory.path(), None).await;
|
||||
let reopened = server.get(resource).await;
|
||||
assert_eq!(reopened.model, changed.model);
|
||||
assert_eq!(reopened.source_project, changed.source_project);
|
||||
assert_eq!(reopened.etag(), changed.etag());
|
||||
assert_pair(&reopened);
|
||||
server.stop().await;
|
||||
}
|
||||
Reference in New Issue
Block a user