Implement Frames

I feel like that gets a bit too abstract, too quickly.

agwpe.go

@@ -64,35 +64,3 @@ func (pe *PacketEngine) Disconnect() error {
 
 	return nil
 }
-
-// import "encoding/binary"
-
-// type Frame struct {
-// 	Port      byte
-// 	Reserved0 [3]byte
-// 	DataKind  byte
-// 	Reserved1 byte
-// 	PID       byte
-// 	Reserved2 byte
-// 	CallFrom  [10]byte
-// 	CallTo    [10]byte
-// 	DataLen   uint32
-// 	User      [4]byte
-// }
-
-// func (f *Frame) Serialize() []byte {
-// 	buf := make([]byte, 36)
-
-// 	buf[0] = f.Port
-// 	// Ignore reserved bytes 1 to 3
-// 	buf[4] = f.DataKind
-// 	// Ignore reserved byte 5
-// 	buf[6] = f.PID
-// 	// Ignore reserved byte 7
-// 	copy(buf[8:18], f.CallFrom[:])
-// 	copy(buf[18:28], f.CallTo[:])
-// 	binary.LittleEndian.PutUint32(buf[28:32], f.DataLen)
-// 	copy(buf[32:36], f.User[:])
-
-// 	return buf
-// }

agwpe_test.go

@@ -1,98 +1,72 @@
 package agwpe
 
 import (
+	"net"
 	"testing"
 	"time"
 )
 
+// NOTE(m): Use more table-driven-tests? At the moment this feels less abstract.
+
 func TestNewPacketEngine(t *testing.T) {
-	tests := []struct {
-		name            string
-		address         string
-		options         []Option
-		expectedError   bool
-		expectedTimeout time.Duration
-	}{
-		{
-			name:            "Default configuration",
-			address:         "localhost:1234",
-			options:         []Option{},
-			expectedError:   false,
-			expectedTimeout: 5 * time.Second,
-		},
-		{
-			name:            "Custom timeout",
-			address:         "localhost:1234",
-			options:         []Option{WithTimeout(30 * time.Second)},
-			expectedError:   false,
-			expectedTimeout: 30 * time.Second,
-		},
+	// Default configuration
+	engine, err := NewPacketEngine("localhost:1234")
+	if err != nil {
+		t.Errorf("Did not expect error: %v", err)
+	}
+	if engine.cfg.Timeout != 5*time.Second {
+		t.Errorf("Expected 5 second timeout, got %v", engine.cfg.Timeout)
+	}
+	if engine.Ready {
+		t.Error("Expected engine that is not ready")
 	}
 
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			engine, err := NewPacketEngine(tt.address, tt.options...)
-
-			if (err != nil) != tt.expectedError {
-				t.Errorf("Expected error: %v, got: %v", tt.expectedError, err)
-			}
-
-			if !tt.expectedError {
-				if engine == nil {
-					t.Fatal("Expected non-nil engine")
-				}
-				if engine.Ready {
-					t.Fatal("Expected engine that is not ready")
-				}
-				if engine.cfg.Timeout != tt.expectedTimeout {
-					t.Errorf("Expected timeout %v, got %v", tt.expectedTimeout, engine.cfg.Timeout)
-				}
-			}
-
-		})
+	// Custom timeout
+	engine, err = NewPacketEngine("localhost:1234", WithTimeout(30*time.Second))
+	if err != nil {
+		t.Errorf("Did not expect error: %v", err)
+	}
+	if engine.cfg.Timeout != 30*time.Second {
+		t.Errorf("Expected 30 second timeout, got %v", engine.cfg.Timeout)
 	}
 }
 
-func TestConnect(t *testing.T) {
-	tests := []struct {
-		name          string
-		address       string
-		options       []Option
-		expectedError bool
-	}{
-		{
-			name:          "Successful connection",
-			address:       "localhost:1234",
-			expectedError: false,
-		},
-		{
-			name:          "Invalid address",
-			address:       "invalid-address",
-			expectedError: true,
-		},
+func TestPacketEngine_Connect(t *testing.T) {
+	listener, err := net.Listen("tcp", "127.0.0.1:0")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer listener.Close()
+	serverAddr := listener.Addr().String()
+
+	// Successful connect
+	engine, _ := NewPacketEngine(serverAddr)
+	err = engine.Connect()
+	if err != nil {
+		t.Errorf("Did not expect error: %v", err)
 	}
 
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			engine, _ := NewPacketEngine(tt.address, tt.options...)
-			err := engine.Connect()
-
-			if tt.expectedError && (err == nil) {
-				t.Errorf("Expected error: %v, got: %v", tt.expectedError, err)
-			}
-
-			if !tt.expectedError && (err != nil) {
-				t.Errorf("Did not expect error: %v", err)
-			}
-		})
+	// Invalid address
+	engine, _ = NewPacketEngine("invalid-address")
+	err = engine.Connect()
+	if err == nil {
+		t.Error("Expected an error")
 	}
 }
 
-func TestDisconnect(t *testing.T) {
-	engine, _ := NewPacketEngine("localhost:1234")
+func TestPacketEngine_Disconnect(t *testing.T) {
+	listener, err := net.Listen("tcp", "127.0.0.1:0")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer listener.Close()
+	serverAddr := listener.Addr().String()
+
+	engine, _ := NewPacketEngine(serverAddr)
 	engine.Connect()
 
-	err := engine.Disconnect()
+	// Disconnect connected engine
+	err = engine.Disconnect()
 	if err != nil {
 		t.Errorf("Did not expect error: %v", err)
 	}
@@ -100,6 +74,6 @@ func TestDisconnect(t *testing.T) {
 	// Call to Disconnect() on disconnected packet engine should return an error
 	err = engine.Disconnect()
 	if err == nil {
-		t.Error("Expected an error, but got", nil)
+		t.Error("Expected an error")
 	}
 }

frame.go

@@ -0,0 +1,35 @@
+package agwpe
+
+import (
+	"encoding/binary"
+)
+
+type FrameHeader struct {
+	Port      byte
+	Reserved0 [3]byte
+	DataKind  byte
+	Reserved1 byte
+	PID       byte
+	Reserved2 byte
+	CallFrom  [10]byte
+	CallTo    [10]byte
+	DataLen   uint32
+	User      [4]byte
+}
+
+func (f *FrameHeader) Serialize() []byte {
+	buf := make([]byte, 36)
+
+	buf[0] = f.Port
+	// Ignore reserved bytes 1 to 3
+	buf[4] = f.DataKind
+	// Ignore reserved byte 5
+	buf[6] = f.PID
+	// Ignore reserved byte 7
+	copy(buf[8:18], f.CallFrom[:])
+	copy(buf[18:28], f.CallTo[:])
+	binary.LittleEndian.PutUint32(buf[28:32], f.DataLen)
+	copy(buf[32:36], f.User[:])
+
+	return buf
+}

frame_test.go

@@ -0,0 +1,13 @@
+package agwpe
+
+import (
+	"testing"
+)
+
+func TestNewFrameHeader(t *testing.T) {
+
+}
+
+func TestFrameHeader_Serialize(t *testing.T) {
+
+}