lislgosms/gateway/internal/upstream/deliver_test.go

package upstream

import (
	"encoding/json"
	"net/http"
	"net/http/httptest"
	"testing"
	"time"

	"cmpp-platform/gateway/internal/queue"

	cmpp "github.com/bigwhite/gocmpp"
)

func TestHandleCMPP2DeliverReceiptPostsReceiptEvent(t *testing.T) {
	events := make(chan queue.ReceiptEvent, 1)
	api := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		if r.URL.Path != "/gateway/events/receipt/intake" {
			t.Fatalf("unexpected path: %s", r.URL.Path)
		}
		var event queue.ReceiptEvent
		if err := json.NewDecoder(r.Body).Decode(&event); err != nil {
			t.Fatalf("decode receipt event: %v", err)
		}
		events <- event
		w.WriteHeader(http.StatusOK)
	}))
	defer api.Close()

	receipt := cmpp.CmppReceiptPkt{
		MsgId:          8412634832294102675,
		Stat:           "DELIVRD",
		SubmitTime:     "2607091558",
		DoneTime:       "2607091559",
		DestTerminalId: "18821203795",
		SmscSequence:   1,
	}
	payload, err := receipt.Pack()
	if err != nil {
		t.Fatalf("pack receipt: %v", err)
	}

	conn := &connection{
		channelID:  "channel-1",
		apiBaseURL: api.URL,
		httpClient: api.Client(),
		tracker: map[uint64]queue.SubmitCommand{
			receipt.MsgId: {
				Envelope: queue.Envelope{
					SchemaVersion: queue.SchemaVersion,
					MessageType:   queue.MessageTypeSubmitCommand,
					TraceID:       "trace-1",
					MessageID:     "message-1",
					ChannelID:     "channel-1",
					CreatedAt:     time.Now(),
				},
				SubmitID: "submit-1",
			},
		},
	}
	if err := conn.handleDeliver(deliverPacketFromCMPP2(&cmpp.Cmpp2DeliverReqPkt{
		SeqId:            7,
		MsgId:            999,
		RegisterDelivery: 1,
		MsgContent:       string(payload),
	})); err != nil {
		t.Fatalf("handle receipt: %v", err)
	}

	select {
	case event := <-events:
		if event.MessageID != "message-1" || event.ChannelID != "channel-1" || event.TraceID != "trace-1" {
			t.Fatalf("unexpected envelope: %+v", event.Envelope)
		}
		if event.SequenceID != 7 {
			t.Fatalf("SequenceID = %d, want 7", event.SequenceID)
		}
		if event.GatewayMessageID != "8412634832294102675" {
			t.Fatalf("GatewayMessageID = %q", event.GatewayMessageID)
		}
		if event.PhoneNumber != "18821203795" {
			t.Fatalf("PhoneNumber = %q", event.PhoneNumber)
		}
		if event.ReceiptStatus != "delivered" || event.RawStatus != "DELIVRD" {
			t.Fatalf("unexpected receipt status: %+v", event)
		}
		if event.ConnectionID != "channel-1-0" {
			t.Fatalf("ConnectionID = %q, want channel-1-0", event.ConnectionID)
		}
	case <-time.After(time.Second):
		t.Fatal("timed out waiting for receipt event")
	}
}

func TestHandleCMPP2UplinkPreservesGatewayMessageIDWithoutPretendingItIsASubmitMessage(t *testing.T) {
	events := make(chan queue.UplinkEvent, 1)
	api := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		if r.URL.Path != "/gateway/events/uplink" {
			t.Fatalf("unexpected path: %s", r.URL.Path)
		}
		var event queue.UplinkEvent
		if err := json.NewDecoder(r.Body).Decode(&event); err != nil {
			t.Fatalf("decode uplink event: %v", err)
		}
		events <- event
		w.WriteHeader(http.StatusOK)
	}))
	defer api.Close()

	conn := &connection{
		channelID:  "channel-1",
		apiBaseURL: api.URL,
		httpClient: api.Client(),
		tracker:    map[uint64]queue.SubmitCommand{},
	}
	if err := conn.handleDeliver(deliverPacketFromCMPP2(&cmpp.Cmpp2DeliverReqPkt{
		SeqId:            8,
		MsgId:            8412634832294102675,
		DestId:           "10690000",
		SrcTerminalId:    "13800000001",
		RegisterDelivery: 0,
		MsgContent:       "TD",
	})); err != nil {
		t.Fatalf("handle uplink: %v", err)
	}

	select {
	case event := <-events:
		if event.GatewayMessageID != "8412634832294102675" {
			t.Fatalf("GatewayMessageID = %q", event.GatewayMessageID)
		}
		if event.MessageID != "" {
			t.Fatalf("MessageID = %q, want empty without a correlated submit", event.MessageID)
		}
		if event.PhoneNumber != "13800000001" || event.DestID != "10690000" || event.Content != "TD" {
			t.Fatalf("unexpected uplink event: %+v", event)
		}
	case <-time.After(time.Second):
		t.Fatal("timed out waiting for uplink event")
	}
}

func TestReceiptStatusTreatsNonDeliveredFinalStatesAsUndelivered(t *testing.T) {
	for _, stat := range []string{"UNKNOWN", "UNDELIV", "EXPIRED", "DELETED", "REJECTD"} {
		if got := receiptStatus(stat); got != "undelivered" {
			t.Fatalf("receiptStatus(%q) = %q, want undelivered", stat, got)
		}
	}
	if got := receiptStatus(""); got != "unknown" {
		t.Fatalf("receiptStatus(empty) = %q, want unknown", got)
	}
}