dingtalk-workspace-cli/internal/event/consume/formatter_test.go

// Copyright 2026 Alibaba Group
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

package consume

import (
	"bytes"
	"encoding/json"
	"errors"
	"strings"
	"testing"

	"github.com/DingTalk-Real-AI/dingtalk-workspace-cli/internal/event/transport"
)

func sampleEvent() transport.Event {
	return transport.Event{
		Type:              transport.FrameTypeEvent,
		Seq:               42,
		EventID:           "ev_abc",
		EventBornTime:     1700000000123,
		EventType:         "im.message.receive_v1",
		EventCorpID:       "corp_x",
		EventUnifiedAppID: "app_y",
		Data:              `{"message":{"message_id":"om_x","chat_id":"oc_y","content":"hi"},"sender":{"sender_id":{"open_id":"ou_z"}}}`,
		ReceivedAtUnixMS:  1700000000999,
	}
}

func TestNormalizeFormat(t *testing.T) {
	cases := []struct {
		in       string
		want     Format
		fellback bool
	}{
		{"", FormatNDJSON, false},
		{"ndjson", FormatNDJSON, false},
		{"json", FormatJSON, false},
		{"pretty", FormatPretty, false},
		{"raw", FormatRaw, false},
		{"compact", FormatCompact, false},
		{"table", FormatNDJSON, true},
		{"csv", FormatNDJSON, true},
		{"yaml", FormatNDJSON, true}, // typo / unsupported → fallback
	}
	for _, c := range cases {
		got, fb := NormalizeFormat(c.in)
		if got != c.want || fb != c.fellback {
			t.Errorf("NormalizeFormat(%q) = (%s, %v), want (%s, %v)", c.in, got, fb, c.want, c.fellback)
		}
	}
}

func TestNDJSONFormatter_OneLinePerEvent(t *testing.T) {
	f, _ := NewFormatter(FormatNDJSON)
	out, err := f.Render(sampleEvent())
	if err != nil {
		t.Fatal(err)
	}
	if !strings.HasSuffix(string(out), "\n") {
		t.Fatal("ndjson output must end with \\n")
	}
	lines := strings.Split(strings.TrimRight(string(out), "\n"), "\n")
	if len(lines) != 1 {
		t.Fatalf("ndjson must be exactly one line, got %d: %s", len(lines), out)
	}
	// Must be valid JSON
	var ev transport.Event
	if err := json.Unmarshal([]byte(lines[0]), &ev); err != nil {
		t.Fatalf("not valid JSON: %v", err)
	}
	if ev.EventID != "ev_abc" {
		t.Errorf("round-trip lost EventID: %q", ev.EventID)
	}
}

func TestPrettyFormatter_MultilineIndented(t *testing.T) {
	f, _ := NewFormatter(FormatPretty)
	out, err := f.Render(sampleEvent())
	if err != nil {
		t.Fatal(err)
	}
	s := string(out)
	if !strings.Contains(s, "\n  ") {
		t.Fatal("pretty output should have 2-space indentation")
	}
	if !strings.HasSuffix(s, "\n") {
		t.Fatal("pretty output should end with \\n")
	}
	// Strip trailing newline and ensure round-trip works (still valid JSON).
	var ev transport.Event
	if err := json.Unmarshal([]byte(strings.TrimRight(s, "\n")), &ev); err != nil {
		t.Fatalf("pretty not valid JSON: %v", err)
	}
}

func TestRawFormatter_WritesDataVerbatim(t *testing.T) {
	f, _ := NewFormatter(FormatRaw)
	out, err := f.Render(transport.Event{Data: `{"foo":"bar"}`})
	if err != nil {
		t.Fatal(err)
	}
	if string(out) != "{\"foo\":\"bar\"}\n" {
		t.Errorf("raw output = %q", out)
	}
}

func TestRawFormatter_PreservesExistingTrailingNewline(t *testing.T) {
	f, _ := NewFormatter(FormatRaw)
	out, _ := f.Render(transport.Event{Data: "already-ends-newline\n"})
	if string(out) != "already-ends-newline\n" {
		t.Errorf("raw should not double the trailing \\n, got %q", out)
	}
}

func TestRawFormatter_EmptyDataYieldsBareNewline(t *testing.T) {
	f, _ := NewFormatter(FormatRaw)
	out, _ := f.Render(transport.Event{})
	if string(out) != "\n" {
		t.Errorf("empty Data → %q, want bare \\n", out)
	}
}

