vendor/gopkg.in/natefinch/lumberjack.v2/lumberjack_test.go - cloudstack-kubernetes-provider - Git at Google

 package lumberjack

 import (
 	"bytes"
 	"compress/gzip"
 	"encoding/json"
 	"fmt"
 	"io/ioutil"
 	"os"
 	"path/filepath"
 	"testing"
 	"time"

 	"github.com/BurntSushi/toml"
 	"gopkg.in/yaml.v2"
 )

 // !!!NOTE!!!
 //
 // Running these tests in parallel will almost certainly cause sporadic (or even
 // regular) failures, because they're all messing with the same global variable
 // that controls the logic's mocked time.Now.  So... don't do that.

 // Since all the tests uses the time to determine filenames etc, we need to
 // control the wall clock as much as possible, which means having a wall clock
 // that doesn't change unless we want it to.
 var fakeCurrentTime = time.Now()

 func fakeTime() time.Time {
 	return fakeCurrentTime
 }

 func TestNewFile(t *testing.T) {
 	currentTime = fakeTime

 	dir := makeTempDir("TestNewFile", t)
 	defer os.RemoveAll(dir)
 	l := &Logger{
 		Filename: logFile(dir),
 	}
 	defer l.Close()
 	b := []byte("boo!")
 	n, err := l.Write(b)
 	isNil(err, t)
 	equals(len(b), n, t)
 	existsWithContent(logFile(dir), b, t)
 	fileCount(dir, 1, t)
 }

 func TestOpenExisting(t *testing.T) {
 	currentTime = fakeTime
 	dir := makeTempDir("TestOpenExisting", t)
 	defer os.RemoveAll(dir)

 	filename := logFile(dir)
 	data := []byte("foo!")
 	err := ioutil.WriteFile(filename, data, 0644)
 	isNil(err, t)
 	existsWithContent(filename, data, t)

 	l := &Logger{
 		Filename: filename,
 	}
 	defer l.Close()
 	b := []byte("boo!")
 	n, err := l.Write(b)
 	isNil(err, t)
 	equals(len(b), n, t)

 	// make sure the file got appended
 	existsWithContent(filename, append(data, b...), t)

 	// make sure no other files were created
 	fileCount(dir, 1, t)
 }

 func TestWriteTooLong(t *testing.T) {
 	currentTime = fakeTime
 	megabyte = 1
 	dir := makeTempDir("TestWriteTooLong", t)
 	defer os.RemoveAll(dir)
 	l := &Logger{
 		Filename: logFile(dir),
 		MaxSize:  5,
 	}
 	defer l.Close()
 	b := []byte("booooooooooooooo!")
 	n, err := l.Write(b)
 	notNil(err, t)
 	equals(0, n, t)
 	equals(err.Error(),
 		fmt.Sprintf("write length %d exceeds maximum file size %d", len(b), l.MaxSize), t)
 	_, err = os.Stat(logFile(dir))
 	assert(os.IsNotExist(err), t, "File exists, but should not have been created")
 }

 func TestMakeLogDir(t *testing.T) {
 	currentTime = fakeTime
 	dir := time.Now().Format("TestMakeLogDir" + backupTimeFormat)
 	dir = filepath.Join(os.TempDir(), dir)
 	defer os.RemoveAll(dir)
 	filename := logFile(dir)
 	l := &Logger{
 		Filename: filename,
 	}
 	defer l.Close()
 	b := []byte("boo!")
 	n, err := l.Write(b)
 	isNil(err, t)
 	equals(len(b), n, t)
 	existsWithContent(logFile(dir), b, t)
 	fileCount(dir, 1, t)
 }

 func TestDefaultFilename(t *testing.T) {
 	currentTime = fakeTime
 	dir := os.TempDir()
 	filename := filepath.Join(dir, filepath.Base(os.Args[0])+"-lumberjack.log")
 	defer os.Remove(filename)
 	l := &Logger{}
 	defer l.Close()
 	b := []byte("boo!")
 	n, err := l.Write(b)

 	isNil(err, t)
 	equals(len(b), n, t)
 	existsWithContent(filename, b, t)
 }

 func TestAutoRotate(t *testing.T) {
 	currentTime = fakeTime
 	megabyte = 1

 	dir := makeTempDir("TestAutoRotate", t)
 	defer os.RemoveAll(dir)

 	filename := logFile(dir)
 	l := &Logger{
 		Filename: filename,
 		MaxSize:  10,
 	}
 	defer l.Close()
 	b := []byte("boo!")
 	n, err := l.Write(b)
 	isNil(err, t)
 	equals(len(b), n, t)

 	existsWithContent(filename, b, t)
 	fileCount(dir, 1, t)

 	newFakeTime()

 	b2 := []byte("foooooo!")
 	n, err = l.Write(b2)
 	isNil(err, t)
 	equals(len(b2), n, t)

 	// the old logfile should be moved aside and the main logfile should have
 	// only the last write in it.
 	existsWithContent(filename, b2, t)

 	// the backup file will use the current fake time and have the old contents.
 	existsWithContent(backupFile(dir), b, t)

 	fileCount(dir, 2, t)
 }

 func TestFirstWriteRotate(t *testing.T) {
 	currentTime = fakeTime
 	megabyte = 1
 	dir := makeTempDir("TestFirstWriteRotate", t)
 	defer os.RemoveAll(dir)

 	filename := logFile(dir)
 	l := &Logger{
 		Filename: filename,
 		MaxSize:  10,
 	}
 	defer l.Close()

 	start := []byte("boooooo!")
 	err := ioutil.WriteFile(filename, start, 0600)
 	isNil(err, t)

 	newFakeTime()

 	// this would make us rotate
 	b := []byte("fooo!")
 	n, err := l.Write(b)
 	isNil(err, t)
 	equals(len(b), n, t)

 	existsWithContent(filename, b, t)
 	existsWithContent(backupFile(dir), start, t)

 	fileCount(dir, 2, t)
 }

 func TestMaxBackups(t *testing.T) {
 	currentTime = fakeTime
 	megabyte = 1
 	dir := makeTempDir("TestMaxBackups", t)
 	defer os.RemoveAll(dir)

 	filename := logFile(dir)
 	l := &Logger{
 		Filename:   filename,
 		MaxSize:    10,
 		MaxBackups: 1,
 	}
 	defer l.Close()
 	b := []byte("boo!")
 	n, err := l.Write(b)
 	isNil(err, t)
 	equals(len(b), n, t)

 	existsWithContent(filename, b, t)
 	fileCount(dir, 1, t)

 	newFakeTime()

 	// this will put us over the max
 	b2 := []byte("foooooo!")
 	n, err = l.Write(b2)
 	isNil(err, t)
 	equals(len(b2), n, t)

 	// this will use the new fake time
 	secondFilename := backupFile(dir)
 	existsWithContent(secondFilename, b, t)

 	// make sure the old file still exists with the same content.
 	existsWithContent(filename, b2, t)

 	fileCount(dir, 2, t)

 	newFakeTime()

 	// this will make us rotate again
 	b3 := []byte("baaaaaar!")
 	n, err = l.Write(b3)
 	isNil(err, t)
 	equals(len(b3), n, t)

 	// this will use the new fake time
 	thirdFilename := backupFile(dir)
 	existsWithContent(thirdFilename, b2, t)

 	existsWithContent(filename, b3, t)

 	// we need to wait a little bit since the files get deleted on a different
 	// goroutine.
 	<-time.After(time.Millisecond * 10)

 	// should only have two files in the dir still
 	fileCount(dir, 2, t)

 	// second file name should still exist
 	existsWithContent(thirdFilename, b2, t)

 	// should have deleted the first backup
 	notExist(secondFilename, t)

 	// now test that we don't delete directories or non-logfile files

 	newFakeTime()

 	// create a file that is close to but different from the logfile name.
 	// It shouldn't get caught by our deletion filters.
 	notlogfile := logFile(dir) + ".foo"
 	err = ioutil.WriteFile(notlogfile, []byte("data"), 0644)
 	isNil(err, t)

 	// Make a directory that exactly matches our log file filters... it still
 	// shouldn't get caught by the deletion filter since it's a directory.
 	notlogfiledir := backupFile(dir)
 	err = os.Mkdir(notlogfiledir, 0700)
 	isNil(err, t)

 	newFakeTime()

 	// this will use the new fake time
 	fourthFilename := backupFile(dir)

 	// Create a log file that is/was being compressed - this should
 	// not be counted since both the compressed and the uncompressed
 	// log files still exist.
 	compLogFile := fourthFilename+compressSuffix
 	err = ioutil.WriteFile(compLogFile, []byte("compress"), 0644)
 	isNil(err, t)

 	// this will make us rotate again
 	b4 := []byte("baaaaaaz!")
 	n, err = l.Write(b4)
 	isNil(err, t)
 	equals(len(b4), n, t)

 	existsWithContent(fourthFilename, b3, t)
 	existsWithContent(fourthFilename+compressSuffix, []byte("compress"), t)

 	// we need to wait a little bit since the files get deleted on a different
 	// goroutine.
 	<-time.After(time.Millisecond * 10)

 	// We should have four things in the directory now - the 2 log files, the
 	// not log file, and the directory
 	fileCount(dir, 5, t)

 	// third file name should still exist
 	existsWithContent(filename, b4, t)

 	existsWithContent(fourthFilename, b3, t)

 	// should have deleted the first filename
 	notExist(thirdFilename, t)

 	// the not-a-logfile should still exist
 	exists(notlogfile, t)

 	// the directory
 	exists(notlogfiledir, t)
 }

 func TestCleanupExistingBackups(t *testing.T) {
 	// test that if we start with more backup files than we're supposed to have
 	// in total, that extra ones get cleaned up when we rotate.

 	currentTime = fakeTime
 	megabyte = 1

 	dir := makeTempDir("TestCleanupExistingBackups", t)
 	defer os.RemoveAll(dir)

 	// make 3 backup files

 	data := []byte("data")
 	backup := backupFile(dir)
 	err := ioutil.WriteFile(backup, data, 0644)
 	isNil(err, t)

 	newFakeTime()

 	backup = backupFile(dir)
 	err = ioutil.WriteFile(backup+compressSuffix, data, 0644)
 	isNil(err, t)

 	newFakeTime()

 	backup = backupFile(dir)
 	err = ioutil.WriteFile(backup, data, 0644)
 	isNil(err, t)

 	// now create a primary log file with some data
 	filename := logFile(dir)
 	err = ioutil.WriteFile(filename, data, 0644)
 	isNil(err, t)

 	l := &Logger{
 		Filename:   filename,
 		MaxSize:    10,
 		MaxBackups: 1,
 	}
 	defer l.Close()

 	newFakeTime()

 	b2 := []byte("foooooo!")
 	n, err := l.Write(b2)
 	isNil(err, t)
 	equals(len(b2), n, t)

 	// we need to wait a little bit since the files get deleted on a different
 	// goroutine.
 	<-time.After(time.Millisecond * 10)

 	// now we should only have 2 files left - the primary and one backup
 	fileCount(dir, 2, t)
 }

 func TestMaxAge(t *testing.T) {
 	currentTime = fakeTime
 	megabyte = 1

 	dir := makeTempDir("TestMaxAge", t)
 	defer os.RemoveAll(dir)

 	filename := logFile(dir)
 	l := &Logger{
 		Filename: filename,
 		MaxSize:  10,
 		MaxAge:   1,
 	}
 	defer l.Close()
 	b := []byte("boo!")
 	n, err := l.Write(b)
 	isNil(err, t)
 	equals(len(b), n, t)

 	existsWithContent(filename, b, t)
 	fileCount(dir, 1, t)

 	// two days later
 	newFakeTime()

 	b2 := []byte("foooooo!")
 	n, err = l.Write(b2)
 	isNil(err, t)
 	equals(len(b2), n, t)
 	existsWithContent(backupFile(dir), b, t)

 	// we need to wait a little bit since the files get deleted on a different
 	// goroutine.
 	<-time.After(10 * time.Millisecond)

 	// We should still have 2 log files, since the most recent backup was just
 	// created.
 	fileCount(dir, 2, t)

 	existsWithContent(filename, b2, t)

 	// we should have deleted the old file due to being too old
 	existsWithContent(backupFile(dir), b, t)

 	// two days later
 	newFakeTime()

 	b3 := []byte("baaaaar!")
 	n, err = l.Write(b3)
 	isNil(err, t)
 	equals(len(b3), n, t)
 	existsWithContent(backupFile(dir), b2, t)

 	// we need to wait a little bit since the files get deleted on a different
 	// goroutine.
 	<-time.After(10 * time.Millisecond)

 	// We should have 2 log files - the main log file, and the most recent
 	// backup.  The earlier backup is past the cutoff and should be gone.
 	fileCount(dir, 2, t)

 	existsWithContent(filename, b3, t)

 	// we should have deleted the old file due to being too old
 	existsWithContent(backupFile(dir), b2, t)
 }

 func TestOldLogFiles(t *testing.T) {
 	currentTime = fakeTime
 	megabyte = 1

 	dir := makeTempDir("TestOldLogFiles", t)
 	defer os.RemoveAll(dir)

 	filename := logFile(dir)
 	data := []byte("data")
 	err := ioutil.WriteFile(filename, data, 07)
 	isNil(err, t)

 	// This gives us a time with the same precision as the time we get from the
 	// timestamp in the name.
 	t1, err := time.Parse(backupTimeFormat, fakeTime().UTC().Format(backupTimeFormat))
 	isNil(err, t)

 	backup := backupFile(dir)
 	err = ioutil.WriteFile(backup, data, 07)
 	isNil(err, t)

 	newFakeTime()

 	t2, err := time.Parse(backupTimeFormat, fakeTime().UTC().Format(backupTimeFormat))
 	isNil(err, t)

 	backup2 := backupFile(dir)
 	err = ioutil.WriteFile(backup2, data, 07)
 	isNil(err, t)

 	l := &Logger{Filename: filename}
 	files, err := l.oldLogFiles()
 	isNil(err, t)
 	equals(2, len(files), t)

 	// should be sorted by newest file first, which would be t2
 	equals(t2, files[0].timestamp, t)
 	equals(t1, files[1].timestamp, t)
 }

 func TestTimeFromName(t *testing.T) {
 	l := &Logger{Filename: "/var/log/myfoo/foo.log"}
 	prefix, ext := l.prefixAndExt()

 	tests := []struct {
 		filename string
 		want     time.Time
 		wantErr  bool
 	}{
 		{"foo-2014-05-04T14-44-33.555.log", time.Date(2014, 5, 4, 14, 44, 33, 555000000, time.UTC), false},
 		{"foo-2014-05-04T14-44-33.555", time.Time{}, true},
 		{"2014-05-04T14-44-33.555.log", time.Time{}, true},
 		{"foo.log", time.Time{}, true},
 	}

 	for _, test := range tests {
 		got, err := l.timeFromName(test.filename, prefix, ext)
 		equals(got, test.want, t)
 		equals(err != nil, test.wantErr, t)
 	}
 }

 func TestLocalTime(t *testing.T) {
 	currentTime = fakeTime
 	megabyte = 1

 	dir := makeTempDir("TestLocalTime", t)
 	defer os.RemoveAll(dir)

 	l := &Logger{
 		Filename:  logFile(dir),
 		MaxSize:   10,
 		LocalTime: true,
 	}
 	defer l.Close()
 	b := []byte("boo!")
 	n, err := l.Write(b)
 	isNil(err, t)
 	equals(len(b), n, t)

 	b2 := []byte("fooooooo!")
 	n2, err := l.Write(b2)
 	isNil(err, t)
 	equals(len(b2), n2, t)

 	existsWithContent(logFile(dir), b2, t)
 	existsWithContent(backupFileLocal(dir), b, t)
 }

 func TestRotate(t *testing.T) {
 	currentTime = fakeTime
 	dir := makeTempDir("TestRotate", t)
 	defer os.RemoveAll(dir)

 	filename := logFile(dir)

 	l := &Logger{
 		Filename:   filename,
 		MaxBackups: 1,
 		MaxSize:    100, // megabytes
 	}
 	defer l.Close()
 	b := []byte("boo!")
 	n, err := l.Write(b)
 	isNil(err, t)
 	equals(len(b), n, t)

 	existsWithContent(filename, b, t)
 	fileCount(dir, 1, t)

 	newFakeTime()

 	err = l.Rotate()
 	isNil(err, t)

 	// we need to wait a little bit since the files get deleted on a different
 	// goroutine.
 	<-time.After(10 * time.Millisecond)

 	filename2 := backupFile(dir)
 	existsWithContent(filename2, b, t)
 	existsWithContent(filename, []byte{}, t)
 	fileCount(dir, 2, t)
 	newFakeTime()

 	err = l.Rotate()
 	isNil(err, t)

 	// we need to wait a little bit since the files get deleted on a different
 	// goroutine.
 	<-time.After(10 * time.Millisecond)

 	filename3 := backupFile(dir)
 	existsWithContent(filename3, []byte{}, t)
 	existsWithContent(filename, []byte{}, t)
 	fileCount(dir, 2, t)

 	b2 := []byte("foooooo!")
 	n, err = l.Write(b2)
 	isNil(err, t)
 	equals(len(b2), n, t)

 	// this will use the new fake time
 	existsWithContent(filename, b2, t)
 }

 func TestCompressOnRotate(t *testing.T) {
 	currentTime = fakeTime
 	megabyte = 1

 	dir := makeTempDir("TestCompressOnRotate", t)
 	defer os.RemoveAll(dir)

 	filename := logFile(dir)
 	l := &Logger{
 		Compress: true,
 		Filename: filename,
 		MaxSize:  10,
 	}
 	defer l.Close()
 	b := []byte("boo!")
 	n, err := l.Write(b)
 	isNil(err, t)
 	equals(len(b), n, t)

 	existsWithContent(filename, b, t)
 	fileCount(dir, 1, t)

 	newFakeTime()

 	err = l.Rotate()
 	isNil(err, t)

 	// the old logfile should be moved aside and the main logfile should have
 	// nothing in it.
 	existsWithContent(filename, []byte{}, t)

 	// we need to wait a little bit since the files get compressed on a different
 	// goroutine.
 	<-time.After(10 * time.Millisecond)

 	// a compressed version of the log file should now exist and the original
 	// should have been removed.
 	bc := new(bytes.Buffer)
 	gz := gzip.NewWriter(bc)
 	_, err = gz.Write(b)
 	isNil(err, t)
 	err = gz.Close()
 	isNil(err, t)
 	existsWithContent(backupFile(dir)+compressSuffix, bc.Bytes(), t)
 	notExist(backupFile(dir), t)

 	fileCount(dir, 2, t)
 }

 func TestCompressOnResume(t *testing.T) {
 	currentTime = fakeTime
 	megabyte = 1

 	dir := makeTempDir("TestCompressOnResume", t)
 	defer os.RemoveAll(dir)

 	filename := logFile(dir)
 	l := &Logger{
 		Compress: true,
 		Filename: filename,
 		MaxSize:  10,
 	}
 	defer l.Close()

 	// Create a backup file and empty "compressed" file.
 	filename2 := backupFile(dir)
 	b := []byte("foo!")
 	err := ioutil.WriteFile(filename2, b, 0644)
 	isNil(err, t)
 	err = ioutil.WriteFile(filename2+compressSuffix, []byte{}, 0644)
 	isNil(err, t)

 	newFakeTime()

 	b2 := []byte("boo!")
 	n, err := l.Write(b2)
 	isNil(err, t)
 	equals(len(b2), n, t)
 	existsWithContent(filename, b2, t)

 	// we need to wait a little bit since the files get compressed on a different
 	// goroutine.
 	<-time.After(10 * time.Millisecond)

 	// The write should have started the compression - a compressed version of
 	// the log file should now exist and the original should have been removed.
 	bc := new(bytes.Buffer)
 	gz := gzip.NewWriter(bc)
 	_, err = gz.Write(b)
 	isNil(err, t)
 	err = gz.Close()
 	isNil(err, t)
 	existsWithContent(filename2+compressSuffix, bc.Bytes(), t)
 	notExist(filename2, t)

 	fileCount(dir, 2, t)
 }

 func TestJson(t *testing.T) {
 	data := []byte(`
 {
 	"filename": "foo",
 	"maxsize": 5,
 	"maxage": 10,
 	"maxbackups": 3,
 	"localtime": true,
 	"compress": true
 }`[1:])

 	l := Logger{}
 	err := json.Unmarshal(data, &l)
 	isNil(err, t)
 	equals("foo", l.Filename, t)
 	equals(5, l.MaxSize, t)
 	equals(10, l.MaxAge, t)
 	equals(3, l.MaxBackups, t)
 	equals(true, l.LocalTime, t)
 	equals(true, l.Compress, t)
 }

 func TestYaml(t *testing.T) {
 	data := []byte(`
 filename: foo
 maxsize: 5
 maxage: 10
 maxbackups: 3
 localtime: true
 compress: true`[1:])

 	l := Logger{}
 	err := yaml.Unmarshal(data, &l)
 	isNil(err, t)
 	equals("foo", l.Filename, t)
 	equals(5, l.MaxSize, t)
 	equals(10, l.MaxAge, t)
 	equals(3, l.MaxBackups, t)
 	equals(true, l.LocalTime, t)
 	equals(true, l.Compress, t)
 }

 func TestToml(t *testing.T) {
 	data := `
 filename = "foo"
 maxsize = 5
 maxage = 10
 maxbackups = 3
 localtime = true
 compress = true`[1:]

 	l := Logger{}
 	md, err := toml.Decode(data, &l)
 	isNil(err, t)
 	equals("foo", l.Filename, t)
 	equals(5, l.MaxSize, t)
 	equals(10, l.MaxAge, t)
 	equals(3, l.MaxBackups, t)
 	equals(true, l.LocalTime, t)
 	equals(true, l.Compress, t)
 	equals(0, len(md.Undecoded()), t)
 }

 // makeTempDir creates a file with a semi-unique name in the OS temp directory.
 // It should be based on the name of the test, to keep parallel tests from
 // colliding, and must be cleaned up after the test is finished.
 func makeTempDir(name string, t testing.TB) string {
 	dir := time.Now().Format(name + backupTimeFormat)
 	dir = filepath.Join(os.TempDir(), dir)
 	isNilUp(os.Mkdir(dir, 0700), t, 1)
 	return dir
 }

 // existsWithContent checks that the given file exists and has the correct content.
 func existsWithContent(path string, content []byte, t testing.TB) {
 	info, err := os.Stat(path)
 	isNilUp(err, t, 1)
 	equalsUp(int64(len(content)), info.Size(), t, 1)

 	b, err := ioutil.ReadFile(path)
 	isNilUp(err, t, 1)
 	equalsUp(content, b, t, 1)
 }

 // logFile returns the log file name in the given directory for the current fake
 // time.
 func logFile(dir string) string {
 	return filepath.Join(dir, "foobar.log")
 }

 func backupFile(dir string) string {
 	return filepath.Join(dir, "foobar-"+fakeTime().UTC().Format(backupTimeFormat)+".log")
 }

 func backupFileLocal(dir string) string {
 	return filepath.Join(dir, "foobar-"+fakeTime().Format(backupTimeFormat)+".log")
 }

 // logFileLocal returns the log file name in the given directory for the current
 // fake time using the local timezone.
 func logFileLocal(dir string) string {
 	return filepath.Join(dir, fakeTime().Format(backupTimeFormat))
 }

 // fileCount checks that the number of files in the directory is exp.
 func fileCount(dir string, exp int, t testing.TB) {
 	files, err := ioutil.ReadDir(dir)
 	isNilUp(err, t, 1)
 	// Make sure no other files were created.
 	equalsUp(exp, len(files), t, 1)
 }

 // newFakeTime sets the fake "current time" to two days later.
 func newFakeTime() {
 	fakeCurrentTime = fakeCurrentTime.Add(time.Hour * 24 * 2)
 }

 func notExist(path string, t testing.TB) {
 	_, err := os.Stat(path)
 	assertUp(os.IsNotExist(err), t, 1, "expected to get os.IsNotExist, but instead got %v", err)
 }

 func exists(path string, t testing.TB) {
 	_, err := os.Stat(path)
 	assertUp(err == nil, t, 1, "expected file to exist, but got error from os.Stat: %v", err)
 }
	package lumberjack

	import (
	"bytes"
	"compress/gzip"
	"encoding/json"
	"fmt"
	"io/ioutil"
	"os"
	"path/filepath"
	"testing"
	"time"

	"github.com/BurntSushi/toml"
	"gopkg.in/yaml.v2"
	)

	// !!!NOTE!!!
	//
	// Running these tests in parallel will almost certainly cause sporadic (or even
	// regular) failures, because they're all messing with the same global variable
	// that controls the logic's mocked time.Now. So... don't do that.

	// Since all the tests uses the time to determine filenames etc, we need to
	// control the wall clock as much as possible, which means having a wall clock
	// that doesn't change unless we want it to.
	var fakeCurrentTime = time.Now()

	func fakeTime() time.Time {
	return fakeCurrentTime
	}

	func TestNewFile(t *testing.T) {
	currentTime = fakeTime

	dir := makeTempDir("TestNewFile", t)
	defer os.RemoveAll(dir)
	l := &Logger{
	Filename: logFile(dir),
	}
	defer l.Close()
	b := []byte("boo!")
	n, err := l.Write(b)
	isNil(err, t)
	equals(len(b), n, t)
	existsWithContent(logFile(dir), b, t)
	fileCount(dir, 1, t)
	}

	func TestOpenExisting(t *testing.T) {
	currentTime = fakeTime
	dir := makeTempDir("TestOpenExisting", t)
	defer os.RemoveAll(dir)

	filename := logFile(dir)
	data := []byte("foo!")
	err := ioutil.WriteFile(filename, data, 0644)
	isNil(err, t)
	existsWithContent(filename, data, t)

	l := &Logger{
	Filename: filename,
	}
	defer l.Close()
	b := []byte("boo!")
	n, err := l.Write(b)
	isNil(err, t)
	equals(len(b), n, t)

	// make sure the file got appended
	existsWithContent(filename, append(data, b...), t)

	// make sure no other files were created
	fileCount(dir, 1, t)
	}

	func TestWriteTooLong(t *testing.T) {
	currentTime = fakeTime
	megabyte = 1
	dir := makeTempDir("TestWriteTooLong", t)
	defer os.RemoveAll(dir)
	l := &Logger{
	Filename: logFile(dir),
	MaxSize: 5,
	}
	defer l.Close()
	b := []byte("booooooooooooooo!")
	n, err := l.Write(b)
	notNil(err, t)
	equals(0, n, t)
	equals(err.Error(),
	fmt.Sprintf("write length %d exceeds maximum file size %d", len(b), l.MaxSize), t)
	_, err = os.Stat(logFile(dir))
	assert(os.IsNotExist(err), t, "File exists, but should not have been created")
	}

	func TestMakeLogDir(t *testing.T) {
	currentTime = fakeTime
	dir := time.Now().Format("TestMakeLogDir" + backupTimeFormat)
	dir = filepath.Join(os.TempDir(), dir)
	defer os.RemoveAll(dir)
	filename := logFile(dir)
	l := &Logger{
	Filename: filename,
	}
	defer l.Close()
	b := []byte("boo!")
	n, err := l.Write(b)
	isNil(err, t)
	equals(len(b), n, t)
	existsWithContent(logFile(dir), b, t)
	fileCount(dir, 1, t)
	}

	func TestDefaultFilename(t *testing.T) {
	currentTime = fakeTime
	dir := os.TempDir()
	filename := filepath.Join(dir, filepath.Base(os.Args[0])+"-lumberjack.log")
	defer os.Remove(filename)
	l := &Logger{}
	defer l.Close()
	b := []byte("boo!")
	n, err := l.Write(b)

	isNil(err, t)
	equals(len(b), n, t)
	existsWithContent(filename, b, t)
	}

	func TestAutoRotate(t *testing.T) {
	currentTime = fakeTime
	megabyte = 1

	dir := makeTempDir("TestAutoRotate", t)
	defer os.RemoveAll(dir)

	filename := logFile(dir)
	l := &Logger{
	Filename: filename,
	MaxSize: 10,
	}
	defer l.Close()
	b := []byte("boo!")
	n, err := l.Write(b)
	isNil(err, t)
	equals(len(b), n, t)

	existsWithContent(filename, b, t)
	fileCount(dir, 1, t)

	newFakeTime()

	b2 := []byte("foooooo!")
	n, err = l.Write(b2)
	isNil(err, t)
	equals(len(b2), n, t)

	// the old logfile should be moved aside and the main logfile should have
	// only the last write in it.
	existsWithContent(filename, b2, t)

	// the backup file will use the current fake time and have the old contents.
	existsWithContent(backupFile(dir), b, t)

	fileCount(dir, 2, t)
	}

	func TestFirstWriteRotate(t *testing.T) {
	currentTime = fakeTime
	megabyte = 1
	dir := makeTempDir("TestFirstWriteRotate", t)
	defer os.RemoveAll(dir)

	filename := logFile(dir)
	l := &Logger{
	Filename: filename,
	MaxSize: 10,
	}
	defer l.Close()

	start := []byte("boooooo!")
	err := ioutil.WriteFile(filename, start, 0600)
	isNil(err, t)

	newFakeTime()

	// this would make us rotate
	b := []byte("fooo!")
	n, err := l.Write(b)
	isNil(err, t)
	equals(len(b), n, t)

	existsWithContent(filename, b, t)
	existsWithContent(backupFile(dir), start, t)

	fileCount(dir, 2, t)
	}

	func TestMaxBackups(t *testing.T) {
	currentTime = fakeTime
	megabyte = 1
	dir := makeTempDir("TestMaxBackups", t)
	defer os.RemoveAll(dir)

	filename := logFile(dir)
	l := &Logger{
	Filename: filename,
	MaxSize: 10,
	MaxBackups: 1,
	}
	defer l.Close()
	b := []byte("boo!")
	n, err := l.Write(b)
	isNil(err, t)
	equals(len(b), n, t)

	existsWithContent(filename, b, t)
	fileCount(dir, 1, t)

	newFakeTime()

	// this will put us over the max
	b2 := []byte("foooooo!")
	n, err = l.Write(b2)
	isNil(err, t)
	equals(len(b2), n, t)

	// this will use the new fake time
	secondFilename := backupFile(dir)
	existsWithContent(secondFilename, b, t)

	// make sure the old file still exists with the same content.
	existsWithContent(filename, b2, t)

	fileCount(dir, 2, t)

	newFakeTime()

	// this will make us rotate again
	b3 := []byte("baaaaaar!")
	n, err = l.Write(b3)
	isNil(err, t)
	equals(len(b3), n, t)

	// this will use the new fake time
	thirdFilename := backupFile(dir)
	existsWithContent(thirdFilename, b2, t)

	existsWithContent(filename, b3, t)

	// we need to wait a little bit since the files get deleted on a different
	// goroutine.
	<-time.After(time.Millisecond * 10)

	// should only have two files in the dir still
	fileCount(dir, 2, t)

	// second file name should still exist
	existsWithContent(thirdFilename, b2, t)

	// should have deleted the first backup
	notExist(secondFilename, t)

	// now test that we don't delete directories or non-logfile files

	newFakeTime()

	// create a file that is close to but different from the logfile name.
	// It shouldn't get caught by our deletion filters.
	notlogfile := logFile(dir) + ".foo"
	err = ioutil.WriteFile(notlogfile, []byte("data"), 0644)
	isNil(err, t)

	// Make a directory that exactly matches our log file filters... it still
	// shouldn't get caught by the deletion filter since it's a directory.
	notlogfiledir := backupFile(dir)
	err = os.Mkdir(notlogfiledir, 0700)
	isNil(err, t)

	newFakeTime()

	// this will use the new fake time
	fourthFilename := backupFile(dir)

	// Create a log file that is/was being compressed - this should
	// not be counted since both the compressed and the uncompressed
	// log files still exist.
	compLogFile := fourthFilename+compressSuffix
	err = ioutil.WriteFile(compLogFile, []byte("compress"), 0644)
	isNil(err, t)

	// this will make us rotate again
	b4 := []byte("baaaaaaz!")
	n, err = l.Write(b4)
	isNil(err, t)
	equals(len(b4), n, t)

	existsWithContent(fourthFilename, b3, t)
	existsWithContent(fourthFilename+compressSuffix, []byte("compress"), t)

	// we need to wait a little bit since the files get deleted on a different
	// goroutine.
	<-time.After(time.Millisecond * 10)

	// We should have four things in the directory now - the 2 log files, the
	// not log file, and the directory
	fileCount(dir, 5, t)

	// third file name should still exist
	existsWithContent(filename, b4, t)

	existsWithContent(fourthFilename, b3, t)

	// should have deleted the first filename
	notExist(thirdFilename, t)

	// the not-a-logfile should still exist
	exists(notlogfile, t)

	// the directory
	exists(notlogfiledir, t)
	}

	func TestCleanupExistingBackups(t *testing.T) {
	// test that if we start with more backup files than we're supposed to have
	// in total, that extra ones get cleaned up when we rotate.

	currentTime = fakeTime
	megabyte = 1

	dir := makeTempDir("TestCleanupExistingBackups", t)
	defer os.RemoveAll(dir)

	// make 3 backup files

	data := []byte("data")
	backup := backupFile(dir)
	err := ioutil.WriteFile(backup, data, 0644)
	isNil(err, t)

	newFakeTime()

	backup = backupFile(dir)
	err = ioutil.WriteFile(backup+compressSuffix, data, 0644)
	isNil(err, t)

	newFakeTime()

	backup = backupFile(dir)
	err = ioutil.WriteFile(backup, data, 0644)
	isNil(err, t)

	// now create a primary log file with some data
	filename := logFile(dir)
	err = ioutil.WriteFile(filename, data, 0644)
	isNil(err, t)

	l := &Logger{
	Filename: filename,
	MaxSize: 10,
	MaxBackups: 1,
	}
	defer l.Close()

	newFakeTime()

	b2 := []byte("foooooo!")
	n, err := l.Write(b2)
	isNil(err, t)
	equals(len(b2), n, t)

	// we need to wait a little bit since the files get deleted on a different
	// goroutine.
	<-time.After(time.Millisecond * 10)

	// now we should only have 2 files left - the primary and one backup
	fileCount(dir, 2, t)
	}

	func TestMaxAge(t *testing.T) {
	currentTime = fakeTime
	megabyte = 1

	dir := makeTempDir("TestMaxAge", t)
	defer os.RemoveAll(dir)

	filename := logFile(dir)
	l := &Logger{
	Filename: filename,
	MaxSize: 10,
	MaxAge: 1,
	}
	defer l.Close()
	b := []byte("boo!")
	n, err := l.Write(b)
	isNil(err, t)
	equals(len(b), n, t)

	existsWithContent(filename, b, t)
	fileCount(dir, 1, t)

	// two days later
	newFakeTime()

	b2 := []byte("foooooo!")
	n, err = l.Write(b2)
	isNil(err, t)
	equals(len(b2), n, t)
	existsWithContent(backupFile(dir), b, t)

	// we need to wait a little bit since the files get deleted on a different
	// goroutine.
	<-time.After(10 * time.Millisecond)

	// We should still have 2 log files, since the most recent backup was just
	// created.
	fileCount(dir, 2, t)

	existsWithContent(filename, b2, t)

	// we should have deleted the old file due to being too old
	existsWithContent(backupFile(dir), b, t)

	// two days later
	newFakeTime()

	b3 := []byte("baaaaar!")
	n, err = l.Write(b3)
	isNil(err, t)
	equals(len(b3), n, t)
	existsWithContent(backupFile(dir), b2, t)

	// we need to wait a little bit since the files get deleted on a different
	// goroutine.
	<-time.After(10 * time.Millisecond)

	// We should have 2 log files - the main log file, and the most recent
	// backup. The earlier backup is past the cutoff and should be gone.
	fileCount(dir, 2, t)

	existsWithContent(filename, b3, t)

	// we should have deleted the old file due to being too old
	existsWithContent(backupFile(dir), b2, t)
	}

	func TestOldLogFiles(t *testing.T) {
	currentTime = fakeTime
	megabyte = 1

	dir := makeTempDir("TestOldLogFiles", t)
	defer os.RemoveAll(dir)

	filename := logFile(dir)
	data := []byte("data")
	err := ioutil.WriteFile(filename, data, 07)
	isNil(err, t)

	// This gives us a time with the same precision as the time we get from the
	// timestamp in the name.
	t1, err := time.Parse(backupTimeFormat, fakeTime().UTC().Format(backupTimeFormat))
	isNil(err, t)

	backup := backupFile(dir)
	err = ioutil.WriteFile(backup, data, 07)
	isNil(err, t)

	newFakeTime()

	t2, err := time.Parse(backupTimeFormat, fakeTime().UTC().Format(backupTimeFormat))
	isNil(err, t)

	backup2 := backupFile(dir)
	err = ioutil.WriteFile(backup2, data, 07)
	isNil(err, t)

	l := &Logger{Filename: filename}
	files, err := l.oldLogFiles()
	isNil(err, t)
	equals(2, len(files), t)

	// should be sorted by newest file first, which would be t2
	equals(t2, files[0].timestamp, t)
	equals(t1, files[1].timestamp, t)
	}

	func TestTimeFromName(t *testing.T) {
	l := &Logger{Filename: "/var/log/myfoo/foo.log"}
	prefix, ext := l.prefixAndExt()

	tests := []struct {
	filename string
	want time.Time
	wantErr bool
	}{
	{"foo-2014-05-04T14-44-33.555.log", time.Date(2014, 5, 4, 14, 44, 33, 555000000, time.UTC), false},
	{"foo-2014-05-04T14-44-33.555", time.Time{}, true},
	{"2014-05-04T14-44-33.555.log", time.Time{}, true},
	{"foo.log", time.Time{}, true},
	}

	for _, test := range tests {
	got, err := l.timeFromName(test.filename, prefix, ext)
	equals(got, test.want, t)
	equals(err != nil, test.wantErr, t)
	}
	}

	func TestLocalTime(t *testing.T) {
	currentTime = fakeTime
	megabyte = 1

	dir := makeTempDir("TestLocalTime", t)
	defer os.RemoveAll(dir)

	l := &Logger{
	Filename: logFile(dir),
	MaxSize: 10,
	LocalTime: true,
	}
	defer l.Close()
	b := []byte("boo!")
	n, err := l.Write(b)
	isNil(err, t)
	equals(len(b), n, t)

	b2 := []byte("fooooooo!")
	n2, err := l.Write(b2)
	isNil(err, t)
	equals(len(b2), n2, t)

	existsWithContent(logFile(dir), b2, t)
	existsWithContent(backupFileLocal(dir), b, t)
	}

	func TestRotate(t *testing.T) {
	currentTime = fakeTime
	dir := makeTempDir("TestRotate", t)
	defer os.RemoveAll(dir)

	filename := logFile(dir)

	l := &Logger{
	Filename: filename,
	MaxBackups: 1,
	MaxSize: 100, // megabytes
	}
	defer l.Close()
	b := []byte("boo!")
	n, err := l.Write(b)
	isNil(err, t)
	equals(len(b), n, t)

	existsWithContent(filename, b, t)
	fileCount(dir, 1, t)

	newFakeTime()

	err = l.Rotate()
	isNil(err, t)

	// we need to wait a little bit since the files get deleted on a different
	// goroutine.
	<-time.After(10 * time.Millisecond)

	filename2 := backupFile(dir)
	existsWithContent(filename2, b, t)
	existsWithContent(filename, []byte{}, t)
	fileCount(dir, 2, t)
	newFakeTime()

	err = l.Rotate()
	isNil(err, t)

	// we need to wait a little bit since the files get deleted on a different
	// goroutine.
	<-time.After(10 * time.Millisecond)

	filename3 := backupFile(dir)
	existsWithContent(filename3, []byte{}, t)
	existsWithContent(filename, []byte{}, t)
	fileCount(dir, 2, t)

	b2 := []byte("foooooo!")
	n, err = l.Write(b2)
	isNil(err, t)
	equals(len(b2), n, t)

	// this will use the new fake time
	existsWithContent(filename, b2, t)
	}

	func TestCompressOnRotate(t *testing.T) {
	currentTime = fakeTime
	megabyte = 1

	dir := makeTempDir("TestCompressOnRotate", t)
	defer os.RemoveAll(dir)

	filename := logFile(dir)
	l := &Logger{
	Compress: true,
	Filename: filename,
	MaxSize: 10,
	}
	defer l.Close()
	b := []byte("boo!")
	n, err := l.Write(b)
	isNil(err, t)
	equals(len(b), n, t)

	existsWithContent(filename, b, t)
	fileCount(dir, 1, t)

	newFakeTime()

	err = l.Rotate()
	isNil(err, t)

	// the old logfile should be moved aside and the main logfile should have
	// nothing in it.
	existsWithContent(filename, []byte{}, t)

	// we need to wait a little bit since the files get compressed on a different
	// goroutine.
	<-time.After(10 * time.Millisecond)

	// a compressed version of the log file should now exist and the original
	// should have been removed.
	bc := new(bytes.Buffer)
	gz := gzip.NewWriter(bc)
	_, err = gz.Write(b)
	isNil(err, t)
	err = gz.Close()
	isNil(err, t)
	existsWithContent(backupFile(dir)+compressSuffix, bc.Bytes(), t)
	notExist(backupFile(dir), t)

	fileCount(dir, 2, t)
	}

	func TestCompressOnResume(t *testing.T) {
	currentTime = fakeTime
	megabyte = 1

	dir := makeTempDir("TestCompressOnResume", t)
	defer os.RemoveAll(dir)

	filename := logFile(dir)
	l := &Logger{
	Compress: true,
	Filename: filename,
	MaxSize: 10,
	}
	defer l.Close()

	// Create a backup file and empty "compressed" file.
	filename2 := backupFile(dir)
	b := []byte("foo!")
	err := ioutil.WriteFile(filename2, b, 0644)
	isNil(err, t)
	err = ioutil.WriteFile(filename2+compressSuffix, []byte{}, 0644)
	isNil(err, t)

	newFakeTime()

	b2 := []byte("boo!")
	n, err := l.Write(b2)
	isNil(err, t)
	equals(len(b2), n, t)
	existsWithContent(filename, b2, t)

	// we need to wait a little bit since the files get compressed on a different
	// goroutine.
	<-time.After(10 * time.Millisecond)

	// The write should have started the compression - a compressed version of
	// the log file should now exist and the original should have been removed.
	bc := new(bytes.Buffer)
	gz := gzip.NewWriter(bc)
	_, err = gz.Write(b)
	isNil(err, t)
	err = gz.Close()
	isNil(err, t)
	existsWithContent(filename2+compressSuffix, bc.Bytes(), t)
	notExist(filename2, t)

	fileCount(dir, 2, t)
	}

	func TestJson(t *testing.T) {
	data := []byte(`
	{
	"filename": "foo",
	"maxsize": 5,
	"maxage": 10,
	"maxbackups": 3,
	"localtime": true,
	"compress": true
	}`[1:])

	l := Logger{}
	err := json.Unmarshal(data, &l)
	isNil(err, t)
	equals("foo", l.Filename, t)
	equals(5, l.MaxSize, t)
	equals(10, l.MaxAge, t)
	equals(3, l.MaxBackups, t)
	equals(true, l.LocalTime, t)
	equals(true, l.Compress, t)
	}

	func TestYaml(t *testing.T) {
	data := []byte(`
	filename: foo
	maxsize: 5
	maxage: 10
	maxbackups: 3
	localtime: true
	compress: true`[1:])

	l := Logger{}
	err := yaml.Unmarshal(data, &l)
	isNil(err, t)
	equals("foo", l.Filename, t)
	equals(5, l.MaxSize, t)
	equals(10, l.MaxAge, t)
	equals(3, l.MaxBackups, t)
	equals(true, l.LocalTime, t)
	equals(true, l.Compress, t)
	}

	func TestToml(t *testing.T) {
	data := `
	filename = "foo"
	maxsize = 5
	maxage = 10
	maxbackups = 3
	localtime = true
	compress = true`[1:]

	l := Logger{}
	md, err := toml.Decode(data, &l)
	isNil(err, t)
	equals("foo", l.Filename, t)
	equals(5, l.MaxSize, t)
	equals(10, l.MaxAge, t)
	equals(3, l.MaxBackups, t)
	equals(true, l.LocalTime, t)
	equals(true, l.Compress, t)
	equals(0, len(md.Undecoded()), t)
	}

	// makeTempDir creates a file with a semi-unique name in the OS temp directory.
	// It should be based on the name of the test, to keep parallel tests from
	// colliding, and must be cleaned up after the test is finished.
	func makeTempDir(name string, t testing.TB) string {
	dir := time.Now().Format(name + backupTimeFormat)
	dir = filepath.Join(os.TempDir(), dir)
	isNilUp(os.Mkdir(dir, 0700), t, 1)
	return dir
	}

	// existsWithContent checks that the given file exists and has the correct content.
	func existsWithContent(path string, content []byte, t testing.TB) {
	info, err := os.Stat(path)
	isNilUp(err, t, 1)
	equalsUp(int64(len(content)), info.Size(), t, 1)

	b, err := ioutil.ReadFile(path)
	isNilUp(err, t, 1)
	equalsUp(content, b, t, 1)
	}

	// logFile returns the log file name in the given directory for the current fake
	// time.
	func logFile(dir string) string {
	return filepath.Join(dir, "foobar.log")
	}

	func backupFile(dir string) string {
	return filepath.Join(dir, "foobar-"+fakeTime().UTC().Format(backupTimeFormat)+".log")
	}

	func backupFileLocal(dir string) string {
	return filepath.Join(dir, "foobar-"+fakeTime().Format(backupTimeFormat)+".log")
	}

	// logFileLocal returns the log file name in the given directory for the current
	// fake time using the local timezone.
	func logFileLocal(dir string) string {
	return filepath.Join(dir, fakeTime().Format(backupTimeFormat))
	}

	// fileCount checks that the number of files in the directory is exp.
	func fileCount(dir string, exp int, t testing.TB) {
	files, err := ioutil.ReadDir(dir)
	isNilUp(err, t, 1)
	// Make sure no other files were created.
	equalsUp(exp, len(files), t, 1)
	}

	// newFakeTime sets the fake "current time" to two days later.
	func newFakeTime() {
	fakeCurrentTime = fakeCurrentTime.Add(time.Hour * 24 * 2)
	}

	func notExist(path string, t testing.TB) {
	_, err := os.Stat(path)
	assertUp(os.IsNotExist(err), t, 1, "expected to get os.IsNotExist, but instead got %v", err)
	}

	func exists(path string, t testing.TB) {
	_, err := os.Stat(path)
	assertUp(err == nil, t, 1, "expected file to exist, but got error from os.Stat: %v", err)
	}