github.com/darmach/terratest@v0.34.8-0.20210517103231-80931f95e3ff/modules/logger/parser/store_test.go (about)

     1  package parser
     2  
     3  import (
     4  	"io/ioutil"
     5  	"os"
     6  	"path/filepath"
     7  	"testing"
     8  
     9  	"github.com/gruntwork-io/go-commons/files"
    10  	"github.com/gruntwork-io/terratest/modules/random"
    11  	"github.com/stretchr/testify/assert"
    12  )
    13  
    14  func createLogWriter(t *testing.T) LogWriter {
    15  	dir := getTempDir(t)
    16  	logWriter := LogWriter{
    17  		lookup:    make(map[string]*os.File),
    18  		outputDir: dir,
    19  	}
    20  	return logWriter
    21  }
    22  
    23  func TestEnsureDirectoryExistsCreatesDirectory(t *testing.T) {
    24  	t.Parallel()
    25  
    26  	dir := getTempDir(t)
    27  	defer os.RemoveAll(dir)
    28  
    29  	logger := NewTestLogger(t)
    30  	tmpd := filepath.Join(dir, "tmpdir")
    31  	assert.False(t, files.IsDir(tmpd))
    32  	ensureDirectoryExists(logger, tmpd)
    33  	assert.True(t, files.IsDir(tmpd))
    34  }
    35  
    36  func TestEnsureDirectoryExistsHandlesExistingDirectory(t *testing.T) {
    37  	t.Parallel()
    38  
    39  	dir := getTempDir(t)
    40  	defer os.RemoveAll(dir)
    41  
    42  	logger := NewTestLogger(t)
    43  	assert.True(t, files.IsDir(dir))
    44  	ensureDirectoryExists(logger, dir)
    45  	assert.True(t, files.IsDir(dir))
    46  }
    47  
    48  func TestGetOrCreateFileCreatesNewFile(t *testing.T) {
    49  	t.Parallel()
    50  
    51  	logWriter := createLogWriter(t)
    52  	defer os.RemoveAll(logWriter.outputDir)
    53  
    54  	logger := NewTestLogger(t)
    55  	testFileName := filepath.Join(logWriter.outputDir, t.Name()+".log")
    56  	assert.False(t, files.FileExists(testFileName))
    57  	file, err := logWriter.getOrCreateFile(logger, t.Name())
    58  	defer file.Close()
    59  	assert.Nil(t, err)
    60  	assert.NotNil(t, file)
    61  	assert.True(t, files.FileExists(testFileName))
    62  }
    63  
    64  func TestGetOrCreateFileCreatesNewFileIfTestNameHasDir(t *testing.T) {
    65  	t.Parallel()
    66  
    67  	logWriter := createLogWriter(t)
    68  	defer os.RemoveAll(logWriter.outputDir)
    69  
    70  	logger := NewTestLogger(t)
    71  	dirName := filepath.Join(logWriter.outputDir, "TestMain")
    72  	testFileName := filepath.Join(dirName, t.Name()+".log")
    73  	assert.False(t, files.IsDir(dirName))
    74  	assert.False(t, files.FileExists(testFileName))
    75  	file, err := logWriter.getOrCreateFile(logger, filepath.Join("TestMain", t.Name()))
    76  	defer file.Close()
    77  	assert.Nil(t, err)
    78  	assert.NotNil(t, file)
    79  	assert.True(t, files.IsDir(dirName))
    80  	assert.True(t, files.FileExists(testFileName))
    81  }
    82  
    83  func TestGetOrCreateChannelReturnsExistingFileHandle(t *testing.T) {
    84  	t.Parallel()
    85  
    86  	logWriter := createLogWriter(t)
    87  	defer os.RemoveAll(logWriter.outputDir)
    88  
    89  	testName := t.Name()
    90  	logger := NewTestLogger(t)
    91  	testFileName := filepath.Join(logWriter.outputDir, t.Name())
    92  	file, err := os.Create(testFileName)
    93  	if err != nil {
    94  		t.Fatalf("error creating test file %s", testFileName)
    95  	}
    96  	defer file.Close()
    97  
    98  	logWriter.lookup[testName] = file
    99  	lookupFile, err := logWriter.getOrCreateFile(logger, testName)
   100  	assert.Nil(t, err)
   101  	assert.Equal(t, lookupFile, file)
   102  }
   103  
   104  func TestCloseFilesClosesAll(t *testing.T) {
   105  	t.Parallel()
   106  
   107  	logWriter := createLogWriter(t)
   108  	defer os.RemoveAll(logWriter.outputDir)
   109  
   110  	logger := NewTestLogger(t)
   111  	testName := t.Name()
   112  	testFileName := filepath.Join(logWriter.outputDir, testName)
   113  	testFile, err := os.Create(testFileName)
   114  	if err != nil {
   115  		t.Fatalf("error creating test file %s", testFileName)
   116  	}
   117  	alternativeTestName := t.Name() + "Alternative"
   118  	alternativeTestFileName := filepath.Join(logWriter.outputDir, alternativeTestName)
   119  	alternativeTestFile, err := os.Create(alternativeTestFileName)
   120  	if err != nil {
   121  		t.Fatalf("error creating test file %s", alternativeTestFileName)
   122  	}
   123  	logWriter.lookup[testName] = testFile
   124  	logWriter.lookup[alternativeTestName] = alternativeTestFile
   125  
   126  	logWriter.closeFiles(logger)
   127  	err = testFile.Close()
   128  	assert.Contains(t, err.Error(), os.ErrClosed.Error())
   129  	err = alternativeTestFile.Close()
   130  	assert.Contains(t, err.Error(), os.ErrClosed.Error())
   131  }
   132  
   133  func TestWriteLogWritesToCorrectLogFile(t *testing.T) {
   134  	t.Parallel()
   135  
   136  	logWriter := createLogWriter(t)
   137  	defer os.RemoveAll(logWriter.outputDir)
   138  
   139  	logger := NewTestLogger(t)
   140  	testName := t.Name()
   141  	testFileName := filepath.Join(logWriter.outputDir, testName)
   142  	testFile, err := os.Create(testFileName)
   143  	if err != nil {
   144  		t.Fatalf("error creating test file %s", testFileName)
   145  	}
   146  	defer testFile.Close()
   147  	alternativeTestName := t.Name() + "Alternative"
   148  	alternativeTestFileName := filepath.Join(logWriter.outputDir, alternativeTestName)
   149  	alternativeTestFile, err := os.Create(alternativeTestFileName)
   150  	if err != nil {
   151  		t.Fatalf("error creating test file %s", alternativeTestFileName)
   152  	}
   153  	defer alternativeTestFile.Close()
   154  	logWriter.lookup[testName] = testFile
   155  	logWriter.lookup[alternativeTestName] = alternativeTestFile
   156  
   157  	randomString := random.UniqueId()
   158  	err = logWriter.writeLog(logger, testName, randomString)
   159  	assert.Nil(t, err)
   160  	alternativeRandomString := random.UniqueId()
   161  	err = logWriter.writeLog(logger, alternativeTestName, alternativeRandomString)
   162  	assert.Nil(t, err)
   163  
   164  	buf, err := ioutil.ReadFile(testFileName)
   165  	assert.Nil(t, err)
   166  	assert.Equal(t, string(buf), randomString+"\n")
   167  	buf, err = ioutil.ReadFile(alternativeTestFileName)
   168  	assert.Nil(t, err)
   169  	assert.Equal(t, string(buf), alternativeRandomString+"\n")
   170  }
   171  
   172  func TestWriteLogCreatesLogFileIfNotExists(t *testing.T) {
   173  	t.Parallel()
   174  
   175  	logWriter := createLogWriter(t)
   176  	defer os.RemoveAll(logWriter.outputDir)
   177  
   178  	logger := NewTestLogger(t)
   179  	testName := t.Name()
   180  	testFileName := filepath.Join(logWriter.outputDir, testName+".log")
   181  
   182  	randomString := random.UniqueId()
   183  	err := logWriter.writeLog(logger, testName, randomString)
   184  	assert.Nil(t, err)
   185  
   186  	assert.True(t, files.FileExists(testFileName))
   187  	buf, err := ioutil.ReadFile(testFileName)
   188  	assert.Nil(t, err)
   189  	assert.Equal(t, string(buf), randomString+"\n")
   190  }