You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
121 lines
2.6 KiB
Go
121 lines
2.6 KiB
Go
package snapshot
|
|
|
|
import (
|
|
"bytes"
|
|
"compress/gzip"
|
|
"crypto/rand"
|
|
"io"
|
|
"io/ioutil"
|
|
"os"
|
|
"testing"
|
|
)
|
|
|
|
// Test_V1Encoder_WriteTo tests that the V1Encoder.WriteTo method
|
|
// writes a valid gzip file.
|
|
func Test_V2Encoder_WriteTo(t *testing.T) {
|
|
testFilePath := makeTempFile(t)
|
|
|
|
// Ensure the test file is deleted after the test
|
|
defer os.Remove(testFilePath)
|
|
|
|
// Create V2Encoder with a test file path
|
|
v := NewV2Encoder(testFilePath)
|
|
|
|
// Create a buffer to serve as the io.Writer
|
|
buf := new(bytes.Buffer)
|
|
|
|
// Write the gzip to the buffer
|
|
_, err := v.WriteTo(buf)
|
|
if err != nil {
|
|
t.Fatalf("Unexpected error in WriteTo: %v", err)
|
|
}
|
|
|
|
// Now we'll read it back and check if it's a valid gzip file
|
|
gz, err := gzip.NewReader(buf)
|
|
if err != nil {
|
|
t.Fatalf("Error creating gzip reader: %v", err)
|
|
}
|
|
defer gz.Close()
|
|
|
|
_, err = ioutil.ReadAll(gz)
|
|
if err != nil {
|
|
t.Fatalf("Error reading gzip file: %v", err)
|
|
}
|
|
}
|
|
|
|
func Test_V2Encoder_WriteToNoFile(t *testing.T) {
|
|
// Create V2Encoder with a test file path
|
|
v := NewV2Encoder("/does/not/exist")
|
|
|
|
// Create a buffer to serve as the io.Writer
|
|
buf := new(bytes.Buffer)
|
|
|
|
// Write the gzip to the buffer
|
|
_, err := v.WriteTo(buf)
|
|
if err == nil {
|
|
t.Fatalf("Expected error in WriteTo due to non-existent file, but got nil")
|
|
}
|
|
}
|
|
|
|
func Test_V2SnapshotEncodeDecode(t *testing.T) {
|
|
f, err := os.CreateTemp(t.TempDir(), "test-file")
|
|
if err != nil {
|
|
t.Fatalf("Error creating temp file: %v", err)
|
|
}
|
|
const size = 1024
|
|
_, err = io.CopyN(f, rand.Reader, size)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
f.Close()
|
|
|
|
// Encode it as a v2 snapshot to a byte buffer.
|
|
var buf bytes.Buffer
|
|
enc := NewV2Encoder(f.Name())
|
|
n, err := enc.WriteTo(&buf)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
// Check that `n` matches the number of bytes in the buffer.
|
|
if n != int64(buf.Len()) {
|
|
t.Fatalf("expected %d bytes, got %d", n, buf.Len())
|
|
}
|
|
|
|
// Pass the byte buffer to a decoder.
|
|
dec := NewV2Decoder(&buf)
|
|
|
|
// Have it decode the snapshot to a second byte buffer.
|
|
var decodeBuf bytes.Buffer
|
|
_, err = dec.WriteTo(&decodeBuf)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
// Check that we get the original contents back.
|
|
f, err = os.Open(f.Name())
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
var originalBuf bytes.Buffer
|
|
_, err = io.Copy(&originalBuf, f)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
if !bytes.Equal(originalBuf.Bytes(), decodeBuf.Bytes()) {
|
|
t.Fatal("original file content and decoded content are not the same")
|
|
}
|
|
}
|
|
|
|
func makeTempFile(t *testing.T) string {
|
|
f, err := os.CreateTemp(t.TempDir(), "test-file")
|
|
if err != nil {
|
|
t.Fatalf("Error creating temp file: %v", err)
|
|
}
|
|
defer f.Close()
|
|
return f.Name()
|
|
}
|