func TestCompactFormatter_DispatchesPerEventType(t *testing.T) {
	f, _ := NewFormatter(FormatCompact)
	out, err := f.Render(sampleEvent())
	if err != nil {
		t.Fatal(err)
	}
	var got map[string]any
	if err := json.Unmarshal([]byte(strings.TrimRight(string(out), "\n")), &got); err != nil {
		t.Fatalf("compact not valid JSON: %v", err)
	}
	// IM message processor should have lifted message_id/chat_id/etc.
	if got["message_id"] != "om_x" || got["chat_id"] != "oc_y" {
		t.Fatalf("compact output missing lifted fields: %+v", got)
	}
	// Header field `type` must equal event_type.
	if got["type"] != "im.message.receive_v1" {
		t.Errorf("type = %v", got["type"])
	}
}

func TestCrossPlatformCoverageStructuredFormatsUseProjector(t *testing.T) {
	projector := Projector(func(ev transport.Event) (any, error) {
		return map[string]any{"type": ev.EventType, "content": "hello"}, nil
	})
	for _, format := range []Format{FormatNDJSON, FormatJSON, FormatPretty, FormatCompact} {
		t.Run(string(format), func(t *testing.T) {
			f, err := NewFormatter(format, WithProjector(projector))
			if err != nil {
				t.Fatal(err)
			}
			out, err := f.Render(transport.Event{EventType: "personal.test", Data: `{"raw":true}`})
			if err != nil {
				t.Fatal(err)
			}
			var got map[string]any
			if err := json.Unmarshal(bytes.TrimSpace(out), &got); err != nil {
				t.Fatalf("output is not JSON: %v", err)
			}
			if got["type"] != "personal.test" || got["content"] != "hello" {
				t.Fatalf("projected output = %#v", got)
			}
			if _, ok := got["data"]; ok {
				t.Fatalf("projected output leaked transport envelope: %#v", got)
			}
		})
	}
}

func TestCrossPlatformCoverageProjectionFailureWarnsAndEmitsFallback(t *testing.T) {
	var warnings bytes.Buffer
	f, err := NewFormatter(
		FormatNDJSON,
		WithProjector(func(ev transport.Event) (any, error) { return ev, errors.New("bad payload") }),
		WithProjectionWarnings(&warnings),
	)
	if err != nil {
		t.Fatal(err)
	}
	ev := transport.Event{EventID: "outer", EventType: "user_im_message_receive_o2o", Data: "not-json"}
	for i := 0; i < 2; i++ {
		out, err := f.Render(ev)
		if err != nil {
			t.Fatal(err)
		}
		var got transport.Event
		if err := json.Unmarshal(bytes.TrimSpace(out), &got); err != nil || got.EventID != "outer" {
			t.Fatalf("fallback output = %s, err = %v", out, err)
		}
	}
	if count := strings.Count(warnings.String(), "WARN: personal event output projection failed"); count != 1 {
		t.Fatalf("warning count = %d, output = %q", count, warnings.String())
	}
	for _, want := range []string{`event_id="outer"`, `event_type="user_im_message_receive_o2o"`, "bad payload"} {
		if !strings.Contains(warnings.String(), want) {
			t.Fatalf("warning missing %q: %q", want, warnings.String())
		}
	}
}

func TestCrossPlatformCoverageRawFormatBypassesProjector(t *testing.T) {
	called := false
	raw := `{"payload":{"uid":100001,"clientId":"internal-client","filterSubId":"internal-filter","bizid":"internal-bizid"}}`
	f, err := NewFormatter(FormatRaw, WithProjector(func(transport.Event) (any, error) {
		called = true
		return map[string]any{"projected": true}, nil
	}))
	if err != nil {
		t.Fatal(err)
	}
	out, err := f.Render(transport.Event{Data: raw})
	if err != nil {
		t.Fatal(err)
	}
	if called || string(out) != raw+"\n" {
		t.Fatalf("raw output = %q, projector called = %v", out, called)
	}
}

func TestNewFormatter_RejectsUnknown(t *testing.T) {
	if _, err := NewFormatter(Format("nope")); err == nil {
		t.Fatal("expected error for unknown format")
	}
}