github.com/stretchr/testify v1.8.4: mock.Mock

Clean-room public code sample — generation instructions

Write a brand-new, minimal, self-contained code sample in this clean-room directory.
Do not copy, paraphrase, or reference any existing project source. Work only from this spec.

A csx.json manifest scaffold already exists. Do not recreate it from memory. Preserve its case.goal, packages and symbols; fill its empty case.contract with exact assertions and correct its environment, commands and verifierAdapter for the files you generate.

Goal: verify github.com/stretchr/testify/mock.Mock in pkg:golang/github.com/stretchr/testify@v1.8.4
Kind: HOW

Use EXACTLY these public packages and versions:
  - pkg:golang/github.com/stretchr/testify@v1.8.4
Demonstrate these symbols/APIs:
  - github.com/stretchr/testify/mock.Mock

Rules:
  - One focused purpose; the smallest project that proves the goal.
  - Include a contract test (test/contract.*) that runs OFFLINE and exits 0 exactly when the goal behavior works.
  - Pin every dependency with a lockfile so resolution is reproducible.
  - No secrets, credentials, or tokens. No real URLs (only example.com or localhost). No absolute paths.
  - No personal names, emails, company names, or project identifiers of any kind.
  - No binaries and no generated output (node_modules, dist, target, venv, .git, .env).
  - Keep it under 200 files and 256KB packed.

{"case":{"caseId":"case:sha256:3caf032b5c1f758c6a815c77c83fe669ba2665e3e6df432a9912803a2f40802e","contract":["mock.Mock embeds into a struct to stub methods with exact argument matching via On and Return","mock.Mock.AssertExpectations passes when registered call expectations are met","mock.Mock tracks call history verifiable by AssertCalled, AssertNotCalled, and AssertNumberOfCalls","mock.Mock supports mock.Anything wildcard argument matching","mock.Mock.AssertExpectations fails when registered call expectations are left unsatisfied"],"goal":"verify github.com/stretchr/testify/mock.Mock in pkg:golang/github.com/stretchr/testify@v1.8.4","kind":"HOW","packages":["pkg:golang/github.com/stretchr/testify@v1.8.4"],"schemaVersion":1,"symbols":["github.com/stretchr/testify/mock.Mock"]},"contractCommand":["go","run","./test"],"environment":{"arch":"x64","distro":"ubuntu","ecosystem":"golang","libc":"glibc","libcVersion":"2.39","os":"linux","osVersionBucket":"24","packageManager":"go","schemaVersion":1},"license":"MIT-0","packages":["pkg:golang/github.com/stretchr/testify@v1.8.4"],"schemaVersion":1,"subject":"pkg:golang/github.com/stretchr/testify@v1.8.4","symbols":["github.com/stretchr/testify/mock.Mock"],"verifierAdapter":"golang@1"}

module sample

go 1.22.0

require github.com/stretchr/testify v1.8.4

require (
	github.com/davecgh/go-spew v1.1.1 // indirect
	github.com/pmezard/go-difflib v1.0.0 // indirect
	github.com/stretchr/objx v0.5.3 // indirect
	gopkg.in/yaml.v3 v3.0.1 // indirect
)

github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
github.com/davecgh/go-spew v1.1.1/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.5.3 h1:jmXUvGomnU1o3W/V5h2VEradbpJDwGrzugQQvL0POH4=
github.com/stretchr/objx v0.5.3/go.mod h1:rDQraq+vQZU7Fde9LOZLr8Tax6zZvy4kuNKF+QYS+U0=
github.com/stretchr/testify v1.8.4 h1:CcVxjf3Q8PM0mHUKJCdn+eZZtm5yQwehR5yeSVQQcUk=
github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo=
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.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

{
  "schemaVersion": 1,
  "goal": "verify github.com/stretchr/testify/mock.Mock in pkg:golang/github.com/stretchr/testify@v1.8.4",
  "kind": "HOW",
  "packages": [
    "pkg:golang/github.com/stretchr/testify@v1.8.4"
  ],
  "symbols": [
    "github.com/stretchr/testify/mock.Mock"
  ]
}

package main

import (
	"errors"
	"fmt"
	"os"

	"github.com/stretchr/testify/mock"
	"sample"
)

// contractTestingT implements mock.TestingT for verifying assertions offline.
type contractTestingT struct {
	errors []string
	failed bool
}

func (t *contractTestingT) Logf(format string, args ...interface{}) {}

func (t *contractTestingT) Errorf(format string, args ...interface{}) {
	t.failed = true
	t.errors = append(t.errors, fmt.Sprintf(format, args...))
}

func (t *contractTestingT) FailNow() {
	t.failed = true
}

