Merge pull request #73 from fabianoflorentino/development

Development to Main

Author: fabianoflorentino

internal/agrupamento_de_dados/topics.go

@@ -24,17 +24,7 @@ const (
 // The topics covered include arrays, slices (with various operations), and maps.
 func AgrupamentoDeDados() {
 	fmt.Printf("\n\n08 - Agrupamento de Dados\n")
-
-	executeSection("Array")
-	executeSection("Slice: literal composta")
-	executeSection("Slice: for range")
-	executeSection("Slice: fatiando ou deletando de uma fatia")
-	executeSection("Slice: anexando a uma slice")
-	executeSection("Slice: make")
-	executeSection("Slice: multi dimensional")
-	executeSection("Slice: a surpresa do array subjacente")
-	executeSection("Maps: introdução")
-	executeSection("Maps: range e deletando")
+	listOfTopics()
 }
 
 // MenuAgrupamentoDeDados returns a slice of format.MenuOptions, each representing a menu option
@@ -80,6 +70,29 @@ func HelpMeAgrupamentoDeDados() {
 	format.PrintHelpMe(hlp)
 }
 
+// listOfTopics executes each topic in the list.
+// It iterates over a predefined list of topics and calls the executeSection
+// function for each topic. This function is used to sequentially execute
+// and display the content of each section.
+func listOfTopics() {
+	listOfTopics := []string{
+		"Array",
+		"Slice: literal composta",
+		"Slice: for range",
+		"Slice: fatiando ou deletando de uma fatia",
+		"Slice: anexando a uma slice",
+		"Slice: make",
+		"Slice: multi dimensional",
+		"Slice: a surpresa do array subjacente",
+		"Maps: introdução",
+		"Maps: range e deletando",
+	}
+
+	for _, topic := range listOfTopics {
+		executeSection(topic)
+	}
+}
+
 // executeSection formats and processes a specific section of data.
 // It takes a section name as a string parameter and uses the FormatSection
 // function from the format package to format the section within the root directory.

internal/aplicacoes/topics.go

@@ -15,25 +15,12 @@ const (
 	rootDir = "internal/aplicacoes"
 )
 
-// Aplicacoes prints the title of Chapter 16 and executes a series of sections related to various topics.
-// The sections include:
-// - JSON Documentation
-// - JSON marshal (ordering)
-// - JSON unmarshal (disordering)
-// - The Writer interface
-// - The sort package
-// - Customizing sort
-// - bcrypt
+// Aplicacoes prints the chapter title and executes a series of sections
+// related to various topics such as JSON handling, interfaces, sorting,
+// and encryption using bcrypt.
 func Aplicacoes() {
 	fmt.Printf("\n\nCapítulo 16: Aplicações\n")
-
-	executeSections("Documentação JSON")
-	executeSections("JSON marshal (ordenação)")
-	executeSections("JSON unmarshal (desornação)")
-	executeSections("A interface Writer")
-	executeSections("O pacote sort")
-	executeSections("Customizando sort")
-	executeSections("bcrypt")
+	listOfTopics()
 }
 
 // MenuAplicacoes returns a slice of format.MenuOptions, each representing a different command-line option
@@ -80,6 +67,22 @@ func HelpMeAplicacoes() {
 	format.PrintHelpMe(hlp)
 }
 
+func listOfTopics() {
+	listOfTopics := []string{
+		"Documentação JSON",
+		"JSON marshal (ordenação)",
+		"JSON unmarshal (desornação)",
+		"A interface Writer",
+		"O pacote sort",
+		"Customizando sort",
+		"bcrypt",
+	}
+
+	for _, topic := range listOfTopics {
+		executeSections(topic)
+	}
+}
+
 // executeSections processes a given section by formatting it.
 // It takes a section name as a string parameter and applies the FormatSection
 // function from the format package to the section, using the rootDir as the base directory.

internal/exercicios_ninja_nivel_11/resolution_exercises_test.go

@@ -110,3 +110,33 @@ func TestResolucaoNaPraticaExercicio4(t *testing.T) {
 		t.Errorf("Expected substring not found.\nWant: %q\nGot: %q", expectedSubstring, result)
 	}
 }
+
+// TestResolucaoNaPraticaExercicio5 tests the function ResolucaoNaPraticaExercicio5
+// by capturing its output and comparing it to the expected result. If the output
+// does not match the expected result, the test will fail. The expected output
+// includes instructions for learning how to write tests in Go and a reference
+// to the file where the solution can be found.
+func TestResolucaoNaPraticaExercicio5(t *testing.T) {
+	output := output.New()
+	result, err := output.Capture(ResolucaoNaPraticaExercicio5)
+	if err != nil {
+		logger.Log("Failed to capture output: %v", err)
+		t.Fatalf("unexpected error: %v", err)
+	}
+
+	expected := `
+- Nos capítulos seguintes, uma das coisas que veremos é testes.
+- Para testar sua habilidade de se virar por conta própria... desafio:
+  - Utilizando as seguintes fontes: https://godoc.org/testing & http://www.golang-book.com/books/intro/12
+  - Tente descobrir por conta própria como funcionam testes em Go.
+  - Pode usar tradutor automático, pode rodar código na sua máquina, pode procurar no Google. Vale tudo.
+  - O exercício é: crie um teste simples de uma função ou método ou pedaço qualquer de código.
+
+Resolução: internal/exercicios_ninja_nivel_11/resolution_exercises_test.go
+`
+	trim := trim.New()
+
+	if !strings.Contains(trim.String(result), trim.String(expected)) {
+		t.Errorf(expectTemplate, expected, result)
+	}
+}

internal/exercicios_ninja_nivel_12/resolution_exercises_test.go

