github.com/kjk/siser@v0.0.0-20220410204903-1b1e84ea1397/pak/all_test.go (about)

     1  package pak
     2  
     3  import (
     4  	"fmt"
     5  	"io/ioutil"
     6  	"os"
     7  	"testing"
     8  
     9  	"github.com/alecthomas/assert"
    10  )
    11  
    12  func must(err error) {
    13  	if err != nil {
    14  		panic(err.Error())
    15  	}
    16  }
    17  
    18  type test struct {
    19  	isFile bool
    20  	data   []byte
    21  	// path is for both data and files
    22  	path string
    23  	// for files, use to over-ride the path of the file
    24  	pathOverride string
    25  	size         int64
    26  	tp           string
    27  }
    28  
    29  func mkFile(path string) *test {
    30  	size, err := getFileSize(path)
    31  	must(err)
    32  	d, err := ioutil.ReadFile(path)
    33  	must(err)
    34  	return &test{
    35  		isFile: true,
    36  		path:   path,
    37  		size:   size,
    38  		data:   d,
    39  	}
    40  }
    41  
    42  func mkData(d []byte, path string) *test {
    43  	return &test{
    44  		data: d,
    45  		path: path,
    46  		size: int64(len(d)),
    47  	}
    48  }
    49  
    50  func writeTests(t *testing.T, archivePath string, tests []*test) {
    51  	w := NewWriter()
    52  
    53  	for _, test := range tests {
    54  		var meta Metadata
    55  		// check additional metadata
    56  		if test.tp != "" {
    57  			meta.Set("Type", test.tp)
    58  		}
    59  		if test.isFile {
    60  			if test.pathOverride != "" {
    61  				meta.Set("Path", test.pathOverride)
    62  			}
    63  			err := w.AddFile(test.path, meta)
    64  			assert.NoError(t, err)
    65  		} else {
    66  			err := w.AddData(test.data, test.path, meta)
    67  			assert.NoError(t, err)
    68  		}
    69  	}
    70  
    71  	f, err := os.Create(archivePath)
    72  	assert.NoError(t, err)
    73  	err = w.Write(f)
    74  	assert.NoError(t, err)
    75  	err = f.Close()
    76  	assert.NoError(t, err)
    77  }
    78  
    79  func readAndVerifyTests(t *testing.T, archivePath string, tests []*test) {
    80  	a, err := ReadArchive(archivePath)
    81  	assert.NoError(t, err)
    82  
    83  	entries := a.Entries
    84  	assert.NoError(t, err)
    85  	assert.Equal(t, len(entries), len(tests))
    86  
    87  	for i, e := range entries {
    88  		test := tests[i]
    89  		d, err := a.ReadEntry(e)
    90  		assert.NoError(t, err)
    91  		assert.Equal(t, test.data, d)
    92  
    93  		path := test.path
    94  		if test.pathOverride != "" {
    95  			path = test.pathOverride
    96  		}
    97  
    98  		assert.Equal(t, path, e.Path)
    99  		v, _ := e.Metadata.Get("Path")
   100  		assert.Equal(t, path, v)
   101  
   102  		assert.Equal(t, test.size, e.Size)
   103  		assert.Equal(t, test.data, d)
   104  		expMetaSize := 3
   105  		if test.tp != "" {
   106  			v, _ = e.Metadata.Get("Type")
   107  			assert.Equal(t, test.tp, v)
   108  			expMetaSize++
   109  		}
   110  		assert.Equal(t, expMetaSize, e.Metadata.Size())
   111  	}
   112  }
   113  
   114  func TestWriteRead(t *testing.T) {
   115  	tests := []*test{
   116  		mkFile("all_test.go"),
   117  		mkFile("metadata.go"),
   118  		mkFile("reader.go"),
   119  		mkFile("writer.go"),
   120  		mkData([]byte{}, "empty_file.txt"),
   121  		mkFile("README.md"),
   122  		mkData([]byte{0x0, 0x1, 0x3, 0x0}, "some_data.dat"),
   123  	}
   124  	tests[1].tp = "sum file"
   125  	tests[2].pathOverride = "LICENSE.overwritten"
   126  
   127  	files, err := ioutil.ReadDir(".")
   128  	assert.NoError(t, err)
   129  	for _, fi := range files {
   130  		if !fi.Mode().IsRegular() {
   131  			continue
   132  		}
   133  		d, err := ioutil.ReadFile(fi.Name())
   134  		must(err)
   135  		test := mkData(d, fi.Name()+".data")
   136  		tests = append(tests, test)
   137  	}
   138  
   139  	writeReadArchiveTests(t, "test_archive.txt", tests)
   140  }
   141  
   142  func writeReadArchiveTests(t *testing.T, archivePath string, tests []*test) {
   143  	writeTests(t, archivePath, tests)
   144  
   145  	// on error leave the archive file for inspection
   146  	defer func() {
   147  		if !t.Failed() {
   148  			err := os.Remove(archivePath)
   149  			if err != nil {
   150  				fmt.Printf("os.Remove('%s') failed with '%s'\n", archivePath, err)
   151  			}
   152  		}
   153  	}()
   154  	readAndVerifyTests(t, archivePath, tests)
   155  
   156  }
   157  
   158  func TestBug(t *testing.T) {
   159  	tests := []*test{
   160  		// siser had issues when reading a record followed by record
   161  		// starting with 0xa
   162  		mkData([]byte{0xa, 0x1, 0x3, 0x0}, "some_data.dat"),
   163  		mkFile("reader.go"),
   164  	}
   165  
   166  	writeReadArchiveTests(t, "test_archive_bug.txt", tests)
   167  }
   168  
   169  func TestMetadata(t *testing.T) {
   170  	var m Metadata
   171  	assert.Equal(t, 0, m.Size())
   172  	var added, ok bool
   173  	var v string
   174  	added = m.Set("Foo", "bar")
   175  	assert.True(t, added)
   176  	v, ok = m.Get("Foo")
   177  	assert.True(t, ok)
   178  	assert.Equal(t, v, "bar")
   179  	added = m.Set("foo", "bar")
   180  	assert.True(t, added) // case insensitive
   181  	assert.Equal(t, 2, m.Size())
   182  	added = m.Set("Foo", "bar2") // update
   183  	assert.False(t, added)
   184  	assert.Equal(t, 2, m.Size())
   185  	v, ok = m.Get("Foo")
   186  	assert.True(t, ok)
   187  	assert.Equal(t, v, "bar2")
   188  }