Owner-authorized recovery of accumulated source changes.
Includes accepted work and in-progress changes; NOT a release or acceptance.
Parent baseline 1b6db09bd1. Runtime data, build caches and local credentials excluded.
617 lines
23 KiB
Rust
617 lines
23 KiB
Rust
//! AC02 / AT-3.7-02: publication validator.
|
|
//!
|
|
//! Проверяется, что публикация повторно проверяет сохранённые URI/MIME и целостность
|
|
//! артефакта (defense-in-depth: строки БД могут пережить более строгую грамматику), а
|
|
//! secret-bearing content (raw credential, private key, access-bypassing reference) блокирует
|
|
//! публикацию. Любой отказ сохраняет Draft и не создаёт Published metadata.
|
|
//!
|
|
//! TL interface decision 4: синтетические канарейки, никаких реальных credentials; при
|
|
//! отсутствии конкретного secret-policy входа точный пробел возвращается TL вместе с готовым
|
|
//! RED (см. `.tmp/t_b132062a/STORY37-ATDD-REPORT.md`).
|
|
|
|
use super::super::helpers::{
|
|
DEFAULT_WORKSPACE_ID, TEST_AUTH_EMAIL, TEST_AUTH_PASSWORD, create_draft, draft_metadata,
|
|
login_client, spawn_authorized, table_row_count,
|
|
};
|
|
use super::{
|
|
create_fixture, overwrite_current_version_mime, overwrite_resource_uri, publish_expect_refusal,
|
|
replace_blob_with_tampered_bytes, spawn_with_storage, update_draft_expect_success,
|
|
};
|
|
use reqwest::StatusCode;
|
|
use serde_json::json;
|
|
use serial_test::serial;
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Defense-in-depth: сохранённые метаданные проверяются заново
|
|
// ---------------------------------------------------------------------------
|
|
|
|
#[tokio::test(flavor = "multi_thread")]
|
|
#[serial]
|
|
async fn story37_at02_publish_revalidates_stored_uri_and_mime_grammar() {
|
|
let (registry, server, client) = spawn_authorized("story37_publish_stored_grammar").await;
|
|
|
|
// (a) сохранённый URI больше не удовлетворяет грамматике D-10 (верхний регистр схемы),
|
|
// хотя ограничение длины и уникальность БД соблюдены.
|
|
let uri_fixture = create_fixture(
|
|
&client,
|
|
&server,
|
|
&draft_metadata(
|
|
"crank://story37/stored-uri",
|
|
"stored_uri",
|
|
"text",
|
|
"text/plain",
|
|
"internal",
|
|
),
|
|
b"stored uri body",
|
|
"story37-stored-uri.txt",
|
|
"text/plain",
|
|
)
|
|
.await;
|
|
overwrite_resource_uri(
|
|
registry.pool(),
|
|
&uri_fixture.resource_id,
|
|
"CRANK://story37/stored-uri",
|
|
)
|
|
.await;
|
|
let refusal = publish_expect_refusal(
|
|
&client,
|
|
&server,
|
|
&uri_fixture.resource_id,
|
|
&uri_fixture.updated_at,
|
|
StatusCode::BAD_REQUEST,
|
|
"AT-3.7-02 stored uri re-validation",
|
|
)
|
|
.await;
|
|
assert_eq!(
|
|
refusal["error"]["code"],
|
|
json!("resource_uri_invalid"),
|
|
"the stored uri grammar failure must keep the existing Resource code: {refusal}"
|
|
);
|
|
assert_eq!(refusal["error"]["context"]["field"], json!("uri"));
|
|
|
|
// (b) сохранённый MIME текущей версии больше не входит в allowlist kind.
|
|
let mime_fixture = create_fixture(
|
|
&client,
|
|
&server,
|
|
&draft_metadata(
|
|
"crank://story37/stored-mime",
|
|
"stored_mime",
|
|
"text",
|
|
"text/plain",
|
|
"internal",
|
|
),
|
|
b"stored mime body",
|
|
"story37-stored-mime.txt",
|
|
"text/plain",
|
|
)
|
|
.await;
|
|
overwrite_current_version_mime(
|
|
registry.pool(),
|
|
&mime_fixture.resource_id,
|
|
"application/zip",
|
|
)
|
|
.await;
|
|
let refusal = publish_expect_refusal(
|
|
&client,
|
|
&server,
|
|
&mime_fixture.resource_id,
|
|
&mime_fixture.updated_at,
|
|
StatusCode::BAD_REQUEST,
|
|
"AT-3.7-02 stored mime re-validation",
|
|
)
|
|
.await;
|
|
assert_eq!(
|
|
refusal["error"]["code"],
|
|
json!("resource_mime_not_allowed"),
|
|
"the stored mime allowlist failure must keep the existing Resource code: {refusal}"
|
|
);
|
|
assert_eq!(refusal["error"]["context"]["field"], json!("mime_type"));
|
|
|
|
// Оба Draft сохранены и остаются читаемыми: отказ не удалил и не переписал состояние.
|
|
assert_eq!(
|
|
table_row_count(registry.pool(), "resources").await,
|
|
2,
|
|
"both refused Drafts must still exist"
|
|
);
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Defense-in-depth: целостность сохранённого артефакта
|
|
// ---------------------------------------------------------------------------
|
|
|
|
#[tokio::test(flavor = "multi_thread")]
|
|
#[serial]
|
|
async fn story37_at02_publish_refuses_tampered_artifact_integrity() {
|
|
let (registry, server, client, storage_root) =
|
|
spawn_with_storage("story37_publish_integrity").await;
|
|
|
|
let bytes = b"integrity fixture body\n";
|
|
let fixture = create_fixture(
|
|
&client,
|
|
&server,
|
|
&draft_metadata(
|
|
"crank://story37/integrity",
|
|
"integrity_doc",
|
|
"text",
|
|
"text/plain",
|
|
"internal",
|
|
),
|
|
bytes,
|
|
"story37-integrity.txt",
|
|
"text/plain",
|
|
)
|
|
.await;
|
|
let digest = fixture.card["version"]["digest"]
|
|
.as_str()
|
|
.expect("Draft card must expose the stored digest")
|
|
.to_owned();
|
|
assert_eq!(
|
|
digest,
|
|
super::super::helpers::sha256_hex(bytes),
|
|
"the fixture digest must match the stored bytes"
|
|
);
|
|
let versions_before = table_row_count(registry.pool(), "resource_versions").await;
|
|
|
|
// Store-контракт сохраняется (обычный read-only файл с одной ссылкой), поэтому отказ
|
|
// обязан прийти именно из digest/размерной проверки.
|
|
replace_blob_with_tampered_bytes(&storage_root, &digest, b"story37-tampered-payload");
|
|
|
|
let refusal = publish_expect_refusal(
|
|
&client,
|
|
&server,
|
|
&fixture.resource_id,
|
|
&fixture.updated_at,
|
|
StatusCode::UNPROCESSABLE_ENTITY,
|
|
"AT-3.7-02 artifact integrity",
|
|
)
|
|
.await;
|
|
assert!(
|
|
!refusal
|
|
.to_string()
|
|
.contains(storage_root.to_str().unwrap_or_default()),
|
|
"an integrity refusal must not disclose the storage path: {refusal}"
|
|
);
|
|
assert_eq!(
|
|
table_row_count(registry.pool(), "resource_versions").await,
|
|
versions_before,
|
|
"a refused publication must not register a new version row"
|
|
);
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Secret-bearing content блокирует публикацию
|
|
// ---------------------------------------------------------------------------
|
|
|
|
/// Синтетический PEM-блок: заголовки реального формата, тело — очевидно неправдоподобная
|
|
/// строка, поэтому ни один настоящий ключ не используется (TL decision 4).
|
|
const SYNTHETIC_PRIVATE_KEY_PEM: &str = "-----BEGIN PRIVATE KEY-----\n\
|
|
c3ludGhldGljLXN0b3J5MzctcHJpdmF0ZS1rZXktYm9keS1ub3QtYS1yZWFsLWtleQ==\n\
|
|
-----END PRIVATE KEY-----\n";
|
|
|
|
/// Синтетическая raw credential: документированный AWS-пример (публичные, учебные значения),
|
|
/// а не рабочий секрет.
|
|
const SYNTHETIC_RAW_CREDENTIAL: &str = "aws_access_key_id = AKIAIOSFODNN7EXAMPLE\n\
|
|
aws_secret_access_key = wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY\n";
|
|
|
|
#[tokio::test(flavor = "multi_thread")]
|
|
#[serial]
|
|
async fn story37_at02_publish_refuses_private_key_content() {
|
|
let (_registry, server, client) = spawn_authorized("story37_secret_private_key").await;
|
|
|
|
let fixture = create_fixture(
|
|
&client,
|
|
&server,
|
|
&draft_metadata(
|
|
"crank://story37/private-key",
|
|
"private_key_doc",
|
|
"text",
|
|
"text/plain",
|
|
"internal",
|
|
),
|
|
SYNTHETIC_PRIVATE_KEY_PEM.as_bytes(),
|
|
"story37-private-key.txt",
|
|
"text/plain",
|
|
)
|
|
.await;
|
|
|
|
let refusal = publish_expect_refusal(
|
|
&client,
|
|
&server,
|
|
&fixture.resource_id,
|
|
&fixture.updated_at,
|
|
StatusCode::UNPROCESSABLE_ENTITY,
|
|
"AT-3.7-02 private key publication refusal",
|
|
)
|
|
.await;
|
|
assert!(
|
|
!refusal.to_string().contains("BEGIN PRIVATE KEY")
|
|
&& !refusal.to_string().contains("c3ludGhldGlj"),
|
|
"the refusal must stay sanitized and must not echo the secret-bearing content: {refusal}"
|
|
);
|
|
}
|
|
|
|
#[tokio::test(flavor = "multi_thread")]
|
|
#[serial]
|
|
async fn story37_at02_publish_refuses_raw_credential_content() {
|
|
let (_registry, server, client) = spawn_authorized("story37_secret_raw_credential").await;
|
|
|
|
let fixture = create_fixture(
|
|
&client,
|
|
&server,
|
|
&draft_metadata(
|
|
"crank://story37/raw-credential",
|
|
"raw_credential_doc",
|
|
"text",
|
|
"text/plain",
|
|
"internal",
|
|
),
|
|
SYNTHETIC_RAW_CREDENTIAL.as_bytes(),
|
|
"story37-raw-credential.txt",
|
|
"text/plain",
|
|
)
|
|
.await;
|
|
|
|
let refusal = publish_expect_refusal(
|
|
&client,
|
|
&server,
|
|
&fixture.resource_id,
|
|
&fixture.updated_at,
|
|
StatusCode::UNPROCESSABLE_ENTITY,
|
|
"AT-3.7-02 raw credential publication refusal",
|
|
)
|
|
.await;
|
|
assert!(
|
|
!refusal.to_string().contains("AKIAIOSFODNN7EXAMPLE")
|
|
&& !refusal.to_string().contains("wJalrXUtnFEMI"),
|
|
"the refusal must stay sanitized and must not echo the credential: {refusal}"
|
|
);
|
|
}
|
|
|
|
#[tokio::test(flavor = "multi_thread")]
|
|
#[serial]
|
|
async fn story37_at02_publish_refuses_access_bypassing_reference() {
|
|
let (registry, server, _client) = spawn_authorized("story37_secret_bypass").await;
|
|
|
|
// WorkspaceB принадлежит тому же аккаунту (Owner membership), поэтому обе сущности
|
|
// доступны одной авторизации, но это разные workspace-скоупы: ссылка из WorkspaceA на
|
|
// секретную сущность WorkspaceB обошла бы scope публикуемого ресурса.
|
|
let owned_workspace = super::super::helpers::create_owned_workspace(®istry).await;
|
|
let workspace_b = server
|
|
.as_ref()
|
|
.replace(DEFAULT_WORKSPACE_ID, owned_workspace.as_str());
|
|
// Сессия логинится уже после выдачи membership.
|
|
let client = login_client(&server, TEST_AUTH_EMAIL, TEST_AUTH_PASSWORD).await;
|
|
|
|
let secret_meta = draft_metadata(
|
|
"crank://story37/secret-source",
|
|
"secret_source",
|
|
"text",
|
|
"text/plain",
|
|
"secret",
|
|
);
|
|
create_draft(
|
|
&client,
|
|
&workspace_b,
|
|
&secret_meta,
|
|
b"secret payload of another workspace",
|
|
"story37-secret-source.txt",
|
|
"text/plain",
|
|
)
|
|
.await;
|
|
|
|
let referencing_content = "include: crank://story37/secret-source\n";
|
|
let fixture = create_fixture(
|
|
&client,
|
|
&server,
|
|
&draft_metadata(
|
|
"crank://story37/bypassing-ref",
|
|
"bypassing_ref",
|
|
"text",
|
|
"text/plain",
|
|
"internal",
|
|
),
|
|
referencing_content.as_bytes(),
|
|
"story37-bypassing-ref.txt",
|
|
"text/plain",
|
|
)
|
|
.await;
|
|
|
|
let refusal = publish_expect_refusal(
|
|
&client,
|
|
&server,
|
|
&fixture.resource_id,
|
|
&fixture.updated_at,
|
|
StatusCode::UNPROCESSABLE_ENTITY,
|
|
"AT-3.7-02 access-bypassing reference refusal",
|
|
)
|
|
.await;
|
|
assert!(
|
|
!refusal.to_string().contains("secret_source")
|
|
&& !refusal
|
|
.to_string()
|
|
.contains("crank://story37/secret-source"),
|
|
"the refusal must not disclose the referenced secret entity: {refusal}"
|
|
);
|
|
}
|
|
|
|
/// Точность детектора: обычный текст, который лишь упоминает категории, не является секретом
|
|
/// и обязан публиковаться (TL decision 4: не считать любую ссылку secret, не вводить
|
|
/// universal scanner).
|
|
#[tokio::test(flavor = "multi_thread")]
|
|
#[serial]
|
|
async fn story37_at02_benign_mentions_are_not_treated_as_secrets() {
|
|
let (_registry, server, client) = spawn_authorized("story37_secret_precision").await;
|
|
|
|
let benign = "Инструкция: не коммитьте private key в репозиторий, \
|
|
используйте secret manager и переменные окружения.\n";
|
|
let fixture = create_fixture(
|
|
&client,
|
|
&server,
|
|
&draft_metadata(
|
|
"crank://story37/benign-mentions",
|
|
"benign_mentions",
|
|
"text",
|
|
"text/plain",
|
|
"internal",
|
|
),
|
|
benign.as_bytes(),
|
|
"story37-benign.txt",
|
|
"text/plain",
|
|
)
|
|
.await;
|
|
|
|
let (status, text, body) =
|
|
super::publish(&client, &server, &fixture.resource_id, &fixture.updated_at).await;
|
|
assert_eq!(
|
|
status,
|
|
StatusCode::OK,
|
|
"a merely descriptive text must stay publishable; observed {} body={text}",
|
|
super::super::helpers::error_signature(status, &body)
|
|
);
|
|
assert_eq!(super::published_metadata(&body)["version"], json!(1));
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Позитивный контроль: отказ не ломает существующий контракт обновления Draft
|
|
// ---------------------------------------------------------------------------
|
|
|
|
#[tokio::test(flavor = "multi_thread")]
|
|
#[serial]
|
|
async fn story37_at02_refusal_keeps_existing_draft_update_contract_intact() {
|
|
let (registry, server, client) = spawn_authorized("story37_refusal_then_update").await;
|
|
|
|
let fixture = create_fixture(
|
|
&client,
|
|
&server,
|
|
&draft_metadata(
|
|
"crank://story37/refusal-update",
|
|
"refusal_update",
|
|
"text",
|
|
"text/plain",
|
|
"internal",
|
|
),
|
|
b"first body",
|
|
"story37-refusal-update.txt",
|
|
"text/plain",
|
|
)
|
|
.await;
|
|
overwrite_current_version_mime(registry.pool(), &fixture.resource_id, "application/zip").await;
|
|
|
|
publish_expect_refusal(
|
|
&client,
|
|
&server,
|
|
&fixture.resource_id,
|
|
&fixture.updated_at,
|
|
StatusCode::BAD_REQUEST,
|
|
"AT-3.7-02 refusal has no side effects",
|
|
)
|
|
.await;
|
|
|
|
// Существующий PUT-контракт после отказа продолжает работать: precondition карточки
|
|
// не сдвинулся, обычное редактирование принимается и возвращает состояние Draft.
|
|
let updated = update_draft_expect_success(
|
|
&client,
|
|
&server,
|
|
&fixture.resource_id,
|
|
&json!({
|
|
"description": "правка после отказа",
|
|
"mime_type": "text/plain",
|
|
"sensitivity": "public",
|
|
"expected_updated_at": fixture.updated_at,
|
|
}),
|
|
b"second body",
|
|
"story37-refusal-update.txt",
|
|
"text/plain",
|
|
)
|
|
.await;
|
|
assert_eq!(updated["version"]["version"], json!(2));
|
|
assert_eq!(updated["version"]["mime_type"], json!("text/plain"));
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// F2/F3/F1 (TL CODE-REVIEW): семантические raw credentials, реальные
|
|
// placeholders и безопасная инспекция malformed содержимого
|
|
// ---------------------------------------------------------------------------
|
|
|
|
/// F2: JSON-credential распознаётся независимо от позиции ключа и от JSON-экранирования;
|
|
/// отказ — тот же generic 422 `field=content` без новых строк публикации/source.
|
|
#[tokio::test(flavor = "multi_thread")]
|
|
#[serial]
|
|
async fn story37_at02_json_credentials_are_detected_semantically() {
|
|
let (registry, server, client) = spawn_authorized("story37_secret_json").await;
|
|
|
|
for (uri, name, content) in [
|
|
(
|
|
"crank://story37/json-later-key",
|
|
"json_later_key",
|
|
br#"{"name":"config","password":"synthetic-password-42"}"#.as_slice(),
|
|
),
|
|
(
|
|
"crank://story37/json-escaped-key",
|
|
"json_escaped_key",
|
|
br#"{"pass\u0077ord":"synthetic-password-42"}"#.as_slice(),
|
|
),
|
|
] {
|
|
let fixture = create_fixture(
|
|
&client,
|
|
&server,
|
|
&draft_metadata(uri, name, "json", "application/json", "internal"),
|
|
content,
|
|
"story37-secret.json",
|
|
"application/json",
|
|
)
|
|
.await;
|
|
// Счётчики берутся после создания Draft: сам Draft владеет одной active-ссылкой.
|
|
let publications_before = table_row_count(registry.pool(), "resource_publications").await;
|
|
let sources_before = table_row_count(registry.pool(), "artifact_sources").await;
|
|
|
|
let refusal = publish_expect_refusal(
|
|
&client,
|
|
&server,
|
|
&fixture.resource_id,
|
|
&fixture.updated_at,
|
|
StatusCode::UNPROCESSABLE_ENTITY,
|
|
"AT-3.7-02 JSON raw credential refusal",
|
|
)
|
|
.await;
|
|
assert_eq!(refusal["error"]["code"], json!("resource_secret_findings"));
|
|
assert_eq!(refusal["error"]["context"]["field"], json!("content"));
|
|
assert!(
|
|
!refusal.to_string().contains("synthetic-password-42"),
|
|
"the refusal must not echo the credential: {refusal}"
|
|
);
|
|
assert_eq!(
|
|
table_row_count(registry.pool(), "resource_publications").await,
|
|
publications_before,
|
|
"a refused JSON credential must not insert a publication row ({content:?})"
|
|
);
|
|
assert_eq!(
|
|
table_row_count(registry.pool(), "artifact_sources").await,
|
|
sources_before,
|
|
"a refused JSON credential must not insert an owning source ({content:?})"
|
|
);
|
|
}
|
|
}
|
|
|
|
/// F2: обычные text-assignment формы (bare `token`, произвольный размер значения) и
|
|
/// Bearer без цифр — те же raw credentials; ни одна не публикуется.
|
|
#[tokio::test(flavor = "multi_thread")]
|
|
#[serial]
|
|
async fn story37_at02_text_assignments_and_digit_free_bearer_are_refused() {
|
|
let (registry, server, client) = spawn_authorized("story37_secret_assignments").await;
|
|
|
|
for (index, content) in [
|
|
"token = synthetic-value-42\n",
|
|
"password = abc123\n",
|
|
"Bearer abcdefghijklmnopqrstuvwx\n",
|
|
]
|
|
.into_iter()
|
|
.enumerate()
|
|
{
|
|
let uri = format!("crank://story37/assignment-{index}");
|
|
let name = format!("assignment_{index}");
|
|
let fixture = create_fixture(
|
|
&client,
|
|
&server,
|
|
&draft_metadata(&uri, &name, "text", "text/plain", "internal"),
|
|
content.as_bytes(),
|
|
"story37-assignment.txt",
|
|
"text/plain",
|
|
)
|
|
.await;
|
|
// Счётчики берутся после создания Draft: сам Draft владеет одной active-ссылкой.
|
|
let publications_before = table_row_count(registry.pool(), "resource_publications").await;
|
|
let sources_before = table_row_count(registry.pool(), "artifact_sources").await;
|
|
|
|
let refusal = publish_expect_refusal(
|
|
&client,
|
|
&server,
|
|
&fixture.resource_id,
|
|
&fixture.updated_at,
|
|
StatusCode::UNPROCESSABLE_ENTITY,
|
|
"AT-3.7-02 text raw credential refusal",
|
|
)
|
|
.await;
|
|
assert_eq!(refusal["error"]["code"], json!("resource_secret_findings"));
|
|
assert_eq!(refusal["error"]["context"]["field"], json!("content"));
|
|
assert_eq!(
|
|
table_row_count(registry.pool(), "resource_publications").await,
|
|
publications_before,
|
|
"a refused raw credential must not insert a publication row ({content:?})"
|
|
);
|
|
assert_eq!(
|
|
table_row_count(registry.pool(), "artifact_sources").await,
|
|
sources_before,
|
|
"a refused raw credential must not insert an owning source ({content:?})"
|
|
);
|
|
}
|
|
}
|
|
|
|
/// F3: полная заглушка в реальной assignment-форме (`Authorization: Bearer ***`)
|
|
/// публикуется; положительный контроль — настоящий синтетический token по-прежнему
|
|
/// блокируется (`story37_at02_text_assignments_and_digit_free_bearer_are_refused`).
|
|
#[tokio::test(flavor = "multi_thread")]
|
|
#[serial]
|
|
async fn story37_at02_authorization_placeholder_is_publishable() {
|
|
let (_registry, server, client) = spawn_authorized("story37_secret_placeholder").await;
|
|
|
|
let fixture = create_fixture(
|
|
&client,
|
|
&server,
|
|
&draft_metadata(
|
|
"crank://story37/auth-placeholder",
|
|
"auth_placeholder",
|
|
"text",
|
|
"text/plain",
|
|
"internal",
|
|
),
|
|
b"Authorization: Bearer ***\n",
|
|
"story37-auth-placeholder.txt",
|
|
"text/plain",
|
|
)
|
|
.await;
|
|
let (status, text, body) =
|
|
super::publish(&client, &server, &fixture.resource_id, &fixture.updated_at).await;
|
|
assert_eq!(
|
|
status,
|
|
StatusCode::OK,
|
|
"a documented placeholder must stay publishable; observed {} body={text}",
|
|
super::super::helpers::error_signature(status, &body)
|
|
);
|
|
assert_eq!(super::published_metadata(&body)["version"], json!(1));
|
|
}
|
|
|
|
/// F1: malformed PEM-подобный префикс с многобайтовыми символами — обычный bounded
|
|
/// ответ (публикация проходит как обычный текст), а не паника/обрыв соединения.
|
|
#[tokio::test(flavor = "multi_thread")]
|
|
#[serial]
|
|
async fn story37_at02_malformed_key_prefix_is_a_normal_bounded_response() {
|
|
let (_registry, server, client) = spawn_authorized("story37_secret_malformed").await;
|
|
|
|
let content = format!("-----BEGIN a{}", "я".repeat(60));
|
|
let fixture = create_fixture(
|
|
&client,
|
|
&server,
|
|
&draft_metadata(
|
|
"crank://story37/malformed-key",
|
|
"malformed_key",
|
|
"text",
|
|
"text/plain",
|
|
"internal",
|
|
),
|
|
content.as_bytes(),
|
|
"story37-malformed-key.txt",
|
|
"text/plain",
|
|
)
|
|
.await;
|
|
let (status, text, body) =
|
|
super::publish(&client, &server, &fixture.resource_id, &fixture.updated_at).await;
|
|
assert_eq!(
|
|
status,
|
|
StatusCode::OK,
|
|
"a malformed non-key prefix must produce a normal bounded response; observed {} body={text}",
|
|
super::super::helpers::error_signature(status, &body)
|
|
);
|
|
assert_eq!(super::published_metadata(&body)["version"], json!(1));
|
|
}
|