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
	rules []model.Rule
	err   error
}

func (f *fakeMatcher) Match(context.Context, int, string) ([]model.Rule, error) {
	if f.err != nil {
		return nil, f.err
	}
	if len(f.rules) > 0 {
		return f.rules, nil
	}
	if f.rule != nil {
		return []model.Rule{*f.rule}, nil
	}
	return nil, nil
}

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
	ruleIDs  []int
}

func (f *fakeRouter) Route(_ context.Context, rule *model.Rule, title, content string) []string {
	f.title = title
	f.content = content
	if rule != nil {
		f.ruleIDs = append(f.ruleIDs, rule.ID)
	}
	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)
	}
}

func TestProcessMultipleRulesSameEvent(t *testing.T) {
	rt := &fakeRouter{channels: []string{"safew:1"}}
	svc := newSvc(
		&fakeMatcher{rules: []model.Rule{
			{ID: 17, TemplateID: 1, Event: "trade.close"},
			{ID: 18, TemplateID: 1, Event: "trade.close"},
		}},
		&fakeTemplates{tmpl: &model.Template{ID: 1, Content: "ok"}},
		rt,
	)
	res, err := svc.Process(context.Background(), Request{
		Source: &model.Source{ID: 11, Name: "crypto-strategy"},
		Event:  "trade.close",
		Data:   map[string]interface{}{"symbol": "CRV"},
	})
	if err != nil {
		t.Fatal(err)
	}
	if !res.Matched || res.Filtered {
		t.Fatalf("%+v", res)
	}
	if len(rt.ruleIDs) != 2 || rt.ruleIDs[0] != 17 || rt.ruleIDs[1] != 18 {
		t.Fatalf("routed=%v", rt.ruleIDs)
	}
	if len(res.Channels) != 2 {
		t.Fatalf("channels=%v", res.Channels)
	}
}

func TestProcessSkipsFilteredSiblingRule(t *testing.T) {
	hlss := json.RawMessage(`[{"field":"strategyCode","op":"eq","value":"HLSS"}]`)
	ai := json.RawMessage(`[{"field":"strategyCode","op":"eq","value":"ai-crypto-signals"}]`)
	rt := &fakeRouter{channels: []string{"safew:1"}}
	svc := newSvc(
		&fakeMatcher{rules: []model.Rule{
			{ID: 1, TemplateID: 1, Event: "trade.close", Conditions: &hlss},
			{ID: 2, TemplateID: 1, Event: "trade.close", Conditions: &ai},
		}},
		&fakeTemplates{tmpl: &model.Template{ID: 1, Content: "ok"}},
		rt,
	)
	res, err := svc.Process(context.Background(), Request{
		Source: &model.Source{ID: 11, Name: "crypto-strategy"},
		Event:  "trade.close",
		Data:   map[string]interface{}{"strategyCode": "ai-crypto-signals"},
	})
	if err != nil {
		t.Fatal(err)
	}
	if !res.Matched || res.Filtered {
		t.Fatalf("%+v", res)
	}
	if len(rt.ruleIDs) != 1 || rt.ruleIDs[0] != 2 {
		t.Fatalf("routed=%v want only rule 2", rt.ruleIDs)
	}
}