github.com/nikandfor/tlog@v0.21.3/ext/tlflag/flag_test.go (about)

     1  package tlflag
     2  
     3  import (
     4  	"os"
     5  	"testing"
     6  
     7  	"github.com/nikandfor/assert"
     8  	"github.com/nikandfor/errors"
     9  
    10  	"github.com/nikandfor/tlog"
    11  	"github.com/nikandfor/tlog/convert"
    12  	"github.com/nikandfor/tlog/tlio"
    13  	"github.com/nikandfor/tlog/tlz"
    14  )
    15  
    16  type testFile string
    17  
    18  func TestingFileOpener(n string, f int, m os.FileMode) (interface{}, error) {
    19  	return testFile(n), nil
    20  }
    21  
    22  func TestFileWriter(t *testing.T) {
    23  	OpenFileWriter = TestingFileOpener
    24  
    25  	const CompressorBlockSize = 1 * tlz.MiB
    26  
    27  	w, err := OpenWriter("stderr")
    28  	assert.NoError(t, err)
    29  	assert.Equal(t, tlio.MultiWriter{
    30  		tlog.NewConsoleWriter(tlog.Stderr, tlog.LstdFlags),
    31  	}, w)
    32  
    33  	w, err = OpenWriter("stderr?dm,stderr?dm")
    34  	assert.NoError(t, err)
    35  	assert.Equal(t, tlio.MultiWriter{
    36  		tlog.NewConsoleWriter(tlog.Stderr, tlog.LdetFlags|tlog.Lmilliseconds),
    37  		tlog.NewConsoleWriter(tlog.Stderr, tlog.LdetFlags|tlog.Lmilliseconds),
    38  	}, w)
    39  
    40  	w, err = OpenWriter(".tl,-.tl")
    41  	assert.NoError(t, err)
    42  	assert.Equal(t, tlio.MultiWriter{
    43  		tlio.NopCloser{Writer: tlog.Stderr},
    44  		tlio.NopCloser{Writer: tlog.Stdout},
    45  	}, w)
    46  
    47  	w, err = OpenWriter(".tlz")
    48  	assert.NoError(t, err)
    49  	assert.Equal(t, tlio.MultiWriter{
    50  		tlz.NewEncoder(tlog.Stderr, CompressorBlockSize),
    51  	}, w)
    52  
    53  	w, err = OpenWriter("file.tlz")
    54  	assert.NoError(t, err)
    55  	assert.Equal(t, tlio.WriteCloser{
    56  		Writer: tlz.NewEncoder(testFile("file.tlz"), CompressorBlockSize),
    57  		Closer: testFile("file.tlz"),
    58  	}, w)
    59  
    60  	w, err = OpenWriter("file.tl.ez")
    61  	assert.NoError(t, err)
    62  	assert.Equal(t, tlio.WriteCloser{
    63  		Writer: tlz.NewEncoder(testFile("file.tl.ez"), CompressorBlockSize),
    64  		Closer: testFile("file.tl.ez"),
    65  	}, w)
    66  
    67  	w, err = OpenWriter("file.ezdump")
    68  	assert.NoError(t, err)
    69  	assert.Equal(t, tlio.WriteCloser{
    70  		Writer: tlz.NewEncoder(tlz.NewDumper(testFile("file.ezdump")), tlz.MiB),
    71  		Closer: testFile("file.ezdump"),
    72  	}, w)
    73  
    74  	w, err = OpenWriter("file.json")
    75  	assert.NoError(t, err)
    76  	assert.Equal(t, tlio.WriteCloser{
    77  		Writer: convert.NewJSON(testFile("file.json")),
    78  		Closer: testFile("file.json"),
    79  	}, w)
    80  
    81  	w, err = OpenWriter("file.json.ez")
    82  	assert.NoError(t, err)
    83  	assert.Equal(t, tlio.WriteCloser{
    84  		Writer: convert.NewJSON(
    85  			tlz.NewEncoder(
    86  				testFile("file.json.ez"),
    87  				CompressorBlockSize)),
    88  		Closer: testFile("file.json.ez"),
    89  	}, w)
    90  }
    91  
    92  func TestURLWriter(t *testing.T) { //nolint:dupl
    93  	OpenFileWriter = func(n string, f int, m os.FileMode) (interface{}, error) {
    94  		return testFile(n), nil
    95  	}
    96  
    97  	w, err := OpenWriter("relative/path.tlog")
    98  	assert.NoError(t, err)
    99  	assert.Equal(t, testFile("relative/path.tlog"), w)
   100  
   101  	w, err = OpenWriter("file://relative/path.tlog")
   102  	assert.NoError(t, err)
   103  	assert.Equal(t, testFile("relative/path.tlog"), w)
   104  
   105  	w, err = OpenWriter("file:///absolute/path.tlog")
   106  	assert.NoError(t, err)
   107  	assert.Equal(t, testFile("/absolute/path.tlog"), w)
   108  }
   109  
   110  func TestFileReader(t *testing.T) {
   111  	OpenFileReader = TestingFileOpener
   112  
   113  	r, err := OpenReader("stdin")
   114  	assert.NoError(t, err)
   115  	assert.Equal(t, tlio.NopCloser{
   116  		Reader: os.Stdin,
   117  	}, r)
   118  
   119  	r, err = OpenReader("./stdin")
   120  	assert.NoError(t, err)
   121  	assert.Equal(t, testFile("./stdin"), r)
   122  
   123  	r, err = OpenReader(".tlog.ez")
   124  	assert.NoError(t, err)
   125  	assert.Equal(t, tlio.NopCloser{Reader: tlz.NewDecoder(os.Stdin)}, r)
   126  }
   127  
   128  func TestURLReader(t *testing.T) { //nolint:dupl
   129  	OpenFileReader = func(n string, f int, m os.FileMode) (interface{}, error) {
   130  		return testFile(n), nil
   131  	}
   132  
   133  	w, err := OpenReader("relative/path.tlog")
   134  	assert.NoError(t, err)
   135  	assert.Equal(t, testFile("relative/path.tlog"), w)
   136  
   137  	w, err = OpenReader("file://relative/path.tlog")
   138  	assert.NoError(t, err)
   139  	assert.Equal(t, testFile("relative/path.tlog"), w)
   140  
   141  	w, err = OpenReader("file:///absolute/path.tlog")
   142  	assert.NoError(t, err)
   143  	assert.Equal(t, testFile("/absolute/path.tlog"), w)
   144  }
   145  
   146  func (testFile) Write(p []byte) (int, error) { return len(p), nil }
   147  
   148  func (testFile) Read(p []byte) (int, error) { return 0, errors.New("test mock") }
   149  
   150  func (testFile) Close() error { return nil }