add: racy test confirm in different file; upd: output writers test, generator output config tests

Author: zamangi

internal/generator/cli/commands/generate/generate_test.go

@@ -256,7 +256,7 @@ func TestNewGenerateCommand(t *testing.T) {
 		cliOpts.SetOut(streams.NewOut(os.Stdout))
 
 		cmd := NewGenerateCommand(cliOpts)
-		cmd.SetArgs([]string{"-F"})
+		cmd.SetArgs([]string{"-f"})
 
 		err = cmd.Execute()
 

internal/generator/cli/confirm/confirm.go

@@ -22,10 +22,13 @@ func BuildConfirmTTY(in io.Reader, out io.Writer) func(ctx context.Context, ques
 	return func(ctx context.Context, question string) (bool, error) {
 		fmt.Fprintln(out)
 
+		cancelableIn := newCancelableReader(in)
+		defer cancelableIn.Close()
+
 		prompt := promptui.Prompt{
 			Label:   question + " [y/N]: ",
 			Default: "y",
-			Stdin:   utils.DummyReadWriteCloser{Reader: in},
+			Stdin:   cancelableIn,
 			Stdout:  utils.DummyReadWriteCloser{Writer: out},
 		}
 		validate := func(s string) error {

internal/generator/cli/confirm/confirm_race_off_test.go

@@ -0,0 +1,90 @@
+//go:build !race
+
+package confirm
+
+import (
+	"bytes"
+	"context"
+	"errors"
+	"fmt"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestConfirmTTY(t *testing.T) {
+	testCases := []struct {
+		name        string
+		ctx         context.Context
+		question    string
+		input       string
+		expected    bool
+		expectedErr error
+	}{
+		{
+			name:     "Y",
+			question: "question",
+			input:    "Y",
+			expected: true,
+		},
+		{
+			name:     "y",
+			question: "question",
+			input:    "y",
+			expected: true,
+		},
+		{
+			name:        "yes",
+			question:    "question",
+			input:       "yes",
+			expectedErr: ErrPromptFailed,
+		},
+		{
+			name:     "N",
+			question: "question",
+			input:    "N",
+			expected: false,
+		},
+		{
+			name:     "n",
+			question: "question",
+			input:    "n",
+			expected: false,
+		},
+		{
+			name:        "no",
+			question:    "question",
+			input:       "no",
+			expectedErr: ErrPromptFailed,
+		},
+		{
+			name:        "Context canceled",
+			expectedErr: context.Canceled,
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			input := bytes.Buffer{}
+			output := bytes.Buffer{}
+
+			confirm := BuildConfirmTTY(&input, &output)
+
+			ctx := context.Background()
+
+			if errors.Is(tc.expectedErr, context.Canceled) {
+				var cancel context.CancelFunc
+
+				ctx, cancel = context.WithCancel(ctx)
+				cancel()
+			}
+
+			input.WriteString(tc.input + "\n")
+
+			res, err := confirm(ctx, tc.question)
+			require.True(t, errors.Is(err, tc.expectedErr), fmt.Sprintf("expected: %v, got: %v", tc.expectedErr, err))
+
+			require.Equal(t, tc.expected, res)
+		})
+	}
+}

internal/generator/cli/confirm/confirm_test.go

@@ -13,93 +13,9 @@ import (
 	rendererMock "github.com/tarantool/sdvg/internal/generator/cli/render/mock"
 )
 
-func TestConfirmTTY(t *testing.T) {
-	input := bytes.Buffer{}
-	output := bytes.Buffer{}
-
-	confirm := BuildConfirmTTY(&input, &output)
-
-	testCases := []struct {
-		name        string
-		ctx         context.Context
-		question    string
-		input       string
-		expected    bool
-		expectedErr error
-	}{
-		{
-			name:     "Y",
-			question: "question",
-			input:    "Y",
-			expected: true,
-		},
-		{
-			name:     "y",
-			question: "question",
-			input:    "y",
-			expected: true,
-		},
-		{
-			name:        "yes",
-			question:    "question",
-			input:       "yes",
-			expectedErr: ErrPromptFailed,
-		},
-		{
-			name:     "N",
-			question: "question",
-			input:    "N",
-			expected: false,
-		},
-		{
-			name:     "n",
-			question: "question",
-			input:    "n",
-			expected: false,
-		},
-		{
-			name:        "no",
-			question:    "question",
-			input:       "no",
-			expectedErr: ErrPromptFailed,
-		},
-		{
-			name:        "Context canceled",
-			expectedErr: context.Canceled,
-		},
-	}
-
-	for _, tc := range testCases {
-		t.Run(tc.name, func(t *testing.T) {
-			ctx := context.Background()
-
-			if errors.Is(tc.expectedErr, context.Canceled) {
-				var cancel context.CancelFunc
-
-				ctx, cancel = context.WithCancel(ctx)
-				cancel()
-			}
-
-			input.WriteString(tc.input + "\n")
-
-			res, err := confirm(ctx, tc.question)
-			require.True(t, errors.Is(err, tc.expectedErr), fmt.Sprintf("expected: %v, got: %v", tc.expectedErr, err))
-
-			require.Equal(t, tc.expected, res)
-
-			input.Reset()
-			output.Reset()
-		})
-	}
-}
-
 var errMockTest = errors.New("mock test error")
 
 func TestConfirmNoTTY(t *testing.T) {
-	output := bytes.Buffer{}
-
-	isUpdatePaused := atomic.Bool{}
-
 	testCases := []struct {
 		name        string
 		ctx         context.Context
@@ -192,9 +108,11 @@ func TestConfirmNoTTY(t *testing.T) {
 	for _, tc := range testCases {
 		t.Run(tc.name, func(t *testing.T) {
 			r := rendererMock.NewRenderer(t)
-
 			tc.mockFunc(r)
 
+			output := bytes.Buffer{}
+			isUpdatePaused := atomic.Bool{}
+
 			confirm := BuildConfirmNoTTY(r, &output, &isUpdatePaused)
 
 			ctx := context.Background()
@@ -210,8 +128,6 @@ func TestConfirmNoTTY(t *testing.T) {
 			require.True(t, errors.Is(err, tc.expectedErr), fmt.Sprintf("expected: %v, got: %v", tc.expectedErr, err))
 
 			require.Equal(t, tc.expected, res)
-
-			output.Reset()
 		})
 	}
 }

internal/generator/cli/confirm/reader.go

@@ -0,0 +1,37 @@
+package confirm
+
+import "io"
+
+// cancelableReader wraps an io.Reader and can be closed to make future reads fail.
+type cancelableReader struct {
+	r      io.Reader
+	closed chan struct{}
+}
+
+// newCancelableReader creates a ReadCloser from an io.Reader.
+// Closing it will make subsequent Read() calls return io.EOF.
+func newCancelableReader(r io.Reader) io.ReadCloser {
+	return &cancelableReader{
+		r:      r,
+		closed: make(chan struct{}),
+	}
+}
+
+func (c *cancelableReader) Read(p []byte) (int, error) {
+	select {
+	case <-c.closed:
+		return 0, io.EOF
+	default:
+		return c.r.Read(p)
+	}
+}
+
+func (c *cancelableReader) Close() error {
+	select {
+	case <-c.closed:
+		// already closed
+	default:
+		close(c.closed)
+	}
+	return nil
+}