146 lines
2.7 KiB
Go
146 lines
2.7 KiB
Go
package tartest
|
|
|
|
import (
|
|
"archive/tar"
|
|
"bytes"
|
|
"compress/gzip"
|
|
"fmt"
|
|
"io"
|
|
"testing"
|
|
)
|
|
|
|
type (
|
|
// Tarrer is an object that can tar itself to an archive
|
|
Tarrer interface {
|
|
Tar(*tar.Writer) error
|
|
}
|
|
|
|
// Tarball is a list of tarrables
|
|
Tarball []Tarrer
|
|
|
|
// Extractable is an empty interface for comparing extracted outputs in tests.
|
|
// Using that just to avoid the ugly `interface{}`.
|
|
Extractable interface{}
|
|
|
|
// Dir is a tarrable directory representation
|
|
Dir struct {
|
|
Name string
|
|
UID int
|
|
}
|
|
|
|
// File is a tarrable file representation
|
|
File struct {
|
|
Name string
|
|
UID int
|
|
Contents *bytes.Buffer
|
|
}
|
|
|
|
// Hardlink is a representation of a hardlink
|
|
Hardlink struct {
|
|
Name string
|
|
UID int
|
|
}
|
|
)
|
|
|
|
// Buffer returns a byte buffer
|
|
func (tb Tarball) Buffer() *bytes.Buffer {
|
|
var buf bytes.Buffer
|
|
tw := tar.NewWriter(&buf)
|
|
for _, member := range tb {
|
|
member.Tar(tw)
|
|
}
|
|
tw.Close()
|
|
return &buf
|
|
}
|
|
|
|
// Gzip returns a gzipped buffer
|
|
func (tb Tarball) Gzip() *bytes.Buffer {
|
|
var buf bytes.Buffer
|
|
w := gzip.NewWriter(&buf)
|
|
_, err := io.Copy(w, tb.Buffer())
|
|
if err != nil {
|
|
panic(fmt.Errorf("Gzip(): %w", err))
|
|
}
|
|
if err := w.Close(); err != nil {
|
|
panic(fmt.Errorf("gzip.Close(): %w", err))
|
|
}
|
|
return &buf
|
|
}
|
|
|
|
// Tar tars the Dir
|
|
func (d Dir) Tar(tw *tar.Writer) error {
|
|
hdr := &tar.Header{
|
|
Typeflag: tar.TypeDir,
|
|
Name: d.Name,
|
|
Mode: 0644,
|
|
Uid: d.UID,
|
|
}
|
|
return tw.WriteHeader(hdr)
|
|
}
|
|
|
|
// Tar tars the File
|
|
func (f File) Tar(tw *tar.Writer) error {
|
|
var contents []byte
|
|
if f.Contents != nil {
|
|
contents = f.Contents.Bytes()
|
|
}
|
|
hdr := &tar.Header{
|
|
Typeflag: tar.TypeReg,
|
|
Name: f.Name,
|
|
Mode: 0644,
|
|
Uid: f.UID,
|
|
Size: int64(len(contents)),
|
|
}
|
|
if err := tw.WriteHeader(hdr); err != nil {
|
|
return err
|
|
}
|
|
if _, err := tw.Write(contents); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// Tar tars the Hardlink
|
|
func (h Hardlink) Tar(tw *tar.Writer) error {
|
|
return tw.WriteHeader(&tar.Header{
|
|
Typeflag: tar.TypeLink,
|
|
Name: h.Name,
|
|
Mode: 0644,
|
|
Uid: h.UID,
|
|
})
|
|
}
|
|
|
|
// Extract extracts a tarball to a slice of extractables
|
|
func Extract(t *testing.T, r io.Reader) []Extractable {
|
|
t.Helper()
|
|
ret := []Extractable{}
|
|
tr := tar.NewReader(r)
|
|
for {
|
|
hdr, err := tr.Next()
|
|
if err == io.EOF {
|
|
break
|
|
}
|
|
if err != nil {
|
|
t.Errorf("expected nil error: %v", err)
|
|
}
|
|
|
|
var elem Extractable
|
|
switch hdr.Typeflag {
|
|
case tar.TypeDir:
|
|
elem = Dir{Name: hdr.Name, UID: hdr.Uid}
|
|
case tar.TypeLink:
|
|
elem = Hardlink{Name: hdr.Name}
|
|
case tar.TypeReg:
|
|
f := File{Name: hdr.Name, UID: hdr.Uid}
|
|
if hdr.Size > 0 {
|
|
var buf bytes.Buffer
|
|
io.Copy(&buf, tr)
|
|
f.Contents = &buf
|
|
}
|
|
elem = f
|
|
}
|
|
ret = append(ret, elem)
|
|
}
|
|
return ret
|
|
}
|