@@ -0,0 +1,46 @@
+// Package exercicios_ninja_nivel_12 contains tests for the exercises of level 12 in the "aprendago" project.
+// These tests are designed to validate the solutions to the practical exercises, ensuring that the output
+// matches the expected results. The package utilizes various helper packages such as logger, output, and trim
+// to capture and compare the output of the exercises.
+package exercicios_ninja_nivel_12
+
+import (
+	"strings"
+	"testing"
+
+	"github.com/fabianoflorentino/aprendago/pkg/logger"
+	"github.com/fabianoflorentino/aprendago/pkg/output"
+	"github.com/fabianoflorentino/aprendago/pkg/trim"
+)
+
+// expectTemplate is a format string used for displaying the expected and actual output
+// in a structured manner. It includes placeholders for the expected value ("want")
+// and the actual value ("got"), making it easier to compare them in test results.
+const (
+	expectTemplate = "\nwant:\n%s\n\ngot:\n%s\n"
+)
+
+// TestResolucaoNaPraticaExercicio1 tests the function ResolucaoNaPraticaExercicio1
+// by capturing its output and comparing it to the expected result.
+// It uses the output.Capture method to capture the function's output and
+// the strings.Contains method to check if the captured output matches the expected output.
+// If there is an error capturing the output or if the output does not match the expected result,
+// the test will fail and log the appropriate error message.
+func TestResolucaoNaPraticaExercicio1(t *testing.T) {
+	output := output.New()
+	result, err := output.Capture(ResolucaoNaPraticaExercicio1)
+	if err != nil {
+		logger.Log("Error capturing output: %v", err)
+		t.Fatalf("Error capturing output: %v", err)
+	}
+
+	expected := `
+A idade do cachorro em anos humanos é: 21
+	`
+
+	trim := trim.New()
+
+	if !strings.Contains(trim.String(result), trim.String(expected)) {
+		t.Errorf(expectTemplate, expected, result)
+	}
+}

pkg/format/helpme.go

@@ -29,6 +29,41 @@ type HelpMe struct {
 	Width       int
 }
 
+// PrintHelpMe formats and prints a slice of HelpMe structs using a predefined template.
+// It first calculates the width for each HelpMe item, then sets up a template with custom functions
+// for formatting. The template is parsed and executed, rendering the formatted output to os.Stdout.
+//
+// Parameters:
+//
+//	helpme []HelpMe - A slice of HelpMe structs to be formatted and printed.
+func PrintHelpMe(helpme []HelpMe) {
+	width := parseWidth(helpme)
+	for i := range helpme {
+		helpme[i].Width = width
+	}
+
+	// funcMap is a map of functions that can be used in the template.
+	// In this case, we are using the printf function from the fmt package to format the output.
+	funcMap := template.FuncMap{
+		"printf": fmt.Sprintf,
+		"indent": indent,
+	}
+
+	// tmpl is a template object that contains the help output template.
+	// The template is a string that contains the formatting for the help output.
+	tmpl, err := template.New("helpme").Funcs(funcMap).Parse(templateHelpMe)
+	if err != nil {
+		panic(err)
+	}
+
+	// The Execute function is used to render the template and print the formatted output.
+	// The first argument is the output destination (os.Stdout) and the second argument is the data model (helpme).
+	err = tmpl.Execute(os.Stdout, helpme)
+	if err != nil {
+		panic(err)
+	}
+}
+
 // parseWidth takes a slice of HelpMe structs and returns the length of the longest
 // flag string within the slice. It iterates through each HelpMe struct, trims any
 // leading or trailing whitespace from the flag string, and updates the maximum
@@ -79,38 +114,3 @@ func indent(width int, description string) string {
 
 	return strings.Join(lines, "\n")
 }
-
-// PrintHelpMe formats and prints a slice of HelpMe structs using a predefined template.
-// It first calculates the width for each HelpMe item, then sets up a template with custom functions
-// for formatting. The template is parsed and executed, rendering the formatted output to os.Stdout.
-//
-// Parameters:
-//
-//	helpme []HelpMe - A slice of HelpMe structs to be formatted and printed.
-func PrintHelpMe(helpme []HelpMe) {
-	width := parseWidth(helpme)
-	for i := range helpme {
-		helpme[i].Width = width
-	}
-
-	// funcMap is a map of functions that can be used in the template.
-	// In this case, we are using the printf function from the fmt package to format the output.
-	funcMap := template.FuncMap{
-		"printf": fmt.Sprintf,
-		"indent": indent,
-	}
-
-	// tmpl is a template object that contains the help output template.
-	// The template is a string that contains the formatting for the help output.
-	tmpl, err := template.New("helpme").Funcs(funcMap).Parse(templateHelpMe)
-	if err != nil {
-		panic(err)
-	}
-
-	// The Execute function is used to render the template and print the formatted output.
-	// The first argument is the output destination (os.Stdout) and the second argument is the data model (helpme).
-	err = tmpl.Execute(os.Stdout, helpme)
-	if err != nil {
-		panic(err)
-	}
-}

pkg/output/output.go

@@ -58,19 +58,15 @@ func (o *Output) Capture(captureOutput func()) (string, error) {
 	wg.Add(1)
 	go func() {
 		defer wg.Done()
-		io.Copy(&buf, o.read) // Captura os dados
+		io.Copy(&buf, o.read)
 	}()
 
-	// Executa a função alvo
 	captureOutput()
 
-	// Fecha o pipe para garantir que todos os dados sejam escritos
 	o.write.Close()
 
-	// Aguarda a goroutine terminar a leitura
 	wg.Wait()
 
-	// **Restaura a saída antes de ler o buffer**
 	os.Stdout = o.stdout
 	os.Stderr = o.stderr
 	log.SetOutput(os.Stderr)