wehub-resource-sync
bf9395e022
CI / license-header (push) Has been skipped
CI / e2e-dry-run (push) Has been skipped
CI / fast-gate (push) Failing after 0s
Test PR Label Logic / test-pr-labels (push) Failing after 1s
Skill Format Check / check-format (push) Failing after 2s
CI / security (push) Failing after 5s
CI / unit-test (push) Has been skipped
CI / lint (push) Has been skipped
CI / script-test (push) Has been skipped
CI / deterministic-gate (push) Has been skipped
CI / coverage (push) Has been skipped
CI / results (push) Has been cancelled
CI / deadcode (push) Has been cancelled
CI / e2e-live (push) Has been cancelled
469 lines
14 KiB
Go
469 lines
14 KiB
Go
// Copyright (c) 2026 Lark Technologies Pte. Ltd.
|
|
// SPDX-License-Identifier: MIT
|
|
|
|
package vc
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"reflect"
|
|
"strings"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/larksuite/cli/internal/event"
|
|
)
|
|
|
|
func TestVCKeys_RecordingEventsRegistered(t *testing.T) {
|
|
t.Setenv("LARKSUITE_CLI_CONFIG_DIR", t.TempDir())
|
|
|
|
for _, tc := range []struct {
|
|
eventType string
|
|
}{
|
|
{eventTypeRecordingStarted},
|
|
{eventTypeRecordingTranscriptGenerated},
|
|
{eventTypeRecordingEnded},
|
|
} {
|
|
t.Run(tc.eventType, func(t *testing.T) {
|
|
def, ok := event.Lookup(tc.eventType)
|
|
if !ok {
|
|
t.Fatalf("%s should be registered via Keys()", tc.eventType)
|
|
}
|
|
if def.Schema.Custom == nil {
|
|
t.Error("Processed key must set Schema.Custom")
|
|
}
|
|
if def.Schema.Native != nil {
|
|
t.Error("Processed key must not set Schema.Native")
|
|
}
|
|
if def.Process == nil {
|
|
t.Error("Process must not be nil for processed key")
|
|
}
|
|
if def.PreConsume == nil {
|
|
t.Error("PreConsume must not be nil for processed key")
|
|
}
|
|
if len(def.Scopes) != 1 || def.Scopes[0] != "vc:recording:read" {
|
|
t.Errorf("Scopes = %v", def.Scopes)
|
|
}
|
|
if len(def.AuthTypes) != 1 || def.AuthTypes[0] != "user" {
|
|
t.Errorf("AuthTypes = %v", def.AuthTypes)
|
|
}
|
|
if len(def.RequiredConsoleEvents) != 1 || def.RequiredConsoleEvents[0] != tc.eventType {
|
|
t.Errorf("RequiredConsoleEvents = %v", def.RequiredConsoleEvents)
|
|
}
|
|
if !strings.Contains(def.Description, "recording_bean") {
|
|
t.Errorf("Description should document recording_bean source, got %q", def.Description)
|
|
}
|
|
if !strings.Contains(def.Description, "connected to Feishu software") {
|
|
t.Errorf("Description should document Feishu software connection requirement, got %q", def.Description)
|
|
}
|
|
if strings.Contains(def.Description, "future") || strings.Contains(def.Description, "software_recording") {
|
|
t.Errorf("Description should not mention future sources, got %q", def.Description)
|
|
}
|
|
if tc.eventType == eventTypeRecordingEnded && (strings.Contains(def.Description, "object_type") || strings.Contains(def.Description, "object_id")) {
|
|
t.Errorf("ended Description should not document object metadata, got %q", def.Description)
|
|
}
|
|
wantSchemaType := reflect.TypeOf(VCRecordingStartedOutput{})
|
|
switch tc.eventType {
|
|
case eventTypeRecordingTranscriptGenerated:
|
|
wantSchemaType = reflect.TypeOf(VCRecordingTranscriptGeneratedOutput{})
|
|
case eventTypeRecordingEnded:
|
|
wantSchemaType = reflect.TypeOf(VCRecordingEndedOutput{})
|
|
}
|
|
if def.Schema.Custom.Type != wantSchemaType {
|
|
t.Errorf("Custom schema Type = %v, want %v", def.Schema.Custom.Type, wantSchemaType)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestProcessVCRecordingStarted(t *testing.T) {
|
|
t.Setenv("LARKSUITE_CLI_CONFIG_DIR", t.TempDir())
|
|
|
|
out := runRecordingProcess[VCRecordingStartedOutput](t, eventTypeRecordingStarted, processVCRecordingStarted, `{
|
|
"schema": "2.0",
|
|
"header": {
|
|
"event_id": "ev_rec_start_001",
|
|
"event_type": "vc.recording.recording_started_v1",
|
|
"create_time": "1761782400000"
|
|
},
|
|
"event": {
|
|
"unique_key": "recording_001",
|
|
"source": "recording_bean"
|
|
}
|
|
}`)
|
|
|
|
if out.Type != eventTypeRecordingStarted {
|
|
t.Errorf("Type = %q", out.Type)
|
|
}
|
|
if out.EventID != "ev_rec_start_001" || out.EventTime != recordingTestEventTime(1761782400000) {
|
|
t.Errorf("EventID/EventTime = %q/%q", out.EventID, out.EventTime)
|
|
}
|
|
if out.UniqueKey != "recording_001" || out.Source != "recording_bean" {
|
|
t.Errorf("UniqueKey/Source = %q/%q", out.UniqueKey, out.Source)
|
|
}
|
|
}
|
|
|
|
func TestProcessVCRecordingTranscriptGenerated(t *testing.T) {
|
|
t.Setenv("LARKSUITE_CLI_CONFIG_DIR", t.TempDir())
|
|
|
|
got := runRecordingProcessRaw(t, eventTypeRecordingTranscriptGenerated, processVCRecordingTranscriptGenerated, `{
|
|
"schema": "2.0",
|
|
"header": {
|
|
"event_id": "ev_rec_transcript_001",
|
|
"event_type": "vc.recording.recording_transcript_generated_v1",
|
|
"create_time": "1761782400100"
|
|
},
|
|
"event": {
|
|
"unique_key": "recording_001",
|
|
"source": "recording_bean",
|
|
"transcript_items": [
|
|
{
|
|
"speaker": {
|
|
"id": {
|
|
"open_id": "ou_0f8bf7acdf2ae69553ecbdbfbbd10a53",
|
|
"union_id": "on_bc03f16d781bff4178a5d11e48eb1867",
|
|
"user_id": null
|
|
},
|
|
"user_type": 100,
|
|
"user_role": 1,
|
|
"user_name": "Alice"
|
|
},
|
|
"text": "hello world",
|
|
"language": "en_us",
|
|
"start_time_ms": "1761782399000",
|
|
"end_time_ms": "1761782400000",
|
|
"sentence_id": "987654321"
|
|
},
|
|
{
|
|
"speaker": {
|
|
"user_name": "Bob"
|
|
},
|
|
"text": "second sentence",
|
|
"language": "en_us",
|
|
"start_time_ms": "1761782401000",
|
|
"end_time_ms": "1761782402000",
|
|
"sentence_id": "987654322"
|
|
}
|
|
]
|
|
}
|
|
}`)
|
|
if got == nil {
|
|
t.Fatal("Process output is nil")
|
|
}
|
|
var out VCRecordingTranscriptGeneratedOutput
|
|
if err := json.Unmarshal(got, &out); err != nil {
|
|
t.Fatalf("Process output is not valid JSON: %v\nraw=%s", err, string(got))
|
|
}
|
|
|
|
if out.Type != eventTypeRecordingTranscriptGenerated {
|
|
t.Errorf("Type = %q", out.Type)
|
|
}
|
|
if out.UniqueKey != "recording_001" || out.Source != "recording_bean" {
|
|
t.Errorf("UniqueKey/Source = %q/%q", out.UniqueKey, out.Source)
|
|
}
|
|
if out.EventTime != recordingTestEventTime(1761782400100) {
|
|
t.Errorf("EventTime = %q", out.EventTime)
|
|
}
|
|
if len(out.TranscriptItems) != 2 {
|
|
t.Fatalf("TranscriptItems len = %d, want 2", len(out.TranscriptItems))
|
|
}
|
|
item := out.TranscriptItems[0]
|
|
if item.SpeakerName != "Alice" || item.Text != "hello world" {
|
|
t.Errorf("Transcript speaker/text = %q/%q", item.SpeakerName, item.Text)
|
|
}
|
|
if item.StartTime != recordingTestEventTime(1761782399000) || item.EndTime != recordingTestEventTime(1761782400000) {
|
|
t.Errorf("Transcript timing = %q/%q", item.StartTime, item.EndTime)
|
|
}
|
|
if item.SentenceID != "987654321" {
|
|
t.Errorf("SentenceID = %q, want 987654321", item.SentenceID)
|
|
}
|
|
if out.TranscriptItems[1].SpeakerName != "Bob" || out.TranscriptItems[1].SentenceID != "987654322" {
|
|
t.Errorf("second transcript item = %+v", out.TranscriptItems[1])
|
|
}
|
|
itemJSON, err := json.Marshal(item)
|
|
if err != nil {
|
|
t.Fatalf("marshal transcript item: %v", err)
|
|
}
|
|
var itemFields map[string]any
|
|
if err := json.Unmarshal(itemJSON, &itemFields); err != nil {
|
|
t.Fatalf("unmarshal transcript item JSON: %v", err)
|
|
}
|
|
wantItemFields := map[string]bool{
|
|
"speaker_name": true,
|
|
"text": true,
|
|
"start_time": true,
|
|
"end_time": true,
|
|
"sentence_id": true,
|
|
}
|
|
for gotField := range itemFields {
|
|
if !wantItemFields[gotField] {
|
|
t.Errorf("Transcript item should not contain field %q, got %s", gotField, string(itemJSON))
|
|
}
|
|
}
|
|
for wantField := range wantItemFields {
|
|
if _, ok := itemFields[wantField]; !ok {
|
|
t.Errorf("Transcript item missing field %q, got %s", wantField, string(itemJSON))
|
|
}
|
|
}
|
|
for _, unexpected := range []string{
|
|
`"seq_id"`,
|
|
`"speaker"`,
|
|
`"user_open_id"`,
|
|
`"user_type"`,
|
|
`"user_role"`,
|
|
`"language"`,
|
|
`"start_time_ms"`,
|
|
`"end_time_ms"`,
|
|
`"sequence_id"`,
|
|
`"transcript_item"`,
|
|
} {
|
|
if strings.Contains(string(got), unexpected) {
|
|
t.Errorf("Transcript output should not contain %s, got %s", unexpected, string(got))
|
|
}
|
|
}
|
|
if !strings.Contains(string(got), `"sentence_id":"987654321"`) {
|
|
t.Errorf("Transcript output should contain sentence_id, got %s", string(got))
|
|
}
|
|
}
|
|
|
|
func TestProcessVCRecordingEnded(t *testing.T) {
|
|
t.Setenv("LARKSUITE_CLI_CONFIG_DIR", t.TempDir())
|
|
|
|
out := runRecordingProcess[VCRecordingEndedOutput](t, eventTypeRecordingEnded, processVCRecordingEnded, `{
|
|
"schema": "2.0",
|
|
"header": {
|
|
"event_id": "ev_rec_end_001",
|
|
"event_type": "vc.recording.recording_ended_v1",
|
|
"create_time": "1761782400200"
|
|
},
|
|
"event": {
|
|
"unique_key": "recording_001",
|
|
"source": "recording_bean",
|
|
"object_type": "minutes",
|
|
"object_id": "minute_token_001"
|
|
}
|
|
}`)
|
|
|
|
if out.Type != eventTypeRecordingEnded {
|
|
t.Errorf("Type = %q", out.Type)
|
|
}
|
|
if out.UniqueKey != "recording_001" || out.Source != "recording_bean" {
|
|
t.Errorf("UniqueKey/Source = %q/%q", out.UniqueKey, out.Source)
|
|
}
|
|
if out.EventTime != recordingTestEventTime(1761782400200) {
|
|
t.Errorf("EventTime = %q", out.EventTime)
|
|
}
|
|
}
|
|
|
|
func TestProcessVCRecordingEnded_DropsObjectMetadata(t *testing.T) {
|
|
t.Setenv("LARKSUITE_CLI_CONFIG_DIR", t.TempDir())
|
|
|
|
got := runRecordingProcessRaw(t, eventTypeRecordingEnded, processVCRecordingEnded, `{
|
|
"schema": "2.0",
|
|
"header": {
|
|
"event_id": "ev_rec_end_001",
|
|
"event_type": "vc.recording.recording_ended_v1",
|
|
"create_time": "1761782400200"
|
|
},
|
|
"event": {
|
|
"unique_key": "recording_001",
|
|
"source": "recording_bean",
|
|
"object_type": "minutes",
|
|
"object_id": "minute_token_001"
|
|
}
|
|
}`)
|
|
|
|
if strings.Contains(string(got), "object_type") || strings.Contains(string(got), "object_id") {
|
|
t.Fatalf("ended output should drop object metadata, got %s", string(got))
|
|
}
|
|
}
|
|
|
|
func TestProcessVCRecording_DropsTimestampField(t *testing.T) {
|
|
t.Setenv("LARKSUITE_CLI_CONFIG_DIR", t.TempDir())
|
|
|
|
got := runRecordingProcessRaw(t, eventTypeRecordingStarted, processVCRecordingStarted, `{
|
|
"schema": "2.0",
|
|
"header": {
|
|
"event_id": "ev_rec_start_001",
|
|
"event_type": "vc.recording.recording_started_v1",
|
|
"create_time": "1761782400000"
|
|
},
|
|
"event": {
|
|
"unique_key": "recording_001",
|
|
"source": "recording_bean"
|
|
}
|
|
}`)
|
|
|
|
if strings.Contains(string(got), `"timestamp"`) {
|
|
t.Fatalf("recording output should use event_time instead of timestamp, got %s", string(got))
|
|
}
|
|
if !strings.Contains(string(got), `"event_time":"`+recordingTestEventTime(1761782400000)+`"`) {
|
|
t.Fatalf("recording output should include ISO 8601 event_time, got %s", string(got))
|
|
}
|
|
}
|
|
|
|
func TestProcessVCRecording_NonRecordingBeanFiltered(t *testing.T) {
|
|
t.Setenv("LARKSUITE_CLI_CONFIG_DIR", t.TempDir())
|
|
|
|
for _, tc := range []struct {
|
|
name string
|
|
eventType string
|
|
process event.ProcessFunc
|
|
payload string
|
|
}{
|
|
{
|
|
name: "started",
|
|
eventType: eventTypeRecordingStarted,
|
|
process: processVCRecordingStarted,
|
|
payload: `{
|
|
"schema": "2.0",
|
|
"header": {"event_id": "ev_rec_start_001", "event_type": "vc.recording.recording_started_v1"},
|
|
"event": {"unique_key": "recording_001", "source": "software_recording"}
|
|
}`,
|
|
},
|
|
{
|
|
name: "transcript",
|
|
eventType: eventTypeRecordingTranscriptGenerated,
|
|
process: processVCRecordingTranscriptGenerated,
|
|
payload: `{
|
|
"schema": "2.0",
|
|
"header": {"event_id": "ev_rec_transcript_001", "event_type": "vc.recording.recording_transcript_generated_v1"},
|
|
"event": {"unique_key": "recording_001", "source": "software_recording", "transcript_items": []}
|
|
}`,
|
|
},
|
|
{
|
|
name: "ended",
|
|
eventType: eventTypeRecordingEnded,
|
|
process: processVCRecordingEnded,
|
|
payload: `{
|
|
"schema": "2.0",
|
|
"header": {"event_id": "ev_rec_end_001", "event_type": "vc.recording.recording_ended_v1"},
|
|
"event": {"unique_key": "recording_001", "source": "software_recording"}
|
|
}`,
|
|
},
|
|
} {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
got := runRecordingProcessRaw(t, tc.eventType, tc.process, tc.payload)
|
|
if got != nil {
|
|
t.Fatalf("non-recording_bean event should be filtered, got %s", string(got))
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestProcessVCRecording_MalformedPayloadPassthrough(t *testing.T) {
|
|
t.Setenv("LARKSUITE_CLI_CONFIG_DIR", t.TempDir())
|
|
|
|
for _, tc := range []struct {
|
|
name string
|
|
eventType string
|
|
process event.ProcessFunc
|
|
}{
|
|
{name: "started", eventType: eventTypeRecordingStarted, process: processVCRecordingStarted},
|
|
{name: "transcript", eventType: eventTypeRecordingTranscriptGenerated, process: processVCRecordingTranscriptGenerated},
|
|
{name: "ended", eventType: eventTypeRecordingEnded, process: processVCRecordingEnded},
|
|
} {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
raw := &event.RawEvent{
|
|
EventType: tc.eventType,
|
|
Payload: json.RawMessage(`not json`),
|
|
Timestamp: time.Now(),
|
|
}
|
|
got, err := tc.process(context.Background(), nil, raw, nil)
|
|
if err != nil {
|
|
t.Fatalf("Process should swallow parse errors, got %v", err)
|
|
}
|
|
if string(got) != "not json" {
|
|
t.Errorf("malformed fallback output = %q, want original bytes", string(got))
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestVCRecording_PreConsumeSubscriptionLifecycle(t *testing.T) {
|
|
t.Setenv("LARKSUITE_CLI_CONFIG_DIR", t.TempDir())
|
|
|
|
for _, tc := range []struct {
|
|
eventType string
|
|
}{
|
|
{eventTypeRecordingStarted},
|
|
{eventTypeRecordingTranscriptGenerated},
|
|
{eventTypeRecordingEnded},
|
|
} {
|
|
t.Run(tc.eventType, func(t *testing.T) {
|
|
def, ok := event.Lookup(tc.eventType)
|
|
if !ok {
|
|
t.Fatalf("%s should be registered via Keys()", tc.eventType)
|
|
}
|
|
|
|
type call struct {
|
|
method string
|
|
path string
|
|
body any
|
|
}
|
|
var calls []call
|
|
rt := &stubAPIClient{
|
|
callFn: func(_ context.Context, method, path string, body any) (json.RawMessage, error) {
|
|
calls = append(calls, call{method: method, path: path, body: body})
|
|
return json.RawMessage(`{"code":0,"msg":"success","data":{}}`), nil
|
|
},
|
|
}
|
|
|
|
cleanup, err := def.PreConsume(context.Background(), rt, nil)
|
|
if err != nil {
|
|
t.Fatalf("PreConsume error: %v", err)
|
|
}
|
|
if cleanup == nil {
|
|
t.Fatal("cleanup must not be nil")
|
|
}
|
|
if len(calls) != 1 {
|
|
t.Fatalf("calls after subscribe = %d, want 1", len(calls))
|
|
}
|
|
if calls[0].method != "POST" || calls[0].path != pathRecordingSubscribe {
|
|
t.Fatalf("subscribe call = %+v", calls[0])
|
|
}
|
|
assertSubscriptionRequest(t, calls[0].body, tc.eventType)
|
|
|
|
cleanup()
|
|
if len(calls) != 2 {
|
|
t.Fatalf("calls after cleanup = %d, want 2", len(calls))
|
|
}
|
|
if calls[1].method != "POST" || calls[1].path != pathRecordingUnsubscribe {
|
|
t.Fatalf("unsubscribe call = %+v", calls[1])
|
|
}
|
|
assertSubscriptionRequest(t, calls[1].body, tc.eventType)
|
|
})
|
|
}
|
|
}
|
|
|
|
func runRecordingProcess[T any](t *testing.T, eventType string, process event.ProcessFunc, payload string) T {
|
|
t.Helper()
|
|
got := runRecordingProcessRaw(t, eventType, process, payload)
|
|
if got == nil {
|
|
t.Fatal("Process output is nil")
|
|
}
|
|
var out T
|
|
if err := json.Unmarshal(got, &out); err != nil {
|
|
t.Fatalf("Process output is not valid JSON: %v\nraw=%s", err, string(got))
|
|
}
|
|
return out
|
|
}
|
|
|
|
func runRecordingProcessRaw(t *testing.T, eventType string, process event.ProcessFunc, payload string) json.RawMessage {
|
|
t.Helper()
|
|
raw := &event.RawEvent{
|
|
EventType: eventType,
|
|
Payload: json.RawMessage(payload),
|
|
Timestamp: time.Now(),
|
|
}
|
|
got, err := process(context.Background(), nil, raw, nil)
|
|
if err != nil {
|
|
t.Fatalf("Process error: %v", err)
|
|
}
|
|
return got
|
|
}
|
|
|
|
func recordingTestEventTime(millis int64) string {
|
|
return time.UnixMilli(millis).Local().Format(time.RFC3339)
|
|
}
|