Go Básico: Testando Saída do Console (stdout) com os.Pipe


Testar a saída do console em programas Go pode ser um desafio, especialmente quando queremos garantir que nossas funções estão imprimindo o resultado correto em nossas aplicações de CLI. Neste artigo, vamos explorar como usar os.Pipe para capturar e verificar a saída do console de maneira eficaz, permitindo a criação de testes unitários robustos para suas funções que escrevem na saída padrão (os.Stdout).

Para exemplificar, vamos utilizar o seguinte exemplo como demonstração, simulando uma possível aplicação. 


package main

import (
	"fmt"
)

func printSomething(s string) {
	fmt.Println(s)
}

func main() {
	printSomething("Hello, World!")
}

Agora vamos supor que queremos testar esta função printSomething e validar se ela realmente está imprimindo o que desejamos de maneira correta. 


package main

import (
	"io"
	"os"
	"testing"
)

func Test_printSomething(t *testing.T) {
	// Save the original standard output
	stdOut := os.Stdout

	// Create a pipe to capture the standard output
	r, w, _ := os.Pipe()

	// Redirect the standard output to the pipe writer
	os.Stdout = w

	// Call the printSomething function with the message and the WaitGroup
	printSomething("This is a test")

	// Close the pipe writer
	w.Close()

	// Read the content from the pipe reader
	result, _ := io.ReadAll(r)

	// Restore the original standard output
	//
	//At the end of the test, we restore os.Stdout to ensure that the program's
	//environment returns to its normal state, allowing the rest of the program
	//and other tests to function correctly.
	os.Stdout = stdOut

	// Check if the captured output is equal to the expected string
	if string(result) != "This is a test\n" {
		// If not, the test fails and displays an error message
		t.Errorf("Expected 'This is a test', got %s", result)
	}
}

A função os.Pipe no pacote os da linguagem Go é usada para criar um canal de comunicação unidirecional entre dois pontos, chamado de pipe. Ela é útil para redirecionar a saída de uma função ou processo para outro, permitindo a comunicação entre diferentes partes de um programa.

Comentários

Postar um comentário

Postagens mais visitadas deste blog

Go Básico: Manipulação de Arquivos

Imagem
Todo desenvolvedor em algum momento já se deparou com a necessidade de manipular e escrever arquivos, não é mesmo? Em Go, existem algumas maneiras bem simples de resolvermos essa necessidade de forma rápida. Para criar um novo arquivo e escrever algum conteúdo neste novo arquivo, podemos escrever o seguinte código. package main import ( "fmt" "os" ) func main() { //Creating a new file f, err := os.Create("test.txt") if err != nil { panic(err) } defer f.Close() //Writing to the new file. size, err := f.Write([]byte("Hello World!")) if err != nil { panic(err) } fmt.Printf("Size file: %d bytes", size) //If the content of your file is only text, you can opt for this other function. //size, err := f.WriteString("Hello World") } Agora que já criamos e escrevemos em um novo arquivo, podemos realizar a leitura deste arquivo com o seguinte código: package main import ( "fmt" ...
Leia mais

Go Básico: Generics

Imagem
A linguagem Go nasceu sem o recurso conhecido como generics , que é uma forma mais "elegante" de criar novos tipos de parâmetros ( exp: um parâmetro de uma função ) que podem ser compostos de outros tipos. Para ilustrar, podemos criar uma função que some a pontuação de todos os jogadores, representada em um mapa com seus nomes e sua pontuação final, que serão inicialmente números inteiros. package main import "fmt" func main() { scores := map[string]int{"User01": 100, "User02": 150, "User03": 50} fmt.Printf("Final score: %d\n", AddScores(scores)) } func AddScores(scores map[string]int) int { var total int for _, score := range scores { total += score } return total } Agora, vamos imaginar que precisamos lidar não apenas com o nosso mapa que representa os pontos em números inteiros, mas também com um novo mapa que representa a pontuação com números decimais. Essa simples alteração faria com que noss...
Leia mais

Kotlin Básico: Tipos Básicos

Imagem
 Embora Kotlin seja uma linguagem fortemente tipada não precisamos declarar os tipos explicitamente. O compilador através do mecanismo de inferência de tipo tenta "descobrir" o tipo da variável segundo a informação incluídas nela. Diferente da linguagem Java, em Kotlin tudo é um objeto promovendo as primitivas a objetos completos e o compilador sempre que possível mapeará os tipos básicos de volta para primitivas da JVM por questões de desempenho.   Números   Todo número tem uma função que converterá o valor em outros tipos numéricos. Por exemplo, para converter um double em um float, usamos a função toFloat() . Booleanos   Chars   Os chars representam um único caractere. Caracteres literais usam aspas simples, como em 'A' ou 'Z'. Alem de permitir scaping como o " \n ", todos os caracteres unicode podem ser representados pelo número unicode como o \u1234 . Strings   As Strings são imutáveis e podem ser criadas usando aspas duplas ...
Leia mais