Files
audita/internal/core/outputschema/registry_test.go

116 lines
3.3 KiB
Go

package outputschema
import (
"encoding/json"
"math"
"reflect"
"strconv"
"strings"
"testing"
"gitea.maximumdirect.net/eric/audita/v3/internal/core/schema"
)
func tinyTranscript() *schema.Transcript {
return &schema.Transcript{Segments: []schema.Segment{
{ID: 1, Speaker: "A", Start: 0, End: 1, Text: "hello"},
}}
}
func TestResolveBareSegments(t *testing.T) {
def, err := Resolve(SchemaBareSegments)
if err != nil {
t.Fatalf("Resolve error: %v", err)
}
raw, err := def.Encoder(tinyTranscript())
if err != nil {
t.Fatalf("encode error: %v", err)
}
if !strings.HasPrefix(strings.TrimSpace(string(raw)), "[") {
t.Fatalf("expected bare-segments array output, got %s", string(raw))
}
}
func TestResolveAuditaV1(t *testing.T) {
def, err := Resolve(SchemaAuditaV1)
if err != nil {
t.Fatalf("Resolve error: %v", err)
}
raw, err := def.Encoder(tinyTranscript())
if err != nil {
t.Fatalf("encode error: %v", err)
}
var out struct {
Schema string `json:"schema"`
Version string `json:"version"`
Segments []map[string]any `json:"segments"`
}
if err := json.Unmarshal(raw, &out); err != nil {
t.Fatalf("unmarshal error: %v", err)
}
if out.Schema != "audita-v1" || out.Version != "v1" || len(out.Segments) != 1 {
t.Fatalf("unexpected audita-v1 output: %+v", out)
}
}
func TestResolveUnknown(t *testing.T) {
_, err := Resolve("seriatim-intermediate")
if err == nil || !strings.Contains(err.Error(), "unsupported output schema") {
t.Fatalf("expected unsupported output schema error, got %v", err)
}
}
func TestSupportedKeysAndIsSupported(t *testing.T) {
want := []string{SchemaBareSegments, SchemaAuditaV1}
if got := SupportedKeys(); !reflect.DeepEqual(got, want) {
t.Fatalf("unexpected supported schema keys: got=%v want=%v", got, want)
}
for _, key := range want {
if !IsSupported(key) {
t.Fatalf("expected schema key %q to be supported", key)
}
}
if IsSupported("seriatim-intermediate") {
t.Fatalf("did not expect unsupported schema to be reported as supported")
}
}
func TestEncodersPreserveSegmentValues(t *testing.T) {
id := 5
if strconv.IntSize == 64 {
id, _ = strconv.Atoi("9007199254740993")
}
input := &schema.Transcript{Segments: []schema.Segment{
{ID: id, Speaker: "A", Start: 0.25, End: 2.75, Text: "first", Categories: []string{"one", "two"}},
{ID: 6, Speaker: "B", Start: 3, End: 5, Text: "second", Categories: []string{}},
}}
for _, key := range []string{SchemaBareSegments, SchemaAuditaV1} {
t.Run(key, func(t *testing.T) {
definition, err := Resolve(key)
if err != nil {
t.Fatal(err)
}
payload, err := definition.Encoder(input)
if err != nil {
t.Fatal(err)
}
decoded, err := schema.ParseSourceTranscriptJSON(payload)
if err != nil {
t.Fatal(err)
}
want := []schema.Segment{
{ID: id, Speaker: "A", Start: 0.25, End: 2.75, Text: "first", Categories: []string{"one", "two"}},
{ID: 6, Speaker: "B", Start: 3, End: 5, Text: "second"},
}
if got := decoded.Canonical().Segments; !reflect.DeepEqual(got, want) {
t.Fatalf("decoded %s: %+v", key, got)
}
invalid := &schema.Transcript{Segments: []schema.Segment{{Start: math.NaN()}}}
if _, err := definition.Encoder(invalid); err == nil {
t.Fatal("nonfinite timestamp encoded successfully")
}
})
}
}