test: update test cases without testify suite

* removes all dependencies for test cases
* update go.mod and go.sum

Author: muthukrishnan24

go.mod

@@ -1,11 +1,3 @@
 module github.com/conventionalcommit/parser
 
 go 1.17
-
-require github.com/stretchr/testify v1.7.0
-
-require (
-	github.com/davecgh/go-spew v1.1.0 // indirect
-	github.com/pmezard/go-difflib v1.0.0 // indirect
-	gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c // indirect
-)

go.sum

@@ -1,11 +0,0 @@
-github.com/davecgh/go-spew v1.1.0 h1:ZDRjVQ15GmhC3fiQ8ni8+OwkZQO4DARzQgrnXU1Liz8=
-github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
-github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
-github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
-github.com/stretchr/testify v1.7.0 h1:nwc3DEeHmmLAfoZucVR881uASk0Mfjw8xYJ99tb5CcY=
-github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
-gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
-gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
-gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c h1:dUUwHk2QECo/6vqA44rthZ8ie2QXMNeKRTHCNY2nXvo=
-gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

parser_header_test.go

@@ -4,8 +4,6 @@ import (
 	"strconv"
 	"strings"
 	"testing"
-
-	"github.com/stretchr/testify/assert"
 )
 
 func TestParseHeaderValid(t *testing.T) {
@@ -28,7 +26,10 @@ func TestParseHeaderValid(t *testing.T) {
 			headerLine := strings.Split(validCase, "\n")[0]
 			commit := &Commit{}
 			err := parseHeader(headerLine, commit)
-			assert.NoError(innerT, err, headerLine)
+			if err != nil {
+				innerT.Error("parseHeader failed for", headerLine, err)
+				return
+			}
 		})
 	}
 }
@@ -53,7 +54,9 @@ func TestParseHeaderInvalid(t *testing.T) {
 			headerLine := strings.Split(validCase, "\n")[0]
 			commit := &Commit{}
 			err := parseHeader(headerLine, commit)
-			assert.Error(innerT, err, headerLine)
+			if err == nil {
+				innerT.Error("parseHeader passed without error for", headerLine)
+			}
 		})
 	}
 }

parser_test.go

@@ -7,7 +7,6 @@ import (
 	"testing"
 
 	"github.com/conventionalcommit/parser"
-	"github.com/stretchr/testify/suite"
 )
 
 const (
@@ -61,48 +60,39 @@ message is here
 	},
 }
 
