fix blank in the config and convert test data as string

pkg/config/config.go

@@ -1,7 +1,6 @@
 package config
 
 import (
-	"io/ioutil"
 	"sort"
 	"strings"
 
@@ -73,19 +72,18 @@ func (g YamlConfig) Parse() (*Config, error) {
 	return &Config{g.Cfg, sections, sectionSeparators}, nil
 }
 
-func InitializeGciConfigFromYAML(filePath string) (*Config, error) {
+func ParseConfig(in string) (*Config, error) {
 	config := YamlConfig{}
-	yamlData, err := ioutil.ReadFile(filePath)
-	if err != nil {
-		return nil, err
-	}
-	err = yaml.Unmarshal(yamlData, &config)
+
+	err := yaml.Unmarshal([]byte(in), &config)
 	if err != nil {
 		return nil, err
 	}
+
 	gciCfg, err := config.Parse()
 	if err != nil {
 		return nil, err
 	}
+
 	return gciCfg, nil
 }

pkg/config/config_test.go

@@ -1,35 +1,13 @@
 package config
 
 import (
-	"path"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
 
 	"github.com/daixiang0/gci/pkg/section"
 )
 
-var testFilesPath = "../gci/internal/testdata"
-
-func TestInitGciConfigFromEmptyYAML(t *testing.T) {
-	gciCfg, err := InitializeGciConfigFromYAML(path.Join(testFilesPath, "defaultValues.cfg.yaml"))
-	assert.NoError(t, err)
-	assert.Equal(t, section.DefaultSections(), gciCfg.Sections)
-	assert.Equal(t, section.DefaultSectionSeparators(), gciCfg.SectionSeparators)
-	assert.False(t, gciCfg.Debug)
-	assert.False(t, gciCfg.NoInlineComments)
-	assert.False(t, gciCfg.NoPrefixComments)
-}
-
-func TestInitGciConfigFromYAML(t *testing.T) {
-	gciCfg, err := InitializeGciConfigFromYAML(path.Join(testFilesPath, "configTest.cfg.yaml"))
-	assert.NoError(t, err)
-	assert.Equal(t, section.SectionList{section.Default{}}, gciCfg.Sections)
-	assert.False(t, gciCfg.Debug)
-	assert.True(t, gciCfg.SkipGenerated)
-	assert.False(t, gciCfg.CustomOrder)
-}
-
 // the custom sections sort alphabetically as default.
 func TestParseOrder(t *testing.T) {
 	cfg := YamlConfig{

pkg/gci/gci.go

@@ -127,11 +127,17 @@ func LoadFormatGoFile(file io.FileObj, cfg config.Config) (src, dist []byte, err
 		return nil, nil, err
 	}
 
+	return LoadFormat(src, file.Path(), cfg)
+}
+
+func LoadFormat(in []byte, path string, cfg config.Config) (src, dist []byte, err error) {
+	src = in
+
 	if cfg.SkipGenerated && parse.IsGeneratedFileByComment(string(src)) {
 		return src, src, nil
 	}
 
-	imports, headEnd, tailStart, cStart, cEnd, err := parse.ParseFile(src, file.Path())
+	imports, headEnd, tailStart, cStart, cEnd, err := parse.ParseFile(src, path)
 	if err != nil {
 		if errors.Is(err, parse.NoImportError{}) {
 			return src, src, nil

pkg/gci/gci_test.go

@@ -1,16 +1,12 @@
 package gci
 
 import (
-	"os"
-	"runtime"
-	"strings"
+	"fmt"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
 
 	"github.com/daixiang0/gci/pkg/config"
-	"github.com/daixiang0/gci/pkg/io"
 	"github.com/daixiang0/gci/pkg/log"
 )
 
@@ -19,91 +15,26 @@ func init() {
 	defer log.L().Sync()
 }
 
-var testFilesPath = "internal/testdata"
-
-func isTestInputFile(_ string, file os.FileInfo) bool {
-	return !file.IsDir() && strings.HasSuffix(file.Name(), ".in.go")
-}
-
 func TestRun(t *testing.T) {
-	if runtime.GOOS == "windows" {
-		t.Skip("Skipping test on Windows")
-	}
+	// if runtime.GOOS == "windows" {
+	// 	t.Skip("Skipping test on Windows")
+	// }
 
-	testFiles, err := io.FindFilesForPath(testFilesPath, isTestInputFile)
-	if err != nil {
-		t.Fatal(err)
-	}
-	for _, testFile := range testFiles {
-		fileBaseName := strings.TrimSuffix(testFile, ".in.go")
-		t.Run("pkg/gci/"+testFile, func(t *testing.T) {
-			t.Parallel()
-
-			gciCfg, err := config.InitializeGciConfigFromYAML(fileBaseName + ".cfg.yaml")
+	for i := range testCases {
+		t.Run(fmt.Sprintf("run case: %s", testCases[i].name), func(t *testing.T) {
+			config, err := config.ParseConfig(testCases[i].config)
 			if err != nil {
 				t.Fatal(err)
 			}
 
-			inputSrcFile := io.File{FilePath: fileBaseName + ".in.go"}
-			inputSrc, err := inputSrcFile.Load()
-			require.NoError(t, err)
-
-			unmodifiedFile, formattedFile, err := LoadFormatGoFile(inputSrcFile, *gciCfg)
+			old, new, err := LoadFormat([]byte(testCases[i].in), "", *config)
 			if err != nil {
 				t.Fatal(err)
 			}
-			assert.Equal(t, inputSrc, unmodifiedFile)
 
-			expectedOutput, err := os.ReadFile(fileBaseName + ".out.go")
-			if err != nil {
-				t.Fatal(err)
-			}
-			assert.Equal(t, string(expectedOutput), string(formattedFile), "output")
 			assert.NoError(t, err)
+			assert.Equal(t, testCases[i].in, string(old))
+			assert.Equal(t, testCases[i].out, string(new))
 		})
 	}
 }
-
-// func TestSkippingOverIncorrectlyFormattedFiles(t *testing.T) {
-// 	cfg, err := config.YamlConfig{}.Parse()
-// 	assert.NoError(t, err)
-
-// 	var importUnclosedCtr, noImportCtr, validCtr int
-// 	var files []io.FileObj
-// 	files = append(files, TestFile{io.File{FilePath: "internal/skipTest/import-unclosed.testgo"}, &importUnclosedCtr})
-// 	files = append(files, TestFile{io.File{FilePath: "internal/skipTest/no-import.testgo"}, &noImportCtr})
-// 	files = append(files, TestFile{io.File{FilePath: "internal/skipTest/valid.testgo"}, &validCtr})
-
-// 	validFileProcessedChan := make(chan bool, len(files))
-
-// 	generatorFunc := func() ([]io.FileObj, error) {
-// 		return files, nil
-// 	}
-// 	fileAccessTestFunc := func(filePath string, unmodifiedFile, formattedFile []byte) error {
-// 		validFileProcessedChan <- true
-// 		return nil
-// 	}
-// 	err = ProcessFiles(generatorFunc, *cfg, fileAccessTestFunc)
-
-// 	assert.NoError(t, err)
-// 	// check all files have been accessed
-// 	assert.Equal(t, importUnclosedCtr, 1)
-// 	assert.Equal(t, noImportCtr, 1)
-// 	assert.Equal(t, validCtr, 1)
-// 	// check that processing for the valid file was called
-// 	assert.True(t, <-validFileProcessedChan)
-// }
-
-// type TestFile struct {
-// 	wrappedFile   io.File
-// 	accessCounter *int
-// }
-
-// func (t TestFile) Load() ([]byte, error) {
-// 	*t.accessCounter++
-// 	return t.wrappedFile.Load()
-// }
-
-// func (t TestFile) Path() string {
-// 	return t.wrappedFile.Path()
-// }