497 lines
12 KiB
Go
497 lines
12 KiB
Go
package archiver
|
|
|
|
import (
|
|
"archive/tar"
|
|
"archive/zip"
|
|
"compress/gzip"
|
|
"github.com/dsnet/compress/bzip2"
|
|
"github.com/stretchr/testify/assert"
|
|
"github.com/ulikunitz/xz"
|
|
"os"
|
|
"regexp"
|
|
"strconv"
|
|
"sync"
|
|
"testing"
|
|
)
|
|
|
|
const (
|
|
testArchiveBaseDir = "./test/archives"
|
|
)
|
|
|
|
var archiveRegex = regexp.MustCompile(`(?m)test[1|5]`)
|
|
|
|
func TestArchiveConcurrency(t *testing.T) {
|
|
err := os.MkdirAll(testArchiveBaseDir, os.ModePerm)
|
|
assert.NoError(t, err)
|
|
|
|
testGenerateZip(t)
|
|
|
|
archive, err := Open(Zip, testArchiveBaseDir+"/test.zip")
|
|
assert.NoError(t, err)
|
|
|
|
var wg sync.WaitGroup
|
|
|
|
t.Log("== ExtractArchiveFile ==")
|
|
|
|
// Slam it, see if it breaks.
|
|
for _ = range 10_000 {
|
|
go func() {
|
|
wg.Add(1)
|
|
defer wg.Done()
|
|
file, err := archive.GetFile("test0.txt")
|
|
assert.NoError(t, err)
|
|
assert.Equal(t, "test0.txt", file.FileName)
|
|
|
|
err = file.Extract(ExtractFileOptions{
|
|
Overwrite: true,
|
|
Folder: testArchiveBaseDir + "/extracted/zip",
|
|
})
|
|
assert.NoError(t, err)
|
|
}()
|
|
}
|
|
|
|
wg.Wait()
|
|
|
|
t.Log("== ExtractArchive ==")
|
|
// Slam it, see if it breaks.
|
|
for _ = range 10_000 {
|
|
go func() {
|
|
wg.Add(1)
|
|
defer wg.Done()
|
|
|
|
err = archive.Extract(ExtractOptions{
|
|
Overwrite: true,
|
|
Folder: testArchiveBaseDir + "/extracted/zip",
|
|
})
|
|
assert.NoError(t, err)
|
|
}()
|
|
}
|
|
|
|
wg.Wait()
|
|
|
|
err = os.RemoveAll(testArchiveBaseDir + "/extracted")
|
|
assert.NoError(t, err)
|
|
|
|
err = archive.Close()
|
|
assert.NoError(t, err)
|
|
}
|
|
|
|
func TestArchiveExtract(t *testing.T) {
|
|
err := os.MkdirAll(testArchiveBaseDir, os.ModePerm)
|
|
assert.NoError(t, err)
|
|
|
|
testGenerateZip(t)
|
|
testGenerateTar(t)
|
|
testGenerateTarXz(t)
|
|
testGenerateTarBzip(t)
|
|
TestArchiveTarGzip(t)
|
|
|
|
t.Log("== ExtractZip ==")
|
|
err = Extract(Zip, testArchiveBaseDir+"/test.zip", ExtractOptions{
|
|
Folder: testArchiveBaseDir + "/extracted/zip",
|
|
})
|
|
assert.NoError(t, err)
|
|
|
|
t.Log("== ExtractTar ==")
|
|
err = Extract(Tar, testArchiveBaseDir+"/test.tar", ExtractOptions{
|
|
Folder: testArchiveBaseDir + "/extracted/tar",
|
|
})
|
|
assert.NoError(t, err)
|
|
|
|
t.Log("== ExtractTarXz ==")
|
|
err = Extract(TarXz, testArchiveBaseDir+"/test.tar.xz", ExtractOptions{
|
|
Folder: testArchiveBaseDir + "/extracted/xz",
|
|
})
|
|
assert.NoError(t, err)
|
|
|
|
t.Log("== ExtractTarBz ==")
|
|
err = Extract(TarBzip, testArchiveBaseDir+"/test.tar.bz2", ExtractOptions{
|
|
Folder: testArchiveBaseDir + "/extracted/bzip",
|
|
})
|
|
assert.NoError(t, err)
|
|
|
|
t.Log("== ExtractTarGz ==")
|
|
err = Extract(TarGzip, testArchiveBaseDir+"/test.tar.gz", ExtractOptions{
|
|
Folder: testArchiveBaseDir + "/extracted/gz",
|
|
})
|
|
assert.NoError(t, err)
|
|
|
|
err = os.RemoveAll(testArchiveBaseDir + "/extracted")
|
|
assert.NoError(t, err)
|
|
|
|
}
|
|
|
|
func TestArchiveZip(t *testing.T) {
|
|
err := os.MkdirAll(testArchiveBaseDir, os.ModePerm)
|
|
assert.NoError(t, err)
|
|
testGenerateZip(t)
|
|
|
|
t.Log("== OpenArchive ==")
|
|
archive, err := Open(Zip, testArchiveBaseDir+"/test.zip")
|
|
assert.NoError(t, err)
|
|
assert.Equal(t, archive.FileCount(), 10)
|
|
|
|
t.Log("== ExtractArchiveFile ==")
|
|
archiveFile, err := archive.GetFile("test0.txt")
|
|
assert.NoError(t, err)
|
|
|
|
err = archiveFile.Extract(ExtractFileOptions{
|
|
Folder: testArchiveBaseDir + "/extracted/zip",
|
|
})
|
|
assert.NoError(t, err)
|
|
|
|
err = os.RemoveAll(testArchiveBaseDir + "/extracted/zip")
|
|
assert.NoError(t, err)
|
|
|
|
t.Log("== ExtractArchive ==")
|
|
err = archive.Extract(ExtractOptions{
|
|
Folder: testArchiveBaseDir + "/extracted/zip",
|
|
})
|
|
assert.NoError(t, err)
|
|
|
|
t.Log("== ExtractArchiveFilter ==")
|
|
err = archive.Extract(ExtractOptions{
|
|
Folder: testArchiveBaseDir + "/extracted/zip",
|
|
Filter: archiveRegex,
|
|
})
|
|
|
|
assert.FileExists(t, testArchiveBaseDir+"/extracted/zip/test1.txt")
|
|
assert.FileExists(t, testArchiveBaseDir+"/extracted/zip/test5.txt")
|
|
|
|
err = os.RemoveAll(testArchiveBaseDir + "/extracted/zip")
|
|
assert.NoError(t, err)
|
|
|
|
err = archive.Close()
|
|
assert.NoError(t, err)
|
|
}
|
|
|
|
func TestArchiveTarGzip(t *testing.T) {
|
|
err := os.MkdirAll(testArchiveBaseDir, os.ModePerm)
|
|
assert.NoError(t, err)
|
|
testGenerateTarGzip(t)
|
|
|
|
t.Log("== OpenArchive ==")
|
|
archive, err := Open(TarGzip, testArchiveBaseDir+"/test.tar.gz")
|
|
assert.NoError(t, err)
|
|
assert.Equal(t, archive.FileCount(), 10)
|
|
|
|
t.Log("== ExtractArchiveFile ==")
|
|
archiveFile, err := archive.GetFile("test0.txt")
|
|
assert.NoError(t, err)
|
|
|
|
err = archiveFile.Extract(ExtractFileOptions{
|
|
Folder: testArchiveBaseDir + "/extracted/gz",
|
|
})
|
|
assert.NoError(t, err)
|
|
|
|
err = os.RemoveAll(testArchiveBaseDir + "/extracted/gz")
|
|
assert.NoError(t, err)
|
|
|
|
t.Log("== ExtractArchive ==")
|
|
err = archive.Extract(ExtractOptions{
|
|
Folder: testArchiveBaseDir + "/extracted/gz",
|
|
})
|
|
assert.NoError(t, err)
|
|
|
|
err = os.RemoveAll(testArchiveBaseDir + "/extracted/gz")
|
|
assert.NoError(t, err)
|
|
|
|
t.Log("== ExtractArchiveFilter ==")
|
|
err = archive.Extract(ExtractOptions{
|
|
Folder: testArchiveBaseDir + "/extracted/gz",
|
|
Filter: archiveRegex,
|
|
})
|
|
|
|
assert.FileExists(t, testArchiveBaseDir+"/extracted/gz/test1.txt")
|
|
assert.FileExists(t, testArchiveBaseDir+"/extracted/gz/test5.txt")
|
|
|
|
err = os.RemoveAll(testArchiveBaseDir + "/extracted/gz")
|
|
assert.NoError(t, err)
|
|
|
|
err = archive.Close()
|
|
assert.NoError(t, err)
|
|
}
|
|
|
|
func TestArchiveTarBzip(t *testing.T) {
|
|
err := os.MkdirAll(testArchiveBaseDir, os.ModePerm)
|
|
assert.NoError(t, err)
|
|
testGenerateTarBzip(t)
|
|
|
|
t.Log("== OpenArchive ==")
|
|
archive, err := Open(TarBzip, testArchiveBaseDir+"/test.tar.bz2")
|
|
assert.NoError(t, err)
|
|
assert.Equal(t, archive.FileCount(), 10)
|
|
|
|
t.Log("== ExtractArchiveFile ==")
|
|
archiveFile, err := archive.GetFile("test0.txt")
|
|
assert.NoError(t, err)
|
|
|
|
err = archiveFile.Extract(ExtractFileOptions{
|
|
Folder: testArchiveBaseDir + "/extracted/bzip",
|
|
})
|
|
assert.NoError(t, err)
|
|
|
|
err = os.RemoveAll(testArchiveBaseDir + "/extracted/bzip")
|
|
assert.NoError(t, err)
|
|
|
|
t.Log("== ExtractArchive ==")
|
|
err = archive.Extract(ExtractOptions{
|
|
Folder: testArchiveBaseDir + "/extracted/bzip",
|
|
})
|
|
assert.NoError(t, err)
|
|
|
|
err = os.RemoveAll(testArchiveBaseDir + "/extracted/bzip")
|
|
assert.NoError(t, err)
|
|
|
|
t.Log("== ExtractArchiveFilter ==")
|
|
err = archive.Extract(ExtractOptions{
|
|
Folder: testArchiveBaseDir + "/extracted/bzip",
|
|
Filter: archiveRegex,
|
|
})
|
|
|
|
assert.FileExists(t, testArchiveBaseDir+"/extracted/bzip/test1.txt")
|
|
assert.FileExists(t, testArchiveBaseDir+"/extracted/bzip/test5.txt")
|
|
|
|
err = os.RemoveAll(testArchiveBaseDir + "/extracted/bzip")
|
|
assert.NoError(t, err)
|
|
|
|
err = archive.Close()
|
|
assert.NoError(t, err)
|
|
}
|
|
|
|
func TestArchiveTarXz(t *testing.T) {
|
|
err := os.MkdirAll(testArchiveBaseDir, os.ModePerm)
|
|
assert.NoError(t, err)
|
|
testGenerateTarXz(t)
|
|
|
|
t.Log("== OpenArchive ==")
|
|
archive, err := Open(TarXz, testArchiveBaseDir+"/test.tar.xz")
|
|
assert.NoError(t, err)
|
|
assert.Equal(t, archive.FileCount(), 10)
|
|
|
|
t.Log("== ExtractArchiveFile ==")
|
|
archiveFile, err := archive.GetFile("test0.txt")
|
|
assert.NoError(t, err)
|
|
|
|
err = archiveFile.Extract(ExtractFileOptions{
|
|
Folder: testArchiveBaseDir + "/extracted/xz",
|
|
})
|
|
assert.NoError(t, err)
|
|
|
|
err = os.RemoveAll(testArchiveBaseDir + "/extracted/xz")
|
|
assert.NoError(t, err)
|
|
|
|
t.Log("== ExtractArchive ==")
|
|
err = archive.Extract(ExtractOptions{
|
|
Folder: testArchiveBaseDir + "/extracted/xz",
|
|
})
|
|
assert.NoError(t, err)
|
|
|
|
err = os.RemoveAll(testArchiveBaseDir + "/extracted/xz")
|
|
assert.NoError(t, err)
|
|
|
|
t.Log("== ExtractArchiveFilter ==")
|
|
err = archive.Extract(ExtractOptions{
|
|
Folder: testArchiveBaseDir + "/extracted/xz",
|
|
Filter: archiveRegex,
|
|
})
|
|
|
|
assert.FileExists(t, testArchiveBaseDir+"/extracted/xz/test1.txt")
|
|
assert.FileExists(t, testArchiveBaseDir+"/extracted/xz/test5.txt")
|
|
|
|
err = os.RemoveAll(testArchiveBaseDir + "/extracted/xz")
|
|
assert.NoError(t, err)
|
|
|
|
err = archive.Close()
|
|
assert.NoError(t, err)
|
|
}
|
|
|
|
func TestArchiveTar(t *testing.T) {
|
|
err := os.MkdirAll(testArchiveBaseDir, os.ModePerm)
|
|
assert.NoError(t, err)
|
|
testGenerateTar(t)
|
|
|
|
t.Log("== OpenArchive ==")
|
|
archive, err := Open(Tar, testArchiveBaseDir+"/test.tar")
|
|
assert.NoError(t, err)
|
|
assert.Equal(t, 10, archive.FileCount())
|
|
|
|
t.Log("== ExtractArchiveFile ==")
|
|
archiveFile, err := archive.GetFile("test0.txt")
|
|
assert.NoError(t, err)
|
|
|
|
err = archiveFile.Extract(ExtractFileOptions{
|
|
Folder: testArchiveBaseDir + "/extracted/tar",
|
|
})
|
|
assert.NoError(t, err)
|
|
|
|
err = os.RemoveAll(testArchiveBaseDir + "/extracted/tar")
|
|
assert.NoError(t, err)
|
|
|
|
t.Log("== ExtractArchive ==")
|
|
err = archive.Extract(ExtractOptions{
|
|
Folder: testArchiveBaseDir + "/extracted/tar",
|
|
})
|
|
assert.NoError(t, err)
|
|
|
|
err = os.RemoveAll(testArchiveBaseDir + "/extracted/tar")
|
|
assert.NoError(t, err)
|
|
|
|
t.Log("== ExtractArchiveFilter ==")
|
|
err = archive.Extract(ExtractOptions{
|
|
Folder: testArchiveBaseDir + "/extracted/tar",
|
|
Filter: archiveRegex,
|
|
})
|
|
|
|
assert.FileExists(t, testArchiveBaseDir+"/extracted/tar/test1.txt")
|
|
assert.FileExists(t, testArchiveBaseDir+"/extracted/tar/test5.txt")
|
|
|
|
err = os.RemoveAll(testArchiveBaseDir + "/extracted/tar")
|
|
assert.NoError(t, err)
|
|
|
|
err = archive.Close()
|
|
assert.NoError(t, err)
|
|
}
|
|
|
|
func testGenerateTar(t *testing.T) {
|
|
tarFile, err := os.Create(testArchiveBaseDir + "/test.tar")
|
|
defer tarFile.Close()
|
|
assert.NoError(t, err)
|
|
|
|
tarWriter := tar.NewWriter(tarFile)
|
|
defer tarWriter.Close()
|
|
|
|
for i := 0; i < 10; i++ {
|
|
tarHeader := &tar.Header{
|
|
Name: "test" + strconv.Itoa(i) + ".txt",
|
|
Size: int64(len([]byte("Hello, World! #" + strconv.Itoa(i)))),
|
|
Mode: 0600,
|
|
}
|
|
err = tarWriter.WriteHeader(tarHeader)
|
|
assert.NoError(t, err)
|
|
|
|
_, err = tarWriter.Write([]byte("Hello, World! #" + strconv.Itoa(i)))
|
|
assert.NoError(t, err)
|
|
}
|
|
|
|
err = tarWriter.Close()
|
|
assert.NoError(t, err)
|
|
err = tarFile.Close()
|
|
assert.NoError(t, err)
|
|
}
|
|
|
|
func testGenerateTarXz(t *testing.T) {
|
|
tarXzFile, err := os.Create(testArchiveBaseDir + "/test.tar.xz")
|
|
defer tarXzFile.Close()
|
|
assert.NoError(t, err)
|
|
|
|
xzWriter, err := xz.NewWriter(tarXzFile)
|
|
defer xzWriter.Close()
|
|
assert.NoError(t, err)
|
|
|
|
tarWriter := tar.NewWriter(xzWriter)
|
|
defer tarWriter.Close()
|
|
|
|
for i := 0; i < 10; i++ {
|
|
tarHeader := &tar.Header{
|
|
Name: "test" + strconv.Itoa(i) + ".txt",
|
|
Size: int64(len([]byte("Hello, World! #" + strconv.Itoa(i)))),
|
|
Mode: 0600,
|
|
}
|
|
err = tarWriter.WriteHeader(tarHeader)
|
|
assert.NoError(t, err)
|
|
|
|
_, err = tarWriter.Write([]byte("Hello, World! #" + strconv.Itoa(i)))
|
|
assert.NoError(t, err)
|
|
}
|
|
|
|
err = tarWriter.Close()
|
|
assert.NoError(t, err)
|
|
err = xzWriter.Close()
|
|
assert.NoError(t, err)
|
|
err = tarXzFile.Close()
|
|
assert.NoError(t, err)
|
|
}
|
|
|
|
func testGenerateTarBzip(t *testing.T) {
|
|
tarBzFile, err := os.Create(testArchiveBaseDir + "/test.tar.bz2")
|
|
defer tarBzFile.Close()
|
|
assert.NoError(t, err)
|
|
|
|
bzipWriter, err := bzip2.NewWriter(tarBzFile, &bzip2.WriterConfig{})
|
|
defer bzipWriter.Close()
|
|
assert.NoError(t, err)
|
|
|
|
tarWriter := tar.NewWriter(bzipWriter)
|
|
defer tarWriter.Close()
|
|
|
|
for i := 0; i < 10; i++ {
|
|
tarHeader := &tar.Header{
|
|
Name: "test" + strconv.Itoa(i) + ".txt",
|
|
Size: int64(len([]byte("Hello, World! #" + strconv.Itoa(i)))),
|
|
Mode: 0600,
|
|
}
|
|
err = tarWriter.WriteHeader(tarHeader)
|
|
assert.NoError(t, err)
|
|
|
|
_, err = tarWriter.Write([]byte("Hello, World! #" + strconv.Itoa(i)))
|
|
assert.NoError(t, err)
|
|
}
|
|
|
|
err = tarWriter.Close()
|
|
assert.NoError(t, err)
|
|
err = bzipWriter.Close()
|
|
assert.NoError(t, err)
|
|
err = tarBzFile.Close()
|
|
assert.NoError(t, err)
|
|
}
|
|
|
|
func testGenerateTarGzip(t *testing.T) {
|
|
tarGzFile, err := os.Create(testArchiveBaseDir + "/test.tar.gz")
|
|
defer tarGzFile.Close()
|
|
assert.NoError(t, err)
|
|
|
|
gzipWriter := gzip.NewWriter(tarGzFile)
|
|
defer gzipWriter.Close()
|
|
|
|
tarWriter := tar.NewWriter(gzipWriter)
|
|
defer tarWriter.Close()
|
|
|
|
for i := 0; i < 10; i++ {
|
|
tarHeader := &tar.Header{
|
|
Name: "test" + strconv.Itoa(i) + ".txt",
|
|
Size: int64(len([]byte("Hello, World! #" + strconv.Itoa(i)))),
|
|
Mode: 0600,
|
|
}
|
|
err = tarWriter.WriteHeader(tarHeader)
|
|
assert.NoError(t, err)
|
|
|
|
_, err = tarWriter.Write([]byte("Hello, World! #" + strconv.Itoa(i)))
|
|
assert.NoError(t, err)
|
|
}
|
|
|
|
err = tarWriter.Close()
|
|
assert.NoError(t, err)
|
|
err = gzipWriter.Close()
|
|
assert.NoError(t, err)
|
|
err = tarGzFile.Close()
|
|
assert.NoError(t, err)
|
|
}
|
|
|
|
func testGenerateZip(t *testing.T) {
|
|
zipFile, err := os.Create(testArchiveBaseDir + "/test.zip")
|
|
defer zipFile.Close()
|
|
assert.NoError(t, err)
|
|
|
|
zipWriter := zip.NewWriter(zipFile)
|
|
for i := 0; i < 10; i++ {
|
|
file, err := zipWriter.Create("test" + strconv.Itoa(i) + ".txt")
|
|
assert.NoError(t, err)
|
|
_, err = file.Write([]byte("Hello, World! #" + strconv.Itoa(i)))
|
|
assert.NoError(t, err)
|
|
}
|
|
err = zipWriter.Close()
|
|
assert.NoError(t, err)
|
|
err = zipFile.Close()
|
|
assert.NoError(t, err)
|
|
}
|