linux_test.go

Documentation: gopkg.in/natefinch/lumberjack.v2

     1  // +build linux
     2  
     3  package lumberjack
     4  
     5  import (
     6  	"os"
     7  	"syscall"
     8  	"testing"
     9  	"time"
    10  )
    11  
    12  func TestMaintainMode(t *testing.T) {
    13  	currentTime = fakeTime
    14  	dir := makeTempDir("TestMaintainMode", t)
    15  	defer os.RemoveAll(dir)
    16  
    17  	filename := logFile(dir)
    18  
    19  	mode := os.FileMode(0600)
    20  	f, err := os.OpenFile(filename, os.O_CREATE|os.O_RDWR, mode)
    21  	isNil(err, t)
    22  	f.Close()
    23  
    24  	l := &Logger{
    25  		Filename:   filename,
    26  		MaxBackups: 1,
    27  		MaxSize:    100, // megabytes
    28  	}
    29  	defer l.Close()
    30  	b := []byte("boo!")
    31  	n, err := l.Write(b)
    32  	isNil(err, t)
    33  	equals(len(b), n, t)
    34  
    35  	newFakeTime()
    36  
    37  	err = l.Rotate()
    38  	isNil(err, t)
    39  
    40  	filename2 := backupFile(dir)
    41  	info, err := os.Stat(filename)
    42  	isNil(err, t)
    43  	info2, err := os.Stat(filename2)
    44  	isNil(err, t)
    45  	equals(mode, info.Mode(), t)
    46  	equals(mode, info2.Mode(), t)
    47  }
    48  
    49  func TestMaintainOwner(t *testing.T) {
    50  	fakeFS := newFakeFS()
    51  	osChown = fakeFS.Chown
    52  	osStat = fakeFS.Stat
    53  	defer func() {
    54  		osChown = os.Chown
    55  		osStat = os.Stat
    56  	}()
    57  	currentTime = fakeTime
    58  	dir := makeTempDir("TestMaintainOwner", t)
    59  	defer os.RemoveAll(dir)
    60  
    61  	filename := logFile(dir)
    62  
    63  	f, err := os.OpenFile(filename, os.O_CREATE|os.O_RDWR, 0644)
    64  	isNil(err, t)
    65  	f.Close()
    66  
    67  	l := &Logger{
    68  		Filename:   filename,
    69  		MaxBackups: 1,
    70  		MaxSize:    100, // megabytes
    71  	}
    72  	defer l.Close()
    73  	b := []byte("boo!")
    74  	n, err := l.Write(b)
    75  	isNil(err, t)
    76  	equals(len(b), n, t)
    77  
    78  	newFakeTime()
    79  
    80  	err = l.Rotate()
    81  	isNil(err, t)
    82  
    83  	equals(555, fakeFS.files[filename].uid, t)
    84  	equals(666, fakeFS.files[filename].gid, t)
    85  }
    86  
    87  func TestCompressMaintainMode(t *testing.T) {
    88  	currentTime = fakeTime
    89  
    90  	dir := makeTempDir("TestCompressMaintainMode", t)
    91  	defer os.RemoveAll(dir)
    92  
    93  	filename := logFile(dir)
    94  
    95  	mode := os.FileMode(0600)
    96  	f, err := os.OpenFile(filename, os.O_CREATE|os.O_RDWR, mode)
    97  	isNil(err, t)
    98  	f.Close()
    99  
   100  	l := &Logger{
   101  		Compress:   true,
   102  		Filename:   filename,
   103  		MaxBackups: 1,
   104  		MaxSize:    100, // megabytes
   105  	}
   106  	defer l.Close()
   107  	b := []byte("boo!")
   108  	n, err := l.Write(b)
   109  	isNil(err, t)
   110  	equals(len(b), n, t)
   111  
   112  	newFakeTime()
   113  
   114  	err = l.Rotate()
   115  	isNil(err, t)
   116  
   117  	// we need to wait a little bit since the files get compressed on a different
   118  	// goroutine.
   119  	<-time.After(10 * time.Millisecond)
   120  
   121  	// a compressed version of the log file should now exist with the correct
   122  	// mode.
   123  	filename2 := backupFile(dir)
   124  	info, err := os.Stat(filename)
   125  	isNil(err, t)
   126  	info2, err := os.Stat(filename2 + compressSuffix)
   127  	isNil(err, t)
   128  	equals(mode, info.Mode(), t)
   129  	equals(mode, info2.Mode(), t)
   130  }
   131  
   132  func TestCompressMaintainOwner(t *testing.T) {
   133  	fakeFS := newFakeFS()
   134  	osChown = fakeFS.Chown
   135  	osStat = fakeFS.Stat
   136  	defer func() {
   137  		osChown = os.Chown
   138  		osStat = os.Stat
   139  	}()
   140  	currentTime = fakeTime
   141  	dir := makeTempDir("TestCompressMaintainOwner", t)
   142  	defer os.RemoveAll(dir)
   143  
   144  	filename := logFile(dir)
   145  
   146  	f, err := os.OpenFile(filename, os.O_CREATE|os.O_RDWR, 0644)
   147  	isNil(err, t)
   148  	f.Close()
   149  
   150  	l := &Logger{
   151  		Compress:   true,
   152  		Filename:   filename,
   153  		MaxBackups: 1,
   154  		MaxSize:    100, // megabytes
   155  	}
   156  	defer l.Close()
   157  	b := []byte("boo!")
   158  	n, err := l.Write(b)
   159  	isNil(err, t)
   160  	equals(len(b), n, t)
   161  
   162  	newFakeTime()
   163  
   164  	err = l.Rotate()
   165  	isNil(err, t)
   166  
   167  	// we need to wait a little bit since the files get compressed on a different
   168  	// goroutine.
   169  	<-time.After(10 * time.Millisecond)
   170  
   171  	// a compressed version of the log file should now exist with the correct
   172  	// owner.
   173  	filename2 := backupFile(dir)
   174  	equals(555, fakeFS.files[filename2+compressSuffix].uid, t)
   175  	equals(666, fakeFS.files[filename2+compressSuffix].gid, t)
   176  }
   177  
   178  type fakeFile struct {
   179  	uid int
   180  	gid int
   181  }
   182  
   183  type fakeFS struct {
   184  	files map[string]fakeFile
   185  }
   186  
   187  func newFakeFS() *fakeFS {
   188  	return &fakeFS{files: make(map[string]fakeFile)}
   189  }
   190  
   191  func (fs *fakeFS) Chown(name string, uid, gid int) error {
   192  	fs.files[name] = fakeFile{uid: uid, gid: gid}
   193  	return nil
   194  }
   195  
   196  func (fs *fakeFS) Stat(name string) (os.FileInfo, error) {
   197  	info, err := os.Stat(name)
   198  	if err != nil {
   199  		return nil, err
   200  	}
   201  	stat := info.Sys().(*syscall.Stat_t)
   202  	stat.Uid = 555
   203  	stat.Gid = 666
   204  	return info, nil
   205  }
   206
View as plain text