120 lines
3.4 KiB
Go
120 lines
3.4 KiB
Go
// Go MySQL Driver - A MySQL-Driver for Go's database/sql package
|
|
//
|
|
// Copyright 2024 The Go-MySQL-Driver Authors. All rights reserved.
|
|
//
|
|
// This Source Code Form is subject to the terms of the Mozilla Public
|
|
// License, v. 2.0. If a copy of the MPL was not distributed with this file,
|
|
// You can obtain one at http://mozilla.org/MPL/2.0/.
|
|
|
|
package mysql
|
|
|
|
import (
|
|
"bytes"
|
|
"crypto/rand"
|
|
"io"
|
|
"testing"
|
|
)
|
|
|
|
func makeRandByteSlice(size int) []byte {
|
|
randBytes := make([]byte, size)
|
|
rand.Read(randBytes)
|
|
return randBytes
|
|
}
|
|
|
|
// compressHelper compresses uncompressedPacket and checks state variables
|
|
func compressHelper(t *testing.T, mc *mysqlConn, uncompressedPacket []byte) []byte {
|
|
conn := new(mockConn)
|
|
mc.netConn = conn
|
|
|
|
err := mc.writePacket(append(make([]byte, 4), uncompressedPacket...))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
return conn.written
|
|
}
|
|
|
|
// uncompressHelper uncompresses compressedPacket and checks state variables
|
|
func uncompressHelper(t *testing.T, mc *mysqlConn, compressedPacket []byte) []byte {
|
|
// mocking out buf variable
|
|
conn := new(mockConn)
|
|
conn.data = compressedPacket
|
|
mc.netConn = conn
|
|
|
|
uncompressedPacket, err := mc.readPacket()
|
|
if err != nil {
|
|
if err != io.EOF {
|
|
t.Fatalf("non-nil/non-EOF error when reading contents: %s", err.Error())
|
|
}
|
|
}
|
|
return uncompressedPacket
|
|
}
|
|
|
|
// roundtripHelper compresses then uncompresses uncompressedPacket and checks state variables
|
|
func roundtripHelper(t *testing.T, cSend *mysqlConn, cReceive *mysqlConn, uncompressedPacket []byte) []byte {
|
|
compressed := compressHelper(t, cSend, uncompressedPacket)
|
|
return uncompressHelper(t, cReceive, compressed)
|
|
}
|
|
|
|
// TestRoundtrip tests two connections, where one is reading and the other is writing
|
|
func TestRoundtrip(t *testing.T) {
|
|
tests := []struct {
|
|
uncompressed []byte
|
|
desc string
|
|
}{
|
|
{uncompressed: []byte("a"),
|
|
desc: "a"},
|
|
{uncompressed: []byte("hello world"),
|
|
desc: "hello world"},
|
|
{uncompressed: make([]byte, 100),
|
|
desc: "100 bytes"},
|
|
{uncompressed: make([]byte, 32768),
|
|
desc: "32768 bytes"},
|
|
{uncompressed: make([]byte, 330000),
|
|
desc: "33000 bytes"},
|
|
{uncompressed: makeRandByteSlice(10),
|
|
desc: "10 rand bytes",
|
|
},
|
|
{uncompressed: makeRandByteSlice(100),
|
|
desc: "100 rand bytes",
|
|
},
|
|
{uncompressed: makeRandByteSlice(32768),
|
|
desc: "32768 rand bytes",
|
|
},
|
|
{uncompressed: bytes.Repeat(makeRandByteSlice(100), 10000),
|
|
desc: "100 rand * 10000 repeat bytes",
|
|
},
|
|
}
|
|
|
|
_, cSend := newRWMockConn(0)
|
|
cSend.compress = true
|
|
cSend.compIO = newCompIO(cSend)
|
|
_, cReceive := newRWMockConn(0)
|
|
cReceive.compress = true
|
|
cReceive.compIO = newCompIO(cReceive)
|
|
|
|
for _, test := range tests {
|
|
t.Run(test.desc, func(t *testing.T) {
|
|
cSend.resetSequence()
|
|
cReceive.resetSequence()
|
|
|
|
uncompressed := roundtripHelper(t, cSend, cReceive, test.uncompressed)
|
|
if len(uncompressed) != len(test.uncompressed) {
|
|
t.Errorf("uncompressed size is unexpected. expected %d but got %d",
|
|
len(test.uncompressed), len(uncompressed))
|
|
}
|
|
if !bytes.Equal(uncompressed, test.uncompressed) {
|
|
t.Errorf("roundtrip failed")
|
|
}
|
|
if cSend.sequence != cReceive.sequence {
|
|
t.Errorf("inconsistent sequence number: send=%v recv=%v",
|
|
cSend.sequence, cReceive.sequence)
|
|
}
|
|
if cSend.compressSequence != cReceive.compressSequence {
|
|
t.Errorf("inconsistent compress sequence number: send=%v recv=%v",
|
|
cSend.compressSequence, cReceive.compressSequence)
|
|
}
|
|
})
|
|
}
|
|
}
|