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