packer_test.go

Documentation: github.com/vbatts/tar-split/tar/storage

     1  package storage
     2  
     3  import (
     4  	"bytes"
     5  	"compress/gzip"
     6  	"io"
     7  	"os"
     8  	"testing"
     9  )
    10  
    11  func TestDuplicateFail(t *testing.T) {
    12  	e := []Entry{
    13  		{
    14  			Type:    FileType,
    15  			Name:    "./hurr.txt",
    16  			Payload: []byte("abcde"),
    17  		},
    18  		{
    19  			Type:    FileType,
    20  			Name:    "./hurr.txt",
    21  			Payload: []byte("deadbeef"),
    22  		},
    23  		{
    24  			Type:    FileType,
    25  			Name:    "hurr.txt", // slightly different path, same file though
    26  			Payload: []byte("deadbeef"),
    27  		},
    28  	}
    29  	buf := []byte{}
    30  	b := bytes.NewBuffer(buf)
    31  
    32  	jp := NewJSONPacker(b)
    33  	if _, err := jp.AddEntry(e[0]); err != nil {
    34  		t.Error(err)
    35  	}
    36  	if _, err := jp.AddEntry(e[1]); err != ErrDuplicatePath {
    37  		t.Errorf("expected failure on duplicate path")
    38  	}
    39  	if _, err := jp.AddEntry(e[2]); err != ErrDuplicatePath {
    40  		t.Errorf("expected failure on duplicate path")
    41  	}
    42  }
    43  
    44  func TestJSONPackerUnpacker(t *testing.T) {
    45  	e := []Entry{
    46  		{
    47  			Type:    SegmentType,
    48  			Payload: []byte("how"),
    49  		},
    50  		{
    51  			Type:    SegmentType,
    52  			Payload: []byte("y'all"),
    53  		},
    54  		{
    55  			Type:    FileType,
    56  			Name:    "./hurr.txt",
    57  			Payload: []byte("deadbeef"),
    58  		},
    59  		{
    60  			Type:    SegmentType,
    61  			Payload: []byte("doin"),
    62  		},
    63  	}
    64  
    65  	buf := []byte{}
    66  	b := bytes.NewBuffer(buf)
    67  
    68  	func() {
    69  		jp := NewJSONPacker(b)
    70  		for i := range e {
    71  			if _, err := jp.AddEntry(e[i]); err != nil {
    72  				t.Error(err)
    73  			}
    74  		}
    75  	}()
    76  
    77  	// >> packer_test.go:43: uncompressed: 266
    78  	//t.Errorf("uncompressed: %d", len(b.Bytes()))
    79  
    80  	b = bytes.NewBuffer(b.Bytes())
    81  	entries := Entries{}
    82  	func() {
    83  		jup := NewJSONUnpacker(b)
    84  		for {
    85  			entry, err := jup.Next()
    86  			if err != nil {
    87  				if err == io.EOF {
    88  					break
    89  				}
    90  				t.Error(err)
    91  			}
    92  			entries = append(entries, *entry)
    93  			t.Logf("got %#v", entry)
    94  		}
    95  	}()
    96  	if len(entries) != len(e) {
    97  		t.Errorf("expected %d entries, got %d", len(e), len(entries))
    98  	}
    99  }
   100  
   101  // you can use a compress Reader/Writer and make nice savings.
   102  //
   103  // For these two tests that are using the same set, it the difference of 266
   104  // bytes uncompressed vs 138 bytes compressed.
   105  func TestGzip(t *testing.T) {
   106  	e := []Entry{
   107  		{
   108  			Type:    SegmentType,
   109  			Payload: []byte("how"),
   110  		},
   111  		{
   112  			Type:    SegmentType,
   113  			Payload: []byte("y'all"),
   114  		},
   115  		{
   116  			Type:    FileType,
   117  			Name:    "./hurr.txt",
   118  			Payload: []byte("deadbeef"),
   119  		},
   120  		{
   121  			Type:    SegmentType,
   122  			Payload: []byte("doin"),
   123  		},
   124  	}
   125  
   126  	buf := []byte{}
   127  	b := bytes.NewBuffer(buf)
   128  	gzW := gzip.NewWriter(b)
   129  	jp := NewJSONPacker(gzW)
   130  	for i := range e {
   131  		if _, err := jp.AddEntry(e[i]); err != nil {
   132  			t.Error(err)
   133  		}
   134  	}
   135  	gzW.Close()
   136  
   137  	// >> packer_test.go:99: compressed: 138
   138  	//t.Errorf("compressed: %d", len(b.Bytes()))
   139  
   140  	b = bytes.NewBuffer(b.Bytes())
   141  	gzR, err := gzip.NewReader(b)
   142  	if err != nil {
   143  		t.Fatal(err)
   144  	}
   145  	entries := Entries{}
   146  	func() {
   147  		jup := NewJSONUnpacker(gzR)
   148  		for {
   149  			entry, err := jup.Next()
   150  			if err != nil {
   151  				if err == io.EOF {
   152  					break
   153  				}
   154  				t.Error(err)
   155  			}
   156  			entries = append(entries, *entry)
   157  			t.Logf("got %#v", entry)
   158  		}
   159  	}()
   160  	if len(entries) != len(e) {
   161  		t.Errorf("expected %d entries, got %d", len(e), len(entries))
   162  	}
   163  }
   164  
   165  func BenchmarkGetPut(b *testing.B) {
   166  	e := []Entry{
   167  		{
   168  			Type:    SegmentType,
   169  			Payload: []byte("how"),
   170  		},
   171  		{
   172  			Type:    SegmentType,
   173  			Payload: []byte("y'all"),
   174  		},
   175  		{
   176  			Type:    FileType,
   177  			Name:    "./hurr.txt",
   178  			Payload: []byte("deadbeef"),
   179  		},
   180  		{
   181  			Type:    SegmentType,
   182  			Payload: []byte("doin"),
   183  		},
   184  	}
   185  	b.RunParallel(func(pb *testing.PB) {
   186  		for pb.Next() {
   187  			func() {
   188  				fh, err := os.CreateTemp("", "tar-split.")
   189  				if err != nil {
   190  					b.Fatal(err)
   191  				}
   192  				defer os.Remove(fh.Name())
   193  				defer fh.Close()
   194  
   195  				jp := NewJSONPacker(fh)
   196  				for i := range e {
   197  					if _, err := jp.AddEntry(e[i]); err != nil {
   198  						b.Fatal(err)
   199  					}
   200  				}
   201  				if err := fh.Sync(); err != nil {
   202  					b.Fatal(err)
   203  				}
   204  
   205  				up := NewJSONUnpacker(fh)
   206  				for {
   207  					_, err := up.Next()
   208  					if err != nil {
   209  						if err == io.EOF {
   210  							break
   211  						}
   212  						b.Fatal(err)
   213  					}
   214  				}
   215  
   216  			}()
   217  		}
   218  	})
   219  }
   220
View as plain text