chore: enable revive comments linting

.golangci.yml

@@ -84,21 +84,6 @@ linters-settings:
     allow-leading-space: true # don't require machine-readable nolint directives (i.e. with no leading space)
     require-explanation: false # don't require an explanation for nolint directives
     require-specific: false # don't require nolint directives to be specific about which linter is being skipped
-  revive:
-    rules:
-      - name: blank-imports
-      - name: context-as-argument
-      - name: context-keys-type
-      - name: dot-imports
-      - name: error-return
-      - name: increment-decrement
-      - name: var-declaration
-      - name: package-comments
-      - name: range
-      - name: time-naming
-      - name: errorf
-      - name: unreachable-code
-      - name: redefines-builtin-id
   staticcheck:
     go: "1.21"
     checks: [ "all", "-SA1019"]
@@ -161,3 +146,6 @@ severity:
     - linters:
         - dupl
       severity: info
+
+issues:
+  exclude-use-default: false

README.md

@@ -161,6 +161,42 @@ emailServiceMock.Setup(
 		}))
 ```
 
+### Verifying Method Calls
+
+You can verify that a method has been called using the `mock.Called()` method:
+
+```go
+// Arrange
+mock := registrationservice.NewMock()
+
+// Act
+mock.Instance().Register("Mark")
+mock.Instance().Register("Jim")
+
+// Assert
+t.True(mock.Called(registrationservice.Register("Mark")))
+t.True(mock.Called(registrationservice.Register(kelpie.Any[string]()).Times(2)))
+t.False(mock.Called(registrationservice.Register("Wendy")))
+```
+
+### Times
+
+You can configure a method call to only match a certain number of times, or verify a method has been called a certain number of times using the `Times()`, `Once()` and `Never()` helpers:
+
+```go
+// Arrange
+mock := registrationservice.NewMock()
+
+// Act
+mock.Instance().Register("Mark")
+mock.Instance().Register("Jim")
+
+// Assert
+t.True(mock.Called(registrationservice.Register("Mark").Once()))
+t.True(mock.Called(registrationservice.Register(kelpie.Any[string]()).Times(2)))
+t.True(mock.Called(registrationservice.Register("Wendy").Never()))
+```
+
 ## FAQ
 
 ### What makes Kelpie so magical

cmd/kelpie/main.go

@@ -1,3 +1,4 @@
+// Package main contains the Kelpie code generator.
 package main
 
 import (
@@ -16,13 +17,13 @@ import (
 //go:embed "mock.go.tmpl"
 var mockTemplate string
 
-type GenerateCmd struct {
+type generateCmd struct {
 	SourceFile string   `short:"s" required:"" env:"GOFILE" help:"The Go source file containing the interface to mock."`
 	Interfaces []string `short:"i" required:"" help:"The names of the interfaces to mock."`
 	OutputDir  string   `short:"o" required:"" default:"mocks" help:"The directory to write the mock out to."`
 }
 
-func (g *GenerateCmd) Run() error {
+func (g *generateCmd) Run() error {
 	file, err := os.Open(g.SourceFile)
 	if err != nil {
 		return errors.Wrap(err, "could not open file for parsing")
@@ -43,9 +44,11 @@ func (g *GenerateCmd) Run() error {
 		err := func() error {
 			outputDirectoryName := filepath.Join(g.OutputDir, i.PackageName)
 			if _, err := os.Stat(outputDirectoryName); os.IsNotExist(err) {
-				os.MkdirAll(outputDirectoryName, 0700)
+				if err := os.MkdirAll(outputDirectoryName, 0700); err != nil {
+					return errors.Wrap(err, "could not create directory for mock")
+				}
 			}
-			file, err := os.Create(filepath.Join(outputDirectoryName, fmt.Sprintf("%s.go", i.PackageName)))
+			file, err := os.Create(filepath.Clean(filepath.Join(outputDirectoryName, fmt.Sprintf("%s.go", i.PackageName))))
 			if err != nil {
 				return errors.Wrap(err, "could not open output file")
 			}
@@ -67,7 +70,7 @@ func (g *GenerateCmd) Run() error {
 }
 
 var cli struct {
-	Generate GenerateCmd `cmd:"" help:"Generate a mock."`
+	Generate generateCmd `cmd:"" help:"Generate a mock."`
 }
 
 func main() {

examples/called_test.go

@@ -0,0 +1,37 @@
+package examples
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/suite"
+
+	"github.com/adamconnelly/kelpie"
+	"github.com/adamconnelly/kelpie/examples/mocks/registrationservice"
+)
+
+//go:generate go run ../cmd/kelpie generate --interfaces RegistrationService
+type RegistrationService interface {
+	Register(name string) error
+}
+
+type CalledTests struct {
+	suite.Suite
+}
+
+func (t *CalledTests) Test_Called_VerifiesWhetherMethodHasBeenCalled() {
+	// Arrange
+	mock := registrationservice.NewMock()
+
+	// Act
+	mock.Instance().Register("Mark")
+	mock.Instance().Register("Jim")
+
+	// Assert
+	t.True(mock.Called(registrationservice.Register("Mark")))
+	t.True(mock.Called(registrationservice.Register(kelpie.Any[string]()).Times(2)))
+	t.False(mock.Called(registrationservice.Register("Wendy")))
+}
+
+func TestCalled(t *testing.T) {
+	suite.Run(t, new(CalledTests))
+}

matcher.go → kelpie.go

@@ -1,3 +1,4 @@
+// Package kelpie contains helpers for matching arguments when configuring a mock.
 package kelpie
 
 import "github.com/adamconnelly/kelpie/mocking"

mocking/matcher.go

@@ -15,3 +15,10 @@ type Matcher[T comparable] struct {
 func (i Matcher[T]) IsMatch(other any) bool {
 	return i.MatchFn(other.(T))
 }
+
+// MethodMatcher is used to match a method call to an expectation.
+type MethodMatcher struct {
+	MethodName       string
+	ArgumentMatchers []ArgumentMatcher
+	Times            *uint
+}