fix some tests

Author: JekaMas

cmd/go-mutesting/main.go

@@ -84,14 +84,19 @@ func checkArguments(args []string, opts *models.Options) (bool, int) {
 	}
 
 	if opts.General.Config != "" {
-		yamlFile, err := ioutil.ReadFile(opts.General.Config)
+		yamlFile, err := os.ReadFile(opts.General.Config)
 		if err != nil {
 			return true, exitError("Could not read config file: %q", opts.General.Config)
 		}
 		err = yaml.Unmarshal(yamlFile, &opts.Config)
 		if err != nil {
 			return true, exitError("Could not unmarshall config file: %q, %v", opts.General.Config, err)
 		}
+
+		// default values
+		if opts.Config.MinMsi == nil {
+			opts.Config.MinMsi = big.NewFloat(0)
+		}
 	}
 
 	return false, 0
@@ -122,6 +127,8 @@ type mutatorItem struct {
 
 func mainCmd(args []string) int {
 	var opts = &models.Options{}
+	opts.Config.MinMsi = big.NewFloat(0)
+
 	var mutationBlackList = map[string]struct{}{}
 
 	if exit, exitCode := checkArguments(args, opts); exit {
@@ -158,7 +165,7 @@ func mainCmd(args []string) int {
 
 	if len(opts.Files.Blacklist) > 0 {
 		for _, f := range opts.Files.Blacklist {
-			c, err := ioutil.ReadFile(f)
+			c, err := os.ReadFile(f)
 			if err != nil {
 				return exitError("Cannot read blacklist file %q: %v", f, err)
 			}
@@ -306,8 +313,9 @@ MUTATOR:
 
 	verbose(opts, "Save report into %q", models.ReportFileName)
 
-	fmt.Println("!!!!!!!!!!!!!!!!", report.MsiScore(), opts.Config.MinMsi.String())
-	if big.NewFloat(report.MsiScore()).Cmp(opts.Config.MinMsi) < 0 {
+	fmt.Printf("MSI minimal %s, actual %s\n", opts.Config.MinMsi.Text('f', 6), report.MsiScore().Text('f', 6))
+
+	if report.MsiScore().Cmp(opts.Config.MinMsi) < 0 {
 		return exitError("The MSI %f is less than the minimum allowed value %f", report.MsiScore(), opts.Config.MinMsi)
 	}
 

cmd/go-mutesting/main_test.go

@@ -4,13 +4,15 @@ import (
 	"bytes"
 	"encoding/json"
 	"fmt"
-	"github.com/JekaMas/go-mutesting/internal/models"
 	"io"
 	"io/ioutil"
+	"math/big"
 	"os"
 	"testing"
 
-	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
+	"github.com/JekaMas/go-mutesting/internal/models"
 )
 
 func TestMainSimple(t *testing.T) {
@@ -64,14 +66,14 @@ func TestMainSkipWithoutTest(t *testing.T) {
 }
 
 func TestMainJSONReport(t *testing.T) {
-	tmpDir, err := ioutil.TempDir("", "go-mutesting-main-test-")
-	assert.NoError(t, err)
+	tmpDir, err := os.MkdirTemp("", "go-mutesting-main-test-")
+	require.NoError(t, err)
 
 	reportFileName := "reportTestMainJSONReport.json"
 	jsonFile := tmpDir + "/" + reportFileName
 	if _, err := os.Stat(jsonFile); err == nil {
 		err = os.Remove(jsonFile)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 	}
 
 	models.ReportFileName = jsonFile
@@ -85,8 +87,8 @@ func TestMainJSONReport(t *testing.T) {
 	)
 
 	info, err := os.Stat(jsonFile)
-	assert.NoError(t, err)
-	assert.NotNil(t, info)
+	require.NoError(t, err)
+	require.NotNil(t, info)
 
 	defer func() {
 		err = os.Remove(jsonFile)
@@ -96,11 +98,11 @@ func TestMainJSONReport(t *testing.T) {
 	}()
 
 	jsonData, err := ioutil.ReadFile(jsonFile)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	var mutationReport models.Report
 	err = json.Unmarshal(jsonData, &mutationReport)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	expectedStats := models.Stats{
 		TotalMutantsCount:    60,
@@ -110,60 +112,62 @@ func TestMainJSONReport(t *testing.T) {
 		ErrorCount:           0,
 		SkippedCount:         0,
 		TimeOutCount:         0,
-		Msi:                  0.5833333333333334,
+		Msi:                  big.NewFloat(0.5833333333333334),
 		MutationCodeCoverage: 0,
 		CoveredCodeMsi:       0,
 		DuplicatedCount:      0,
 	}
 
-	assert.Equal(t, expectedStats, mutationReport.Stats)
-	assert.Equal(t, 25, len(mutationReport.Escaped))
-	assert.Nil(t, mutationReport.Timeouted)
-	assert.Equal(t, 35, len(mutationReport.Killed))
-	assert.Nil(t, mutationReport.Errored)
+	require.Equal(t, expectedStats, mutationReport.Stats)
+	require.Equal(t, 25, len(mutationReport.Escaped))
+	require.Nil(t, mutationReport.Timeouted)
+	require.Equal(t, 35, len(mutationReport.Killed))
+	require.Nil(t, mutationReport.Errored)
 
 	for i := 0; i < len(mutationReport.Escaped); i++ {
-		assert.Contains(t, mutationReport.Escaped[i].ProcessOutput, "FAIL")
+		require.Contains(t, mutationReport.Escaped[i].ProcessOutput, "FAIL")
 	}
 	for i := 0; i < len(mutationReport.Killed); i++ {
-		assert.Contains(t, mutationReport.Killed[i].ProcessOutput, "PASS")
+		require.Contains(t, mutationReport.Killed[i].ProcessOutput, "PASS")
 	}
 }
 
 func testMain(t *testing.T, root string, exec []string, expectedExitCode int, contains string) {
+	t.Helper()
+
 	saveStderr := os.Stderr
 	saveStdout := os.Stdout
 	saveCwd, err := os.Getwd()
-	assert.Nil(t, err)
+	require.Nil(t, err)
 
 	r, w, err := os.Pipe()
-	assert.Nil(t, err)
+	require.Nil(t, err)
 
 	os.Stderr = w
 	os.Stdout = w
-	assert.Nil(t, os.Chdir(root))
+	require.Nil(t, os.Chdir(root))
 
 	bufChannel := make(chan string)
 
 	go func() {
 		buf := new(bytes.Buffer)
 		_, err = io.Copy(buf, r)
-		assert.Nil(t, err)
-		assert.Nil(t, r.Close())
+		require.Nil(t, err)
+		require.Nil(t, r.Close())
 
 		bufChannel <- buf.String()
 	}()
 
 	exitCode := mainCmd(exec)
 
-	assert.Nil(t, w.Close())
+	require.Nil(t, w.Close())
 
 	os.Stderr = saveStderr
 	os.Stdout = saveStdout
-	assert.Nil(t, os.Chdir(saveCwd))
+	require.Nil(t, os.Chdir(saveCwd))
 
 	out := <-bufChannel
 
-	assert.Equal(t, expectedExitCode, exitCode)
-	assert.Contains(t, out, contains)
+	require.Equal(t, expectedExitCode, exitCode)
+	require.Contains(t, out, contains)
 }