fix: panic when method has no results

cmd/kelpie/mock.go.tmpl

@@ -19,7 +19,7 @@
 {{- end -}}
 
 {{- define "observationCallback" -}}
-func({{ template "parameterWithTypeList" .Parameters }}) {{ template "resultTypeList" .Results }}
+func({{ template "parameterWithTypeList" .Parameters }}){{ if .Results }} {{ template "resultTypeList" .Results }}{{ end }}
 {{- end -}}
 
 {{- define "matcherTypeParams" -}}
@@ -58,12 +58,17 @@ type Instance struct {
 
 {{- range $method := .Methods }}
 
-func (m *Instance) {{ $method.Name }}({{ template "parameterWithTypeList" $method.Parameters }}) ({{ template "resultWithTypeList" $method.Results }}) {
+func (m *Instance) {{ $method.Name }}({{ template "parameterWithTypeList" $method.Parameters }}){{ if $method.Results }} ({{ template "resultWithTypeList" $method.Results }}){{ end }} {
 	expectation := m.mock.Call("{{ $method.Name }}", {{ template "parameterList" $method.Parameters }})
 	if expectation != nil {
 		if expectation.ObserveFn != nil {
 			observe := expectation.ObserveFn.({{ template "observationCallback" $method }})
+			{{- if $method.Results }}
 			return observe({{ template "parameterList" $method.Parameters }})
+			{{- else }}
+			observe({{ template "parameterList" $method.Parameters }})
+			return
+			{{- end }}
 		}
 
 		if expectation.PanicArg != nil {
@@ -121,6 +126,8 @@ func (e *{{ $method.Name }}Expectation) CreateExpectation() *mocking.Expectation
 	return &e.expectation
 }
 
+{{- if $method.Results }}
+
 func (a *{{ $method.Name }}MethodMatcher) Return({{ template "resultWithTypeList" $method.Results }}) *{{ $method.Name }}Expectation {
 	return &{{ $method.Name }}Expectation{
 		expectation: mocking.Expectation{
@@ -129,6 +136,7 @@ func (a *{{ $method.Name }}MethodMatcher) Return({{ template "resultWithTypeList
 		},
 	}
 }
+{{- end }}
 
 func (a *{{ $method.Name }}MethodMatcher) Panic(arg any) *{{ $method.Name }}Expectation {
 	return &{{ $method.Name }}Expectation{

examples/result_test.go

@@ -3,13 +3,15 @@ package examples
 import (
 	"testing"
 
+	"github.com/adamconnelly/kelpie"
 	"github.com/adamconnelly/kelpie/examples/mocks/accountservice"
 	"github.com/stretchr/testify/suite"
 )
 
 //go:generate go run ../cmd/kelpie generate --source-file result_test.go --package github.com/adamconnelly/kelpie/examples --interfaces AccountService
 type AccountService interface {
 	SendActivationEmail(emailAddress string) bool
+	DisableAccount(id uint)
 }
 
 type ResultTests struct {
@@ -53,6 +55,21 @@ func (t *ResultTests) Test_CustomAction() {
 	t.Equal("[email protected]", recipientAddress)
 }
 
+func (t *ResultTests) Test_CanMockMethodsWithNoReturnArgs() {
+	// Arrange
+	var accountID uint
+	mock := accountservice.NewMock()
+	mock.Setup(accountservice.DisableAccount(kelpie.Any[uint]()).When(func(id uint) {
+		accountID = id
+	}))
+
+	// Act
+	mock.Instance().DisableAccount(uint(123))
+
+	// Assert
+	t.Equal(uint(123), accountID)
+}
+
 func TestResults(t *testing.T) {
 	suite.Run(t, new(ResultTests))
 }

parser/parser.go

@@ -83,18 +83,20 @@ func Parse(reader io.Reader, packageName string, filter InterfaceFilter) ([]Mock
 								}
 							}
 
-							for _, result := range funcType.Results.List {
-								if len(result.Names) > 0 {
-									for _, resultName := range result.Names {
+							if funcType.Results != nil {
+								for _, result := range funcType.Results.List {
+									if len(result.Names) > 0 {
+										for _, resultName := range result.Names {
+											methodDefinition.Results = append(methodDefinition.Results, ResultDefinition{
+												Name: resultName.Name,
+												Type: result.Type.(*ast.Ident).Name,
+											})
+										}
+									} else {
 										methodDefinition.Results = append(methodDefinition.Results, ResultDefinition{
-											Name: resultName.Name,
 											Type: result.Type.(*ast.Ident).Name,
 										})
 									}
-								} else {
-									methodDefinition.Results = append(methodDefinition.Results, ResultDefinition{
-										Type: result.Type.(*ast.Ident).Name,
-									})
 								}
 							}
 

parser/parser_test.go

@@ -120,6 +120,40 @@ type NotificationService interface {
 	t.Equal("error", broadcastNotification.Results[1].Type)
 }
 
+func (t *ParserTests) Test_Parse_SupportsMethodsWithNoResults() {
+	// Arrange
+	input := `package test
+
+type NotificationService interface {
+	Block(recipient string)
+}`
+
+	t.interfaceFilter.Setup(interfacefilter.Include("github.com/adamconnelly/kelpie/tests.UserService").Return(false))
+
+	// Act
+	result, err := parser.Parse(strings.NewReader(input), "github.com/adamconnelly/kelpie/tests", t.interfaceFilter.Instance())
+
+	// Assert
+	t.NoError(err)
+	t.Len(result, 1)
+
+	notificationService := slices.FirstOrPanic(result, func(mock parser.MockedInterface) bool {
+		return mock.Name == "NotificationService"
+	})
+	t.Equal("notificationservice", notificationService.PackageName)
+	t.Len(notificationService.Methods, 1)
+
+	block := slices.FirstOrPanic(notificationService.Methods, func(method parser.MethodDefinition) bool {
+		return method.Name == "Block"
+	})
+
+	t.Len(block.Parameters, 1)
+	t.Equal("recipient", block.Parameters[0].Name)
+	t.Equal("string", block.Parameters[0].Type)
+
+	t.Len(block.Results, 0)
+}
+
 // TODO: what about empty interfaces? Return a warning?
 
 func TestParser(t *testing.T) {