Task service unit tests

* Create task unit tests
* Retrieve task results unit tests

internal/service/task/service.go

@@ -13,6 +13,10 @@ import (
 	goatask "code.vereign.com/gaiax/tsa/task/gen/task"
 )
 
+//go:generate counterfeiter . Storage
+//go:generate counterfeiter . Queue
+//go:generate counterfeiter . Cache
+
 // Storage for retrieving predefined task templates.
 type Storage interface {
 	TaskTemplate(ctx context.Context, taskName string) (*Task, error)
@@ -51,6 +55,10 @@ func New(template Storage, queue Queue, cache Cache, logger *zap.Logger) *Servic
 
 // Create a new task and put it in a Queue for later execution.
 func (s *Service) Create(ctx context.Context, req *goatask.CreateRequest) (res *goatask.CreateResult, err error) {
+	if req.TaskName == "" {
+		return nil, errors.New(errors.BadRequest, "missing taskName")
+	}
+
 	logger := s.logger.With(zap.String("taskName", req.TaskName))
 
 	// get predefined task definition from storage
@@ -105,9 +113,10 @@ func (s *Service) TaskResult(ctx context.Context, req *goatask.TaskResultRequest
 	if task == nil {
 		task, err = s.storage.Task(ctx, req.TaskID)
 		if err != nil {
-			if !errors.Is(errors.NotFound, err) {
-				logger.Error("error getting task from history collection", zap.Error(err))
+			if errors.Is(errors.NotFound, err) {
+				return nil, errors.New("task is not found", err)
 			}
+			logger.Error("error getting task from history collection", zap.Error(err))
 			return nil, err
 		}
 	}

internal/service/task/service_test.go

+package task_test
+
+import (
+	"context"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"go.uber.org/zap"
+
+	"code.vereign.com/gaiax/tsa/golib/errors"
+	"code.vereign.com/gaiax/tsa/golib/ptr"
+	goatask "code.vereign.com/gaiax/tsa/task/gen/task"
+	"code.vereign.com/gaiax/tsa/task/internal/service/task"
+	"code.vereign.com/gaiax/tsa/task/internal/service/task/taskfakes"
+)
+
+func TestNew(t *testing.T) {
+	svc := task.New(nil, nil, nil, zap.NewNop())
+	assert.Implements(t, (*goatask.Service)(nil), svc)
+}
+
+func TestService_Create(t *testing.T) {
+	tests := []struct {
+		name    string
+		req     *goatask.CreateRequest
+		storage *taskfakes.FakeStorage
+		queue   *taskfakes.FakeQueue
+		cache   *taskfakes.FakeCache
+
+		errkind errors.Kind
+		errtext string
+	}{
+		{
+			name:    "empty task name",
+			req:     &goatask.CreateRequest{},
+			errkind: errors.BadRequest,
+			errtext: "missing taskName",
+		},
+		{
+			name: "task template not found",
+			req:  &goatask.CreateRequest{TaskName: "taskname"},
+			storage: &taskfakes.FakeStorage{
+				TaskTemplateStub: func(ctx context.Context, taskName string) (*task.Task, error) {
+					return nil, errors.New(errors.NotFound)
+				},
+			},
+			errkind: errors.NotFound,
+			errtext: "not found",
+		},
+		{
+			name: "fail to add task to queue",
+			req:  &goatask.CreateRequest{TaskName: "taskname"},
+			storage: &taskfakes.FakeStorage{
+				TaskTemplateStub: func(ctx context.Context, taskName string) (*task.Task, error) {
+					return &task.Task{}, nil
+				},
+			},
+			queue: &taskfakes.FakeQueue{
+				AddStub: func(ctx context.Context, t *task.Task) error {
+					return errors.New("some error")
+				},
+			},
+			errkind: errors.Unknown,
+			errtext: "some error",
+		},
+		{
+			name: "successfully add task to queue",
+			req:  &goatask.CreateRequest{TaskName: "taskname"},
+			storage: &taskfakes.FakeStorage{
+				TaskTemplateStub: func(ctx context.Context, taskName string) (*task.Task, error) {
+					return &task.Task{}, nil
+				},
+			},
+			queue: &taskfakes.FakeQueue{
+				AddStub: func(ctx context.Context, t *task.Task) error {
+					return nil
+				},
+			},
+		},
+		{
+			name: "successfully add task to queue with namespace and scope",
+			req: &goatask.CreateRequest{
+				TaskName:       "taskname",
+				CacheNamespace: ptr.String("login"),
+				CacheScope:     ptr.String("user"),
+			},
+			storage: &taskfakes.FakeStorage{
+				TaskTemplateStub: func(ctx context.Context, taskName string) (*task.Task, error) {
+					return &task.Task{}, nil
+				},
+			},
+			queue: &taskfakes.FakeQueue{
+				AddStub: func(ctx context.Context, t *task.Task) error {
+					return nil
+				},
+			},
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			svc := task.New(test.storage, test.queue, test.cache, zap.NewNop())
+			res, err := svc.Create(context.Background(), test.req)
+			if err != nil {
+				assert.NotEmpty(t, test.errtext)
+				e, ok := err.(*errors.Error)
+				assert.True(t, ok)
+				assert.Equal(t, test.errkind, e.Kind)
+				assert.Contains(t, e.Error(), test.errtext)
+				assert.Nil(t, res)
+			} else {
+				assert.Empty(t, test.errtext)
+				assert.NotNil(t, res)
+				assert.NotEmpty(t, res.TaskID)
+			}
+		})
+	}
+}
+
+func TestService_TaskResult(t *testing.T) {
+	tests := []struct {
+		name    string
+		req     *goatask.TaskResultRequest
+		storage *taskfakes.FakeStorage
+		cache   *taskfakes.FakeCache
+
+		res     interface{}
+		errkind errors.Kind
+		errtext string
+	}{
+		{
+			name:    "missing taskID",
+			req:     &goatask.TaskResultRequest{},
+			errkind: errors.BadRequest,
+			errtext: "missing taskID",
+		},
+		{
+			name: "error getting task history from storage",
+			req:  &goatask.TaskResultRequest{TaskID: "123"},
+			storage: &taskfakes.FakeStorage{
+				TaskHistoryStub: func(ctx context.Context, taskID string) (*task.Task, error) {
+					return nil, errors.New("some error")
+				},
+			},
+			errkind: errors.Unknown,
+			errtext: "some error",
+		},
+		{
+			name: "task not found in history and fail to retrieve it from tasks queue collection too",
+			req:  &goatask.TaskResultRequest{TaskID: "123"},
+			storage: &taskfakes.FakeStorage{
+				TaskHistoryStub: func(ctx context.Context, taskID string) (*task.Task, error) {
+					return nil, errors.New(errors.NotFound)
+				},
+				TaskStub: func(ctx context.Context, taskID string) (*task.Task, error) {
+					return nil, errors.New("another error")
+				},
+			},
+			errkind: errors.Unknown,
+			errtext: "another error",
+		},
+		{
+			name: "task not found neither in history nor in tasks queue collection",
+			req:  &goatask.TaskResultRequest{TaskID: "123"},
+			storage: &taskfakes.FakeStorage{
+				TaskHistoryStub: func(ctx context.Context, taskID string) (*task.Task, error) {
+					return nil, errors.New(errors.NotFound)
+				},
+				TaskStub: func(ctx context.Context, taskID string) (*task.Task, error) {
+					return nil, errors.New(errors.NotFound)
+				},
+			},
+			errkind: errors.NotFound,
+			errtext: "task is not found",
+		},
+		{
+			name: "task is not yet completed",
+			req:  &goatask.TaskResultRequest{TaskID: "123"},
+			storage: &taskfakes.FakeStorage{
+				TaskHistoryStub: func(ctx context.Context, taskID string) (*task.Task, error) {
+					return nil, errors.New(errors.NotFound)
+				},
+				TaskStub: func(ctx context.Context, taskID string) (*task.Task, error) {
+					return &task.Task{State: task.Pending}, nil
+				},
+			},
+			errkind: errors.NotFound,
+			errtext: "no result, task is not completed",
+		},
+		{
+			name: "error getting task result from cache",
+			req:  &goatask.TaskResultRequest{TaskID: "123"},
+			storage: &taskfakes.FakeStorage{
+				TaskHistoryStub: func(ctx context.Context, taskID string) (*task.Task, error) {
+					return nil, errors.New(errors.NotFound)
+				},
+				TaskStub: func(ctx context.Context, taskID string) (*task.Task, error) {
+					return &task.Task{State: task.Done}, nil
+				},
+			},
+			cache: &taskfakes.FakeCache{
+				GetStub: func(ctx context.Context, key string, ns string, scope string) ([]byte, error) {
+					return nil, errors.New("cache error")
+				},
+			},
+			errkind: errors.Unknown,
+			errtext: "cache error",
+		},
+		{
+			name: "getting invalid JSON result from cache",
+			req:  &goatask.TaskResultRequest{TaskID: "123"},
+			storage: &taskfakes.FakeStorage{
+				TaskHistoryStub: func(ctx context.Context, taskID string) (*task.Task, error) {
+					return nil, errors.New(errors.NotFound)
+				},
+				TaskStub: func(ctx context.Context, taskID string) (*task.Task, error) {
+					return &task.Task{State: task.Done}, nil
+				},
+			},
+			cache: &taskfakes.FakeCache{
+				GetStub: func(ctx context.Context, key string, ns string, scope string) ([]byte, error) {
+					return []byte("asdfads"), nil
+				},
+			},
+			errkind: errors.Unknown,
+			errtext: "error decoding result from cache",
+		},
+		{
+			name: "get task result successfully",
+			req:  &goatask.TaskResultRequest{TaskID: "123"},
+			storage: &taskfakes.FakeStorage{
+				TaskHistoryStub: func(ctx context.Context, taskID string) (*task.Task, error) {
+					return nil, errors.New(errors.NotFound)
+				},
+				TaskStub: func(ctx context.Context, taskID string) (*task.Task, error) {
+					return &task.Task{State: task.Done}, nil
+				},
+			},
+			cache: &taskfakes.FakeCache{
+				GetStub: func(ctx context.Context, key string, ns string, scope string) ([]byte, error) {
+					return []byte(`{"result":"success"}`), nil
+				},
+			},
+			res: map[string]interface{}{"result": "success"},
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			svc := task.New(test.storage, nil, test.cache, zap.NewNop())
+			res, err := svc.TaskResult(context.Background(), test.req)
+			if err != nil {
+				assert.NotEmpty(t, test.errtext)
+				e, ok := err.(*errors.Error)
+				assert.True(t, ok)
+				assert.Equal(t, test.errkind, e.Kind)
+				assert.Contains(t, e.Error(), test.errtext)
+				assert.Nil(t, res)
+			} else {
+				assert.Empty(t, test.errtext)
+				assert.NotNil(t, res)
+				assert.Equal(t, test.res, res)
+			}
+		})
+	}
+}

internal/service/task/taskfakes/fake_cache.go

+// Code generated by counterfeiter. DO NOT EDIT.
+package taskfakes
+
+import (
+	"context"
+	"sync"
+
+	"code.vereign.com/gaiax/tsa/task/internal/service/task"
+)
+
+type FakeCache struct {
+	GetStub        func(context.Context, string, string, string) ([]byte, error)
+	getMutex       sync.RWMutex
+	getArgsForCall []struct {
+		arg1 context.Context
+		arg2 string
+		arg3 string
+		arg4 string
+	}
+	getReturns struct {
+		result1 []byte
+		result2 error
+	}
+	getReturnsOnCall map[int]struct {
+		result1 []byte
+		result2 error
+	}
+	invocations      map[string][][]interface{}
+	invocationsMutex sync.RWMutex
+}
+
+func (fake *FakeCache) Get(arg1 context.Context, arg2 string, arg3 string, arg4 string) ([]byte, error) {
+	fake.getMutex.Lock()
+	ret, specificReturn := fake.getReturnsOnCall[len(fake.getArgsForCall)]
+	fake.getArgsForCall = append(fake.getArgsForCall, struct {
+		arg1 context.Context
+		arg2 string
+		arg3 string
+		arg4 string
+	}{arg1, arg2, arg3, arg4})
+	stub := fake.GetStub
+	fakeReturns := fake.getReturns
+	fake.recordInvocation("Get", []interface{}{arg1, arg2, arg3, arg4})
+	fake.getMutex.Unlock()
+	if stub != nil {
+		return stub(arg1, arg2, arg3, arg4)
+	}
+	if specificReturn {
+		return ret.result1, ret.result2
+	}
+	return fakeReturns.result1, fakeReturns.result2
+}
+
+func (fake *FakeCache) GetCallCount() int {
+	fake.getMutex.RLock()
+	defer fake.getMutex.RUnlock()
+	return len(fake.getArgsForCall)
+}
+
+func (fake *FakeCache) GetCalls(stub func(context.Context, string, string, string) ([]byte, error)) {
+	fake.getMutex.Lock()
+	defer fake.getMutex.Unlock()
+	fake.GetStub = stub
+}
+
+func (fake *FakeCache) GetArgsForCall(i int) (context.Context, string, string, string) {
+	fake.getMutex.RLock()
+	defer fake.getMutex.RUnlock()
+	argsForCall := fake.getArgsForCall[i]
+	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4
+}
+
+func (fake *FakeCache) GetReturns(result1 []byte, result2 error) {
+	fake.getMutex.Lock()
+	defer fake.getMutex.Unlock()
+	fake.GetStub = nil
+	fake.getReturns = struct {
+		result1 []byte
+		result2 error
+	}{result1, result2}
+}
+
+func (fake *FakeCache) GetReturnsOnCall(i int, result1 []byte, result2 error) {
+	fake.getMutex.Lock()
+	defer fake.getMutex.Unlock()
+	fake.GetStub = nil
+	if fake.getReturnsOnCall == nil {
+		fake.getReturnsOnCall = make(map[int]struct {
+			result1 []byte
+			result2 error
+		})
+	}
+	fake.getReturnsOnCall[i] = struct {
+		result1 []byte
+		result2 error
+	}{result1, result2}
+}
+
+func (fake *FakeCache) Invocations() map[string][][]interface{} {
+	fake.invocationsMutex.RLock()
+	defer fake.invocationsMutex.RUnlock()
+	fake.getMutex.RLock()
+	defer fake.getMutex.RUnlock()
+	copiedInvocations := map[string][][]interface{}{}
+	for key, value := range fake.invocations {
+		copiedInvocations[key] = value
+	}
+	return copiedInvocations
+}
+
+func (fake *FakeCache) recordInvocation(key string, args []interface{}) {
+	fake.invocationsMutex.Lock()
+	defer fake.invocationsMutex.Unlock()
+	if fake.invocations == nil {
+		fake.invocations = map[string][][]interface{}{}
+	}
+	if fake.invocations[key] == nil {
+		fake.invocations[key] = [][]interface{}{}
+	}
+	fake.invocations[key] = append(fake.invocations[key], args)
+}
+
+var _ task.Cache = new(FakeCache)

internal/service/task/taskfakes/fake_queue.go

+// Code generated by counterfeiter. DO NOT EDIT.
+package taskfakes
+
+import (
+	"context"
+	"sync"
+
+	"code.vereign.com/gaiax/tsa/task/internal/service/task"
+)
+
+type FakeQueue struct {
+	AckStub        func(context.Context, *task.Task) error
+	ackMutex       sync.RWMutex
+	ackArgsForCall []struct {
+		arg1 context.Context
+		arg2 *task.Task
+	}
+	ackReturns struct {
+		result1 error
+	}
+	ackReturnsOnCall map[int]struct {
+		result1 error
+	}
+	AddStub        func(context.Context, *task.Task) error
+	addMutex       sync.RWMutex
+	addArgsForCall []struct {
+		arg1 context.Context
+		arg2 *task.Task
+	}
+	addReturns struct {
+		result1 error
+	}
+	addReturnsOnCall map[int]struct {
+		result1 error
+	}
+	PollStub        func(context.Context) (*task.Task, error)
+	pollMutex       sync.RWMutex
+	pollArgsForCall []struct {
+		arg1 context.Context
+	}
+	pollReturns struct {
+		result1 *task.Task
+		result2 error
+	}
+	pollReturnsOnCall map[int]struct {
+		result1 *task.Task
+		result2 error
+	}
+	UnackStub        func(context.Context, *task.Task) error
+	unackMutex       sync.RWMutex
+	unackArgsForCall []struct {
+		arg1 context.Context
+		arg2 *task.Task
+	}
+	unackReturns struct {
+		result1 error
+	}
+	unackReturnsOnCall map[int]struct {
+		result1 error
+	}
+	invocations      map[string][][]interface{}
+	invocationsMutex sync.RWMutex
+}
+
+func (fake *FakeQueue) Ack(arg1 context.Context, arg2 *task.Task) error {
+	fake.ackMutex.Lock()
+	ret, specificReturn := fake.ackReturnsOnCall[len(fake.ackArgsForCall)]
+	fake.ackArgsForCall = append(fake.ackArgsForCall, struct {
+		arg1 context.Context
+		arg2 *task.Task
+	}{arg1, arg2})
+	stub := fake.AckStub
+	fakeReturns := fake.ackReturns
+	fake.recordInvocation("Ack", []interface{}{arg1, arg2})
+	fake.ackMutex.Unlock()
+	if stub != nil {
+		return stub(arg1, arg2)
+	}
+	if specificReturn {
+		return ret.result1
+	}
+	return fakeReturns.result1
+}
+
+func (fake *FakeQueue) AckCallCount() int {
+	fake.ackMutex.RLock()
+	defer fake.ackMutex.RUnlock()
+	return len(fake.ackArgsForCall)
+}
+
+func (fake *FakeQueue) AckCalls(stub func(context.Context, *task.Task) error) {
+	fake.ackMutex.Lock()
+	defer fake.ackMutex.Unlock()
+	fake.AckStub = stub
+}
+
+func (fake *FakeQueue) AckArgsForCall(i int) (context.Context, *task.Task) {
+	fake.ackMutex.RLock()
+	defer fake.ackMutex.RUnlock()
+	argsForCall := fake.ackArgsForCall[i]
+	return argsForCall.arg1, argsForCall.arg2
+}
+
+func (fake *FakeQueue) AckReturns(result1 error) {
+	fake.ackMutex.Lock()
+	defer fake.ackMutex.Unlock()
+	fake.AckStub = nil
+	fake.ackReturns = struct {
+		result1 error
+	}{result1}
+}
+
+func (fake *FakeQueue) AckReturnsOnCall(i int, result1 error) {
+	fake.ackMutex.Lock()
+	defer fake.ackMutex.Unlock()
+	fake.AckStub = nil
+	if fake.ackReturnsOnCall == nil {
+		fake.ackReturnsOnCall = make(map[int]struct {
+			result1 error
+		})
+	}
+	fake.ackReturnsOnCall[i] = struct {
+		result1 error
+	}{result1}
+}
+
+func (fake *FakeQueue) Add(arg1 context.Context, arg2 *task.Task) error {
+	fake.addMutex.Lock()
+	ret, specificReturn := fake.addReturnsOnCall[len(fake.addArgsForCall)]
+	fake.addArgsForCall = append(fake.addArgsForCall, struct {
+		arg1 context.Context
+		arg2 *task.Task
+	}{arg1, arg2})
+	stub := fake.AddStub
+	fakeReturns := fake.addReturns
+	fake.recordInvocation("Add", []interface{}{arg1, arg2})
+	fake.addMutex.Unlock()
+	if stub != nil {
+		return stub(arg1, arg2)
+	}
+	if specificReturn {
+		return ret.result1
+	}
+	return fakeReturns.result1
+}
+
+func (fake *FakeQueue) AddCallCount() int {
+	fake.addMutex.RLock()
+	defer fake.addMutex.RUnlock()
+	return len(fake.addArgsForCall)
+}
+
+func (fake *FakeQueue) AddCalls(stub func(context.Context, *task.Task) error) {
+	fake.addMutex.Lock()
+	defer fake.addMutex.Unlock()
+	fake.AddStub = stub
+}
+
+func (fake *FakeQueue) AddArgsForCall(i int) (context.Context, *task.Task) {
+	fake.addMutex.RLock()
+	defer fake.addMutex.RUnlock()
+	argsForCall := fake.addArgsForCall[i]
+	return argsForCall.arg1, argsForCall.arg2
+}
+
+func (fake *FakeQueue) AddReturns(result1 error) {
+	fake.addMutex.Lock()
+	defer fake.addMutex.Unlock()
+	fake.AddStub = nil
+	fake.addReturns = struct {
+		result1 error
+	}{result1}
+}
+
+func (fake *FakeQueue) AddReturnsOnCall(i int, result1 error) {
+	fake.addMutex.Lock()
+	defer fake.addMutex.Unlock()
+	fake.AddStub = nil
+	if fake.addReturnsOnCall == nil {
+		fake.addReturnsOnCall = make(map[int]struct {
+			result1 error
+		})
+	}
+	fake.addReturnsOnCall[i] = struct {
+		result1 error
+	}{result1}
+}
+
+func (fake *FakeQueue) Poll(arg1 context.Context) (*task.Task, error) {
+	fake.pollMutex.Lock()
+	ret, specificReturn := fake.pollReturnsOnCall[len(fake.pollArgsForCall)]
+	fake.pollArgsForCall = append(fake.pollArgsForCall, struct {
+		arg1 context.Context
+	}{arg1})
+	stub := fake.PollStub
+	fakeReturns := fake.pollReturns
+	fake.recordInvocation("Poll", []interface{}{arg1})
+	fake.pollMutex.Unlock()
+	if stub != nil {
+		return stub(arg1)
+	}
+	if specificReturn {
+		return ret.result1, ret.result2
+	}
+	return fakeReturns.result1, fakeReturns.result2
+}
+
+func (fake *FakeQueue) PollCallCount() int {
+	fake.pollMutex.RLock()
+	defer fake.pollMutex.RUnlock()
+	return len(fake.pollArgsForCall)
+}
+
+func (fake *FakeQueue) PollCalls(stub func(context.Context) (*task.Task, error)) {
+	fake.pollMutex.Lock()
+	defer fake.pollMutex.Unlock()
+	fake.PollStub = stub
+}
+
+func (fake *FakeQueue) PollArgsForCall(i int) context.Context {
+	fake.pollMutex.RLock()
+	defer fake.pollMutex.RUnlock()
+	argsForCall := fake.pollArgsForCall[i]
+	return argsForCall.arg1
+}
+
+func (fake *FakeQueue) PollReturns(result1 *task.Task, result2 error) {
+	fake.pollMutex.Lock()
+	defer fake.pollMutex.Unlock()
+	fake.PollStub = nil
+	fake.pollReturns = struct {
+		result1 *task.Task
+		result2 error
+	}{result1, result2}
+}
+
+func (fake *FakeQueue) PollReturnsOnCall(i int, result1 *task.Task, result2 error) {
+	fake.pollMutex.Lock()
+	defer fake.pollMutex.Unlock()
+	fake.PollStub = nil
+	if fake.pollReturnsOnCall == nil {
+		fake.pollReturnsOnCall = make(map[int]struct {
+			result1 *task.Task
+			result2 error
+		})
+	}
+	fake.pollReturnsOnCall[i] = struct {
+		result1 *task.Task
+		result2 error
+	}{result1, result2}
+}
+
+func (fake *FakeQueue) Unack(arg1 context.Context, arg2 *task.Task) error {
+	fake.unackMutex.Lock()
+	ret, specificReturn := fake.unackReturnsOnCall[len(fake.unackArgsForCall)]
+	fake.unackArgsForCall = append(fake.unackArgsForCall, struct {
+		arg1 context.Context
+		arg2 *task.Task
+	}{arg1, arg2})
+	stub := fake.UnackStub
+	fakeReturns := fake.unackReturns
+	fake.recordInvocation("Unack", []interface{}{arg1, arg2})
+	fake.unackMutex.Unlock()
+	if stub != nil {
+		return stub(arg1, arg2)
+	}
+	if specificReturn {
+		return ret.result1
+	}
+	return fakeReturns.result1
+}
+
+func (fake *FakeQueue) UnackCallCount() int {
+	fake.unackMutex.RLock()
+	defer fake.unackMutex.RUnlock()
+	return len(fake.unackArgsForCall)
+}
+
+func (fake *FakeQueue) UnackCalls(stub func(context.Context, *task.Task) error) {
+	fake.unackMutex.Lock()
+	defer fake.unackMutex.Unlock()
+	fake.UnackStub = stub
+}
+
+func (fake *FakeQueue) UnackArgsForCall(i int) (context.Context, *task.Task) {
+	fake.unackMutex.RLock()
+	defer fake.unackMutex.RUnlock()
+	argsForCall := fake.unackArgsForCall[i]
+	return argsForCall.arg1, argsForCall.arg2
+}
+
+func (fake *FakeQueue) UnackReturns(result1 error) {
+	fake.unackMutex.Lock()
+	defer fake.unackMutex.Unlock()
+	fake.UnackStub = nil
+	fake.unackReturns = struct {
+		result1 error
+	}{result1}
+}
+
+func (fake *FakeQueue) UnackReturnsOnCall(i int, result1 error) {
+	fake.unackMutex.Lock()
+	defer fake.unackMutex.Unlock()
+	fake.UnackStub = nil
+	if fake.unackReturnsOnCall == nil {
+		fake.unackReturnsOnCall = make(map[int]struct {
+			result1 error
+		})
+	}
+	fake.unackReturnsOnCall[i] = struct {
+		result1 error
+	}{result1}
+}
+
+func (fake *FakeQueue) Invocations() map[string][][]interface{} {
+	fake.invocationsMutex.RLock()
+	defer fake.invocationsMutex.RUnlock()
+	fake.ackMutex.RLock()
+	defer fake.ackMutex.RUnlock()
+	fake.addMutex.RLock()
+	defer fake.addMutex.RUnlock()
+	fake.pollMutex.RLock()
+	defer fake.pollMutex.RUnlock()
+	fake.unackMutex.RLock()
+	defer fake.unackMutex.RUnlock()
+	copiedInvocations := map[string][][]interface{}{}
+	for key, value := range fake.invocations {
+		copiedInvocations[key] = value
+	}
+	return copiedInvocations
+}
+
+func (fake *FakeQueue) recordInvocation(key string, args []interface{}) {
+	fake.invocationsMutex.Lock()
+	defer fake.invocationsMutex.Unlock()
+	if fake.invocations == nil {
+		fake.invocations = map[string][][]interface{}{}
+	}
+	if fake.invocations[key] == nil {
+		fake.invocations[key] = [][]interface{}{}
+	}
+	fake.invocations[key] = append(fake.invocations[key], args)
+}
+
+var _ task.Queue = new(FakeQueue)

internal/service/task/taskfakes/fake_storage.go

+// Code generated by counterfeiter. DO NOT EDIT.
+package taskfakes
+
+import (
+	"context"
+	"sync"
+
+	"code.vereign.com/gaiax/tsa/task/internal/service/task"
+)
+
+type FakeStorage struct {
+	TaskStub        func(context.Context, string) (*task.Task, error)
+	taskMutex       sync.RWMutex
+	taskArgsForCall []struct {
+		arg1 context.Context
+		arg2 string
+	}
+	taskReturns struct {
+		result1 *task.Task
+		result2 error
+	}
+	taskReturnsOnCall map[int]struct {
+		result1 *task.Task
+		result2 error
+	}
+	TaskHistoryStub        func(context.Context, string) (*task.Task, error)
+	taskHistoryMutex       sync.RWMutex
+	taskHistoryArgsForCall []struct {
+		arg1 context.Context
+		arg2 string
+	}
+	taskHistoryReturns struct {
+		result1 *task.Task
+		result2 error
+	}
+	taskHistoryReturnsOnCall map[int]struct {
+		result1 *task.Task
+		result2 error
+	}
+	TaskTemplateStub        func(context.Context, string) (*task.Task, error)
+	taskTemplateMutex       sync.RWMutex
+	taskTemplateArgsForCall []struct {
+		arg1 context.Context
+		arg2 string
+	}
+	taskTemplateReturns struct {
+		result1 *task.Task
+		result2 error
+	}
+	taskTemplateReturnsOnCall map[int]struct {
+		result1 *task.Task
+		result2 error
+	}
+	invocations      map[string][][]interface{}
+	invocationsMutex sync.RWMutex
+}
+
+func (fake *FakeStorage) Task(arg1 context.Context, arg2 string) (*task.Task, error) {
+	fake.taskMutex.Lock()
+	ret, specificReturn := fake.taskReturnsOnCall[len(fake.taskArgsForCall)]
+	fake.taskArgsForCall = append(fake.taskArgsForCall, struct {
+		arg1 context.Context
+		arg2 string
+	}{arg1, arg2})
+	stub := fake.TaskStub
+	fakeReturns := fake.taskReturns
+	fake.recordInvocation("Task", []interface{}{arg1, arg2})
+	fake.taskMutex.Unlock()
+	if stub != nil {
+		return stub(arg1, arg2)
+	}
+	if specificReturn {
+		return ret.result1, ret.result2
+	}
+	return fakeReturns.result1, fakeReturns.result2
+}
+
+func (fake *FakeStorage) TaskCallCount() int {
+	fake.taskMutex.RLock()
+	defer fake.taskMutex.RUnlock()
+	return len(fake.taskArgsForCall)
+}
+
+func (fake *FakeStorage) TaskCalls(stub func(context.Context, string) (*task.Task, error)) {
+	fake.taskMutex.Lock()
+	defer fake.taskMutex.Unlock()
+	fake.TaskStub = stub
+}
+
+func (fake *FakeStorage) TaskArgsForCall(i int) (context.Context, string) {
+	fake.taskMutex.RLock()
+	defer fake.taskMutex.RUnlock()
+	argsForCall := fake.taskArgsForCall[i]
+	return argsForCall.arg1, argsForCall.arg2
+}
+
+func (fake *FakeStorage) TaskReturns(result1 *task.Task, result2 error) {
+	fake.taskMutex.Lock()
+	defer fake.taskMutex.Unlock()
+	fake.TaskStub = nil
+	fake.taskReturns = struct {
+		result1 *task.Task
+		result2 error
+	}{result1, result2}
+}
+
+func (fake *FakeStorage) TaskReturnsOnCall(i int, result1 *task.Task, result2 error) {
+	fake.taskMutex.Lock()
+	defer fake.taskMutex.Unlock()
+	fake.TaskStub = nil
+	if fake.taskReturnsOnCall == nil {
+		fake.taskReturnsOnCall = make(map[int]struct {
+			result1 *task.Task
+			result2 error
+		})
+	}
+	fake.taskReturnsOnCall[i] = struct {
+		result1 *task.Task
+		result2 error
+	}{result1, result2}
+}
+
+func (fake *FakeStorage) TaskHistory(arg1 context.Context, arg2 string) (*task.Task, error) {
+	fake.taskHistoryMutex.Lock()
+	ret, specificReturn := fake.taskHistoryReturnsOnCall[len(fake.taskHistoryArgsForCall)]
+	fake.taskHistoryArgsForCall = append(fake.taskHistoryArgsForCall, struct {
+		arg1 context.Context
+		arg2 string
+	}{arg1, arg2})
+	stub := fake.TaskHistoryStub
+	fakeReturns := fake.taskHistoryReturns
+	fake.recordInvocation("TaskHistory", []interface{}{arg1, arg2})
+	fake.taskHistoryMutex.Unlock()
+	if stub != nil {
+		return stub(arg1, arg2)
+	}
+	if specificReturn {
+		return ret.result1, ret.result2
+	}
+	return fakeReturns.result1, fakeReturns.result2
+}
+
+func (fake *FakeStorage) TaskHistoryCallCount() int {
+	fake.taskHistoryMutex.RLock()
+	defer fake.taskHistoryMutex.RUnlock()
+	return len(fake.taskHistoryArgsForCall)
+}
+
+func (fake *FakeStorage) TaskHistoryCalls(stub func(context.Context, string) (*task.Task, error)) {
+	fake.taskHistoryMutex.Lock()
+	defer fake.taskHistoryMutex.Unlock()
+	fake.TaskHistoryStub = stub
+}
+
+func (fake *FakeStorage) TaskHistoryArgsForCall(i int) (context.Context, string) {
+	fake.taskHistoryMutex.RLock()
+	defer fake.taskHistoryMutex.RUnlock()
+	argsForCall := fake.taskHistoryArgsForCall[i]
+	return argsForCall.arg1, argsForCall.arg2
+}
+
+func (fake *FakeStorage) TaskHistoryReturns(result1 *task.Task, result2 error) {
+	fake.taskHistoryMutex.Lock()
+	defer fake.taskHistoryMutex.Unlock()
+	fake.TaskHistoryStub = nil
+	fake.taskHistoryReturns = struct {
+		result1 *task.Task
+		result2 error
+	}{result1, result2}
+}
+
+func (fake *FakeStorage) TaskHistoryReturnsOnCall(i int, result1 *task.Task, result2 error) {
+	fake.taskHistoryMutex.Lock()
+	defer fake.taskHistoryMutex.Unlock()
+	fake.TaskHistoryStub = nil
+	if fake.taskHistoryReturnsOnCall == nil {
+		fake.taskHistoryReturnsOnCall = make(map[int]struct {
+			result1 *task.Task
+			result2 error
+		})
+	}
+	fake.taskHistoryReturnsOnCall[i] = struct {
+		result1 *task.Task
+		result2 error
+	}{result1, result2}
+}
+
+func (fake *FakeStorage) TaskTemplate(arg1 context.Context, arg2 string) (*task.Task, error) {
+	fake.taskTemplateMutex.Lock()
+	ret, specificReturn := fake.taskTemplateReturnsOnCall[len(fake.taskTemplateArgsForCall)]
+	fake.taskTemplateArgsForCall = append(fake.taskTemplateArgsForCall, struct {
+		arg1 context.Context
+		arg2 string
+	}{arg1, arg2})
+	stub := fake.TaskTemplateStub
+	fakeReturns := fake.taskTemplateReturns
+	fake.recordInvocation("TaskTemplate", []interface{}{arg1, arg2})
+	fake.taskTemplateMutex.Unlock()
+	if stub != nil {
+		return stub(arg1, arg2)
+	}
+	if specificReturn {
+		return ret.result1, ret.result2
+	}
+	return fakeReturns.result1, fakeReturns.result2
+}
+
+func (fake *FakeStorage) TaskTemplateCallCount() int {
+	fake.taskTemplateMutex.RLock()
+	defer fake.taskTemplateMutex.RUnlock()
+	return len(fake.taskTemplateArgsForCall)
+}
+
+func (fake *FakeStorage) TaskTemplateCalls(stub func(context.Context, string) (*task.Task, error)) {
+	fake.taskTemplateMutex.Lock()
+	defer fake.taskTemplateMutex.Unlock()
+	fake.TaskTemplateStub = stub
+}
+
+func (fake *FakeStorage) TaskTemplateArgsForCall(i int) (context.Context, string) {
+	fake.taskTemplateMutex.RLock()
+	defer fake.taskTemplateMutex.RUnlock()
+	argsForCall := fake.taskTemplateArgsForCall[i]
+	return argsForCall.arg1, argsForCall.arg2
+}
+
+func (fake *FakeStorage) TaskTemplateReturns(result1 *task.Task, result2 error) {
+	fake.taskTemplateMutex.Lock()
+	defer fake.taskTemplateMutex.Unlock()
+	fake.TaskTemplateStub = nil
+	fake.taskTemplateReturns = struct {
+		result1 *task.Task
+		result2 error
+	}{result1, result2}
+}
+
+func (fake *FakeStorage) TaskTemplateReturnsOnCall(i int, result1 *task.Task, result2 error) {
+	fake.taskTemplateMutex.Lock()
+	defer fake.taskTemplateMutex.Unlock()
+	fake.TaskTemplateStub = nil
+	if fake.taskTemplateReturnsOnCall == nil {
+		fake.taskTemplateReturnsOnCall = make(map[int]struct {
+			result1 *task.Task
+			result2 error
+		})
+	}
+	fake.taskTemplateReturnsOnCall[i] = struct {
+		result1 *task.Task
+		result2 error
+	}{result1, result2}
+}
+
+func (fake *FakeStorage) Invocations() map[string][][]interface{} {
+	fake.invocationsMutex.RLock()
+	defer fake.invocationsMutex.RUnlock()
+	fake.taskMutex.RLock()
+	defer fake.taskMutex.RUnlock()
+	fake.taskHistoryMutex.RLock()
+	defer fake.taskHistoryMutex.RUnlock()
+	fake.taskTemplateMutex.RLock()
+	defer fake.taskTemplateMutex.RUnlock()
+	copiedInvocations := map[string][][]interface{}{}
+	for key, value := range fake.invocations {
+		copiedInvocations[key] = value
+	}
+	return copiedInvocations
+}
+
+func (fake *FakeStorage) recordInvocation(key string, args []interface{}) {
+	fake.invocationsMutex.Lock()
+	defer fake.invocationsMutex.Unlock()
+	if fake.invocations == nil {
+		fake.invocations = map[string][][]interface{}{}
+	}
+	if fake.invocations[key] == nil {
+		fake.invocations[key] = [][]interface{}{}
+	}
+	fake.invocations[key] = append(fake.invocations[key], args)
+}
+
+var _ task.Storage = new(FakeStorage)