create remaining tests, copy over old sam3 test

compatibility_test.go

@@ -0,0 +1,635 @@
+package sam3
+
+import (
+	"reflect"
+	"strings"
+	"testing"
+)
+
+// TestSAM3CompatibilityAPI verifies that all documented types and functions from sigs.md
+// are available and have correct signatures for drop-in replacement functionality.
+// This test ensures perfect API surface compatibility with the original sam3 library.
+func TestSAM3CompatibilityAPI(t *testing.T) {
+	t.Run("CoreTypes", func(t *testing.T) {
+		// Verify all core types exist and are properly aliased
+		coreTypes := map[string]interface{}{
+			"SAM":             (*SAM)(nil),
+			"StreamSession":   (*StreamSession)(nil),
+			"DatagramSession": (*DatagramSession)(nil),
+			"RawSession":      (*RawSession)(nil),
+			"PrimarySession":  (*PrimarySession)(nil),
+			"SAMConn":         (*SAMConn)(nil),
+			"StreamListener":  (*StreamListener)(nil),
+			"SAMResolver":     (*SAMResolver)(nil),
+			"I2PConfig":       (*I2PConfig)(nil),
+			"SAMEmit":         (*SAMEmit)(nil),
+			"Options":         (*Options)(nil),
+			"Option":          (*Option)(nil),
+			"BaseSession":     (*BaseSession)(nil),
+		}
+
+		for typeName, typeValue := range coreTypes {
+			if typeValue == nil {
+				t.Errorf("Type %s should not be nil", typeName)
+				continue
+			}
+
+			// Verify type is not nil interface
+			typeOf := reflect.TypeOf(typeValue)
+			if typeOf == nil {
+				t.Errorf("Type %s has nil reflection type", typeName)
+				continue
+			}
+
+			t.Logf("✓ Type %s exists and is properly defined", typeName)
+		}
+	})
+
+	t.Run("Constants", func(t *testing.T) {
+		// Verify all signature constants exist
+		expectedConstants := map[string]string{
+			"Sig_NONE":                 Sig_NONE,
+			"Sig_DSA_SHA1":             Sig_DSA_SHA1,
+			"Sig_ECDSA_SHA256_P256":    Sig_ECDSA_SHA256_P256,
+			"Sig_ECDSA_SHA384_P384":    Sig_ECDSA_SHA384_P384,
+			"Sig_ECDSA_SHA512_P521":    Sig_ECDSA_SHA512_P521,
+			"Sig_EdDSA_SHA512_Ed25519": Sig_EdDSA_SHA512_Ed25519,
+		}
+
+		for constName, constValue := range expectedConstants {
+			if constValue == "" {
+				t.Errorf("Constant %s is empty", constName)
+				continue
+			}
+			if !strings.Contains(constValue, "SIGNATURE_TYPE=") {
+				t.Errorf("Constant %s does not contain expected prefix: %s", constName, constValue)
+				continue
+			}
+			t.Logf("✓ Constant %s = %s", constName, constValue)
+		}
+	})
+
+	t.Run("OptionVariables", func(t *testing.T) {
+		// Verify all option variables exist and have expected structure
+		optionVars := map[string][]string{
+			"Options_Humongous":       Options_Humongous,
+			"Options_Large":           Options_Large,
+			"Options_Wide":            Options_Wide,
+			"Options_Medium":          Options_Medium,
+			"Options_Default":         Options_Default,
+			"Options_Small":           Options_Small,
+			"Options_Warning_ZeroHop": Options_Warning_ZeroHop,
+		}
+
+		for varName, varValue := range optionVars {
+			if len(varValue) == 0 {
+				t.Errorf("Option variable %s is empty", varName)
+				continue
+			}
+
+			// Verify it contains expected tunnel options
+			hasInbound := false
+			hasOutbound := false
+			for _, option := range varValue {
+				if strings.Contains(option, "inbound.") {
+					hasInbound = true
+				}
+				if strings.Contains(option, "outbound.") {
+					hasOutbound = true
+				}
+			}
+
+			if !hasInbound || !hasOutbound {
+				t.Errorf("Option variable %s missing inbound/outbound options", varName)
+				continue
+			}
+
+			t.Logf("✓ Option variable %s has %d options", varName, len(varValue))
+		}
+	})
+
+	t.Run("EnvironmentVariables", func(t *testing.T) {
+		// Verify environment variable handling
+		if SAM_HOST == "" {
+			t.Error("SAM_HOST should have a default value")
+		}
+		if SAM_PORT == "" {
+			t.Error("SAM_PORT should have a default value")
+		}
+
+		t.Logf("✓ SAM_HOST = %s", SAM_HOST)
+		t.Logf("✓ SAM_PORT = %s", SAM_PORT)
+	})
+}
+
+// TestSAM3CompatibilityFunctions verifies that all documented functions from sigs.md
+// exist and have the correct signatures for perfect drop-in replacement compatibility.
+func TestSAM3CompatibilityFunctions(t *testing.T) {
+	t.Run("UtilityFunctions", func(t *testing.T) {
+		// Test utility functions exist and have correct signatures
+		utilityTests := []struct {
+			name string
+			test func(*testing.T)
+		}{
+			{
+				name: "PrimarySessionString",
+				test: func(t *testing.T) {
+					result := PrimarySessionString()
+					if result == "" {
+						t.Error("PrimarySessionString should return non-empty string")
+					}
+					t.Logf("✓ PrimarySessionString() = %s", result)
+				},
+			},
+			{
+				name: "RandString",
+				test: func(t *testing.T) {
+					result := RandString()
+					if len(result) == 0 {
+						t.Error("RandString should return non-empty string")
+					}
+					t.Logf("✓ RandString() = %s", result)
+				},
+			},
+			{
+				name: "SAMDefaultAddr",
+				test: func(t *testing.T) {
+					result := SAMDefaultAddr("")
+					if result == "" {
+						t.Error("SAMDefaultAddr should return non-empty string")
+					}
+					t.Logf("✓ SAMDefaultAddr(\"\") = %s", result)
+				},
+			},
+			{
+				name: "ExtractDest",
+				test: func(t *testing.T) {
+					input := "test-dest RESULT=OK DESTINATION=other-dest"
+					result := ExtractDest(input)
+					if result != "test-dest" {
+						t.Errorf("ExtractDest expected 'test-dest', got '%s'", result)
+					}
+					t.Logf("✓ ExtractDest works correctly")
+				},
+			},
+			{
+				name: "ExtractPairString",
+				test: func(t *testing.T) {
+					input := "KEY1=value1 KEY2=value2"
+					result := ExtractPairString(input, "KEY1")
+					if result != "value1" {
+						t.Errorf("ExtractPairString expected 'value1', got '%s'", result)
+					}
+					t.Logf("✓ ExtractPairString works correctly")
+				},
+			},
+			{
+				name: "ExtractPairInt",
+				test: func(t *testing.T) {
+					input := "PORT=7656 COUNT=10"
+					result := ExtractPairInt(input, "PORT")
+					if result != 7656 {
+						t.Errorf("ExtractPairInt expected 7656, got %d", result)
+					}
+					t.Logf("✓ ExtractPairInt works correctly")
+				},
+			},
+		}
+
+		for _, test := range utilityTests {
+			t.Run(test.name, test.test)
+		}
+	})
+
+	t.Run("ConstructorFunctions", func(t *testing.T) {
+		// Test constructor functions exist - we can't test actual functionality
+		// without I2P connection, but we can verify signatures
+		constructorTests := []struct {
+			name string
+			test func(*testing.T)
+		}{
+			{
+				name: "NewSAM",
+				test: func(t *testing.T) {
+					// Test that function exists and has correct signature
+					fnType := reflect.TypeOf(NewSAM)
+					if fnType.NumIn() != 1 || fnType.NumOut() != 2 {
+						t.Error("NewSAM should have signature: (string) (*SAM, error)")
+					}
+					t.Logf("✓ NewSAM has correct signature")
+				},
+			},
+			{
+				name: "NewSAMResolver",
+				test: func(t *testing.T) {
+					fnType := reflect.TypeOf(NewSAMResolver)
+					if fnType.NumIn() != 1 || fnType.NumOut() != 2 {
+						t.Error("NewSAMResolver should have signature: (*SAM) (*SAMResolver, error)")
+					}
+					t.Logf("✓ NewSAMResolver has correct signature")
+				},
+			},
+			{
+				name: "NewFullSAMResolver",
+				test: func(t *testing.T) {
+					fnType := reflect.TypeOf(NewFullSAMResolver)
+					if fnType.NumIn() != 1 || fnType.NumOut() != 2 {
+						t.Error("NewFullSAMResolver should have signature: (string) (*SAMResolver, error)")
+					}
+					t.Logf("✓ NewFullSAMResolver has correct signature")
+				},
+			},
+		}
+
+		for _, test := range constructorTests {
+			t.Run(test.name, test.test)
+		}
+	})
+
+	t.Run("ConfigurationFunctions", func(t *testing.T) {
+		// Test configuration functions exist and work correctly
+		configTests := []struct {
+			name string
+			test func(*testing.T)
+		}{
+			{
+				name: "NewConfig",
+				test: func(t *testing.T) {
+					config, err := NewConfig()
+					if err != nil {
+						t.Errorf("NewConfig() failed: %v", err)
+					}
+					if config == nil {
+						t.Error("NewConfig() returned nil config")
+					}
+					t.Logf("✓ NewConfig works correctly")
+				},
+			},
+			{
+				name: "NewEmit",
+				test: func(t *testing.T) {
+					emit, err := NewEmit()
+					if err != nil {
+						t.Errorf("NewEmit() failed: %v", err)
+					}
+					if emit == nil {
+						t.Error("NewEmit() returned nil emit")
+					}
+					t.Logf("✓ NewEmit works correctly")
+				},
+			},
+			{
+				name: "SetType",
+				test: func(t *testing.T) {
+					emit, _ := NewEmit()
+					err := SetType("STREAM")(emit)
+					if err != nil {
+						t.Errorf("SetType failed: %v", err)
+					}
+					if emit.Style != "STREAM" {
+						t.Errorf("SetType did not set style correctly")
+					}
+					t.Logf("✓ SetType works correctly")
+				},
+			},
+		}
+
+		for _, test := range configTests {
+			t.Run(test.name, test.test)
+		}
+	})
+}
+
+// TestSAM3CompatibilityIntegration tests drop-in replacement functionality with
+// real I2P connections when available. These tests verify that the wrapper
+// behaves identically to the original sam3 library in actual usage scenarios.
+func TestSAM3CompatibilityIntegration(t *testing.T) {
+	if testing.Short() {
+		t.Skip("Skipping integration tests in short mode")
+	}
+
+	t.Run("BasicSAMConnection", func(t *testing.T) {
+		// Test basic SAM connection using sam3 API patterns
+		sam, err := NewSAM(SAMDefaultAddr(""))
+		if err != nil {
+			t.Skipf("Cannot connect to I2P SAM bridge: %v", err)
+		}
+		defer sam.Close()
+
+		// Verify SAM connection provides expected functionality
+		if sam == nil {
+			t.Fatal("SAM connection should not be nil")
+		}
+
+		// Test key generation through SAM
+		keys, err := sam.NewKeys()
+		if err != nil {
+			t.Fatalf("Failed to generate keys: %v", err)
+		}
+
+		if keys.String() == "" {
+			t.Fatal("Generated keys should not be empty")
+		}
+
+		t.Log("✓ Basic SAM connection and key generation work correctly")
+	})
+
+	t.Run("SessionCreationPatterns", func(t *testing.T) {
+		// Test common sam3 usage patterns for session creation
+		sam, err := NewSAM(SAMDefaultAddr(""))
+		if err != nil {
+			t.Skipf("Cannot connect to I2P SAM bridge: %v", err)
+		}
+		defer sam.Close()
+
+		keys, err := sam.NewKeys()
+		if err != nil {
+			t.Fatalf("Failed to generate keys: %v", err)
+		}
+
+		// Test the typical sam3 usage pattern for each session type
+		sessionTests := []struct {
+			name string
+			test func(*testing.T)
+		}{
+			{
+				name: "PrimarySessionPattern",
+				test: func(t *testing.T) {
+					session, err := sam.NewPrimarySession("compat-primary-"+RandString(), keys, Options_Default)
+					if err != nil {
+						t.Errorf("Primary session creation failed: %v", err)
+						return
+					}
+					defer session.Close()
+
+					// Verify primary session can create sub-sessions
+					if session.SubSessionCount() != 0 {
+						t.Error("New primary session should have 0 sub-sessions")
+					}
+
+					t.Log("✓ Primary session creation pattern works")
+				},
+			},
+			{
+				name: "StreamSessionPattern",
+				test: func(t *testing.T) {
+					session, err := sam.NewStreamSession("compat-stream-"+RandString(), keys, Options_Small)
+					if err != nil {
+						t.Errorf("Stream session creation failed: %v", err)
+						return
+					}
+					defer session.Close()
+
+					// Test listener creation - typical sam3 pattern
+					listener, err := session.Listen()
+					if err != nil {
+						t.Errorf("Stream listener creation failed: %v", err)
+						return
+					}
+					defer listener.Close()
+
+					if listener.Addr() == nil {
+						t.Error("Stream listener should have non-nil address")
+					}
+
+					t.Log("✓ Stream session creation and listener pattern works")
+				},
+			},
+			{
+				name: "DatagramSessionPattern",
+				test: func(t *testing.T) {
+					session, err := sam.NewDatagramSession("compat-datagram-"+RandString(), keys, Options_Small)
+					if err != nil {
+						t.Errorf("Datagram session creation failed: %v", err)
+						return
+					}
+					defer session.Close()
+
+					// Verify datagram session provides expected interface
+					if session.LocalAddr() == nil {
+						t.Error("Datagram session should have non-nil local address")
+					}
+
+					t.Log("✓ Datagram session creation pattern works")
+				},
+			},
+			{
+				name: "RawSessionPattern",
+				test: func(t *testing.T) {
+					session, err := sam.NewRawSession("compat-raw-"+RandString(), keys, Options_Small, 0)
+					if err != nil {
+						t.Errorf("Raw session creation failed: %v", err)
+						return
+					}
+					defer session.Close()
+
+					// Verify raw session provides expected interface
+					if session.LocalAddr() == nil {
+						t.Error("Raw session should have non-nil local address")
+					}
+
+					t.Log("✓ Raw session creation pattern works")
+				},
+			},
+		}
+
+		for _, test := range sessionTests {
+			t.Run(test.name, test.test)
+		}
+	})
+
+	t.Run("ErrorHandlingCompatibility", func(t *testing.T) {
+		// Test that error handling matches expected sam3 patterns
+
+		// Test invalid SAM address
+		_, err := NewSAM("invalid-address:999999")
+		if err == nil {
+			t.Error("Expected error for invalid SAM address")
+		}
+		t.Logf("✓ Invalid address error: %v", err)
+
+		// Test with valid connection for other error cases
+		sam, err := NewSAM(SAMDefaultAddr(""))
+		if err != nil {
+			t.Skipf("Cannot connect to I2P SAM bridge: %v", err)
+		}
+		defer sam.Close()
+
+		// Test invalid session type
+		emit, _ := NewEmit()
+		err = SetType("INVALID_TYPE")(emit)
+		if err == nil {
+			t.Error("Expected error for invalid session type")
+		}
+		t.Logf("✓ Invalid session type error: %v", err)
+
+		// Test invalid configuration values
+		err = SetInLength(-1)(emit)
+		if err == nil {
+			t.Error("Expected error for invalid tunnel length")
+		}
+		t.Logf("✓ Invalid configuration error: %v", err)
+	})
+}
+
+// TestSAM3CompatibilityBehavior verifies that the wrapper exhibits identical
+// behavior to the original sam3 library in edge cases and specific scenarios.
+func TestSAM3CompatibilityBehavior(t *testing.T) {
+	t.Run("AddressHandling", func(t *testing.T) {
+		// Test SAM address handling compatibility
+		tests := []struct {
+			name     string
+			input    string
+			expected string
+		}{
+			{"DefaultHost", "", SAM_HOST + ":" + SAM_PORT},
+			{"ExplicitAddress", "192.168.1.1:7656", SAM_HOST + ":" + SAM_PORT}, // SAMDefaultAddr ignores input when defaults are set
+			{"HostOnly", "localhost", SAM_HOST + ":" + SAM_PORT},               // SAMDefaultAddr ignores input when defaults are set
+		}
+
+		for _, test := range tests {
+			t.Run(test.name, func(t *testing.T) {
+				result := SAMDefaultAddr(test.input)
+				if result != test.expected {
+					t.Errorf("SAMDefaultAddr(%s) = %s, expected %s", test.input, result, test.expected)
+				}
+				t.Logf("✓ SAMDefaultAddr(%s) = %s", test.input, result)
+			})
+		}
+	})
+
+	t.Run("StringParsing", func(t *testing.T) {
+		// Test string parsing functions for SAM protocol compatibility
+		testCases := []struct {
+			name     string
+			input    string
+			expected map[string]interface{}
+		}{
+			{
+				name:  "DestinationExtraction",
+				input: "abcd1234.b32.i2p RESULT=OK VERSION=3.3",
+				expected: map[string]interface{}{
+					"dest": "abcd1234.b32.i2p",
+				},
+			},
+			{
+				name:  "MultipleParams",
+				input: "test.b32.i2p RESULT=OK MESSAGE=Connected",
+				expected: map[string]interface{}{
+					"dest":    "test.b32.i2p",
+					"message": "Connected",
+					"result":  "OK",
+				},
+			},
+		}
+
+		for _, test := range testCases {
+			t.Run(test.name, func(t *testing.T) {
+				dest := ExtractDest(test.input)
+				if expectedDest, ok := test.expected["dest"]; ok {
+					if dest != expectedDest {
+						t.Errorf("ExtractDest expected %s, got %s", expectedDest, dest)
+					}
+				}
+
+				message := ExtractPairString(test.input, "MESSAGE")
+				if expectedMsg, ok := test.expected["message"]; ok {
+					if message != expectedMsg {
+						t.Errorf("ExtractPairString(MESSAGE) expected %s, got %s", expectedMsg, message)
+					}
+				}
+
+				t.Logf("✓ String parsing works correctly for %s", test.name)
+			})
+		}
+	})
+
+	t.Run("ConfigurationBehavior", func(t *testing.T) {
+		// Test configuration behavior matches sam3 expectations
+		emit, _ := NewEmit()
+
+		// Test option string generation
+		options := []string{"inbound.length=3", "outbound.length=3"}
+		optString := GenerateOptionString(options)
+
+		if !strings.Contains(optString, "inbound.length=3") {
+			t.Error("Generated option string should contain inbound.length=3")
+		}
+		if !strings.Contains(optString, "outbound.length=3") {
+			t.Error("Generated option string should contain outbound.length=3")
+		}
+
+		// Test configuration chaining
+		err := SetType("STREAM")(emit)
+		if err != nil {
+			t.Errorf("Configuration chaining failed: %v", err)
+		}
+
+		err = SetSAMHost("127.0.0.1")(emit)
+		if err != nil {
+			t.Errorf("Configuration chaining failed: %v", err)
+		}
+
+		if emit.Style != "STREAM" {
+			t.Error("Configuration chaining did not preserve previous settings")
+		}
+		if emit.I2PConfig.SamHost != "127.0.0.1" {
+			t.Error("Configuration chaining did not apply new settings")
+		}
+
+		t.Log("✓ Configuration behavior matches sam3 patterns")
+	})
+}
+
+// BenchmarkSAM3Compatibility benchmarks critical operations to ensure
+// performance is comparable to original sam3 library expectations.
+func BenchmarkSAM3Compatibility(b *testing.B) {
+	b.Run("UtilityFunctions", func(b *testing.B) {
+		b.Run("RandString", func(b *testing.B) {
+			for i := 0; i < b.N; i++ {
+				_ = RandString()
+			}
+		})
+
+		b.Run("SAMDefaultAddr", func(b *testing.B) {
+			for i := 0; i < b.N; i++ {
+				_ = SAMDefaultAddr("")
+			}
+		})
+
+		b.Run("ExtractDest", func(b *testing.B) {
+			input := "HELLO REPLY RESULT=OK DESTINATION=test.b32.i2p"
+			for i := 0; i < b.N; i++ {
+				_ = ExtractDest(input)
+			}
+		})
+
+		b.Run("GenerateOptionString", func(b *testing.B) {
+			options := Options_Default
+			for i := 0; i < b.N; i++ {
+				_ = GenerateOptionString(options)
+			}
+		})
+	})
+
+	b.Run("Configuration", func(b *testing.B) {
+		b.Run("NewEmit", func(b *testing.B) {
+			for i := 0; i < b.N; i++ {
+				_, _ = NewEmit()
+			}
+		})
+
+		b.Run("SetType", func(b *testing.B) {
+			emit, _ := NewEmit()
+			for i := 0; i < b.N; i++ {
+				_ = SetType("STREAM")(emit)
+			}
+		})
+
+		b.Run("OptionVariableAccess", func(b *testing.B) {
+			for i := 0; i < b.N; i++ {
+				_ = Options_Default
+			}
+		})
+	})
+}