feat: review feedback

Author: mirkoCrobu

cmd/arduino-app-cli/board/board.go

@@ -81,18 +81,18 @@ func newSyncAppCmd() *cobra.Command {
 			}
 			defer s.Close()
 			s.OnPull = func(name, path string) {
-				feedback.Printf(" ⬆️ Pulled app %q to folder %q", name, path)
+				feedback.Info(fmt.Sprintf(" ⬆️ Pulled app %q to folder %q", name, path))
 			}
 			s.OnPush = func(name string) {
-				feedback.Printf(" ⬇️ Pushed app %q to the board", name)
+				feedback.Info(fmt.Sprintf(" ⬇️ Pushed app %q to the board", name))
 			}
 
 			tmp, err := s.EnableSyncApp(remote)
 			if err != nil {
 				return fmt.Errorf("failed to enable sync for app %q: %w", remote, err)
 			}
 
-			feedback.Printf("Enable sync of %q at %q", remote, tmp)
+			feedback.Info(fmt.Sprintf("Enable sync of %q at %q", remote, tmp))
 
 			<-cmd.Context().Done()
 			_ = s.DisableSyncApp(remote)
@@ -119,7 +119,7 @@ func newBoardListCmd() *cobra.Command {
 				default:
 					panic("unreachable")
 				}
-				feedback.Printf("%s (%s) - Connection: %s [%s]\n", b.BoardName, b.CustomName, b.Protocol, address)
+				feedback.Info(fmt.Sprintf("%s (%s) - Connection: %s [%s]\n", b.BoardName, b.CustomName, b.Protocol, address))
 			}
 			return nil
 		},
@@ -140,7 +140,7 @@ func newBoardSetName() *cobra.Command {
 			if err := board.SetCustomName(cmd.Context(), conn, name); err != nil {
 				return fmt.Errorf("failed to set custom name: %w", err)
 			}
-			feedback.Printf("Custom name set to %q\n", name)
+			feedback.Info(fmt.Sprintf("Custom name set to %q\n", name))
 			return nil
 		},
 	}

cmd/feedback/feedback.go

@@ -127,16 +127,6 @@ func GetFormat() OutputFormat {
 	return format
 }
 
