auth::basic_auth_policy policy;

const http::outcome created = auth::basic_auth_policy::create(

"transcript", "alice", "wonderland", policy);

if (!created.ok()) return policy;

return policy;

http::request_head head;

head.raw_target = "/secret";

head.route_path = "/secret";

head.request_method = http::method::known(http::method_id::get);

head.request_protocol = http::protocol::http_1_1;

head.head_fields.append("Host", "127.0.0.1");

for (const parity::send_segment& segment : c.sends) {

std::string_view line(segment.bytes);

constexpr std::string_view k_field = "Authorization: ";

if (line.rfind(k_field, 0) != 0) continue;

line.remove_prefix(k_field.size());

while (!line.empty() && (line.back() == '\r' || line.back() == '\n')) {

line.remove_suffix(1);

}

head.head_fields.append("Authorization", line);

}

return head;

fields.append("Content-Type", "text/plain");

fields.append("Content-Length", "9");

body = "secret-ok";

const parity::transcript t = parity::parse_transcript_file(

std::string(PARITY_TRANSCRIPT_DIR "/auth_basic.tseq"));

const parity::tcase* found = nullptr;

for (const parity::tcase& c : t.cases) {

if (c.name == case_name) found = &c;

}

if (found == nullptr) {

return "case not found: " + std::string(case_name);

}

const auth::basic_auth_policy policy = transcript_policy();

const auth::basic_auth_verdict verdict = policy.check(case_request(*found));

std::uint16_t status = 200;

http::fields fields;

std::string body;

if (verdict.allowed()) {

secret_response(fields, body);

} else {

status = verdict.challenge_status().code();

fields = verdict.challenge_fields();

}

http1_response_framer framer;

std::string wire;

const http::request_head& request = case_request(*found);

const http::outcome head_out = framer.start_head(

wire, request, http::status::from_code(status), fields);

if (!head_out.ok()) return "start_head: " + head_out.message();

if (!body.empty()) {

const http::outcome pushed =

framer.push_body(wire, as_bytes(body), unlimited);

if (!pushed.ok()) return "push_body: " + pushed.message();

}

const http::outcome ended = framer.finish_body(wire, http::fields());

if (!ended.ok()) return "finish_body: " + ended.message();

response_frame_parser parser;

std::vector<observed_response> responses = parser.feed(wire);

for (observed_response& r : parser.finish()) {

responses.push_back(std::move(r));

}

if (parser.failed()) return "parser: " + parser.error();

if (responses.size() != 1) {

return "expected one parsed response, got "

+ std::to_string(responses.size());

}

const std::vector<parity::normalized_exchange> exchanges{

parity::normalize(responses.front())};

const http1_response_mode mode = http1_response_mode::compute(

request, http::status::from_code(status), fields);

const http1_keepalive verdict_keepalive =

httpserver::detail::http1_response_keepalive(

request, mode.kind, mode.close_policy);

std::size_t index = 0;

bool first = true;

for (const parity::expectation& e : found->expects) {

const bool advances = e.kind == parity::expect_kind::status

|| e.kind == parity::expect_kind::status_line;

if (advances && !first) ++index;

if (advances) first = false;

if (e.kind == parity::expect_kind::connection) {

const bool want_keep = e.value != "close";

const bool got_keep =

verdict_keepalive == http1_keepalive::keep_alive;

if (want_keep != got_keep) {

return "expect-line=" + std::to_string(e.line)

+ ": connection " + e.value + " vs keepalive verdict";

}

continue;

}

if (e.kind == parity::expect_kind::closer) continue;

if (index >= exchanges.size()) return "cursor past observed";

const parity::match_result m = parity::check_expectation(

e, exchanges[index], PARITY_TRANSCRIPT_DIR);

if (!m.ok) return m.diff;

}

return "";

if (!diff.empty()) {

std::cerr << "[replay " << what << "] " << diff << "\n";

}