Refactor tests for better execution (#142)

* Refactor tests for better execution

* fix typo

internal/pkg/print/json/json_test.go

@@ -1,78 +1,53 @@
-package json_test
+package json
 
 import (
 	"testing"
 
 	"github.com/segmentio/terraform-docs/internal/pkg/print"
-	"github.com/segmentio/terraform-docs/internal/pkg/print/json"
-	"github.com/segmentio/terraform-docs/internal/pkg/tfconf"
+	"github.com/segmentio/terraform-docs/internal/pkg/testutil"
 	"github.com/stretchr/testify/assert"
 )
 
-func TestPrint(t *testing.T) {
-	var settings = &print.Settings{}
+func TestJson(t *testing.T) {
+	assert := assert.New(t)
+	settings := &print.Settings{}
 
-	module, err := tfconf.CreateModule("../../../../examples")
-	if err != nil {
-		t.Fatal(err)
-	}
+	module, expected, err := testutil.GetExpected("json")
+	assert.Nil(err)
 
-	actual, err := json.Print(module, settings)
-	if err != nil {
-		t.Fatal(err)
-	}
+	actual, err := Print(module, settings)
 
-	expected, err := print.ReadGoldenFile("json")
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	assert.Equal(t, expected, actual)
+	assert.Nil(err)
+	assert.Equal(expected, actual)
 }
 
-func TestPrintWithSortByName(t *testing.T) {
-	var settings = &print.Settings{
+func TestJsonSortByName(t *testing.T) {
+	assert := assert.New(t)
+	settings := &print.Settings{
 		SortByName: true,
 	}
 
-	module, err := tfconf.CreateModule("../../../../examples")
-	if err != nil {
-		t.Fatal(err)
-	}
+	module, expected, err := testutil.GetExpected("json-SortByName")
+	assert.Nil(err)
 
-	actual, err := json.Print(module, settings)
-	if err != nil {
-		t.Fatal(err)
-	}
+	actual, err := Print(module, settings)
 
-	expected, err := print.ReadGoldenFile("json-WithSortByName")
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	assert.Equal(t, expected, actual)
+	assert.Nil(err)
+	assert.Equal(expected, actual)
 }
 
-func TestPrintWithSortInputsByRequired(t *testing.T) {
-	var settings = &print.Settings{
+func TestJsonSortByRequired(t *testing.T) {
+	assert := assert.New(t)
+	settings := &print.Settings{
 		SortByName:           true,
 		SortInputsByRequired: true,
 	}
 
-	module, err := tfconf.CreateModule("../../../../examples")
-	if err != nil {
-		t.Fatal(err)
-	}
+	module, expected, err := testutil.GetExpected("json-SortByRequired")
+	assert.Nil(err)
 
-	actual, err := json.Print(module, settings)
-	if err != nil {
-		t.Fatal(err)
-	}
+	actual, err := Print(module, settings)
 
-	expected, err := print.ReadGoldenFile("json-WithSortInputsByRequired")
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	assert.Equal(t, expected, actual)
+	assert.Nil(err)
+	assert.Equal(expected, actual)
 }

internal/pkg/print/markdown/document/document_test.go

@@ -1,193 +1,128 @@
-package document_test
+package document
 
 import (
 	"testing"
 
 	"github.com/segmentio/terraform-docs/internal/pkg/print"
-	"github.com/segmentio/terraform-docs/internal/pkg/print/markdown/document"
-	"github.com/segmentio/terraform-docs/internal/pkg/tfconf"
+	"github.com/segmentio/terraform-docs/internal/pkg/testutil"
 	"github.com/stretchr/testify/assert"
 )
 
-func TestPrint(t *testing.T) {
-	var settings = &print.Settings{}
+func TestDocument(t *testing.T) {
+	assert := assert.New(t)
+	settings := &print.Settings{}
 
-	module, err := tfconf.CreateModule("../../../../../examples")
-	if err != nil {
-		t.Fatal(err)
-	}
+	module, expected, err := testutil.GetExpected("document")
+	assert.Nil(err)
 
-	actual, err := document.Print(module, settings)
-	if err != nil {
-		t.Fatal(err)
-	}
+	actual, err := Print(module, settings)
 
-	expected, err := print.ReadGoldenFile("document")
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	assert.Equal(t, expected, actual)
+	assert.Nil(err)
+	assert.Equal(expected, actual)
 }
 
-func TestPrintWithRequired(t *testing.T) {
-	var settings = &print.Settings{
+func TestDocumentWithRequired(t *testing.T) {
+	assert := assert.New(t)
+	settings := &print.Settings{
 		ShowRequired: true,
 	}
 
-	module, err := tfconf.CreateModule("../../../../../examples")
-	if err != nil {
-		t.Fatal(err)
-	}
+	module, expected, err := testutil.GetExpected("document-WithRequired")
+	assert.Nil(err)
 
-	actual, err := document.Print(module, settings)
-	if err != nil {
-		t.Fatal(err)
-	}
+	actual, err := Print(module, settings)
 
-	expected, err := print.ReadGoldenFile("document-WithRequired")
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	assert.Equal(t, expected, actual)
+	assert.Nil(err)
+	assert.Equal(expected, actual)
 }
 
-func TestPrintWithSortByName(t *testing.T) {
-	var settings = &print.Settings{
+func TestDocumentSortByName(t *testing.T) {
+	assert := assert.New(t)
+	settings := &print.Settings{
 		SortByName: true,
 	}
 
-	module, err := tfconf.CreateModule("../../../../../examples")
-	if err != nil {
-		t.Fatal(err)
-	}
+	module, expected, err := testutil.GetExpected("document-SortByName")
+	assert.Nil(err)
 
-	actual, err := document.Print(module, settings)
-	if err != nil {
-		t.Fatal(err)
-	}
+	actual, err := Print(module, settings)
 
-	expected, err := print.ReadGoldenFile("document-WithSortByName")
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	assert.Equal(t, expected, actual)
+	assert.Nil(err)
+	assert.Equal(expected, actual)
 }
 
-func TestPrintWithSortInputsByRequired(t *testing.T) {
-	var settings = &print.Settings{
+func TestDocumentSortByRequired(t *testing.T) {
+	assert := assert.New(t)
+	settings := &print.Settings{
 		SortByName:           true,
 		SortInputsByRequired: true,
 	}
 
-	module, err := tfconf.CreateModule("../../../../../examples")
-	if err != nil {
-		t.Fatal(err)
-	}
+	module, expected, err := testutil.GetExpected("document-SortByRequired")
+	assert.Nil(err)
 
-	actual, err := document.Print(module, settings)
-	if err != nil {
-		t.Fatal(err)
-	}
+	actual, err := Print(module, settings)
 
-	expected, err := print.ReadGoldenFile("document-WithSortInputsByRequired")
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	assert.Equal(t, expected, actual)
+	assert.Nil(err)
+	assert.Equal(expected, actual)
 }
 
-func TestPrintWithEscapeName(t *testing.T) {
-	var settings = &print.Settings{
+func TestDocumentEscapeMarkdown(t *testing.T) {
+	assert := assert.New(t)
+	settings := &print.Settings{
 		EscapeMarkdown: true,
 	}
 
-	module, err := tfconf.CreateModule("../../../../../examples")
-	if err != nil {
-		t.Fatal(err)
-	}
+	module, expected, err := testutil.GetExpected("document-EscapeMarkdown")
+	assert.Nil(err)
 
-	actual, err := document.Print(module, settings)
-	if err != nil {
-		t.Fatal(err)
-	}
+	actual, err := Print(module, settings)
 
-	expected, err := print.ReadGoldenFile("document-WithEscapeName")
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	assert.Equal(t, expected, actual)
+	assert.Nil(err)
+	assert.Equal(expected, actual)
 }
 
-func TestPrintWithIndentationBellowAllowed(t *testing.T) {
-	var settings = &print.Settings{
+func TestDocumentIndentationBellowAllowed(t *testing.T) {
+	assert := assert.New(t)
+	settings := &print.Settings{
 		MarkdownIndent: 0,
 	}
 
-	module, err := tfconf.CreateModule("../../../../../examples")
-	if err != nil {
-		t.Fatal(err)
-	}
+	module, expected, err := testutil.GetExpected("document-IndentationBellowAllowed")
+	assert.Nil(err)
 
-	actual, err := document.Print(module, settings)
-	if err != nil {
-		t.Fatal(err)
-	}
+	actual, err := Print(module, settings)
 
-	expected, err := print.ReadGoldenFile("document-WithIndentationBellowAllowed")
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	assert.Equal(t, expected, actual)
+	assert.Nil(err)
+	assert.Equal(expected, actual)
 }
 
-func TestPrintWithIndentationAboveAllowed(t *testing.T) {
-	var settings = &print.Settings{
+func TestDocumentIndentationAboveAllowed(t *testing.T) {
+	assert := assert.New(t)
+	settings := &print.Settings{
 		MarkdownIndent: 10,
 	}
 
-	module, err := tfconf.CreateModule("../../../../../examples")
-	if err != nil {
-		t.Fatal(err)
-	}
+	module, expected, err := testutil.GetExpected("document-IndentationAboveAllowed")
+	assert.Nil(err)
 
-	actual, err := document.Print(module, settings)
-	if err != nil {
-		t.Fatal(err)
-	}
+	actual, err := Print(module, settings)
 
-	expected, err := print.ReadGoldenFile("document-WithIndentationAboveAllowed")
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	assert.Equal(t, expected, actual)
+	assert.Nil(err)
+	assert.Equal(expected, actual)
 }
 
-func TestPrintWithIndentationOfFour(t *testing.T) {
-	var settings = &print.Settings{
+func TestDocumentIndentationOfFour(t *testing.T) {
+	assert := assert.New(t)
+	settings := &print.Settings{
 		MarkdownIndent: 4,
 	}
 
-	module, err := tfconf.CreateModule("../../../../../examples")
-	if err != nil {
-		t.Fatal(err)
-	}
+	module, expected, err := testutil.GetExpected("document-IndentationOfFour")
+	assert.Nil(err)
 
-	actual, err := document.Print(module, settings)
-	if err != nil {
-		t.Fatal(err)
-	}
+	actual, err := Print(module, settings)
 
-	expected, err := print.ReadGoldenFile("document-WithIndentationOfFour")
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	assert.Equal(t, expected, actual)
+	assert.Nil(err)
+	assert.Equal(expected, actual)
 }

internal/pkg/print/markdown/table/table_test.go

@@ -1,193 +1,128 @@
-package table_test
+package table
 
 import (
 	"testing"
 
 	"github.com/segmentio/terraform-docs/internal/pkg/print"
-	"github.com/segmentio/terraform-docs/internal/pkg/print/markdown/table"
-	"github.com/segmentio/terraform-docs/internal/pkg/tfconf"
+	"github.com/segmentio/terraform-docs/internal/pkg/testutil"
 	"github.com/stretchr/testify/assert"
 )
 
-func TestPrint(t *testing.T) {
-	var settings = &print.Settings{}
+func TestTable(t *testing.T) {
+	assert := assert.New(t)
+	settings := &print.Settings{}
 
-	module, err := tfconf.CreateModule("../../../../../examples")
-	if err != nil {
-		t.Fatal(err)
-	}
+	module, expected, err := testutil.GetExpected("table")
+	assert.Nil(err)
 
-	actual, err := table.Print(module, settings)
-	if err != nil {
-		t.Fatal(err)
-	}
+	actual, err := Print(module, settings)
 
-	expected, err := print.ReadGoldenFile("table")
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	assert.Equal(t, expected, actual)
+	assert.Nil(err)
+	assert.Equal(expected, actual)
 }
 
-func TestPrintWithRequired(t *testing.T) {
-	var settings = &print.Settings{
+func TestTableWithRequired(t *testing.T) {
+	assert := assert.New(t)
+	settings := &print.Settings{
 		ShowRequired: true,
 	}
 
-	module, err := tfconf.CreateModule("../../../../../examples")
-	if err != nil {
-		t.Fatal(err)
-	}
+	module, expected, err := testutil.GetExpected("table-WithRequired")
+	assert.Nil(err)
 
-	actual, err := table.Print(module, settings)
-	if err != nil {
-		t.Fatal(err)
-	}
+	actual, err := Print(module, settings)
 
-	expected, err := print.ReadGoldenFile("table-WithRequired")
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	assert.Equal(t, expected, actual)
+	assert.Nil(err)
+	assert.Equal(expected, actual)
 }
 
-func TestPrintWithSortByName(t *testing.T) {
-	var settings = &print.Settings{
+func TestTableSortByName(t *testing.T) {
+	assert := assert.New(t)
+	settings := &print.Settings{
 		SortByName: true,
 	}
 
-	module, err := tfconf.CreateModule("../../../../../examples")
-	if err != nil {
-		t.Fatal(err)
-	}
+	module, expected, err := testutil.GetExpected("table-SortByName")
+	assert.Nil(err)
 
-	actual, err := table.Print(module, settings)
-	if err != nil {
-		t.Fatal(err)
-	}
+	actual, err := Print(module, settings)
 
-	expected, err := print.ReadGoldenFile("table-WithSortByName")
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	assert.Equal(t, expected, actual)
+	assert.Nil(err)
+	assert.Equal(expected, actual)
 }
 
-func TestPrintWithSortInputsByRequired(t *testing.T) {
-	var settings = &print.Settings{
+func TestTableSortByRequired(t *testing.T) {
+	assert := assert.New(t)
+	settings := &print.Settings{
 		SortByName:           true,
 		SortInputsByRequired: true,
 	}
 
-	module, err := tfconf.CreateModule("../../../../../examples")
-	if err != nil {
-		t.Fatal(err)
-	}
+	module, expected, err := testutil.GetExpected("table-SortByRequired")
+	assert.Nil(err)
 
-	actual, err := table.Print(module, settings)
-	if err != nil {
-		t.Fatal(err)
-	}
+	actual, err := Print(module, settings)
 
-	expected, err := print.ReadGoldenFile("table-WithSortInputsByRequired")
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	assert.Equal(t, expected, actual)
+	assert.Nil(err)
+	assert.Equal(expected, actual)
 }
 
-func TestPrintWithEscapeName(t *testing.T) {
-	var settings = &print.Settings{
+func TestTableEscapeMarkdown(t *testing.T) {
+	assert := assert.New(t)
+	settings := &print.Settings{
 		EscapeMarkdown: true,
 	}
 
-	module, err := tfconf.CreateModule("../../../../../examples")
-	if err != nil {
-		t.Fatal(err)
-	}
+	module, expected, err := testutil.GetExpected("table-EscapeMarkdown")
+	assert.Nil(err)
 
-	actual, err := table.Print(module, settings)
-	if err != nil {
-		t.Fatal(err)
-	}
+	actual, err := Print(module, settings)
 
-	expected, err := print.ReadGoldenFile("table-WithEscapeName")
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	assert.Equal(t, expected, actual)
+	assert.Nil(err)
+	assert.Equal(expected, actual)
 }
 
-func TestPrintWithIndentationBellowAllowed(t *testing.T) {
-	var settings = &print.Settings{
+func TestTableIndentationBellowAllowed(t *testing.T) {
+	assert := assert.New(t)
+	settings := &print.Settings{
 		MarkdownIndent: 0,
 	}
 
-	module, err := tfconf.CreateModule("../../../../../examples")
-	if err != nil {
-		t.Fatal(err)
-	}
+	module, expected, err := testutil.GetExpected("table-IndentationBellowAllowed")
+	assert.Nil(err)
 
-	actual, err := table.Print(module, settings)
-	if err != nil {
-		t.Fatal(err)
-	}
+	actual, err := Print(module, settings)
 
-	expected, err := print.ReadGoldenFile("table-WithIndentationBellowAllowed")
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	assert.Equal(t, expected, actual)
+	assert.Nil(err)
+	assert.Equal(expected, actual)
 }
 
-func TestPrintWithIndentationAboveAllowed(t *testing.T) {
-	var settings = &print.Settings{
+func TestTableIndentationAboveAllowed(t *testing.T) {
+	assert := assert.New(t)
+	settings := &print.Settings{
 		MarkdownIndent: 10,
 	}
 
-	module, err := tfconf.CreateModule("../../../../../examples")
-	if err != nil {
-		t.Fatal(err)
-	}
+	module, expected, err := testutil.GetExpected("table-IndentationAboveAllowed")
+	assert.Nil(err)
 
-	actual, err := table.Print(module, settings)
-	if err != nil {
-		t.Fatal(err)
-	}
+	actual, err := Print(module, settings)
 
-	expected, err := print.ReadGoldenFile("table-WithIndentationAboveAllowed")
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	assert.Equal(t, expected, actual)
+	assert.Nil(err)
+	assert.Equal(expected, actual)
 }
 
-func TestPrintWithIndentationOfFour(t *testing.T) {
-	var settings = &print.Settings{
+func TestTableIndentationOfFour(t *testing.T) {
+	assert := assert.New(t)
+	settings := &print.Settings{
 		MarkdownIndent: 4,
 	}
 
-	module, err := tfconf.CreateModule("../../../../../examples")
-	if err != nil {
-		t.Fatal(err)
-	}
+	module, expected, err := testutil.GetExpected("table-IndentationOfFour")
+	assert.Nil(err)
 
-	actual, err := table.Print(module, settings)
-	if err != nil {
-		t.Fatal(err)
-	}
+	actual, err := Print(module, settings)
 
-	expected, err := print.ReadGoldenFile("table-WithIndentationOfFour")
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	assert.Equal(t, expected, actual)
+	assert.Nil(err)
+	assert.Equal(expected, actual)
 }

internal/pkg/print/pretty/pretty_test.go

@@ -1,78 +1,53 @@
-package pretty_test
+package pretty
 
 import (
 	"testing"
 
 	"github.com/segmentio/terraform-docs/internal/pkg/print"
-	"github.com/segmentio/terraform-docs/internal/pkg/print/pretty"
-	"github.com/segmentio/terraform-docs/internal/pkg/tfconf"
+	"github.com/segmentio/terraform-docs/internal/pkg/testutil"
 	"github.com/stretchr/testify/assert"
 )
 
 func TestPretty(t *testing.T) {
-	var settings = &print.Settings{}
+	assert := assert.New(t)
+	settings := &print.Settings{}
 
-	module, err := tfconf.CreateModule("../../../../examples")
-	if err != nil {
-		t.Fatal(err)
-	}
+	module, expected, err := testutil.GetExpected("pretty")
+	assert.Nil(err)
 
-	actual, err := pretty.Print(module, settings)
-	if err != nil {
-		t.Fatal(err)
-	}
+	actual, err := Print(module, settings)
 
-	expected, err := print.ReadGoldenFile("pretty")
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	assert.Equal(t, expected, actual)
+	assert.Nil(err)
+	assert.Equal(expected, actual)
 }
 
-func TestPrettyWithSortByName(t *testing.T) {
-	var settings = &print.Settings{
+func TestPrettySortByName(t *testing.T) {
+	assert := assert.New(t)
+	settings := &print.Settings{
 		SortByName: true,
 	}
 
-	module, err := tfconf.CreateModule("../../../../examples")
-	if err != nil {
-		t.Fatal(err)
-	}
+	module, expected, err := testutil.GetExpected("pretty-SortByName")
+	assert.Nil(err)
 
-	actual, err := pretty.Print(module, settings)
-	if err != nil {
-		t.Fatal(err)
-	}
+	actual, err := Print(module, settings)
 
-	expected, err := print.ReadGoldenFile("pretty-WithSortByName")
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	assert.Equal(t, expected, actual)
+	assert.Nil(err)
+	assert.Equal(expected, actual)
 }
 
-func TestPrettyWithSortInputsByRequired(t *testing.T) {
-	var settings = &print.Settings{
+func TestPrettySortByRequired(t *testing.T) {
+	assert := assert.New(t)
+	settings := &print.Settings{
 		SortByName:           true,
 		SortInputsByRequired: true,
 	}
 
-	module, err := tfconf.CreateModule("../../../../examples")
-	if err != nil {
-		t.Fatal(err)
-	}
+	module, expected, err := testutil.GetExpected("pretty-SortByRequired")
+	assert.Nil(err)
 
-	actual, err := pretty.Print(module, settings)
-	if err != nil {
-		t.Fatal(err)
-	}
+	actual, err := Print(module, settings)
 
-	expected, err := print.ReadGoldenFile("pretty-WithSortInputsByRequired")
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	assert.Equal(t, expected, actual)
+	assert.Nil(err)
+	assert.Equal(expected, actual)
 }

internal/pkg/print/testing.go

@@ -1,22 +0,0 @@
-package print
-
-import (
-	"io/ioutil"
-	"path/filepath"
-)
-
-// ReadGoldenFile reads a .golden file from test data by name.
-func ReadGoldenFile(name string) (string, error) {
-	path := filepath.Join(testDataPath(), name+".golden")
-
-	bytes, err := ioutil.ReadFile(path)
-	if err != nil {
-		return "", err
-	}
-
-	return string(bytes), nil
-}
-
-func testDataPath() string {
-	return filepath.Join("testdata")
-}

internal/pkg/testutil/testing.go

@@ -0,0 +1,49 @@
+package testutil
+
+import (
+	"io/ioutil"
+	"os"
+	"path/filepath"
+	"runtime"
+
+	"github.com/segmentio/terraform-docs/internal/pkg/tfconf"
+)
+
+// GetExpected returns 'example' Module and expected Golden file content
+func GetExpected(goldenFile string) (*tfconf.Module, string, error) {
+	path, err := getExampleFolder()
+	if err != nil {
+		return nil, "", err
+	}
+
+	module, err := tfconf.CreateModule(path)
+	if err != nil {
+		return nil, "", err
+	}
+
+	expected, err := readGoldenFile(goldenFile)
+
+	return module, expected, err
+}
+
+func getExampleFolder() (string, error) {
+	_, b, _, _ := runtime.Caller(0)
+	path := filepath.Join(filepath.Dir(b), "..", "..", "..", "examples")
+	if _, err := os.Stat(path); os.IsNotExist(err) {
+		return "", err
+	}
+	return path, nil
+}
+
+func readGoldenFile(name string) (string, error) {
+	path := filepath.Join(testDataPath(), name+".golden")
+	bytes, err := ioutil.ReadFile(path)
+	if err != nil {
+		return "", err
+	}
+	return string(bytes), nil
+}
+
+func testDataPath() string {
+	return filepath.Join("testdata")
+}