mirror of
https://github.com/hanzo-ml/kuberay.git
synced 2026-10-30 19:48:47 +00:00
130 lines
3.5 KiB
Go
130 lines
3.5 KiB
Go
package compression
|
|
|
|
import (
|
|
"bytes"
|
|
"io"
|
|
"os"
|
|
"testing"
|
|
)
|
|
|
|
func compressBytesForTest(data []byte) ([]byte, error) {
|
|
var buf bytes.Buffer
|
|
err := CompressStream(&buf, bytes.NewReader(data))
|
|
return buf.Bytes(), err
|
|
}
|
|
|
|
func decompressBytesForTest(data []byte) ([]byte, error) {
|
|
var buf bytes.Buffer
|
|
err := DecompressStream(&buf, bytes.NewReader(data))
|
|
return buf.Bytes(), err
|
|
}
|
|
|
|
func TestCompressDecompressStream(t *testing.T) {
|
|
originalData := []byte("Streaming log compression payload testing across io.Reader and io.Writer")
|
|
|
|
var compressedBuf bytes.Buffer
|
|
if err := CompressStream(&compressedBuf, bytes.NewReader(originalData)); err != nil {
|
|
t.Fatalf("CompressStream failed: %v", err)
|
|
}
|
|
|
|
var decompressedBuf bytes.Buffer
|
|
if err := DecompressStream(&decompressedBuf, &compressedBuf); err != nil {
|
|
t.Fatalf("DecompressStream failed: %v", err)
|
|
}
|
|
|
|
if !bytes.Equal(originalData, decompressedBuf.Bytes()) {
|
|
t.Fatalf("Stream decompressed data mismatch.\nExpected: %s\nGot: %s", originalData, decompressedBuf.Bytes())
|
|
}
|
|
}
|
|
|
|
type mockStorageWriter struct {
|
|
writtenData []byte
|
|
}
|
|
|
|
func (m *mockStorageWriter) WriteFile(file string, reader io.ReadSeeker) error {
|
|
var err error
|
|
m.writtenData, err = io.ReadAll(reader)
|
|
return err
|
|
}
|
|
|
|
func TestWriteCompressedFile(t *testing.T) {
|
|
tmpFile, err := os.CreateTemp("", "test-raw-*.txt")
|
|
if err != nil {
|
|
t.Fatalf("CreateTemp failed: %v", err)
|
|
}
|
|
defer os.Remove(tmpFile.Name())
|
|
|
|
rawData := []byte("upload compression payload test")
|
|
if _, err := tmpFile.Write(rawData); err != nil {
|
|
t.Fatalf("Write failed: %v", err)
|
|
}
|
|
tmpFile.Close()
|
|
|
|
mockWriter := &mockStorageWriter{}
|
|
if err := WriteCompressedFile(mockWriter, "test/remote.gz", tmpFile.Name()); err != nil {
|
|
t.Fatalf("WriteCompressedFile failed: %v", err)
|
|
}
|
|
|
|
decompressed, err := decompressBytesForTest(mockWriter.writtenData)
|
|
if err != nil {
|
|
t.Fatalf("decompressBytesForTest failed: %v", err)
|
|
}
|
|
|
|
if !bytes.Equal(rawData, decompressed) {
|
|
t.Fatalf("Decompressed written data mismatch.\nExpected: %s\nGot: %s", rawData, decompressed)
|
|
}
|
|
}
|
|
|
|
func TestWriteCompressedBytes(t *testing.T) {
|
|
rawData := []byte("upload in-memory bytes payload test")
|
|
mockWriter := &mockStorageWriter{}
|
|
|
|
if err := WriteCompressedBytes(mockWriter, "test/bytes.gz", rawData); err != nil {
|
|
t.Fatalf("WriteCompressedBytes failed: %v", err)
|
|
}
|
|
|
|
decompressed, err := decompressBytesForTest(mockWriter.writtenData)
|
|
if err != nil {
|
|
t.Fatalf("decompressBytesForTest failed: %v", err)
|
|
}
|
|
|
|
if !bytes.Equal(rawData, decompressed) {
|
|
t.Fatalf("Decompressed written bytes mismatch.\nExpected: %s\nGot: %s", rawData, decompressed)
|
|
}
|
|
}
|
|
|
|
type mockStorageReader struct {
|
|
content []byte
|
|
}
|
|
|
|
func (m *mockStorageReader) GetContent(clusterId string, fileName string) io.Reader {
|
|
if m.content == nil {
|
|
return nil
|
|
}
|
|
return bytes.NewReader(m.content)
|
|
}
|
|
|
|
func TestReadCompressedContent(t *testing.T) {
|
|
originalText := []byte("Universal cloud storage reader decompression test")
|
|
compressed, err := compressBytesForTest(originalText)
|
|
if err != nil {
|
|
t.Fatalf("compressBytesForTest failed: %v", err)
|
|
}
|
|
|
|
mockReader := &mockStorageReader{content: compressed}
|
|
rc, err := ReadCompressedContent(mockReader, "cluster-1", "log.gz")
|
|
if err != nil {
|
|
t.Fatalf("ReadCompressedContent failed: %v", err)
|
|
}
|
|
defer rc.Close()
|
|
|
|
decompressed, err := io.ReadAll(rc)
|
|
if err != nil {
|
|
t.Fatalf("io.ReadAll failed: %v", err)
|
|
}
|
|
|
|
if !bytes.Equal(originalText, decompressed) {
|
|
t.Fatalf("Decompressed read content mismatch.\nExpected: %s\nGot: %s", originalText, decompressed)
|
|
}
|
|
}
|