Add some tests

internal/multiplex/session.go

@@ -139,6 +139,7 @@ func (sesh *Session) delStream(id uint32) {
 func (sesh *Session) recvDataFromRemote(data []byte) {
 	frame, err := sesh.Deobfs(data)
 	if err != nil {
+		// TODO: return this error
 		log.Debugf("Failed to decrypt a frame for session %v: %v", sesh.id, err)
 		return
 	}

internal/multiplex/session_test.go

@@ -1,19 +1,138 @@
 package multiplex
 
 import (
+	"bytes"
 	"github.com/cbeuw/Cloak/internal/util"
 	"math/rand"
 	"testing"
 )
 
-var seshConfig = &SessionConfig{
+var seshConfigOrdered = &SessionConfig{
 	Obfuscator: nil,
 	Valve:      nil,
 	UnitRead:   util.ReadTLS,
 }
 
-func BenchmarkRecvDataFromRemote(b *testing.B) {
+var seshConfigUnordered = &SessionConfig{
-	testPayload := make([]byte, 1024)
+	Obfuscator: nil,
+	Valve:      nil,
+	UnitRead:   util.ReadTLS,
+	Unordered:  true,
+}
+
+func TestRecvDataFromRemote(t *testing.T) {
+	testPayloadLen := 1024
+	testPayload := make([]byte, testPayloadLen)
+	rand.Read(testPayload)
+	f := &Frame{
+		1,
+		0,
+		0,
+		testPayload,
+	}
+	obfsBuf := make([]byte, 17000)
+
+	sessionKey := make([]byte, 32)
+	rand.Read(sessionKey)
+	t.Run("plain ordered", func(t *testing.T) {
+		obfuscator, _ := GenerateObfs(0x00, sessionKey)
+		seshConfigOrdered.Obfuscator = obfuscator
+		sesh := MakeSession(0, seshConfigOrdered)
+		n, _ := sesh.Obfs(f, obfsBuf)
+
+		sesh.recvDataFromRemote(obfsBuf[:n])
+		stream, err := sesh.Accept()
+		if err != nil {
+			t.Error(err)
+			return
+		}
+
+		resultPayload := make([]byte, testPayloadLen)
+		_, err = stream.Read(resultPayload)
+		if err != nil {
+			t.Error(err)
+			return
+		}
+		if !bytes.Equal(testPayload, resultPayload) {
+			t.Errorf("Expecting %x, got %x", testPayload, resultPayload)
+		}
+	})
+	t.Run("aes-gcm ordered", func(t *testing.T) {
+		obfuscator, _ := GenerateObfs(0x01, sessionKey)
+		seshConfigOrdered.Obfuscator = obfuscator
+		sesh := MakeSession(0, seshConfigOrdered)
+		n, _ := sesh.Obfs(f, obfsBuf)
+
+		sesh.recvDataFromRemote(obfsBuf[:n])
+		stream, err := sesh.Accept()
+		if err != nil {
+			t.Error(err)
+			return
+		}
+
+		resultPayload := make([]byte, testPayloadLen)
+		_, err = stream.Read(resultPayload)
+		if err != nil {
+			t.Error(err)
+			return
+		}
+		if !bytes.Equal(testPayload, resultPayload) {
+			t.Errorf("Expecting %x, got %x", testPayload, resultPayload)
+		}
+	})
+	t.Run("chacha20-poly1305 ordered", func(t *testing.T) {
+		obfuscator, _ := GenerateObfs(0x02, sessionKey)
+		seshConfigOrdered.Obfuscator = obfuscator
+		sesh := MakeSession(0, seshConfigOrdered)
+		n, _ := sesh.Obfs(f, obfsBuf)
+
+		sesh.recvDataFromRemote(obfsBuf[:n])
+		stream, err := sesh.Accept()
+		if err != nil {
+			t.Error(err)
+			return
+		}
+
+		resultPayload := make([]byte, testPayloadLen)
+		_, err = stream.Read(resultPayload)
+		if err != nil {
+			t.Error(err)
+			return
+		}
+		if !bytes.Equal(testPayload, resultPayload) {
+			t.Errorf("Expecting %x, got %x", testPayload, resultPayload)
+		}
+	})
+
+	t.Run("plain unordered", func(t *testing.T) {
+		obfuscator, _ := GenerateObfs(0x00, sessionKey)
+		seshConfigUnordered.Obfuscator = obfuscator
+		sesh := MakeSession(0, seshConfigOrdered)
+		n, _ := sesh.Obfs(f, obfsBuf)
+
+		sesh.recvDataFromRemote(obfsBuf[:n])
+		stream, err := sesh.Accept()
+		if err != nil {
+			t.Error(err)
+			return
+		}
+
+		resultPayload := make([]byte, testPayloadLen)
+		_, err = stream.Read(resultPayload)
+		if err != nil {
+			t.Error(err)
+			return
+		}
+		if !bytes.Equal(testPayload, resultPayload) {
+			t.Errorf("Expecting %x, got %x", testPayload, resultPayload)
+		}
+	})
+
+}
+
+func BenchmarkRecvDataFromRemote_Ordered(b *testing.B) {
+	testPayloadLen := 1024
+	testPayload := make([]byte, testPayloadLen)
 	rand.Read(testPayload)
 	f := &Frame{
 		1,
@@ -28,8 +147,8 @@ func BenchmarkRecvDataFromRemote(b *testing.B) {
 
 	b.Run("plain", func(b *testing.B) {
 		obfuscator, _ := GenerateObfs(0x00, sessionKey)
-		seshConfig.Obfuscator = obfuscator
+		seshConfigOrdered.Obfuscator = obfuscator
-		sesh := MakeSession(0, seshConfig)
+		sesh := MakeSession(0, seshConfigOrdered)
 		n, _ := sesh.Obfs(f, obfsBuf)
 
 		b.ResetTimer()
@@ -41,8 +160,8 @@ func BenchmarkRecvDataFromRemote(b *testing.B) {
 
 	b.Run("aes-gcm", func(b *testing.B) {
 		obfuscator, _ := GenerateObfs(0x01, sessionKey)
-		seshConfig.Obfuscator = obfuscator
+		seshConfigOrdered.Obfuscator = obfuscator
-		sesh := MakeSession(0, seshConfig)
+		sesh := MakeSession(0, seshConfigOrdered)
 		n, _ := sesh.Obfs(f, obfsBuf)
 
 		b.ResetTimer()
@@ -54,8 +173,8 @@ func BenchmarkRecvDataFromRemote(b *testing.B) {
 
 	b.Run("chacha20-poly1305", func(b *testing.B) {
 		obfuscator, _ := GenerateObfs(0x02, sessionKey)
-		seshConfig.Obfuscator = obfuscator
+		seshConfigOrdered.Obfuscator = obfuscator
-		sesh := MakeSession(0, seshConfig)
+		sesh := MakeSession(0, seshConfigOrdered)
 		n, _ := sesh.Obfs(f, obfsBuf)
 
 		b.ResetTimer()

internal/multiplex/stream_test.go

@@ -48,7 +48,7 @@ func (b *blackhole) SetDeadline(t time.Time) error      { return nil }
 func (b *blackhole) SetReadDeadline(t time.Time) error  { return nil }
 func (b *blackhole) SetWriteDeadline(t time.Time) error { return nil }
 
-func BenchmarkStream_Write(b *testing.B) {
+func BenchmarkStream_Write_Ordered(b *testing.B) {
 	const PAYLOAD_LEN = 1000
 	hole := newBlackHole()
 	sesh := setupSesh(false)
@@ -70,7 +70,7 @@ func BenchmarkStream_Write(b *testing.B) {
 	}
 }
 
-func BenchmarkStream_Read(b *testing.B) {
+func BenchmarkStream_Read_Ordered(b *testing.B) {
 	sesh := setupSesh(false)
 	const PAYLOAD_LEN = 1000
 	testPayload := make([]byte, PAYLOAD_LEN)