moved validation logic into its own scope, and cleanup

Author: Oppodelldog

config/configuration_test.go

@@ -44,76 +44,6 @@ func TestGetProjectConfigurationByName_NotFound(t *testing.T) {
 	assert.Contains(t, err.Error(), "not found")
 }
 
-func TestValidate(t *testing.T) {
-
-	testDataSet := []struct {
-		BranchName    string
-		CommitMessage string
-		ErrorContains string
-	}{
-		{
-			BranchName:    "branch1",
-			CommitMessage: "commit message that contains A.",
-			ErrorContains: "",
-		},
-		{
-			BranchName:    "branch1",
-			CommitMessage: "commit message that contains B.",
-			ErrorContains: "",
-		},
-		{
-			BranchName:    "branch2",
-			CommitMessage: "commit message that contains A.",
-			ErrorContains: "",
-		},
-		{
-			BranchName:    "branch2",
-			CommitMessage: "commit message that contains B.",
-			ErrorContains: "",
-		},
-		{
-			BranchName:    "branch3",
-			CommitMessage: "does not matter what this contains, since there are no validator for branch3",
-			ErrorContains: "",
-		},
-		{
-			BranchName:    "branch1",
-			CommitMessage: "commit message that contains Z.",
-			ErrorContains: "validation error for branch 'branch1'",
-		},
-	}
-
-	for testName, testData := range testDataSet {
-		t.Run(string(testName), func(t *testing.T) {
-
-			cfg := &Project{
-				BranchTypes: map[string]BranchTypePattern{
-					"branch1": `^branch1$`,
-					"branch2": `^branch2$`,
-					"branch3": `^branch3$`,
-				},
-				Validation: map[string]BranchValidationConfiguration{
-					"branch1": map[string]string{
-						"(A)": "contains B",
-						"(B)": "contains A",
-					},
-					"branch2": map[string]string{
-						"([AB])": "contains A or B (one or multiple)",
-					},
-					"branch3": map[string]string{},
-				},
-			}
-
-			err := cfg.Validate(testData.BranchName, testData.CommitMessage)
-			if testData.ErrorContains != "" {
-				assert.Contains(t, err.Error(), testData.ErrorContains)
-			} else {
-				assert.NoError(t, err)
-			}
-		})
-	}
-}
-
 func createTestConfiguration() Configuration {
 	cfg := Configuration{
 		"test1": Project{Path: "/home"},

config/parsing_test.go

@@ -26,7 +26,7 @@ func TestParse(t *testing.T) {
 				"*": `{.BranchName}: {.CommitMessage}`,
 			},
 			Validation: map[string]BranchValidationConfiguration{
-				"feature": {
+				"*": {
 					`(?m)(?:\s|^|/)(([A-Z](_)*)+-[0-9]+)([\s,;:!.-]|$)`: "valid ticket ID",
 				},
 				"develop": {

config/project.go

@@ -1,10 +1,6 @@
 package config
 
 import (
-	"bytes"
-	"errors"
-	"fmt"
-
 	"github.com/glenn-brown/golang-pkg-pcre/src/pkg/pcre"
 )
 
@@ -35,11 +31,9 @@ func (projConf *Project) GetBranchType(branchName string) string {
 	return ""
 }
 
-func regexMatchesString(pattern string, branchName string) bool {
-	return pcre.MustCompile(pattern, 0).MatcherString(branchName, 0).Matches()
-}
-
-func (projConf *Project) getValidators(branchType string) map[string]string {
+// GetValidator returns the validator that matches the given branch type
+// if no
+func (projConf *Project) GetValidator(branchType string) map[string]string {
 	var foundValidators map[string]string
 	for configBranchName, validators := range projConf.Validation {
 		if configBranchName == branchType || configBranchName == "*" && foundValidators == nil {
@@ -50,36 +44,6 @@ func (projConf *Project) getValidators(branchType string) map[string]string {
 	return foundValidators
 }
 
-// Validate validates the given commitMessage. It uses the validations configured for the given branchName.
-// As soon as one validation check succeeds, the validation passes.
-func (projConf *Project) Validate(branchName string, commitMessage string) error {
-
-	branchType := projConf.GetBranchType(branchName)
-	validators := projConf.getValidators(branchType)
-	if len(validators) == 0 {
-		return nil
-	}
-
-	for validationPattern := range validators {
-		if regexMatchesString(validationPattern, commitMessage) {
-			return nil
-		}
-	}
-
-	return prepareError(branchName, validators)
-
-}
-
-func prepareError(branchName string, validators map[string]string) error {
-	buffer := bytes.NewBufferString("validation error for branch ")
-	buffer.WriteString(fmt.Sprintf("'%s'\n", branchName))
-	buffer.WriteString("at least expected one of the following to match\n")
-
-	for _, validationDescription := range validators {
-		buffer.WriteString(" - ")
-		buffer.WriteString(validationDescription)
-		buffer.WriteString("\n")
-	}
-
-	return errors.New(buffer.String())
+func regexMatchesString(pattern string, branchName string) bool {
+	return pcre.MustCompile(pattern, 0).MatcherString(branchName, 0).Matches()
 }

config/test-data.yaml

@@ -19,8 +19,6 @@
   # define validation rules per branch type
   # for example "commit messages in feature branches should always contain a ticket reference"
   validation:
-     feature:
-       "(?m)(?:\\s|^|/)(([A-Z](_)*)+-[0-9]+)([\\s,;:!.-]|$)" : "valid ticket ID"
      develop:
        "(?m)(?:\\s|^|/)(([A-Z](_)*)+-[0-9]+)([\\s,;:!.-]|$)" : "valid ticket ID"
        "(?m)@noissue" : "@noissue"
@@ -31,3 +29,5 @@
      master:
        "(?m)(?:\\s|^|/)(([A-Z](_)*)+-[0-9]+)([\\s,;:!.-]|$)" : "valid ticket ID"
        "(?m)@noissue" : "@noissue"
+     "*":
+       "(?m)(?:\\s|^|/)(([A-Z](_)*)+-[0-9]+)([\\s,;:!.-]|$)" : "valid ticket ID (fallback validator)"

hook/modifier.go

@@ -18,16 +18,15 @@ type (
 
 	createViewModelFuncDef       func(gitCommitMessage string, branchName string) ViewModel
 	validateCommitMessageFuncDef func(branchName, modifiedCommitMessage string) error
-	renderCommitMessageFuncDef   func(branchName string, viewModel ViewModel) (string, error)
+	renderCommitMessageFuncDef   func(viewModel ViewModel) (string, error)
 )
 
 // NewCommitMessageModifier create a CommitMessageModifier
 func NewCommitMessageModifier(projectConfiguration config.Project) CommitMessageModifier {
-	commitMessageRenderer := &CommitMessageRenderer{projectConfiguration}
 	return &commitMessageModifier{
 		createViewModelFunc:       createViewModel,
-		renderCommitMessageFunc:   commitMessageRenderer.RenderCommitMessage,
-		validateCommitmessageFunc: projectConfiguration.Validate,
+		renderCommitMessageFunc:   NewCommitMessageRenderer(projectConfiguration).Render,
+		validateCommitmessageFunc: NewCommitMessageValidator(projectConfiguration).Validate,
 	}
 }
 
@@ -49,7 +48,7 @@ func (m *commitMessageModifier) ModifyGitCommitMessage(gitCommitMessage string,
 
 	viewModel := createViewModel(gitCommitMessage, branchName)
 
-	modifiedCommitMessage, err = m.renderCommitMessageFunc(branchName, viewModel)
+	modifiedCommitMessage, err = m.renderCommitMessageFunc(viewModel)
 	if err != nil {
 		return
 	}

hook/modifier_test.go

@@ -96,7 +96,7 @@ func TestModifyGitCommitMessage_commitMessageRendererReturnsError_ExpectError(t
 	branchName := "feature123"
 	errStub := errors.New("stubbed renderer error")
 	modifier := NewCommitMessageModifier(config.Project{})
-	modifier.(*commitMessageModifier).renderCommitMessageFunc = func(branchName string, viewModel ViewModel) (string, error) {
+	modifier.(*commitMessageModifier).renderCommitMessageFunc = func(viewModel ViewModel) (string, error) {
 		return "", errStub
 	}
 	_, err := modifier.ModifyGitCommitMessage(commitMessage, branchName)

hook/renderer.go

@@ -7,14 +7,26 @@ import (
 	"github.com/Oppodelldog/git-commit-hook/config"
 )
 
-// CommitMessageRenderer renders a commit message by resolving the branch names template from project configuration
-type CommitMessageRenderer struct {
+// CommitMessageRenderer implements rendering a commit message by a given
+type CommitMessageRenderer interface {
+	Render(viewModel ViewModel) (string, error)
+}
+
+//NewCommitMessageRenderer create a new CommitMessageRenderer
+func NewCommitMessageRenderer(projConf config.Project) CommitMessageRenderer {
+	return &commitMessageRenderer{
+		projConf: projConf,
+	}
+}
+
+// commitMessageRenderer renders a commit message by resolving the branch names template from project configuration
+type commitMessageRenderer struct {
 	projConf config.Project
 }
 
-// RenderCommitMessage renders a commit message using the template defined for the given resolveBranchNameFunc
-func (r *CommitMessageRenderer) RenderCommitMessage(branchName string, viewModel ViewModel) (string, error) {
-	branchType := r.projConf.GetBranchType(branchName)
+// Render renders a commit message using the template defined for the given resolveBranchNameFunc
+func (r *commitMessageRenderer) Render(viewModel ViewModel) (string, error) {
+	branchType := r.projConf.GetBranchType(viewModel.BranchName)
 	commitMessageTemplate := r.getTemplate(branchType)
 	if commitMessageTemplate == "" {
 		commitMessageTemplate = getFallbackCommitMessageTemplate()
@@ -33,7 +45,7 @@ func getFallbackCommitMessageTemplate() string {
 	return "{{.CommitMessage}}"
 }
 
-func (r *CommitMessageRenderer) getTemplate(branchType string) string {
+func (r *commitMessageRenderer) getTemplate(branchType string) string {
 	foundTemplate := ""
 	for configBranchType, branchTypeTemplate := range r.projConf.Templates {
 		if configBranchType == branchType || configBranchType == "*" && foundTemplate == "" {

hook/renderer_test.go

@@ -8,7 +8,6 @@ import (
 )
 
 func TestRenderCommitMessage(t *testing.T) {
-	configBranchName := "feature"
 	viewModel := ViewModel{
 		BranchName:    "feature/PRJ_TEST-1242",
 		CommitMessage: "initial commit",
@@ -20,18 +19,17 @@ func TestRenderCommitMessage(t *testing.T) {
 		Templates: map[string]config.BranchTypeTemplate{
 			"feature": "{{.BranchName}}: {{.CommitMessage}}",
 		}}
-	renderer := CommitMessageRenderer{*cfg}
-	modifiedCommitMessage, err := renderer.RenderCommitMessage(configBranchName, viewModel)
+	renderer := commitMessageRenderer{*cfg}
+	modifiedCommitMessage, err := renderer.Render(viewModel)
 	if err != nil {
-		t.Fatalf("Did not expect RenderCommitMessage to return an error, but got: %v ", err)
+		t.Fatalf("Did not expect Render to return an error, but got: %v ", err)
 	}
 
 	expectedCommitMessage := "feature/PRJ_TEST-1242: initial commit"
 	assert.Exactly(t, expectedCommitMessage, modifiedCommitMessage)
 }
 
 func TestRenderCommitMessage_InvalidTemplate_ReturnsError(t *testing.T) {
-	configBranchName := "feature"
 	invalidTemplate := "{{{{{ HELLO"
 	viewModel := ViewModel{}
 	cfg := &config.Project{
@@ -42,15 +40,14 @@ func TestRenderCommitMessage_InvalidTemplate_ReturnsError(t *testing.T) {
 			"feature": config.BranchTypeTemplate(invalidTemplate),
 		}}
 
-	renderer := CommitMessageRenderer{*cfg}
-	_, err := renderer.RenderCommitMessage(configBranchName, viewModel)
+	renderer := commitMessageRenderer{*cfg}
+	_, err := renderer.Render(viewModel)
 
 	assert.Contains(t, err.Error(), "template:")
 }
 
 func TestRenderCommitMessage_NoTemplateFound_PassesBackTheGivenCommitMessage(t *testing.T) {
 	givenCommitMessage := "some commit message"
-	configBranchName := "feature"
 	viewModel := ViewModel{
 		CommitMessage: givenCommitMessage,
 	}
@@ -60,10 +57,10 @@ func TestRenderCommitMessage_NoTemplateFound_PassesBackTheGivenCommitMessage(t *
 		},
 		Templates: map[string]config.BranchTypeTemplate{}}
 
-	renderer := CommitMessageRenderer{*cfg}
-	modifiedCommitMessage, err := renderer.RenderCommitMessage(configBranchName, viewModel)
+	renderer := commitMessageRenderer{*cfg}
+	modifiedCommitMessage, err := renderer.Render(viewModel)
 	if err != nil {
-		t.Fatalf("Did not expect RenderCommitMessage to return an error, but got: %v ", err)
+		t.Fatalf("Did not expect Render to return an error, but got: %v ", err)
 	}
 
 	assert.Exactly(t, givenCommitMessage, modifiedCommitMessage)
@@ -78,7 +75,7 @@ func TestGetTemplate(t *testing.T) {
 			"branch4": "templ4",
 		},
 	}
-	renderer := CommitMessageRenderer{*cfg}
+	renderer := commitMessageRenderer{*cfg}
 	template := renderer.getTemplate("branch2")
 	assert.Exactly(t, "templ2", template)
 
@@ -91,18 +88,17 @@ func TestGetTemplate(t *testing.T) {
 
 func TestRenderCommitMessage_NoBranchConfiguration_PassesBackTheGivenCommitMessage(t *testing.T) {
 	givenCommitMessage := "some commit message"
-	configBranchName := "feature"
 	viewModel := ViewModel{
 		CommitMessage: givenCommitMessage,
 	}
 	cfg := &config.Project{
 		BranchTypes: map[string]config.BranchTypePattern{},
 		Templates:   map[string]config.BranchTypeTemplate{}}
 
-	renderer := CommitMessageRenderer{*cfg}
-	modifiedCommitMessage, err := renderer.RenderCommitMessage(configBranchName, viewModel)
+	renderer := commitMessageRenderer{*cfg}
+	modifiedCommitMessage, err := renderer.Render(viewModel)
 	if err != nil {
-		t.Fatalf("Did not expect RenderCommitMessage to return an error, but got: %v ", err)
+		t.Fatalf("Did not expect Render to return an error, but got: %v ", err)
 	}
 
 	assert.Exactly(t, givenCommitMessage, modifiedCommitMessage)