diff --git a/Makefile b/Makefile
index 587742a..33f477d 100644
--- a/Makefile
+++ b/Makefile
@@ -1,18 +1,35 @@
 APP_NAME=asyncroutinemanager
 
+MKFILE_PATH := $(abspath $(lastword $(MAKEFILE_LIST)))
+PROJECT_PATH := $(patsubst %/,%,$(dir $(MKFILE_PATH)))
+LOCAL_BIN_PATH := $(PROJECT_PATH)/bin
+
+export PATH := $(LOCAL_BIN_PATH):$(PATH)
+
 .PHONY: all build test clean
 
 all: build
 
+MOCKGEN := $(LOCAL_BIN_PATH)/mockgen
+
+.PHONY: mockgen-install
+mockgen-install:
+	@GOBIN=$(LOCAL_BIN_PATH) go install go.uber.org/mock/mockgen@v0.2.0 ;\
+
 ginkgo:
 	go install github.com/onsi/ginkgo/v2/ginkgo
 
 tools: ginkgo
 
+
+.PHONY: generate
+generate: mockgen-install
+	go generate ./...
+
 build:
 	go build -o $(APP_NAME)
 
-test: tools
+test: tools generate
 	ginkgo -r -v
 
 clean:
diff --git a/async_routine.go b/async_routine.go
index 4effe66..ec1b577 100644
--- a/async_routine.go
+++ b/async_routine.go
@@ -24,6 +24,8 @@ const (
 var _ AsyncRoutine = (*asyncRoutine)(nil)
 
 // AsyncRoutine is the public interface for managed async routines
+//
+//go:generate mockgen -source=async_routine.go -package=async -destination=mock_async_routine.go
 type AsyncRoutine interface {
 	Name() string
 	CreatedAt() time.Time
diff --git a/mock_async_routine.go b/mock_async_routine.go
new file mode 100644
index 0000000..46166b8
--- /dev/null
+++ b/mock_async_routine.go
@@ -0,0 +1,215 @@
+// Code generated by MockGen. DO NOT EDIT.
+// Source: async_routine.go
+
+// Package async is a generated GoMock package.
+package async
+
+import (
+	reflect "reflect"
+	time "time"
+
+	gomock "go.uber.org/mock/gomock"
+)
+
+// MockAsyncRoutine is a mock of AsyncRoutine interface.
+type MockAsyncRoutine struct {
+	ctrl     *gomock.Controller
+	recorder *MockAsyncRoutineMockRecorder
+}
+
+// MockAsyncRoutineMockRecorder is the mock recorder for MockAsyncRoutine.
+type MockAsyncRoutineMockRecorder struct {
+	mock *MockAsyncRoutine
+}
+
+// NewMockAsyncRoutine creates a new mock instance.
+func NewMockAsyncRoutine(ctrl *gomock.Controller) *MockAsyncRoutine {
+	mock := &MockAsyncRoutine{ctrl: ctrl}
+	mock.recorder = &MockAsyncRoutineMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use.
+func (m *MockAsyncRoutine) EXPECT() *MockAsyncRoutineMockRecorder {
+	return m.recorder
+}
+
+// CreatedAt mocks base method.
+func (m *MockAsyncRoutine) CreatedAt() time.Time {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CreatedAt")
+	ret0, _ := ret[0].(time.Time)
+	return ret0
+}
+
+// CreatedAt indicates an expected call of CreatedAt.
+func (mr *MockAsyncRoutineMockRecorder) CreatedAt() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreatedAt", reflect.TypeOf((*MockAsyncRoutine)(nil).CreatedAt))
+}
+
+// FinishedAt mocks base method.
+func (m *MockAsyncRoutine) FinishedAt() *time.Time {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "FinishedAt")
+	ret0, _ := ret[0].(*time.Time)
+	return ret0
+}
+
+// FinishedAt indicates an expected call of FinishedAt.
+func (mr *MockAsyncRoutineMockRecorder) FinishedAt() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FinishedAt", reflect.TypeOf((*MockAsyncRoutine)(nil).FinishedAt))
+}
+
+// GetData mocks base method.
+func (m *MockAsyncRoutine) GetData() map[string]string {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetData")
+	ret0, _ := ret[0].(map[string]string)
+	return ret0
+}
+
+// GetData indicates an expected call of GetData.
+func (mr *MockAsyncRoutineMockRecorder) GetData() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetData", reflect.TypeOf((*MockAsyncRoutine)(nil).GetData))
+}
+
+// Name mocks base method.
+func (m *MockAsyncRoutine) Name() string {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Name")
+	ret0, _ := ret[0].(string)
+	return ret0
+}
+
+// Name indicates an expected call of Name.
+func (mr *MockAsyncRoutineMockRecorder) Name() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Name", reflect.TypeOf((*MockAsyncRoutine)(nil).Name))
+}
+
+// OpId mocks base method.
+func (m *MockAsyncRoutine) OpId() string {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "OpId")
+	ret0, _ := ret[0].(string)
+	return ret0
+}
+
+// OpId indicates an expected call of OpId.
+func (mr *MockAsyncRoutineMockRecorder) OpId() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OpId", reflect.TypeOf((*MockAsyncRoutine)(nil).OpId))
+}
+
+// OriginatorOpId mocks base method.
+func (m *MockAsyncRoutine) OriginatorOpId() string {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "OriginatorOpId")
+	ret0, _ := ret[0].(string)
+	return ret0
+}
+
+// OriginatorOpId indicates an expected call of OriginatorOpId.
+func (mr *MockAsyncRoutineMockRecorder) OriginatorOpId() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OriginatorOpId", reflect.TypeOf((*MockAsyncRoutine)(nil).OriginatorOpId))
+}
+
+// StartedAt mocks base method.
+func (m *MockAsyncRoutine) StartedAt() *time.Time {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "StartedAt")
+	ret0, _ := ret[0].(*time.Time)
+	return ret0
+}
+
+// StartedAt indicates an expected call of StartedAt.
+func (mr *MockAsyncRoutineMockRecorder) StartedAt() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartedAt", reflect.TypeOf((*MockAsyncRoutine)(nil).StartedAt))
+}
+
+// Status mocks base method.
+func (m *MockAsyncRoutine) Status() RoutineStatus {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Status")
+	ret0, _ := ret[0].(RoutineStatus)
+	return ret0
+}
+
+// Status indicates an expected call of Status.
+func (mr *MockAsyncRoutineMockRecorder) Status() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Status", reflect.TypeOf((*MockAsyncRoutine)(nil).Status))
+}
+
+// hasExceededTimebox mocks base method.
+func (m *MockAsyncRoutine) hasExceededTimebox() bool {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "hasExceededTimebox")
+	ret0, _ := ret[0].(bool)
+	return ret0
+}
+
+// hasExceededTimebox indicates an expected call of hasExceededTimebox.
+func (mr *MockAsyncRoutineMockRecorder) hasExceededTimebox() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "hasExceededTimebox", reflect.TypeOf((*MockAsyncRoutine)(nil).hasExceededTimebox))
+}
+
+// id mocks base method.
+func (m *MockAsyncRoutine) id() string {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "id")
+	ret0, _ := ret[0].(string)
+	return ret0
+}
+
+// id indicates an expected call of id.
+func (mr *MockAsyncRoutineMockRecorder) id() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "id", reflect.TypeOf((*MockAsyncRoutine)(nil).id))
+}
+
+// isFinished mocks base method.
+func (m *MockAsyncRoutine) isFinished() bool {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "isFinished")
+	ret0, _ := ret[0].(bool)
+	return ret0
+}
+
+// isFinished indicates an expected call of isFinished.
+func (mr *MockAsyncRoutineMockRecorder) isFinished() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "isFinished", reflect.TypeOf((*MockAsyncRoutine)(nil).isFinished))
+}
+
+// isRunning mocks base method.
+func (m *MockAsyncRoutine) isRunning() bool {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "isRunning")
+	ret0, _ := ret[0].(bool)
+	return ret0
+}
+
+// isRunning indicates an expected call of isRunning.
+func (mr *MockAsyncRoutineMockRecorder) isRunning() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "isRunning", reflect.TypeOf((*MockAsyncRoutine)(nil).isRunning))
+}
+
+// run mocks base method.
+func (m *MockAsyncRoutine) run(manager AsyncRoutineManager) {
+	m.ctrl.T.Helper()
+	m.ctrl.Call(m, "run", manager)
+}
+
+// run indicates an expected call of run.
+func (mr *MockAsyncRoutineMockRecorder) run(manager interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "run", reflect.TypeOf((*MockAsyncRoutine)(nil).run), manager)
+}