🥮 mooncakes.io

    jhshuai/moontestledger/ledger does not have a README file

    InputError

    source
    pub(all) suberror InputError {
      Invalid(Diagnostic)
    } derive(
    Debug    )

    AttemptRecord

    source
    pub(all) struct AttemptRecord {
      report_id : String
      attempt : Int
      observation : ObservedCase
    } derive(Eq, 
    Debug    )

    AttemptRecord::equal

    source

    AttemptRecord::not_equal

    source
    fn AttemptRecord::not_equal(x : AttemptRecord, y : AttemptRecord) -> Bool

    AttemptRecord::to_repr

    source

    CaseKey

    source
    pub(all) struct CaseKey {
      classname : String
      name : String
    } derive(Compare, Eq, Hash, 
    Debug    )

    Exact producer identity. Parameterized names are not normalized.

    CaseKey::compare

    source
    fn CaseKey::compare(CaseKey, CaseKey) -> Int

    CaseKey::equal

    source
    fn CaseKey::equal(CaseKey, CaseKey) -> Bool

    CaseKey::hash

    source
    fn CaseKey::hash(self : CaseKey) -> Int

    CaseKey::hash_combine

    source
    fn CaseKey::hash_combine(CaseKey, Hasher) -> Unit

    CaseKey::not_equal

    source
    fn CaseKey::not_equal(x : CaseKey, y : CaseKey) -> Bool

    CaseKey::op_ge

    source
    fn CaseKey::op_ge(x : CaseKey, y : CaseKey) -> Bool

    CaseKey::op_gt

    source
    fn CaseKey::op_gt(x : CaseKey, y : CaseKey) -> Bool

    CaseKey::op_le

    source
    fn CaseKey::op_le(x : CaseKey, y : CaseKey) -> Bool

    CaseKey::op_lt

    source
    fn CaseKey::op_lt(x : CaseKey, y : CaseKey) -> Bool

    CaseKey::to_repr

    source

    CaseSummary

    source
    pub(all) struct CaseSummary {
      environment : String
      shard : String
      key : CaseKey
      verdict : Verdict
      attempts : Array[AttemptRecord]
    } derive(Eq, 
    Debug    )

    CaseSummary::equal

    source
    fn CaseSummary::equal(CaseSummary, CaseSummary) -> Bool

    CaseSummary::not_equal

    source
    fn CaseSummary::not_equal(x : CaseSummary, y : CaseSummary) -> Bool

    CaseSummary::to_repr

    source

    Diagnostic

    source
    pub(all) struct Diagnostic {
      code : String
      report_id : String
      path : String
      message : String
      line : Int
      column : Int
    } derive(Eq, 
    Debug    )

    Diagnostic::equal

    source
    fn Diagnostic::equal(Diagnostic, Diagnostic) -> Bool

    Diagnostic::not_equal

    source
    fn Diagnostic::not_equal(x : Diagnostic, y : Diagnostic) -> Bool

    Diagnostic::to_repr

    source

    Document

    source
    pub(all) struct Document {
      binding : ReportBinding
      report : ParsedReport
    } derive(Eq, 
    Debug    )

    Document::equal

    source
    fn Document::equal(Document, Document) -> Bool

    Document::not_equal

    source
    fn Document::not_equal(x : Document, y : Document) -> Bool

    Document::to_repr

    source

    ExpectedReport

    source
    pub(all) struct ExpectedReport {
      id : String
      environment : String
      shard : String
      attempt : Int
      cases : Array[CaseKey]
    } derive(Eq, 
    Debug    )

    ExpectedReport::equal

    source

    ExpectedReport::not_equal

    source
    fn ExpectedReport::not_equal(x : ExpectedReport, y : ExpectedReport) -> Bool

    ExpectedReport::to_repr

    source

    Ledger

    source
    type Ledger

    Accepted documents are immutable snapshots. A conflicting re-import cannot replace earlier evidence, and rejected input leaves this ledger unchanged.

    Ledger::ingest

    source
    fn Ledger::ingest(self : Ledger, document : Document) -> Unit raise InputError

    Ledger::new

    source
    fn Ledger::new(plan : RunPlan, limits? : Limits) -> Ledger raise InputError

    Ledger::snapshot

    source
    fn Ledger::snapshot(self : Ledger) -> Snapshot

    Export a fresh snapshot, ordered by the plan. Mutating its arrays cannot alter the ledger; absent expected reports remain absent in the document list.

    Ledger::source

    source
    fn Ledger::source(self : Ledger, report_id : String) -> String?

    Ledger::summary

    source
    fn Ledger::summary(self : Ledger) -> Summary

    Return a fresh evidence snapshot in canonical environment/shard/identity order, regardless of the order documents were ingested.

    Limits

    source
    pub(all) struct Limits {
      max_reports : Int
      max_cases : Int
      max_source_units : Int
      max_total_source_units : Int
      max_events : Int
      max_depth : Int
      max_attributes : Int
      max_problems : Int
    } derive(Eq, 
    Debug    )

    Limits::default

    source
    fn Limits::default() -> Limits

    Limits::equal

    source
    fn Limits::equal(Limits, Limits) -> Bool

    Limits::not_equal

    source
    fn Limits::not_equal(x : Limits, y : Limits) -> Bool

    Limits::to_repr

    source

    Limits::validate

    source
    fn Limits::validate(self : Limits) -> Unit raise InputError

    Validate budgets before allocating or accepting data. Upper bounds keep counter arithmetic and retained-source allocation explicitly bounded.

    MissingCase

    source
    pub(all) struct MissingCase {
      report_id : String
      key : CaseKey
    } derive(Eq, 
    Debug    )

    MissingCase::equal

    source
    fn MissingCase::equal(MissingCase, MissingCase) -> Bool

    MissingCase::not_equal

    source
    fn MissingCase::not_equal(x : MissingCase, y : MissingCase) -> Bool

    MissingCase::to_repr

    source

    ObservedCase

    source
    pub(all) struct ObservedCase {
      key : CaseKey
      outcome : Outcome
      problems : Array[Problem]
      skipped_reason : String?
      path : String
      line : Int
      column : Int
    } derive(Eq, 
    Debug    )

    ObservedCase::equal

    source

    ObservedCase::not_equal

    source
    fn ObservedCase::not_equal(x : ObservedCase, y : ObservedCase) -> Bool

    ObservedCase::to_repr

    source

    Outcome

    source
    pub(all) enum Outcome {
      Pass
      Failure
      Error
      Skip
    } derive(Eq, 
    Debug    )

    Outcome::equal

    source
    fn Outcome::equal(Outcome, Outcome) -> Bool

    Outcome::not_equal

    source
    fn Outcome::not_equal(x : Outcome, y : Outcome) -> Bool

    Outcome::to_repr

    source

    ParsedReport

    source
    pub(all) struct ParsedReport {
      source : String
      cases : Array[ObservedCase]
    } derive(Eq, 
    Debug    )

    The entire input is retained, including inert metadata and output.

    ParsedReport::equal

    source

    ParsedReport::not_equal

    source
    fn ParsedReport::not_equal(x : ParsedReport, y : ParsedReport) -> Bool

    ParsedReport::to_repr

    source

    Problem

    source
    pub(all) struct Problem {
      kind : ProblemKind
      message : String?
      type_name : String?
      text : String
      path : String
      line : Int
      column : Int
    } derive(Eq, 
    Debug    )

    Problem::equal

    source
    fn Problem::equal(Problem, Problem) -> Bool

    Problem::not_equal

    source
    fn Problem::not_equal(x : Problem, y : Problem) -> Bool

    Problem::to_repr

    source

    ProblemKind

    source
    pub(all) enum ProblemKind {
      Failure
      Error
    } derive(Eq, 
    Debug    )

    ProblemKind::equal

    source
    fn ProblemKind::equal(ProblemKind, ProblemKind) -> Bool

    ProblemKind::not_equal

    source
    fn ProblemKind::not_equal(x : ProblemKind, y : ProblemKind) -> Bool

    ProblemKind::to_repr

    source

    ReportBinding

    source
    pub(all) struct ReportBinding {
      id : String
      run_id : String
      revision : String
      environment : String
      shard : String
      attempt : Int
    } derive(Eq, 
    Debug    )

    Metadata supplied by the producer; it is checked against the plan. This is a binding contract, not cryptographic proof of artifact origin.

    ReportBinding::equal

    source

    ReportBinding::not_equal

    source
    fn ReportBinding::not_equal(x : ReportBinding, y : ReportBinding) -> Bool

    ReportBinding::to_repr

    source

    RunPlan

    source
    pub(all) struct RunPlan {
      run_id : String
      revision : String
      reports : Array[ExpectedReport]
    } derive(Eq, 
    Debug    )

    RunPlan::equal

    source
    fn RunPlan::equal(RunPlan, RunPlan) -> Bool

    RunPlan::new

    source
    fn RunPlan::new(run_id : String, revision : String, reports : Array[ExpectedReport], limits? : Limits) -> RunPlan raise InputError

    Construct a canonical inventory. Retry subsets and shard membership are declared, never guessed from file names, timestamps or observed totals.

    RunPlan::not_equal

    source
    fn RunPlan::not_equal(x : RunPlan, y : RunPlan) -> Bool

    RunPlan::to_repr

    source

    Snapshot

    source
    pub(all) struct Snapshot {
      plan : RunPlan
      documents : Array[Document]
    } derive(Eq, 
    Debug    )

    Independent copies of the expected inventory and accepted evidence.

    Snapshot::equal

    source
    fn Snapshot::equal(Snapshot, Snapshot) -> Bool

    Snapshot::not_equal

    source
    fn Snapshot::not_equal(x : Snapshot, y : Snapshot) -> Bool

    Snapshot::to_repr

    source

    Summary

    source
    pub(all) struct Summary {
      run_id : String
      revision : String
      complete : Bool
      cases : Array[CaseSummary]
      missing_reports : Array[String]
      missing_cases : Array[MissingCase]
    } derive(Eq, 
    Debug    )

    Summary::equal

    source
    fn Summary::equal(Summary, Summary) -> Bool

    Summary::exit_code

    source
    fn Summary::exit_code(self : Summary, deny_recovered? : Bool) -> Int

    0: complete passing/skipped/recovered; 1: failed/unresolved or denied recovery; 3: incomplete inventory. Invalid input is reported separately.

    Summary::not_equal

    source
    fn Summary::not_equal(x : Summary, y : Summary) -> Bool

    Summary::to_repr

    source

    Verdict

    source
    pub(all) enum Verdict {
      Passed
      Failed
      Error
      Skipped
      RecoveredOnRetry
      Unresolved
      Incomplete
    } derive(Eq, 
    Debug    )

    Verdict::equal

    source
    fn Verdict::equal(Verdict, Verdict) -> Bool

    Verdict::not_equal

    source
    fn Verdict::not_equal(x : Verdict, y : Verdict) -> Bool

    Verdict::to_repr

    source

    Source Files

    Powered by MoonBit

    Site sourceReport issueModulesSkillsCLIBuild queueStatistics

    © 2026 mooncakes.io