github.imxd.top/openshift/source-to-image@v1.2.0/pkg/test/tar.go (about)

     1  package test
     2  
     3  import (
     4  	"errors"
     5  	"io"
     6  	"regexp"
     7  	"sync"
     8  
     9  	"github.com/openshift/source-to-image/pkg/tar"
    10  )
    11  
    12  // FakeTar provides a fake UNIX tar interface
    13  type FakeTar struct {
    14  	CreateTarBase   string
    15  	CreateTarDir    string
    16  	CreateTarResult string
    17  	CreateTarError  error
    18  
    19  	ExtractTarDir    string
    20  	ExtractTarReader io.Reader
    21  	ExtractTarError  error
    22  
    23  	lock sync.Mutex
    24  }
    25  
    26  // Copy returns a copy of the FakeTar object
    27  func (f *FakeTar) Copy() *FakeTar {
    28  	f.lock.Lock()
    29  	defer f.lock.Unlock()
    30  	// copy everything except .lock...
    31  	n := &FakeTar{
    32  		CreateTarBase:    f.CreateTarBase,
    33  		CreateTarDir:     f.CreateTarDir,
    34  		CreateTarResult:  f.CreateTarResult,
    35  		CreateTarError:   f.CreateTarError,
    36  		ExtractTarDir:    f.ExtractTarDir,
    37  		ExtractTarReader: f.ExtractTarReader,
    38  		ExtractTarError:  f.ExtractTarError,
    39  	}
    40  	return n
    41  }
    42  
    43  // CreateTarFile creates a new fake UNIX tar file
    44  func (f *FakeTar) CreateTarFile(base, dir string) (string, error) {
    45  	f.lock.Lock()
    46  	defer f.lock.Unlock()
    47  	f.CreateTarBase = base
    48  	f.CreateTarDir = dir
    49  	return f.CreateTarResult, f.CreateTarError
    50  }
    51  
    52  // ExtractTarStreamWithLogging streams a content of fake tar
    53  func (f *FakeTar) ExtractTarStreamWithLogging(dir string, reader io.Reader, logger io.Writer) error {
    54  	f.lock.Lock()
    55  	defer f.lock.Unlock()
    56  	f.ExtractTarDir = dir
    57  	f.ExtractTarReader = reader
    58  	return f.ExtractTarError
    59  }
    60  
    61  // ExtractTarStreamFromTarReader streams a content of fake tar from a tar.Reader
    62  func (f *FakeTar) ExtractTarStreamFromTarReader(dir string, tarReader tar.Reader, logger io.Writer) error {
    63  	return errors.New("not implemented")
    64  }
    65  
    66  // ExtractTarStream streams a content of fake tar
    67  func (f *FakeTar) ExtractTarStream(dir string, reader io.Reader) error {
    68  	return f.ExtractTarStreamWithLogging(dir, reader, nil)
    69  }
    70  
    71  // SetExclusionPattern sets the exclusion pattern
    72  func (f *FakeTar) SetExclusionPattern(*regexp.Regexp) {
    73  }
    74  
    75  // CreateTarStreamToTarWriter creates a tar from the given directory and streams
    76  // it to the given writer.
    77  func (f *FakeTar) CreateTarStreamToTarWriter(dir string, includeDirInPath bool, writer tar.Writer, logger io.Writer) error {
    78  	f.lock.Lock()
    79  	defer f.lock.Unlock()
    80  	f.CreateTarDir = dir
    81  	return f.CreateTarError
    82  }
    83  
    84  // CreateTarStream creates a tar from the given directory and streams it to the
    85  // given writer.
    86  func (f *FakeTar) CreateTarStream(dir string, includeDirInPath bool, writer io.Writer) error {
    87  	return f.CreateTarStreamToTarWriter(dir, includeDirInPath, nil, nil)
    88  }
    89  
    90  // CreateTarStreamReader returns an io.ReadCloser from which a tar stream can be
    91  // read.  The tar stream is created using CreateTarStream.
    92  func (f *FakeTar) CreateTarStreamReader(dir string, includeDirInPath bool) io.ReadCloser {
    93  	f.CreateTarStreamToTarWriter(dir, includeDirInPath, nil, nil)
    94  	r, w := io.Pipe()
    95  	go w.CloseWithError(f.CreateTarError)
    96  	return r
    97  }