aiaa-notification-server/internal/notify/service_test.go

package notify

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

	"aiaa-notification-service/internal/engine"
	"aiaa-notification-service/internal/model"
)

type fakeMatcher struct {
	rule *model.Rule
	err  error
}

func (f *fakeMatcher) Match(context.Context, int, string) (*model.Rule, error) {
	return f.rule, f.err
}

type fakeTemplates struct {
	tmpl *model.Template
	err  error
}

func (f *fakeTemplates) GetTemplate(context.Context, int) (*model.Template, error) {
	return f.tmpl, f.err
}

type fakeRouter struct {
	channels []string
	title    string
	content  string
}

func (f *fakeRouter) Route(_ context.Context, _ *model.Rule, title, content string) []string {
	f.title = title
	f.content = content
	return f.channels
}

type fakeLogs struct{}

func (f *fakeLogs) CreateMessageLog(context.Context, *model.MessageLog) error { return nil }

func newSvc(m *fakeMatcher, t *fakeTemplates, rt *fakeRouter) *Service {
	return NewService(m, t, engine.NewRenderer(), rt, &fakeLogs{})
}

func TestProcessNoRule(t *testing.T) {
	svc := newSvc(&fakeMatcher{err: errors.New("no rule")}, &fakeTemplates{}, &fakeRouter{})
	res, err := svc.Process(context.Background(), Request{
		Source: &model.Source{ID: 1, Name: "trade-signal"},
		Event:  "trade.open",
		Data:   map[string]interface{}{"symbol": "BTCUSDT"},
	})
	if err != nil {
		t.Fatal(err)
	}
	if res.Matched {
		t.Fatal("expected unmatched")
	}
}

func TestProcessFiltered(t *testing.T) {
	raw := json.RawMessage(`[{"field":"symbol","op":"eq","value":"ETHUSDT"}]`)
	svc := newSvc(&fakeMatcher{rule: &model.Rule{ID: 1, TemplateID: 1, Conditions: &raw}}, &fakeTemplates{}, &fakeRouter{})
	res, err := svc.Process(context.Background(), Request{
		Source: &model.Source{ID: 1, Name: "trade-signal"},
		Event:  "trade.open",
		Data:   map[string]interface{}{"symbol": "BTCUSDT"},
	})
	if err != nil {
		t.Fatal(err)
	}
	if !res.Matched || !res.Filtered || res.Reason != "condition not met" {
		t.Fatalf("%+v", res)
	}
}

func TestProcessMatched(t *testing.T) {
	svc := newSvc(
		&fakeMatcher{rule: &model.Rule{ID: 9, TemplateID: 1}},
		&fakeTemplates{tmpl: &model.Template{ID: 1, Content: "{{.formatted}}"}},
		&fakeRouter{channels: []string{"dingtalk:3"}},
	)
	res, err := svc.Process(context.Background(), Request{
		Source: &model.Source{ID: 1, Name: "trade-signal"},
		Event:  "trade.open",
		Data:   map[string]interface{}{"formatted": "多单开仓"},
	})
	if err != nil {
		t.Fatal(err)
	}
	if !res.Matched || res.Filtered || len(res.Channels) != 1 || res.Channels[0] != "dingtalk:3" {
		t.Fatalf("%+v", res)
	}
}

func TestProcessTemplateCanSwitchOnEvent(t *testing.T) {
	svc := newSvc(
		&fakeMatcher{rule: &model.Rule{ID: 9, TemplateID: 1}},
		&fakeTemplates{tmpl: &model.Template{ID: 1, Content: `{{case .event ".open" "开仓" ".close" "平仓"}}`}},
		&fakeRouter{channels: []string{"safew:1"}},
	)
	res, err := svc.Process(context.Background(), Request{
		Source: &model.Source{ID: 1, Name: "crypto-strategy"},
		Event:  "trade.close",
		Data:   map[string]interface{}{"symbol": "XAU"},
	})
	if err != nil {
		t.Fatal(err)
	}
	if !res.Matched {
		t.Fatalf("%+v", res)
	}
}

func TestProcessInjectsPushedAt(t *testing.T) {
	rt := &fakeRouter{channels: []string{"safew:1"}}
	svc := newSvc(
		&fakeMatcher{rule: &model.Rule{ID: 9, TemplateID: 1}},
		&fakeTemplates{tmpl: &model.Template{ID: 1, Content: `{{line "推送时间" .pushedAt}}`}},
		rt,
	)
	res, err := svc.Process(context.Background(), Request{
		Source: &model.Source{ID: 1, Name: "crypto-strategy"},
		Event:  "trade.open",
		Data:   map[string]interface{}{"symbol": "QNT"},
	})
	if err != nil {
		t.Fatal(err)
	}
	if !res.Matched {
		t.Fatalf("%+v", res)
	}
	if !strings.Contains(rt.content, "推送时间：") {
		t.Fatalf("content=%q", rt.content)
	}
}

func TestProcessInvalidConditions(t *testing.T) {
	raw := json.RawMessage(`not-json`)
	svc := newSvc(&fakeMatcher{rule: &model.Rule{ID: 1, TemplateID: 1, Conditions: &raw}}, &fakeTemplates{}, &fakeRouter{})
	_, err := svc.Process(context.Background(), Request{
		Source: &model.Source{ID: 1, Name: "s"},
		Event:  "e",
		Data:   map[string]interface{}{},
	})
	if !errors.Is(err, ErrUnprocessable) {
		t.Fatalf("err=%v", err)
	}
}

func TestProcessTemplateMissing(t *testing.T) {
	svc := newSvc(&fakeMatcher{rule: &model.Rule{ID: 1, TemplateID: 1}}, &fakeTemplates{err: errors.New("nope")}, &fakeRouter{})
	_, err := svc.Process(context.Background(), Request{
		Source: &model.Source{ID: 1, Name: "s"},
		Event:  "e",
		Data:   map[string]interface{}{},
	})
	if err == nil || errors.Is(err, ErrUnprocessable) {
		t.Fatalf("want retryable error, got %v", err)
	}
}