Fix linting issues

pkg/workceptor/kubernetes.go

@@ -166,7 +166,7 @@ func (kw *kubeUnit) kubeLoggingConnectionHandler(timestamps bool) (io.ReadCloser
 	return logStream, nil
 }
 
-func (kw *kubeUnit) kubeLoggingNoReconnect(streamWait *sync.WaitGroup, stdout *stdoutWriter, stdoutErr *error) {
+func (kw *kubeUnit) kubeLoggingNoReconnect(streamWait *sync.WaitGroup, stdout *STDoutWriter, stdoutErr *error) {
 	// Legacy method, for use on k8s < v1.23.14
 	// uses io.Copy to stream data from pod to stdout file
 	// known issues around this, as logstream can terminate due to log rotation
@@ -190,7 +190,7 @@ func (kw *kubeUnit) kubeLoggingNoReconnect(streamWait *sync.WaitGroup, stdout *s
 	}
 }
 
-func (kw *kubeUnit) kubeLoggingWithReconnect(streamWait *sync.WaitGroup, stdout *stdoutWriter, stdinErr *error, stdoutErr *error) {
+func (kw *kubeUnit) kubeLoggingWithReconnect(streamWait *sync.WaitGroup, stdout *STDoutWriter, stdinErr *error, stdoutErr *error) {
 	// preferred method for k8s >= 1.23.14
 	defer streamWait.Done()
 	var sinceTime time.Time
@@ -606,7 +606,7 @@ func (kw *kubeUnit) runWorkUsingLogger() {
 	stdinErrChan := make(chan struct{}) // signal that stdin goroutine have errored and stop stdout goroutine
 
 	// open stdin reader that reads from the work unit's data directory
-	var stdin *stdinReader
+	var stdin *STDinReader
 	if !skipStdin {
 		var err error
 		stdin, err = NewStdinReader(FileSystem{}, kw.UnitDir())
@@ -950,7 +950,7 @@ func (kw *kubeUnit) runWorkUsingTCP() {
 	}
 
 	// Open stdin reader
-	var stdin *stdinReader
+	var stdin *STDinReader
 	stdin, err = NewStdinReader(FileSystem{}, kw.UnitDir())
 	if err != nil {
 		errMsg := fmt.Sprintf("Error opening stdin file: %s", err)

pkg/workceptor/stdio_utils.go

@@ -56,29 +56,29 @@ func saveStdoutSize(unitdir string, stdoutSize int64) error {
 	})
 }
 
-// StdoutWriter writes to a stdout file while also updating the status file.
-type stdoutWriter struct {
+// STDoutWriter writes to a stdout file while also updating the status file.
+type STDoutWriter struct {
 	unitdir      string
 	writer       FileWriteCloser
 	bytesWritten int64
 }
 
 // NewStdoutWriter allocates a new stdoutWriter, which writes to both the stdout and status files.
-func NewStdoutWriter(fs FileSystemer, unitdir string) (*stdoutWriter, error) {
+func NewStdoutWriter(fs FileSystemer, unitdir string) (*STDoutWriter, error) {
 	writer, err := fs.OpenFile(path.Join(unitdir, "stdout"), os.O_CREATE+os.O_WRONLY+os.O_SYNC, 0o600)
 	if err != nil {
 		return nil, err
 	}
 
-	return &stdoutWriter{
+	return &STDoutWriter{
 		unitdir:      unitdir,
 		writer:       writer,
 		bytesWritten: 0,
 	}, nil
 }
 
 // Write writes data to the stdout file and status file, implementing io.Writer.
-func (sw *stdoutWriter) Write(p []byte) (n int, err error) {
+func (sw *STDoutWriter) Write(p []byte) (n int, err error) {
 	wn, werr := sw.writer.Write(p)
 	var serr error
 	if wn > 0 {
@@ -93,17 +93,17 @@ func (sw *stdoutWriter) Write(p []byte) (n int, err error) {
 }
 
 // Size returns the current size of the stdout file.
-func (sw *stdoutWriter) Size() int64 {
+func (sw *STDoutWriter) Size() int64 {
 	return sw.bytesWritten
 }
 
 // SetWriter sets the writer var.
-func (sw *stdoutWriter) SetWriter(writer FileWriteCloser) {
+func (sw *STDoutWriter) SetWriter(writer FileWriteCloser) {
 	sw.writer = writer
 }
 
-// stdinReader reads from a stdin file and provides a Done function.
-type stdinReader struct {
+// STDinReader reads from a stdin file and provides a Done function.
+type STDinReader struct {
 	reader   FileReadCloser
 	lasterr  error
 	doneChan chan struct{}
@@ -113,7 +113,7 @@ type stdinReader struct {
 var errFileSizeZero = errors.New("file is empty")
 
 // NewStdinReader allocates a new stdinReader, which reads from a stdin file and provides a Done function.
-func NewStdinReader(fs FileSystemer, unitdir string) (*stdinReader, error) {
+func NewStdinReader(fs FileSystemer, unitdir string) (*STDinReader, error) {
 	stdinpath := path.Join(unitdir, "stdin")
 	stat, err := fs.Stat(stdinpath)
 	if err != nil {
@@ -127,7 +127,7 @@ func NewStdinReader(fs FileSystemer, unitdir string) (*stdinReader, error) {
 		return nil, err
 	}
 
-	return &stdinReader{
+	return &STDinReader{
 		reader:   reader,
 		lasterr:  nil,
 		doneChan: make(chan struct{}),
@@ -136,7 +136,7 @@ func NewStdinReader(fs FileSystemer, unitdir string) (*stdinReader, error) {
 }
 
 // Read reads data from the stdout file, implementing io.Reader.
-func (sr *stdinReader) Read(p []byte) (n int, err error) {
+func (sr *STDinReader) Read(p []byte) (n int, err error) {
 	n, err = sr.reader.Read(p)
 	if err != nil {
 		sr.lasterr = err
@@ -149,16 +149,16 @@ func (sr *stdinReader) Read(p []byte) (n int, err error) {
 }
 
 // Done returns a channel that will be closed on error (including EOF) in the reader.
-func (sr *stdinReader) Done() <-chan struct{} {
+func (sr *STDinReader) Done() <-chan struct{} {
 	return sr.doneChan
 }
 
 // Error returns the most recent error encountered in the reader.
-func (sr *stdinReader) Error() error {
+func (sr *STDinReader) Error() error {
 	return sr.lasterr
 }
 
 // SetReader sets the reader var.
-func (sr *stdinReader) SetReader(reader FileReadCloser) {
+func (sr *STDinReader) SetReader(reader FileReadCloser) {
 	sr.reader = reader
 }

pkg/workceptor/stdio_utils_test.go

@@ -23,18 +23,42 @@ func checkErrorAndNum(err error, expectedErr string, num int, expectedNum int, t
 	}
 }
 
-func TestWrite(t *testing.T) {
+func setup(t *testing.T) (*gomock.Controller, *mock_workceptor.MockFileSystemer) {
 	ctrl := gomock.NewController(t)
 	defer ctrl.Finish()
 
 	mockfilesystemer := mock_workceptor.NewMockFileSystemer(ctrl)
-	mockfilewc := mock_workceptor.NewMockFileWriteCloser(ctrl)
+	return ctrl, mockfilesystemer
+}
 
+func setupWriter(t *testing.T) (*gomock.Controller, *workceptor.STDoutWriter) {
+	ctrl, mockfilesystemer := setup(t)
 	mockfilesystemer.EXPECT().OpenFile(gomock.Any(), gomock.Any(), gomock.Any()).Return(&os.File{}, nil)
 	wc, err := workceptor.NewStdoutWriter(mockfilesystemer, "")
 	if err != nil {
 		t.Errorf("Error while creating std writer: %v", err)
 	}
+	return ctrl, wc
+}
+
+func setupReader(t *testing.T) (*gomock.Controller, *workceptor.STDinReader) {
+	ctrl, mockfilesystemer := setup(t)
+	statObj := NewInfo("test", 1, 0, time.Now())
+
+	mockfilesystemer.EXPECT().Stat(gomock.Any()).Return(statObj, nil)
+	mockfilesystemer.EXPECT().Open(gomock.Any()).Return(&os.File{}, nil)
+
+	wc, err := workceptor.NewStdinReader(mockfilesystemer, "")
+	if err != nil {
+		t.Errorf(stdinError)
+	}
+
+	return ctrl, wc
+}
+
+func TestWrite(t *testing.T) {
+	ctrl, wc := setupWriter(t)
+	mockfilewc := mock_workceptor.NewMockFileWriteCloser(ctrl)
 	wc.SetWriter(mockfilewc)
 
 	writeTestCases := []struct {
@@ -59,16 +83,7 @@ func TestWrite(t *testing.T) {
 }
 
 func TestWriteSize(t *testing.T) {
-	ctrl := gomock.NewController(t)
-	defer ctrl.Finish()
-
-	mockfilesystemer := mock_workceptor.NewMockFileSystemer(ctrl)
-
-	mockfilesystemer.EXPECT().OpenFile(gomock.Any(), gomock.Any(), gomock.Any()).Return(&os.File{}, nil)
-	wc, err := workceptor.NewStdoutWriter(mockfilesystemer, "")
-	if err != nil {
-		t.Errorf("Error while creating std writer: %v", err)
-	}
+	_, wc := setupWriter(t)
 
 	sizeTestCases := []struct {
 		name         string
@@ -130,19 +145,7 @@ func (i *Info) Sys() interface{} {
 const stdinError = "Error creating stdinReader"
 
 func TestRead(t *testing.T) {
-	ctrl := gomock.NewController(t)
-	defer ctrl.Finish()
-
-	mockfilesystemer := mock_workceptor.NewMockFileSystemer(ctrl)
-	statObj := NewInfo("test", 1, 0, time.Now())
-
-	mockfilesystemer.EXPECT().Stat(gomock.Any()).Return(statObj, nil)
-	mockfilesystemer.EXPECT().Open(gomock.Any()).Return(&os.File{}, nil)
-
-	wc, err := workceptor.NewStdinReader(mockfilesystemer, "")
-	if err != nil {
-		t.Errorf(stdinError)
-	}
+	ctrl, wc := setupReader(t)
 
 	mockReadClose := mock_workceptor.NewMockFileReadCloser(ctrl)
 	wc.SetReader(mockReadClose)
@@ -168,19 +171,7 @@ func TestRead(t *testing.T) {
 }
 
 func TestDone(t *testing.T) {
-	ctrl := gomock.NewController(t)
-	defer ctrl.Finish()
-
-	mockfilesystemer := mock_workceptor.NewMockFileSystemer(ctrl)
-	statObj := NewInfo("test", 1, 0, time.Now())
-
-	mockfilesystemer.EXPECT().Stat(gomock.Any()).Return(statObj, nil)
-	mockfilesystemer.EXPECT().Open(gomock.Any()).Return(&os.File{}, nil)
-
-	wc, err := workceptor.NewStdinReader(mockfilesystemer, "")
-	if err != nil {
-		t.Errorf(stdinError)
-	}
+	_, wc := setupReader(t)
 
 	channel := wc.Done()
 	if channel == nil {
@@ -189,21 +180,9 @@ func TestDone(t *testing.T) {
 }
 
 func TestError(t *testing.T) {
-	ctrl := gomock.NewController(t)
-	defer ctrl.Finish()
-
-	mockfilesystemer := mock_workceptor.NewMockFileSystemer(ctrl)
-	statObj := NewInfo("test", 1, 0, time.Now())
-
-	mockfilesystemer.EXPECT().Stat(gomock.Any()).Return(statObj, nil)
-	mockfilesystemer.EXPECT().Open(gomock.Any()).Return(&os.File{}, nil)
-
-	wc, err := workceptor.NewStdinReader(mockfilesystemer, "")
-	if err != nil {
-		t.Errorf(stdinError)
-	}
+	_, wc := setupReader(t)
 
-	err = wc.Error()
+	err := wc.Error()
 	if err != nil {
 		t.Errorf("Unexpected error returned from stdreader")
 	}