116 lines
3.3 KiB
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")
|
|
}
|
|
})
|
|
}
|
|
}
|