-// Printf behaves like fmt.Printf but writes on the out writer and adds a newline.
-func Printf(format string, v ...interface{}) {
-	Print(fmt.Sprintf(format, v...))
-}
-
-// Print behaves like fmt.Print but writes on the out writer and adds a newline.
-func Print(v string) {
-	fmt.Fprintln(feedbackOut, v)
-}
-
 // FatalError outputs the error and exits with status exitCode.
 func FatalError(err error, exitCode ExitCode) {
 	Fatal(err.Error(), exitCode)
@@ -264,41 +254,40 @@ func Minimal(message string) {
 	if logLevel < LogLevelMinimal {
 		return
 	}
-	printLogMessage("step", message)
+	printLogMessage(message)
 }
 
 func Info(message string) {
 	if logLevel < LogLevelInfo {
 		return
 	}
-	printLogMessage("info", message)
+	printLogMessage(message)
 }
 
 func Debug(message string) {
 	if logLevel < LogLevelDebug {
 		return
 	}
-	printLogMessage("debug", message)
+	printLogMessage(message)
 }
 
 func Warning(message string) {
 	if logLevel < LogLevelInfo {
 		return
 	}
-	printLogMessage("warning", message)
+	printLogMessage(message)
 }
 
-func printLogMessage(level string, message string) {
+func printLogMessage(message string) {
 	switch format {
 	case JSON, MinifiedJSON:
 		type logMsg struct {
-			Level   string `json:"level"`
 			Message string `json:"message"`
 		}
-		output, _ := json.Marshal(logMsg{Level: level, Message: message})
-		fmt.Fprintln(feedbackOut, string(output))
+		output, _ := json.Marshal(logMsg{Message: message})
+		fmt.Fprintln(stdOut, string(output))
 	default: // Text
-		fmt.Fprintf(feedbackErr, "%s %s\n", "["+strings.ToUpper(level)+"]", message)
+		fmt.Fprintf(feedbackErr, "%s\n", message)
 	}
 }
 

cmd/feedback/feedback_test.go

@@ -31,17 +31,20 @@ func TestOutputSelection(t *testing.T) {
 	myOut := new(bytes.Buffer)
 	SetOut(myOut)
 	SetErr(myErr)
+
+	// Set the log level to minimal to ensure the message is printed
+	SetLogLevel(LogLevelMinimal)
 	SetFormat(Text)
 
-	// Could not change output stream after format has been set
 	require.Panics(t, func() { SetOut(nil) })
 	require.Panics(t, func() { SetErr(nil) })
-
-	// Coule not change output format twice
 	require.Panics(t, func() { SetFormat(JSON) })
 
-	Print("Hello")
-	require.Equal(t, myOut.String(), "Hello\n")
+	Minimal("Hello")
+
+	require.Equal(t, "Hello\n", myErr.String())
+	// The standard output stream should be empty
+	require.Empty(t, myOut.String())
 }
 
 func TestJSONOutputStream(t *testing.T) {
@@ -65,59 +68,42 @@ func TestJSONOutputStream(t *testing.T) {
 	require.JSONEq(t, string(d), `{"stdout":"Hello\ufffdA","stderr":"Hello ERR"}`)
 }
 
-func TestJsonOutputOnCustomStreams(t *testing.T) {
+func TestJsonOutput(t *testing.T) {
 	reset()
 
+	// Setup custom buffers for stdout and stderr
 	myErr := new(bytes.Buffer)
 	myOut := new(bytes.Buffer)
 	SetOut(myOut)
 	SetErr(myErr)
-	SetFormat(JSON)
 
-	// Could not change output stream after format has been set
-	require.Panics(t, func() { SetOut(nil) })
-	require.Panics(t, func() { SetErr(nil) })
-	// Could not change output format twice
-	require.Panics(t, func() { SetFormat(JSON) })
+	// Set the state for the test
+	SetLogLevel(LogLevelMinimal)
+	SetFormat(JSON)
 
-	Print("Hello") // Output interactive data
+	// --- Test 1: Verify a log message ---
+	Minimal("Hello")
 
-	require.Equal(t, "", myOut.String())
-	require.Equal(t, "", myErr.String())
-	require.Equal(t, "Hello\n", bufferOut.String())
+	// In JSON mode, logs are JSON Lines sent to stdout (myOut).
+	expectedLog := `{"message": "Hello"}` // Assuming your printLogMessage does this
+	require.JSONEq(t, expectedLog, myOut.String())
+	require.Empty(t, myErr.String(), "Stderr should be empty for a log message")
+	myOut.Reset() // Reset the buffer for the next test
 
+	// --- Test 2: Verify a result message ---
 	PrintResult(&testResult{Success: true})
 
-	require.JSONEq(t, myOut.String(), `{ "success": true }`)
-	require.Equal(t, myErr.String(), "")
-	myOut.Reset()
-
-	_, _, res := OutputStreams()
-	PrintResult(&testResult{Success: false, Output: res()})
-
-	require.JSONEq(t, `
-{
-  "success": false,
-  "output": {
-    "stdout": "Hello\n",
-    "stderr": ""
-  }
-}`, myOut.String())
-	require.Equal(t, myErr.String(), "")
+	// PrintResult should output a well-formed JSON object to stdout (myOut).
+	expectedResult := `{
+		"success": true
+	}`
+	require.JSONEq(t, expectedResult, myOut.String())
+	require.Empty(t, myErr.String(), "Stderr should be empty for a success result")
 }
 
 type testResult struct {
-	Success bool                 `json:"success"`
-	Output  *OutputStreamsResult `json:"output,omitempty"`
+	Success bool `json:"success"`
 }
 
-func (r *testResult) Data() interface{} {
-	return r
-}
-
-func (r *testResult) String() string {
-	if r.Success {
-		return "Success"
-	}
-	return "Failure"
-}
+func (r testResult) String() string    { return fmt.Sprintf("Success: %t", r.Success) }
+func (r testResult) Data() interface{} { return r }