func main() {
	// Assertion 1: On and Return stubbing with exact matching
	mockRepo := new(sample.MockUserRepository)
	expectedUser := &sample.User{ID: 101, Name: "Alice", Email: "alice@example.com"}

	mockRepo.On("FindByID", 101).Return(expectedUser, nil)

	service := sample.NewUserService(mockRepo)
	user, err := service.GetUser(101)
	if err != nil {
		fmt.Fprintf(os.Stderr, "FAIL: unexpected error from GetUser: %v\n", err)
		os.Exit(1)
	}
	if user == nil || user.ID != 101 || user.Name != "Alice" {
		fmt.Fprintf(os.Stderr, "FAIL: expected user %+v, got %+v\n", expectedUser, user)
		os.Exit(1)
	}

	// Assertion 2: AssertExpectations passes when all registered expectations are satisfied
	t1 := &contractTestingT{}
	if !mockRepo.AssertExpectations(t1) || t1.failed {
		fmt.Fprintf(os.Stderr, "FAIL: AssertExpectations failed when expectations were met: %v\n", t1.errors)
		os.Exit(1)
	}

	// Assertion 3: AssertCalled and AssertNumberOfCalls verify invocation history
	t2 := &contractTestingT{}
	if !mockRepo.AssertCalled(t2, "FindByID", 101) || t2.failed {
		fmt.Fprintf(os.Stderr, "FAIL: AssertCalled failed for FindByID(101)\n")
		os.Exit(1)
	}
	if !mockRepo.AssertNumberOfCalls(t2, "FindByID", 1) || t2.failed {
		fmt.Fprintf(os.Stderr, "FAIL: AssertNumberOfCalls failed for FindByID\n")
		os.Exit(1)
	}
	if !mockRepo.AssertNotCalled(t2, "Delete", mock.Anything) || t2.failed {
		fmt.Fprintf(os.Stderr, "FAIL: AssertNotCalled failed for Delete\n")
		os.Exit(1)
	}

	// Assertion 4: mock.Anything argument matcher and error returns
	mockRepo2 := new(sample.MockUserRepository)
	mockErr := errors.New("user not found")
	mockRepo2.On("FindByID", mock.Anything).Return(nil, mockErr)

	service2 := sample.NewUserService(mockRepo2)
	missingUser, err2 := service2.GetUser(999)
	if missingUser != nil {
		fmt.Fprintf(os.Stderr, "FAIL: expected nil user on error, got %+v\n", missingUser)
		os.Exit(1)
	}
	if !errors.Is(err2, mockErr) {
		fmt.Fprintf(os.Stderr, "FAIL: expected mockErr %v, got %v\n", mockErr, err2)
		os.Exit(1)
	}

	// Assertion 5: AssertExpectations correctly reports unsatisfied expectations
	mockRepoUnsatisfied := new(sample.MockUserRepository)
	mockRepoUnsatisfied.On("Delete", 42).Return(true, nil)

	t3 := &contractTestingT{}
	satisfied := mockRepoUnsatisfied.AssertExpectations(t3)
	if satisfied || !t3.failed {
		fmt.Fprintf(os.Stderr, "FAIL: AssertExpectations should fail when expected call was not made\n")
		os.Exit(1)
	}

	fmt.Println("PASS: github.com/stretchr/testify/mock.Mock contract passed")
}

package sample

import (
	"github.com/stretchr/testify/mock"
)

// User represents a simple domain entity.
type User struct {
	ID    int
	Name  string
	Email string
}

// UserRepository defines interface methods for user persistence.
type UserRepository interface {
	FindByID(id int) (*User, error)
	Save(user *User) error
	Delete(id int) (bool, error)
}

// MockUserRepository embeds mock.Mock to provide a mock implementation of UserRepository.
type MockUserRepository struct {
	mock.Mock
}

// FindByID mocks finding a user by ID.
func (m *MockUserRepository) FindByID(id int) (*User, error) {
	args := m.Called(id)
	if u := args.Get(0); u != nil {
		return u.(*User), args.Error(1)
	}
	return nil, args.Error(1)
}

// Save mocks saving a user entity.
func (m *MockUserRepository) Save(user *User) error {
	args := m.Called(user)
	return args.Error(0)
}

// Delete mocks deleting a user by ID.
func (m *MockUserRepository) Delete(id int) (bool, error) {
	args := m.Called(id)
	return args.Bool(0), args.Error(1)
}

// UserService coordinates user operations with a UserRepository.
type UserService struct {
	repo UserRepository
}

// NewUserService creates a new UserService with the provided repository.
func NewUserService(repo UserRepository) *UserService {
	return &UserService{repo: repo}
}

// GetUser retrieves a user by ID.
func (s *UserService) GetUser(id int) (*User, error) {
	return s.repo.FindByID(id)
}

// RegisterUser saves a user.
func (s *UserService) RegisterUser(user *User) error {
	return s.repo.Save(user)
}

// RemoveUser deletes a user by ID.
func (s *UserService) RemoveUser(id int) (bool, error) {
	return s.repo.Delete(id)
}