Update documentation

[rbdr/mobius] / hotline / server_blackbox_test.go

diff --git a/hotline/server_blackbox_test.go b/hotline/server_blackbox_test.go
index 17ad7f49418779b40db14832e2ab15ef1277106d..45d32d4dc2285f121e233f157080321814fee02d 100644 (file)
--- a/hotline/server_blackbox_test.go
+++ b/hotline/server_blackbox_test.go
@@ -1,44 +1,86 @@
 package hotline
 
 import (
 package hotline
 
 import (

+       "cmp"
+       "encoding/binary"
+       "encoding/hex"

        "github.com/stretchr/testify/assert"
        "github.com/stretchr/testify/assert"

-       "go.uber.org/zap"
-       "go.uber.org/zap/zapcore"
+       "log/slog"

        "os"
        "os"

+       "slices"

        "testing"
 )
 
        "testing"
 )
 

-func NewTestLogger() *zap.SugaredLogger {
-       encoderCfg := zap.NewProductionEncoderConfig()
-       encoderCfg.TimeKey = "timestamp"
-       encoderCfg.EncodeTime = zapcore.ISO8601TimeEncoder
+func NewTestLogger() *slog.Logger {
+       return slog.New(slog.NewTextHandler(os.Stdout, nil))
+}
+
+// assertTransferBytesEqual takes a string with a hexdump in the same format that `hexdump -C` produces and compares with
+// a hexdump for the bytes in got, after stripping the create/modify timestamps.
+// I don't love this, but as git does not  preserve file create/modify timestamps, we either need to fully mock the
+// filesystem interactions or work around in this way.
+// TODO: figure out a better solution
+func assertTransferBytesEqual(t *testing.T, wantHexDump string, got []byte) bool {
+       if wantHexDump == "" {
+               return true
+       }

 
 

-       core := zapcore.NewCore(
-               zapcore.NewConsoleEncoder(encoderCfg),
-               zapcore.Lock(os.Stdout),
-               zap.DebugLevel,
+       clean := slices.Concat(
+               got[:92],
+               make([]byte, 16),
+               got[108:],

        )
        )

+       return assert.Equal(t, wantHexDump, hex.Dump(clean))
+}

 
 

-       cores := []zapcore.Core{core}
-       l := zap.New(zapcore.NewTee(cores...))
-       defer func() { _ = l.Sync() }()
-       return l.Sugar()
+var tranSortFunc = func(a, b Transaction) int {
+       return cmp.Compare(
+               binary.BigEndian.Uint16(a.clientID[:]),
+               binary.BigEndian.Uint16(b.clientID[:]),
+       )

 }
 
 }
 

-// tranAssertEqual compares equality of transactions slices after stripping out the random ID
+// tranAssertEqual compares equality of transactions slices after stripping out the random transaction Type

 func tranAssertEqual(t *testing.T, tran1, tran2 []Transaction) bool {
        var newT1 []Transaction
        var newT2 []Transaction
 func tranAssertEqual(t *testing.T, tran1, tran2 []Transaction) bool {
        var newT1 []Transaction
        var newT2 []Transaction

+

        for _, trans := range tran1 {
        for _, trans := range tran1 {

-               trans.ID = []byte{0, 0, 0, 0}
+               trans.ID = [4]byte{0, 0, 0, 0}
+               var fs []Field
+               for _, field := range trans.Fields {
+                       if field.Type == FieldRefNum { // FieldRefNum
+                               continue
+                       }
+                       if field.Type == FieldChatID { // FieldChatID
+                               continue
+                       }
+
+                       fs = append(fs, field)
+               }
+               trans.Fields = fs

                newT1 = append(newT1, trans)
        }
 
        for _, trans := range tran2 {
                newT1 = append(newT1, trans)
        }
 
        for _, trans := range tran2 {

-               trans.ID = []byte{0, 0, 0, 0}
-               newT2 = append(newT2, trans)
+               trans.ID = [4]byte{0, 0, 0, 0}
+               var fs []Field
+               for _, field := range trans.Fields {
+                       if field.Type == FieldRefNum { // FieldRefNum
+                               continue
+                       }
+                       if field.Type == FieldChatID { // FieldChatID
+                               continue
+                       }

 
 

+                       fs = append(fs, field)
+               }
+               trans.Fields = fs
+               newT2 = append(newT2, trans)

        }
 
        }
 

+       slices.SortFunc(newT1, tranSortFunc)
+       slices.SortFunc(newT2, tranSortFunc)
+

        return assert.Equal(t, newT1, newT2)
 }
        return assert.Equal(t, newT1, newT2)
 }