-func TestParser(t *testing.T) {
-	ps := &parserSuite{}
-	suite.Run(t, ps)
-}
-
-type parserSuite struct {
-	suite.Suite
-}
-
-func (s *parserSuite) TestDescription() {
+func TestParserDescription(t *testing.T) {
 	expectedCommit := &parser.Commit{
 		Header: parser.Header{
 			Type:        commitType,
 			Description: commitDescription,
 		},
 	}
-	s.parseMsgAndCompare("description", expectedCommit)
+	parseMsgAndCompare(t, "description", expectedCommit)
 }
 
-func (s *parserSuite) TestDescriptionScope() {
+func TestParserDescriptionScope(t *testing.T) {
 	expectedCommit := &parser.Commit{
 		Header: parser.Header{
 			Type:        commitType,
 			Scope:       commitScope,
 			Description: commitDescription,
 		},
 	}
-	s.parseMsgAndCompare("description_scope", expectedCommit)
+	parseMsgAndCompare(t, "description_scope", expectedCommit)
 }
 
-func (s *parserSuite) TestBreakingChangeDescription() {
+func TestParserBreakingChangeDescription(t *testing.T) {
 	expectedCommit := &parser.Commit{
 		Header: parser.Header{
 			Type:        commitType,
 			Description: commitDescription,
 		},
 		BreakingChange: true,
 	}
-	s.parseMsgAndCompare("breaking_change_description", expectedCommit)
+	parseMsgAndCompare(t, "breaking_change_description", expectedCommit)
 }
 
-func (s *parserSuite) TestBreakingChangeDescriptionScope() {
+func TestParserBreakingChangeDescriptionScope(t *testing.T) {
 	expectedCommit := &parser.Commit{
 		Header: parser.Header{
 			Type:        commitType,
@@ -111,21 +101,21 @@ func (s *parserSuite) TestBreakingChangeDescriptionScope() {
 		},
 		BreakingChange: true,
 	}
-	s.parseMsgAndCompare("breaking_change_description_scope", expectedCommit)
+	parseMsgAndCompare(t, "breaking_change_description_scope", expectedCommit)
 }
 
-func (s *parserSuite) TestDescriptionBody() {
+func TestParserDescriptionBody(t *testing.T) {
 	expectedCommit := &parser.Commit{
 		Header: parser.Header{
 			Type:        commitType,
 			Description: commitDescription,
 		},
 		Body: commitBody,
 	}
-	s.parseMsgAndCompare("description_body", expectedCommit)
+	parseMsgAndCompare(t, "description_body", expectedCommit)
 }
 
-func (s *parserSuite) TestDescriptionScopeBody() {
+func TestParserDescriptionScopeBody(t *testing.T) {
 	expectedCommit := &parser.Commit{
 		Header: parser.Header{
 			Type:        commitType,
@@ -134,10 +124,10 @@ func (s *parserSuite) TestDescriptionScopeBody() {
 		},
 		Body: commitBody,
 	}
-	s.parseMsgAndCompare("description_scope_body", expectedCommit)
+	parseMsgAndCompare(t, "description_scope_body", expectedCommit)
 }
 
-func (s *parserSuite) TestBreakingChangeDescriptionBody() {
+func TestParserBreakingChangeDescriptionBody(t *testing.T) {
 	expectedCommit := &parser.Commit{
 		Header: parser.Header{
 			Type:        commitType,
@@ -146,10 +136,10 @@ func (s *parserSuite) TestBreakingChangeDescriptionBody() {
 		Body:           commitBody,
 		BreakingChange: true,
 	}
-	s.parseMsgAndCompare("breaking_change_description_body", expectedCommit)
+	parseMsgAndCompare(t, "breaking_change_description_body", expectedCommit)
 }
 
-func (s *parserSuite) TestBreakingChangeDescriptionScopeBody() {
+func TestParserBreakingChangeDescriptionScopeBody(t *testing.T) {
 	expectedCommit := &parser.Commit{
 		Header: parser.Header{
 			Type:        commitType,
@@ -159,21 +149,21 @@ func (s *parserSuite) TestBreakingChangeDescriptionScopeBody() {
 		Body:           commitBody,
 		BreakingChange: true,
 	}
-	s.parseMsgAndCompare("breaking_change_description_scope_body", expectedCommit)
+	parseMsgAndCompare(t, "breaking_change_description_scope_body", expectedCommit)
 }
 
-func (s *parserSuite) TestDescriptionFooters() {
+func TestParserDescriptionFooters(t *testing.T) {
 	expectedCommit := &parser.Commit{
 		Header: parser.Header{
 			Type:        commitType,
 			Description: commitDescription,
 		},
 		Footer: commitFooters,
 	}
-	s.parseMsgAndCompare("description_footers", expectedCommit)
+	parseMsgAndCompare(t, "description_footers", expectedCommit)
 }
 
-func (s *parserSuite) TestDescriptionScopeFooters() {
+func TestParserDescriptionScopeFooters(t *testing.T) {
 	expectedCommit := &parser.Commit{
 		Header: parser.Header{
 			Type:        commitType,
@@ -182,10 +172,10 @@ func (s *parserSuite) TestDescriptionScopeFooters() {
 		},
 		Footer: commitFooters,
 	}
-	s.parseMsgAndCompare("description_scope_footers", expectedCommit)
+	parseMsgAndCompare(t, "description_scope_footers", expectedCommit)
 }
 
-func (s *parserSuite) TestDescriptionBodyFooters() {
+func TestParserDescriptionBodyFooters(t *testing.T) {
 	expectedCommit := &parser.Commit{
 		Header: parser.Header{
 			Type:        commitType,
@@ -194,10 +184,10 @@ func (s *parserSuite) TestDescriptionBodyFooters() {
 		Body:   commitBody,
 		Footer: commitFooters,
 	}
-	s.parseMsgAndCompare("description_body_footers", expectedCommit)
+	parseMsgAndCompare(t, "description_body_footers", expectedCommit)
 }
 
-func (s *parserSuite) TestDescriptionScopeBodyFooters() {
+func TestParserDescriptionScopeBodyFooters(t *testing.T) {
 	expectedCommit := &parser.Commit{
 		Header: parser.Header{
 			Type:        commitType,
@@ -207,10 +197,10 @@ func (s *parserSuite) TestDescriptionScopeBodyFooters() {
 		Body:   commitBody,
 		Footer: commitFooters,
 	}
-	s.parseMsgAndCompare("description_scope_body_footers", expectedCommit)
+	parseMsgAndCompare(t, "description_scope_body_footers", expectedCommit)
 }
 
-func (s *parserSuite) TestDescriptionFootersBreakingChange() {
+func TestParserDescriptionFootersBreakingChange(t *testing.T) {
 	expectedCommit := &parser.Commit{
 		Header: parser.Header{
 			Type:        commitType,
@@ -219,10 +209,10 @@ func (s *parserSuite) TestDescriptionFootersBreakingChange() {
 		Footer:         breakingChangeFooter,
 		BreakingChange: true,
 	}
-	s.parseMsgAndCompare("description_footers_breaking_change", expectedCommit)
+	parseMsgAndCompare(t, "description_footers_breaking_change", expectedCommit)
 }
 
-func (s *parserSuite) TestBreakingChangeDescriptionFooters() {
+func TestParserBreakingChangeDescriptionFooters(t *testing.T) {
 	expectedCommit := &parser.Commit{
 		BreakingChange: true,
 		Header: parser.Header{
@@ -231,10 +221,10 @@ func (s *parserSuite) TestBreakingChangeDescriptionFooters() {
 		},
 		Footer: commitFooters,
 	}
-	s.parseMsgAndCompare("breaking_change_description_footers", expectedCommit)
+	parseMsgAndCompare(t, "breaking_change_description_footers", expectedCommit)
 }
 
-func (s *parserSuite) TestBreakingChangeDescriptionBodyFooters() {
+func TestParserBreakingChangeDescriptionBodyFooters(t *testing.T) {
 	expectedCommit := &parser.Commit{
 		BreakingChange: true,
 		Header: parser.Header{
@@ -244,10 +234,10 @@ func (s *parserSuite) TestBreakingChangeDescriptionBodyFooters() {
 		Body:   commitBody,
 		Footer: commitFooters,
 	}
-	s.parseMsgAndCompare("breaking_change_description_body_footers", expectedCommit)
+	parseMsgAndCompare(t, "breaking_change_description_body_footers", expectedCommit)
 }
 
-func (s *parserSuite) TestBreakingChangeDescriptionScopeFooters() {
+func TestParserBreakingChangeDescriptionScopeFooters(t *testing.T) {
 	expectedCommit := &parser.Commit{
 		Header: parser.Header{
 			Type:        commitType,
@@ -257,10 +247,10 @@ func (s *parserSuite) TestBreakingChangeDescriptionScopeFooters() {
 		Footer:         commitFooters,
 		BreakingChange: true,
 	}
-	s.parseMsgAndCompare("breaking_change_description_scope_footers", expectedCommit)
+	parseMsgAndCompare(t, "breaking_change_description_scope_footers", expectedCommit)
 }
 
-func (s *parserSuite) TestBreakingChangeDescriptionScopeBodyFooters() {
+func TestParserBreakingChangeDescriptionScopeBodyFooters(t *testing.T) {
 	expectedCommit := &parser.Commit{
 		Header: parser.Header{
 			Type:        commitType,
@@ -271,27 +261,29 @@ func (s *parserSuite) TestBreakingChangeDescriptionScopeBodyFooters() {
 		Footer:         commitFooters,
 		BreakingChange: true,
 	}
-	s.parseMsgAndCompare("breaking_change_description_scope_body_footers", expectedCommit)
+	parseMsgAndCompare(t, "breaking_change_description_scope_body_footers", expectedCommit)
 }
 
-func (s *parserSuite) TestFooterMultiLine() {
+func TestParserFooterMultiLine(t *testing.T) {
 	expectedCommit := &parser.Commit{
 		Header: parser.Header{
 			Type:        commitType,
 			Description: commitDescription,
 		},
 		Footer: multiLineFooters,
 	}
-	s.parseMsgAndCompare("footer_multi_line", expectedCommit)
+	parseMsgAndCompare(t, "footer_multi_line", expectedCommit)
 }
 
-func (s *parserSuite) TestErrNoBlankLine() {
-	t := s.T()
-
+func TestParserErrNoBlankLine(t *testing.T) {
 	fileName := "err_no_blank_line"
 
-	commitMsg := s.loadCommitMsgFromFile(filepath.Join(testDataDir, fileName))
-	_, err := parser.Parse(commitMsg)
+	commitMsg, err := loadCommitMsgFromFile(filepath.Join(testDataDir, fileName))
+	if err != nil {
+		t.Error(err)
+	}
+
+	_, err = parser.Parse(commitMsg)
 	if err == nil {
 		t.Errorf("no error: test file %v passed", fileName)
 		return
@@ -302,13 +294,15 @@ func (s *parserSuite) TestErrNoBlankLine() {
 	}
 }
 
-func (s *parserSuite) TestErrHeaderLine() {
-	t := s.T()
-
+func TestParserErrHeaderLine(t *testing.T) {
 	fileName := "err_header_line"
 
-	commitMsg := s.loadCommitMsgFromFile(filepath.Join(testDataDir, fileName))
-	_, err := parser.Parse(commitMsg)
+	commitMsg, err := loadCommitMsgFromFile(filepath.Join(testDataDir, fileName))
+	if err != nil {
+		t.Error(err)
+	}
+
+	_, err = parser.Parse(commitMsg)
 	if err == nil {
 		t.Errorf("no error: test file %v passed", fileName)
 		return
@@ -319,39 +313,36 @@ func (s *parserSuite) TestErrHeaderLine() {
 	}
 }
 
-func (s *parserSuite) parseMsgAndCompare(fileName string, expectedCommit *parser.Commit) {
-	t := s.T()
-	t.Helper()
+func parseMsgAndCompare(t *testing.T, fileName string, expectedCommit *parser.Commit) {
+	commitMsg, err := loadCommitMsgFromFile(filepath.Join(testDataDir, fileName))
+	if err != nil {
+		t.Errorf("Received unexpected error:\n%+v", err)
+		return
+	}
 
-	commitMsg := s.loadCommitMsgFromFile(filepath.Join(testDataDir, fileName))
 	actualCommit, err := parser.Parse(commitMsg)
 	if err != nil {
 		t.Errorf("Received unexpected error:\n%+v", err)
 		return
 	}
 
-	if !s.compareCommit(actualCommit, expectedCommit) {
+	if !compareCommit(t, actualCommit, expectedCommit) {
 		t.Errorf("Commit not equal :\n\tExpected: %v,\n\tActual: %v", expectedCommit, actualCommit)
 		return
 	}
 }
 
 // loadCommitMsgFromFile loads a file and returns the entire contents as a string. Any
 // leading or trailing whitespace is removed
-func (s *parserSuite) loadCommitMsgFromFile(fileName string) string {
-	t := s.T()
-	t.Helper()
-
+func loadCommitMsgFromFile(fileName string) (string, error) {
 	out, err := os.ReadFile(fileName)
 	if err != nil {
-		t.Errorf("error in test setup; unable to load file %s", fileName)
+		return "", err
 	}
-	return strings.TrimSpace(string(out))
+	return strings.TrimSpace(string(out)), nil
 }
 
-func (s *parserSuite) compareCommit(a, b *parser.Commit) bool {
-	t := s.T()
-
+func compareCommit(t *testing.T, a, b *parser.Commit) bool {
 	if a.Header.Type != b.Header.Type {
 		t.Log("Header Type Not Equal")
 		return false