diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml
index 43645ab3d49ad3517a70e607f9b12ac09b14dd08..c92e8694f8f984638f7769e9cf29d719ff1b6adf 100644
--- a/.gitlab-ci.yml
+++ b/.gitlab-ci.yml
@@ -14,7 +14,7 @@ linters:
     - golangci-lint run
 
 unit tests:
-  image: golang:1.21.4
+  image: golang:1.21.5
   stage: test
   script:
     - go version
@@ -23,7 +23,7 @@ unit tests:
   coverage: '/total:\s+\(statements\)\s+(\d+.\d+\%)/'
 
 govulncheck:
-  image: golang:1.21.4
+  image: golang:1.21.5
   stage: test
   script:
     - go version
diff --git a/README.md b/README.md
index bb9489e75347321409dd98e959026b3183dd7df1..a23a7e07504e0463b20f1dd4bd9c878fd4a313fd 100644
--- a/README.md
+++ b/README.md
@@ -17,18 +17,21 @@ environment, the Swagger URL is available at http://localhost:8082/swagger-ui/
 ```mermaid  
 flowchart LR  
 	A([client]) -- HTTP --> B[Task API] 
-	subgraph task 
-		B --> C[(tasks DB)] 
-		C --> D[Executor] 
+	subgraph task
+        B --- C[(Storage)]
+        C --- E[Executor]
+        B --> D[(Queue)]
+        D --> E[Executor]
 	end 
-	D --> E[Policy]
-	D --> F[Cache]
+	E --> F[Policy]
+	E --> G[Cache]
 ```
 
-Tasks are created by clients making HTTP requests. The newly created tasks are
-stored in a persistent database which is used like Queue. An executor component
-is retrieving tasks from the Queue for execution. Clients receive an 
-immediate response with the `taskID` for the created task and can later query
+Tasks are created by clients making HTTP requests.
+In order to create a Task, a TaskTemplate must be present in the Storage. The newly created tasks are
+added to a Queue. Current implementation of the [Queue interface](internal/service/queue.go)
+is a persistent database. An executor component is retrieving tasks from the Queue for execution.
+Clients receive an immediate response with the `taskID` for the created task and can later query
 the state of task and retrieve its result either by directly querying the Cache
 service, or by querying the task HTTP interface for task results.
 
@@ -36,6 +39,7 @@ service, or by querying the task HTTP interface for task results.
 * [Tasks](docs/task.md)
 * [Task lists](docs/task-list.md)
 * [Queue](docs/queue.md)
+* [Storage](docs/storage.md)
 
 
 ### Cache events
diff --git a/deployment/ci/Dockerfile b/deployment/ci/Dockerfile
index b15f77b948866b29e9ebbb9437c1fde68c53aaab..729429e4dab363e5bde1fac12470f5c4d3a6b4f6 100644
--- a/deployment/ci/Dockerfile
+++ b/deployment/ci/Dockerfile
@@ -1,4 +1,4 @@
-FROM golang:1.21.4-alpine3.17 as builder
+FROM golang:1.21.5-alpine3.17 as builder
 
 RUN apk add git
 
diff --git a/deployment/compose/Dockerfile b/deployment/compose/Dockerfile
index 39ce5b58496b0447f5edcc15bd1017ecc38842b6..2efd50dda9b1091fb60d5dc7cca5cf12e16c5977 100644
--- a/deployment/compose/Dockerfile
+++ b/deployment/compose/Dockerfile
@@ -1,4 +1,4 @@
-FROM golang:1.21.4
+FROM golang:1.21.5
 
 RUN go install github.com/ysmood/kit/cmd/guard@v0.25.11
 
diff --git a/docs/cache-event-task.md b/docs/cache-event-task.md
index 7c6ad78e89050c612fae47ffd7c8a23522674a77..82e177d98fa07dace8c6eb335e7498e397a469f8 100644
--- a/docs/cache-event-task.md
+++ b/docs/cache-event-task.md
@@ -13,8 +13,8 @@ NATS_SUBJECT="subject"
 ### Event Task definition
 
 In order to create a Task upon receiving a Cache event an `event task template` **must**
-be available. Event task JSON templates are stored in Mongo database in a collection
-named `eventTask`. Below is an example of event task template definition:
+be available. Event task JSON templates are stored in Storage. Currently, a Mongo database collection
+named `eventTask` is used for storing event task templates. Below is an example of event task template definition:
 
 ```json
 {
diff --git a/docs/queue.md b/docs/queue.md
index bcf05b85713d16e6370e475da9dd91d7b42c94e3..f546f657398a53a75345fa77728895b200a6b165 100644
--- a/docs/queue.md
+++ b/docs/queue.md
@@ -1,6 +1,11 @@
 # Task service - Queue
 
-### Why the Queue is Database
+### Queue Interface
+
+The Task Queue is an interface and can be reviewed [here](../internal/service/queue.go).
+Current [implementation](../internal/storage/storage.go) uses persistent database.
+
+### Why the current implementation of the Queue is Database
 
 Why we decided to use a database as queue instead of a universal message queue product
 like Kafka, so that the executor won't need to poll for new tasks, but will instead
diff --git a/docs/storage.md b/docs/storage.md
new file mode 100644
index 0000000000000000000000000000000000000000..eba5097e360f4716c8d01152b4cb917e0bffa54d
--- /dev/null
+++ b/docs/storage.md
@@ -0,0 +1,62 @@
+# Task service - Storage
+
+### Storage Interface
+
+The Task Storage is an interface and can be reviewed [here](../internal/service/storage.go). 
+
+### Storage implementation
+
+Current [implementation](../internal/storage/storage.go) uses MongoDB database.
+Adding other implementations is easy - just implement the Storage interface.
+
+### Task Storage
+
+In current implementation there are three Mongo collections with different purpose.
+
+1. **taskTemplates**
+
+    The collection contains predefined task definitions in JSON format. Here are defined
+what tasks can be created and executed by the service.
+
+2. **tasks**
+
+    The collection contains newly created tasks *pending* for execution. It acts like a 
+FIFO queue and is used by the task executor to retrieve tasks for workers to execute.
+
+3. **tasksHistory**
+
+    The collection contains successfully completed tasks for results querying,
+audit, reporting and debugging purposes.
+
+### Task List Storage
+
+In current implementation there are four Mongo collections with different purpose.
+
+1. **taskListTemplates**
+
+    The collection contains predefined task list definitions in JSON format. Each definition contains
+groups of tasks which must be instantiated and later executed as part of the task list.
+
+2. **taskLists**
+
+    The collection contains newly created task lists *pending* for execution. It acts like a
+FIFO queue and is used by the task list executor to retrieve task lists for workers to execute.
+
+3. **tasks**
+
+    The collection contains the tasks belonging to a group which is part of a task list. When a task list
+is fetched for execution, all tasks are fetched and executed for that particular task list.
+
+4. **tasksListHistory**
+
+    The collection contains completed task lists for results querying,
+audit, reporting and debugging purposes.
+
+### Event Task definition Storage
+
+In current implementation there is one Mongo collection for storing Event Task definitions.
+
+1. **eventTasks**
+
+    The collection contains predefined Event Task definitions in JSON format. Each definition 
+contains event metadata fields and a valid Task name. See: [cache event tasks](cache-event-task.md)
diff --git a/docs/task-list.md b/docs/task-list.md
index 93fc8a0b8475373535265df05c3bc5fe28b05000..999b867d3c2b8e98041cda0255f01ab83d8b0986 100644
--- a/docs/task-list.md
+++ b/docs/task-list.md
@@ -141,28 +141,4 @@ If there are multiple instances (pods) of the service, multiply by their number
 If this is not enough, the poll interval can be decreased, or we can slightly modify
 the polling function to fetch many task lists at once (and also increase the number of workers).
 
-To learn more about the queue and why we use database as queue see [queue](queue.md)
-
-### Task List Storage
-
-We use MongoDB for task list storage. There are three Mongo collections with different purpose.
-
-1. **taskListTemplates**
-
-The collection contains predefined task list definitions in JSON format. Each definition contains
-groups of tasks which must be instantiated and later executed as part of the task list.
-
-2. **taskLists**
-
-The collection contains newly created task lists *pending* for execution. It acts like a
-FIFO queue and is used by the task list executor to retrieve task lists for workers to execute.
-
-3. **tasks**
-
-The collection contains the tasks belonging to a group which is part of a task list. When a task list
-is fetched for execution, all tasks are fetched and executed for that particular task list. 
-
-4. **tasksListHistory**
-
-The collection contains completed task lists for results querying,
-audit, reporting and debugging purposes.
+To learn more about the queue and why we use database as queue see [queue](queue.md).
diff --git a/docs/task.md b/docs/task.md
index aed81cbec2a2a2f2f2b08b1b67d2f5556ebfab90..982455eee575245a0ec1515dd7b466196d102a1f 100644
--- a/docs/task.md
+++ b/docs/task.md
@@ -71,23 +71,4 @@ Maximum task retries specifies how many failed attempts to execute a single task
 to be made by workers before the task is removed from the queue. In the example above workers are going to
 execute a task 10 times and fail before the task is removed.
 
-To learn more about the queue and why we use database as queue see [queue](queue.md)
-
-### Task Storage
-
-We use MongoDB for tasks storage. There are three Mongo collections with different purpose.
-
-1. **taskTemplates**
-
-The collection contains predefined task definitions in JSON format. Here are defined
-what tasks can be created and executed by the service.
-
-2. **tasks**
-
-The collection contains newly created tasks *pending* for execution. It acts like a
-FIFO queue and is used by the task executor to retrieve tasks for workers to execute.
-
-3. **tasksHistory**
-
-The collection contains successfully completed tasks for results querying,
-audit, reporting and debugging purposes.
+To learn more about the queue and why current implementation uses database as queue see [queue](queue.md).
diff --git a/internal/clients/event/client.go b/internal/clients/event/client.go
index 8c1b7669b1ffcb88448315b3997e1a12cce4a3ab..efa6d15dbf8e89efb4ff019857145414d7df4351 100644
--- a/internal/clients/event/client.go
+++ b/internal/clients/event/client.go
@@ -11,19 +11,19 @@ import (
 	"github.com/google/uuid"
 
 	"gitlab.eclipse.org/eclipse/xfsc/tsa/golib/errors"
-	taskpkg "gitlab.eclipse.org/eclipse/xfsc/tsa/task/internal/service/task"
+	"gitlab.eclipse.org/eclipse/xfsc/tsa/task/internal/service"
 )
 
 const eventDataKey = "key"
 
 type Client struct {
-	storage  taskpkg.Storage
-	queue    taskpkg.Queue
+	storage  service.Storage
+	queue    service.Queue
 	consumer *nats.Consumer
 	events   cloudevents.Client
 }
 
-func New(s taskpkg.Storage, q taskpkg.Queue, addr, subject string) (*Client, error) {
+func New(s service.Storage, q service.Queue, addr, subject string) (*Client, error) {
 	// create cloudevents NATS consumer
 	// other protocol implementations: https://github.com/cloudevents/sdk-go/tree/main/protocol
 	c, err := nats.NewConsumer(addr, subject, nats.NatsOptions())
@@ -99,7 +99,7 @@ func (c *Client) handler(ctx context.Context, event cloudevents.Event) error {
 	return nil
 }
 
-func (c *Client) enqueueTask(ctx context.Context, eventTask *taskpkg.EventTask) error {
+func (c *Client) enqueueTask(ctx context.Context, eventTask *service.EventTask) error {
 	// get predefined task definition from storage
 	task, err := c.storage.TaskTemplate(ctx, eventTask.TaskName)
 	if err != nil {
@@ -116,7 +116,7 @@ func (c *Client) enqueueTask(ctx context.Context, eventTask *taskpkg.EventTask)
 	}
 
 	task.ID = uuid.NewString()
-	task.State = taskpkg.Created
+	task.State = service.Created
 	task.CreatedAt = time.Now()
 	task.Request = input
 
diff --git a/internal/executor/executor.go b/internal/executor/executor.go
index ee13e9954c660669864c7e090a81ad51d19e5968..81dc86e3cc08d41666d19b307bd8971d6811fbb5 100644
--- a/internal/executor/executor.go
+++ b/internal/executor/executor.go
@@ -9,7 +9,7 @@ import (
 	"go.uber.org/zap"
 
 	"gitlab.eclipse.org/eclipse/xfsc/tsa/golib/errors"
-	"gitlab.eclipse.org/eclipse/xfsc/tsa/task/internal/service/task"
+	"gitlab.eclipse.org/eclipse/xfsc/tsa/task/internal/service"
 )
 
 // Policy client.
@@ -17,26 +17,15 @@ type Policy interface {
 	Evaluate(ctx context.Context, policy string, data []byte) ([]byte, error)
 }
 
-// Queue allows retrieving, returning and deleting tasks from storage.
-type Queue interface {
-	Poll(ctx context.Context) (*task.Task, error)
-	Ack(ctx context.Context, task *task.Task) error
-	Unack(ctx context.Context, task *task.Task) error
-}
-
-type Storage interface {
-	SaveTaskHistory(ctx context.Context, task *task.Task) error
-}
-
 type Cache interface {
 	Set(ctx context.Context, key, namespace, scope string, value []byte) error
 	Get(ctx context.Context, key, namespace, scope string) ([]byte, error)
 }
 
 type Executor struct {
-	queue          Queue
+	queue          service.Queue
 	policy         Policy
-	storage        Storage
+	storage        service.Storage
 	cache          Cache
 	workers        int
 	pollInterval   time.Duration
@@ -47,9 +36,9 @@ type Executor struct {
 }
 
 func New(
-	queue Queue,
+	queue service.Queue,
 	policy Policy,
-	storage Storage,
+	storage service.Storage,
 	cache Cache,
 	workers int,
 	pollInterval time.Duration,
@@ -74,7 +63,7 @@ func (e *Executor) Start(ctx context.Context) error {
 	defer e.logger.Info("task executor stopped")
 
 	var wg sync.WaitGroup
-	tasks := make(chan *task.Task)
+	tasks := make(chan *service.Task)
 	for i := 0; i < e.workers; i++ {
 		wg.Add(1)
 		go func() {
diff --git a/internal/executor/worker.go b/internal/executor/worker.go
index 48685f1b8d6214c73cb5c8844573ee7400ae62f6..05053286302a0f4e680368875b66b9f6c0f5ebb0 100644
--- a/internal/executor/worker.go
+++ b/internal/executor/worker.go
@@ -10,14 +10,14 @@ import (
 	"go.uber.org/zap"
 
 	"gitlab.eclipse.org/eclipse/xfsc/tsa/golib/errors"
-	taskpkg "gitlab.eclipse.org/eclipse/xfsc/tsa/task/internal/service/task"
+	"gitlab.eclipse.org/eclipse/xfsc/tsa/task/internal/service"
 )
 
 type Worker struct {
-	tasks          chan *taskpkg.Task
-	queue          Queue
+	tasks          chan *service.Task
+	queue          service.Queue
 	policy         Policy
-	storage        Storage
+	storage        service.Storage
 	cache          Cache
 	maxTaskRetries int
 	httpClient     *http.Client
@@ -25,10 +25,10 @@ type Worker struct {
 }
 
 func newWorker(
-	tasks chan *taskpkg.Task,
-	queue Queue,
+	tasks chan *service.Task,
+	queue service.Queue,
 	policy Policy,
-	storage Storage,
+	storage service.Storage,
 	cache Cache,
 	maxTaskRetries int,
 	httpClient *http.Client,
@@ -107,7 +107,7 @@ func (w *Worker) Start(ctx context.Context) {
 	}
 }
 
-func (w *Worker) Execute(ctx context.Context, task *taskpkg.Task) (*taskpkg.Task, error) {
+func (w *Worker) Execute(ctx context.Context, task *service.Task) (*service.Task, error) {
 	task.StartedAt = time.Now()
 
 	var response []byte
@@ -153,12 +153,12 @@ func (w *Worker) Execute(ctx context.Context, task *taskpkg.Task) (*taskpkg.Task
 		task.Response = resp
 	}
 
-	task.State = taskpkg.Done
+	task.State = service.Done
 	task.FinishedAt = time.Now()
 	return task, nil
 }
 
-func (w *Worker) doHTTPTask(ctx context.Context, task *taskpkg.Task) (status int, response []byte, err error) {
+func (w *Worker) doHTTPTask(ctx context.Context, task *service.Task) (status int, response []byte, err error) {
 	req, err := http.NewRequest(task.Method, task.URL, bytes.NewReader(task.Request))
 	if err != nil {
 		return 0, nil, errors.New("error creating http request", err)
diff --git a/internal/listexecutor/listexecutor.go b/internal/listexecutor/listexecutor.go
index 18d0b2a3cccc3b212e60fa7ea31adbf45d4b0ffe..d3d78a7cdecb69eb9adebcdc4bf51a342ab6c0cf 100644
--- a/internal/listexecutor/listexecutor.go
+++ b/internal/listexecutor/listexecutor.go
@@ -14,8 +14,7 @@ import (
 	"gitlab.eclipse.org/eclipse/xfsc/tsa/golib/errors"
 	"gitlab.eclipse.org/eclipse/xfsc/tsa/golib/ptr"
 	goatasklist "gitlab.eclipse.org/eclipse/xfsc/tsa/task/gen/task_list"
-	taskpkg "gitlab.eclipse.org/eclipse/xfsc/tsa/task/internal/service/task"
-	"gitlab.eclipse.org/eclipse/xfsc/tsa/task/internal/service/tasklist"
+	"gitlab.eclipse.org/eclipse/xfsc/tsa/task/internal/service"
 )
 
 type token struct{}
@@ -30,28 +29,15 @@ type Policy interface {
 	Evaluate(ctx context.Context, policy string, data []byte) ([]byte, error)
 }
 
-// Queue allows retrieving, returning and deleting taskLists and group tasks from storage.
-type Queue interface {
-	PollList(ctx context.Context) (*tasklist.TaskList, error)
-	AckList(ctx context.Context, taskList *tasklist.TaskList) error
-	AckGroupTasks(ctx context.Context, group *tasklist.Group) error
-}
-
-type Storage interface {
-	GetGroupTasks(ctx context.Context, group *tasklist.Group) ([]*taskpkg.Task, error)
-	SaveTaskHistory(ctx context.Context, task *taskpkg.Task) error
-	SaveTaskListHistory(ctx context.Context, task *tasklist.TaskList) error
-}
-
 type Cache interface {
 	Set(ctx context.Context, key, namespace, scope string, value []byte) error
 	Get(ctx context.Context, key, namespace, scope string) ([]byte, error)
 }
 
 type ListExecutor struct {
-	queue        Queue
+	queue        service.Queue
 	policy       Policy
-	storage      Storage
+	storage      service.Storage
 	cache        Cache
 	workers      int
 	pollInterval time.Duration
@@ -61,9 +47,9 @@ type ListExecutor struct {
 }
 
 func New(
-	queue Queue,
+	queue service.Queue,
 	policy Policy,
-	storage Storage,
+	storage service.Storage,
 	cache Cache,
 	workers int,
 	pollInterval time.Duration,
@@ -105,7 +91,7 @@ loop:
 				continue
 			}
 
-			go func(list *tasklist.TaskList) {
+			go func(list *service.TaskList) {
 				l.Execute(ctx, list)
 				<-sem // release the semaphore
 			}(taskList)
@@ -120,12 +106,12 @@ loop:
 	return ctx.Err()
 }
 
-func (l *ListExecutor) Execute(ctx context.Context, list *tasklist.TaskList) {
+func (l *ListExecutor) Execute(ctx context.Context, list *service.TaskList) {
 	logger := l.logger.With(
 		zap.String("taskListID", list.ID),
 		zap.String("taskListName", list.Name),
 	)
-	list.State = taskpkg.Pending
+	list.State = service.Pending
 	list.StartedAt = time.Now()
 
 	var state goatasklist.TaskListStatusResponse
@@ -135,19 +121,19 @@ func (l *ListExecutor) Execute(ctx context.Context, list *tasklist.TaskList) {
 		groupState, err := l.executeGroup(ctx, &list.Groups[i])
 		if err != nil {
 			logger.Error("error executing group", zap.Error(err))
-			list.Groups[i].State = taskpkg.Failed
-			list.State = taskpkg.Failed
+			list.Groups[i].State = service.Failed
+			list.State = service.Failed
 		}
 		state.Groups = append(state.Groups, groupState)
 
 		//mark taskList as `Failed` if the group's state is `Failed`
-		if *groupState.Status == taskpkg.Failed {
-			list.State = taskpkg.Failed
+		if *groupState.Status == service.Failed {
+			list.State = service.Failed
 		}
 	}
 
-	if list.State != taskpkg.Failed {
-		list.State = taskpkg.Done
+	if list.State != service.Failed {
+		list.State = service.Done
 	}
 	list.FinishedAt = time.Now()
 
@@ -176,7 +162,7 @@ func (l *ListExecutor) Execute(ctx context.Context, list *tasklist.TaskList) {
 	}
 }
 
-func (l *ListExecutor) executeGroup(ctx context.Context, group *tasklist.Group) (*goatasklist.GroupStatus, error) {
+func (l *ListExecutor) executeGroup(ctx context.Context, group *service.Group) (*goatasklist.GroupStatus, error) {
 	switch exec := group.Execution; exec {
 	case sequential:
 		return l.executeSequential(ctx, group)
@@ -187,8 +173,8 @@ func (l *ListExecutor) executeGroup(ctx context.Context, group *tasklist.Group)
 	return nil, errors.New("unknown type of group execution")
 }
 
-func (l *ListExecutor) executeSequential(ctx context.Context, group *tasklist.Group) (*goatasklist.GroupStatus, error) {
-	group.State = taskpkg.Pending
+func (l *ListExecutor) executeSequential(ctx context.Context, group *service.Group) (*goatasklist.GroupStatus, error) {
+	group.State = service.Pending
 	var state goatasklist.GroupStatus
 
 	tasks, err := l.storage.GetGroupTasks(ctx, group)
@@ -207,9 +193,9 @@ func (l *ListExecutor) executeSequential(ctx context.Context, group *tasklist.Gr
 		)
 
 		// mark all subsequent tasks as failed if one task already failed
-		if group.State == taskpkg.Failed {
-			task.State = taskpkg.Failed
-			taskState.Status = ptr.String(taskpkg.Failed)
+		if group.State == service.Failed {
+			task.State = service.Failed
+			taskState.Status = ptr.String(service.Failed)
 			state.Tasks = append(state.Tasks, &taskState)
 			continue
 		}
@@ -217,10 +203,10 @@ func (l *ListExecutor) executeSequential(ctx context.Context, group *tasklist.Gr
 		task.Request = req
 		err := l.executeTask(ctx, task)
 		if err != nil {
-			task.State = taskpkg.Failed
-			taskState.Status = ptr.String(taskpkg.Failed)
+			task.State = service.Failed
+			taskState.Status = ptr.String(service.Failed)
 			state.Tasks = append(state.Tasks, &taskState)
-			group.State = taskpkg.Failed
+			group.State = service.Failed
 			logger.Error("error executing task", zap.Error(err))
 			continue
 		}
@@ -256,8 +242,8 @@ func (l *ListExecutor) executeSequential(ctx context.Context, group *tasklist.Gr
 		l.logger.With(zap.String("groupID", group.ID)).Error("failed to ack group tasks in queue", zap.Error(err))
 	}
 
-	if group.State != taskpkg.Failed {
-		group.State = taskpkg.Done
+	if group.State != service.Failed {
+		group.State = service.Done
 	}
 
 	state.ID = &group.ID
@@ -266,8 +252,8 @@ func (l *ListExecutor) executeSequential(ctx context.Context, group *tasklist.Gr
 	return &state, nil
 }
 
-func (l *ListExecutor) executeParallel(ctx context.Context, group *tasklist.Group) (*goatasklist.GroupStatus, error) {
-	group.State = taskpkg.Pending
+func (l *ListExecutor) executeParallel(ctx context.Context, group *service.Group) (*goatasklist.GroupStatus, error) {
+	group.State = service.Pending
 	var state goatasklist.GroupStatus
 
 	tasks, err := l.storage.GetGroupTasks(ctx, group)
@@ -278,7 +264,7 @@ func (l *ListExecutor) executeParallel(ctx context.Context, group *tasklist.Grou
 	var wg sync.WaitGroup
 	for _, task := range tasks {
 		wg.Add(1)
-		go func(t *taskpkg.Task) {
+		go func(t *service.Task) {
 			taskState := goatasklist.TaskStatus{
 				ID: &t.ID,
 			}
@@ -292,10 +278,10 @@ func (l *ListExecutor) executeParallel(ctx context.Context, group *tasklist.Grou
 			t.Request = group.Request
 
 			if err := l.executeTask(ctx, t); err != nil {
-				t.State = taskpkg.Failed
-				taskState.Status = ptr.String(taskpkg.Failed)
+				t.State = service.Failed
+				taskState.Status = ptr.String(service.Failed)
 				state.Tasks = append(state.Tasks, &taskState)
-				group.State = taskpkg.Failed
+				group.State = service.Failed
 				logger.Error("error executing task", zap.Error(err))
 				return
 			}
@@ -332,8 +318,8 @@ func (l *ListExecutor) executeParallel(ctx context.Context, group *tasklist.Grou
 		l.logger.With(zap.String("groupID", group.ID)).Error("failed to ack group tasks in queue", zap.Error(err))
 	}
 
-	if group.State != taskpkg.Failed {
-		group.State = taskpkg.Done
+	if group.State != service.Failed {
+		group.State = service.Done
 	}
 
 	state.ID = &group.ID
@@ -342,7 +328,7 @@ func (l *ListExecutor) executeParallel(ctx context.Context, group *tasklist.Grou
 	return &state, nil
 }
 
-func (l *ListExecutor) executeTask(ctx context.Context, task *taskpkg.Task) error {
+func (l *ListExecutor) executeTask(ctx context.Context, task *service.Task) error {
 	task.StartedAt = time.Now()
 
 	var response []byte
@@ -388,12 +374,12 @@ func (l *ListExecutor) executeTask(ctx context.Context, task *taskpkg.Task) erro
 		task.Response = resp
 	}
 
-	task.State = taskpkg.Done
+	task.State = service.Done
 	task.FinishedAt = time.Now()
 	return nil
 }
 
-func (l *ListExecutor) doHTTPTask(ctx context.Context, task *taskpkg.Task) (status int, response []byte, err error) {
+func (l *ListExecutor) doHTTPTask(ctx context.Context, task *service.Task) (status int, response []byte, err error) {
 	reqBody := task.Request
 	if task.Method == http.MethodGet {
 		reqBody = nil
diff --git a/internal/service/queue.go b/internal/service/queue.go
new file mode 100644
index 0000000000000000000000000000000000000000..9f5e310adcc226f30e78cb2d053b74e1ebfa4393
--- /dev/null
+++ b/internal/service/queue.go
@@ -0,0 +1,19 @@
+package service
+
+import "context"
+
+//go:generate counterfeiter . Queue
+
+type Queue interface {
+	// Task related methods
+	Add(ctx context.Context, task *Task) error
+	Poll(ctx context.Context) (*Task, error)
+	Ack(ctx context.Context, task *Task) error
+	Unack(ctx context.Context, task *Task) error
+
+	// TaskList related methods
+	AddTaskList(ctx context.Context, taskList *TaskList, tasks []*Task) error
+	PollList(ctx context.Context) (*TaskList, error)
+	AckList(ctx context.Context, taskList *TaskList) error
+	AckGroupTasks(ctx context.Context, group *Group) error
+}
diff --git a/internal/service/servicefakes/fake_queue.go b/internal/service/servicefakes/fake_queue.go
new file mode 100644
index 0000000000000000000000000000000000000000..97973e502193438fa7a6fc0e1f2c22efdc456ce1
--- /dev/null
+++ b/internal/service/servicefakes/fake_queue.go
@@ -0,0 +1,659 @@
+// Code generated by counterfeiter. DO NOT EDIT.
+package servicefakes
+
+import (
+	"context"
+	"sync"
+
+	"gitlab.eclipse.org/eclipse/xfsc/tsa/task/internal/service"
+)
+
+type FakeQueue struct {
+	AckStub        func(context.Context, *service.Task) error
+	ackMutex       sync.RWMutex
+	ackArgsForCall []struct {
+		arg1 context.Context
+		arg2 *service.Task
+	}
+	ackReturns struct {
+		result1 error
+	}
+	ackReturnsOnCall map[int]struct {
+		result1 error
+	}
+	AckGroupTasksStub        func(context.Context, *service.Group) error
+	ackGroupTasksMutex       sync.RWMutex
+	ackGroupTasksArgsForCall []struct {
+		arg1 context.Context
+		arg2 *service.Group
+	}
+	ackGroupTasksReturns struct {
+		result1 error
+	}
+	ackGroupTasksReturnsOnCall map[int]struct {
+		result1 error
+	}
+	AckListStub        func(context.Context, *service.TaskList) error
+	ackListMutex       sync.RWMutex
+	ackListArgsForCall []struct {
+		arg1 context.Context
+		arg2 *service.TaskList
+	}
+	ackListReturns struct {
+		result1 error
+	}
+	ackListReturnsOnCall map[int]struct {
+		result1 error
+	}
+	AddStub        func(context.Context, *service.Task) error
+	addMutex       sync.RWMutex
+	addArgsForCall []struct {
+		arg1 context.Context
+		arg2 *service.Task
+	}
+	addReturns struct {
+		result1 error
+	}
+	addReturnsOnCall map[int]struct {
+		result1 error
+	}
+	AddTaskListStub        func(context.Context, *service.TaskList, []*service.Task) error
+	addTaskListMutex       sync.RWMutex
+	addTaskListArgsForCall []struct {
+		arg1 context.Context
+		arg2 *service.TaskList
+		arg3 []*service.Task
+	}
+	addTaskListReturns struct {
+		result1 error
+	}
+	addTaskListReturnsOnCall map[int]struct {
+		result1 error
+	}
+	PollStub        func(context.Context) (*service.Task, error)
+	pollMutex       sync.RWMutex
+	pollArgsForCall []struct {
+		arg1 context.Context
+	}
+	pollReturns struct {
+		result1 *service.Task
+		result2 error
+	}
+	pollReturnsOnCall map[int]struct {
+		result1 *service.Task
+		result2 error
+	}
+	PollListStub        func(context.Context) (*service.TaskList, error)
+	pollListMutex       sync.RWMutex
+	pollListArgsForCall []struct {
+		arg1 context.Context
+	}
+	pollListReturns struct {
+		result1 *service.TaskList
+		result2 error
+	}
+	pollListReturnsOnCall map[int]struct {
+		result1 *service.TaskList
+		result2 error
+	}
+	UnackStub        func(context.Context, *service.Task) error
+	unackMutex       sync.RWMutex
+	unackArgsForCall []struct {
+		arg1 context.Context
+		arg2 *service.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 *service.Task) error {
+	fake.ackMutex.Lock()
+	ret, specificReturn := fake.ackReturnsOnCall[len(fake.ackArgsForCall)]
+	fake.ackArgsForCall = append(fake.ackArgsForCall, struct {
+		arg1 context.Context
+		arg2 *service.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, *service.Task) error) {
+	fake.ackMutex.Lock()
+	defer fake.ackMutex.Unlock()
+	fake.AckStub = stub
+}
+
+func (fake *FakeQueue) AckArgsForCall(i int) (context.Context, *service.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) AckGroupTasks(arg1 context.Context, arg2 *service.Group) error {
+	fake.ackGroupTasksMutex.Lock()
+	ret, specificReturn := fake.ackGroupTasksReturnsOnCall[len(fake.ackGroupTasksArgsForCall)]
+	fake.ackGroupTasksArgsForCall = append(fake.ackGroupTasksArgsForCall, struct {
+		arg1 context.Context
+		arg2 *service.Group
+	}{arg1, arg2})
+	stub := fake.AckGroupTasksStub
+	fakeReturns := fake.ackGroupTasksReturns
+	fake.recordInvocation("AckGroupTasks", []interface{}{arg1, arg2})
+	fake.ackGroupTasksMutex.Unlock()
+	if stub != nil {
+		return stub(arg1, arg2)
+	}
+	if specificReturn {
+		return ret.result1
+	}
+	return fakeReturns.result1
+}
+
+func (fake *FakeQueue) AckGroupTasksCallCount() int {
+	fake.ackGroupTasksMutex.RLock()
+	defer fake.ackGroupTasksMutex.RUnlock()
+	return len(fake.ackGroupTasksArgsForCall)
+}
+
+func (fake *FakeQueue) AckGroupTasksCalls(stub func(context.Context, *service.Group) error) {
+	fake.ackGroupTasksMutex.Lock()
+	defer fake.ackGroupTasksMutex.Unlock()
+	fake.AckGroupTasksStub = stub
+}
+
+func (fake *FakeQueue) AckGroupTasksArgsForCall(i int) (context.Context, *service.Group) {
+	fake.ackGroupTasksMutex.RLock()
+	defer fake.ackGroupTasksMutex.RUnlock()
+	argsForCall := fake.ackGroupTasksArgsForCall[i]
+	return argsForCall.arg1, argsForCall.arg2
+}
+
+func (fake *FakeQueue) AckGroupTasksReturns(result1 error) {
+	fake.ackGroupTasksMutex.Lock()
+	defer fake.ackGroupTasksMutex.Unlock()
+	fake.AckGroupTasksStub = nil
+	fake.ackGroupTasksReturns = struct {
+		result1 error
+	}{result1}
+}
+
+func (fake *FakeQueue) AckGroupTasksReturnsOnCall(i int, result1 error) {
+	fake.ackGroupTasksMutex.Lock()
+	defer fake.ackGroupTasksMutex.Unlock()
+	fake.AckGroupTasksStub = nil
+	if fake.ackGroupTasksReturnsOnCall == nil {
+		fake.ackGroupTasksReturnsOnCall = make(map[int]struct {
+			result1 error
+		})
+	}
+	fake.ackGroupTasksReturnsOnCall[i] = struct {
+		result1 error
+	}{result1}
+}
+
+func (fake *FakeQueue) AckList(arg1 context.Context, arg2 *service.TaskList) error {
+	fake.ackListMutex.Lock()
+	ret, specificReturn := fake.ackListReturnsOnCall[len(fake.ackListArgsForCall)]
+	fake.ackListArgsForCall = append(fake.ackListArgsForCall, struct {
+		arg1 context.Context
+		arg2 *service.TaskList
+	}{arg1, arg2})
+	stub := fake.AckListStub
+	fakeReturns := fake.ackListReturns
+	fake.recordInvocation("AckList", []interface{}{arg1, arg2})
+	fake.ackListMutex.Unlock()
+	if stub != nil {
+		return stub(arg1, arg2)
+	}
+	if specificReturn {
+		return ret.result1
+	}
+	return fakeReturns.result1
+}
+
+func (fake *FakeQueue) AckListCallCount() int {
+	fake.ackListMutex.RLock()
+	defer fake.ackListMutex.RUnlock()
+	return len(fake.ackListArgsForCall)
+}
+
+func (fake *FakeQueue) AckListCalls(stub func(context.Context, *service.TaskList) error) {
+	fake.ackListMutex.Lock()
+	defer fake.ackListMutex.Unlock()
+	fake.AckListStub = stub
+}
+
+func (fake *FakeQueue) AckListArgsForCall(i int) (context.Context, *service.TaskList) {
+	fake.ackListMutex.RLock()
+	defer fake.ackListMutex.RUnlock()
+	argsForCall := fake.ackListArgsForCall[i]
+	return argsForCall.arg1, argsForCall.arg2
+}
+
+func (fake *FakeQueue) AckListReturns(result1 error) {
+	fake.ackListMutex.Lock()
+	defer fake.ackListMutex.Unlock()
+	fake.AckListStub = nil
+	fake.ackListReturns = struct {
+		result1 error
+	}{result1}
+}
+
+func (fake *FakeQueue) AckListReturnsOnCall(i int, result1 error) {
+	fake.ackListMutex.Lock()
+	defer fake.ackListMutex.Unlock()
+	fake.AckListStub = nil
+	if fake.ackListReturnsOnCall == nil {
+		fake.ackListReturnsOnCall = make(map[int]struct {
+			result1 error
+		})
+	}
+	fake.ackListReturnsOnCall[i] = struct {
+		result1 error
+	}{result1}
+}
+
+func (fake *FakeQueue) Add(arg1 context.Context, arg2 *service.Task) error {
+	fake.addMutex.Lock()
+	ret, specificReturn := fake.addReturnsOnCall[len(fake.addArgsForCall)]
+	fake.addArgsForCall = append(fake.addArgsForCall, struct {
+		arg1 context.Context
+		arg2 *service.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, *service.Task) error) {
+	fake.addMutex.Lock()
+	defer fake.addMutex.Unlock()
+	fake.AddStub = stub
+}
+
+func (fake *FakeQueue) AddArgsForCall(i int) (context.Context, *service.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) AddTaskList(arg1 context.Context, arg2 *service.TaskList, arg3 []*service.Task) error {
+	var arg3Copy []*service.Task
+	if arg3 != nil {
+		arg3Copy = make([]*service.Task, len(arg3))
+		copy(arg3Copy, arg3)
+	}
+	fake.addTaskListMutex.Lock()
+	ret, specificReturn := fake.addTaskListReturnsOnCall[len(fake.addTaskListArgsForCall)]
+	fake.addTaskListArgsForCall = append(fake.addTaskListArgsForCall, struct {
+		arg1 context.Context
+		arg2 *service.TaskList
+		arg3 []*service.Task
+	}{arg1, arg2, arg3Copy})
+	stub := fake.AddTaskListStub
+	fakeReturns := fake.addTaskListReturns
+	fake.recordInvocation("AddTaskList", []interface{}{arg1, arg2, arg3Copy})
+	fake.addTaskListMutex.Unlock()
+	if stub != nil {
+		return stub(arg1, arg2, arg3)
+	}
+	if specificReturn {
+		return ret.result1
+	}
+	return fakeReturns.result1
+}
+
+func (fake *FakeQueue) AddTaskListCallCount() int {
+	fake.addTaskListMutex.RLock()
+	defer fake.addTaskListMutex.RUnlock()
+	return len(fake.addTaskListArgsForCall)
+}
+
+func (fake *FakeQueue) AddTaskListCalls(stub func(context.Context, *service.TaskList, []*service.Task) error) {
+	fake.addTaskListMutex.Lock()
+	defer fake.addTaskListMutex.Unlock()
+	fake.AddTaskListStub = stub
+}
+
+func (fake *FakeQueue) AddTaskListArgsForCall(i int) (context.Context, *service.TaskList, []*service.Task) {
+	fake.addTaskListMutex.RLock()
+	defer fake.addTaskListMutex.RUnlock()
+	argsForCall := fake.addTaskListArgsForCall[i]
+	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
+}
+
+func (fake *FakeQueue) AddTaskListReturns(result1 error) {
+	fake.addTaskListMutex.Lock()
+	defer fake.addTaskListMutex.Unlock()
+	fake.AddTaskListStub = nil
+	fake.addTaskListReturns = struct {
+		result1 error
+	}{result1}
+}
+
+func (fake *FakeQueue) AddTaskListReturnsOnCall(i int, result1 error) {
+	fake.addTaskListMutex.Lock()
+	defer fake.addTaskListMutex.Unlock()
+	fake.AddTaskListStub = nil
+	if fake.addTaskListReturnsOnCall == nil {
+		fake.addTaskListReturnsOnCall = make(map[int]struct {
+			result1 error
+		})
+	}
+	fake.addTaskListReturnsOnCall[i] = struct {
+		result1 error
+	}{result1}
+}
+
+func (fake *FakeQueue) Poll(arg1 context.Context) (*service.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) (*service.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 *service.Task, result2 error) {
+	fake.pollMutex.Lock()
+	defer fake.pollMutex.Unlock()
+	fake.PollStub = nil
+	fake.pollReturns = struct {
+		result1 *service.Task
+		result2 error
+	}{result1, result2}
+}
+
+func (fake *FakeQueue) PollReturnsOnCall(i int, result1 *service.Task, result2 error) {
+	fake.pollMutex.Lock()
+	defer fake.pollMutex.Unlock()
+	fake.PollStub = nil
+	if fake.pollReturnsOnCall == nil {
+		fake.pollReturnsOnCall = make(map[int]struct {
+			result1 *service.Task
+			result2 error
+		})
+	}
+	fake.pollReturnsOnCall[i] = struct {
+		result1 *service.Task
+		result2 error
+	}{result1, result2}
+}
+
+func (fake *FakeQueue) PollList(arg1 context.Context) (*service.TaskList, error) {
+	fake.pollListMutex.Lock()
+	ret, specificReturn := fake.pollListReturnsOnCall[len(fake.pollListArgsForCall)]
+	fake.pollListArgsForCall = append(fake.pollListArgsForCall, struct {
+		arg1 context.Context
+	}{arg1})
+	stub := fake.PollListStub
+	fakeReturns := fake.pollListReturns
+	fake.recordInvocation("PollList", []interface{}{arg1})
+	fake.pollListMutex.Unlock()
+	if stub != nil {
+		return stub(arg1)
+	}
+	if specificReturn {
+		return ret.result1, ret.result2
+	}
+	return fakeReturns.result1, fakeReturns.result2
+}
+
+func (fake *FakeQueue) PollListCallCount() int {
+	fake.pollListMutex.RLock()
+	defer fake.pollListMutex.RUnlock()
+	return len(fake.pollListArgsForCall)
+}
+
+func (fake *FakeQueue) PollListCalls(stub func(context.Context) (*service.TaskList, error)) {
+	fake.pollListMutex.Lock()
+	defer fake.pollListMutex.Unlock()
+	fake.PollListStub = stub
+}
+
+func (fake *FakeQueue) PollListArgsForCall(i int) context.Context {
+	fake.pollListMutex.RLock()
+	defer fake.pollListMutex.RUnlock()
+	argsForCall := fake.pollListArgsForCall[i]
+	return argsForCall.arg1
+}
+
+func (fake *FakeQueue) PollListReturns(result1 *service.TaskList, result2 error) {
+	fake.pollListMutex.Lock()
+	defer fake.pollListMutex.Unlock()
+	fake.PollListStub = nil
+	fake.pollListReturns = struct {
+		result1 *service.TaskList
+		result2 error
+	}{result1, result2}
+}
+
+func (fake *FakeQueue) PollListReturnsOnCall(i int, result1 *service.TaskList, result2 error) {
+	fake.pollListMutex.Lock()
+	defer fake.pollListMutex.Unlock()
+	fake.PollListStub = nil
+	if fake.pollListReturnsOnCall == nil {
+		fake.pollListReturnsOnCall = make(map[int]struct {
+			result1 *service.TaskList
+			result2 error
+		})
+	}
+	fake.pollListReturnsOnCall[i] = struct {
+		result1 *service.TaskList
+		result2 error
+	}{result1, result2}
+}
+
+func (fake *FakeQueue) Unack(arg1 context.Context, arg2 *service.Task) error {
+	fake.unackMutex.Lock()
+	ret, specificReturn := fake.unackReturnsOnCall[len(fake.unackArgsForCall)]
+	fake.unackArgsForCall = append(fake.unackArgsForCall, struct {
+		arg1 context.Context
+		arg2 *service.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, *service.Task) error) {
+	fake.unackMutex.Lock()
+	defer fake.unackMutex.Unlock()
+	fake.UnackStub = stub
+}
+
+func (fake *FakeQueue) UnackArgsForCall(i int) (context.Context, *service.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.ackGroupTasksMutex.RLock()
+	defer fake.ackGroupTasksMutex.RUnlock()
+	fake.ackListMutex.RLock()
+	defer fake.ackListMutex.RUnlock()
+	fake.addMutex.RLock()
+	defer fake.addMutex.RUnlock()
+	fake.addTaskListMutex.RLock()
+	defer fake.addTaskListMutex.RUnlock()
+	fake.pollMutex.RLock()
+	defer fake.pollMutex.RUnlock()
+	fake.pollListMutex.RLock()
+	defer fake.pollListMutex.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 _ service.Queue = new(FakeQueue)
diff --git a/internal/service/servicefakes/fake_storage.go b/internal/service/servicefakes/fake_storage.go
new file mode 100644
index 0000000000000000000000000000000000000000..a4614864a30ae271301f317c3ee679e3c67cae9d
--- /dev/null
+++ b/internal/service/servicefakes/fake_storage.go
@@ -0,0 +1,928 @@
+// Code generated by counterfeiter. DO NOT EDIT.
+package servicefakes
+
+import (
+	"context"
+	"sync"
+
+	"gitlab.eclipse.org/eclipse/xfsc/tsa/task/internal/service"
+)
+
+type FakeStorage struct {
+	EventTaskStub        func(context.Context, string, string, string) (*service.EventTask, error)
+	eventTaskMutex       sync.RWMutex
+	eventTaskArgsForCall []struct {
+		arg1 context.Context
+		arg2 string
+		arg3 string
+		arg4 string
+	}
+	eventTaskReturns struct {
+		result1 *service.EventTask
+		result2 error
+	}
+	eventTaskReturnsOnCall map[int]struct {
+		result1 *service.EventTask
+		result2 error
+	}
+	GetGroupTasksStub        func(context.Context, *service.Group) ([]*service.Task, error)
+	getGroupTasksMutex       sync.RWMutex
+	getGroupTasksArgsForCall []struct {
+		arg1 context.Context
+		arg2 *service.Group
+	}
+	getGroupTasksReturns struct {
+		result1 []*service.Task
+		result2 error
+	}
+	getGroupTasksReturnsOnCall map[int]struct {
+		result1 []*service.Task
+		result2 error
+	}
+	SaveTaskHistoryStub        func(context.Context, *service.Task) error
+	saveTaskHistoryMutex       sync.RWMutex
+	saveTaskHistoryArgsForCall []struct {
+		arg1 context.Context
+		arg2 *service.Task
+	}
+	saveTaskHistoryReturns struct {
+		result1 error
+	}
+	saveTaskHistoryReturnsOnCall map[int]struct {
+		result1 error
+	}
+	SaveTaskListHistoryStub        func(context.Context, *service.TaskList) error
+	saveTaskListHistoryMutex       sync.RWMutex
+	saveTaskListHistoryArgsForCall []struct {
+		arg1 context.Context
+		arg2 *service.TaskList
+	}
+	saveTaskListHistoryReturns struct {
+		result1 error
+	}
+	saveTaskListHistoryReturnsOnCall map[int]struct {
+		result1 error
+	}
+	TaskStub        func(context.Context, string) (*service.Task, error)
+	taskMutex       sync.RWMutex
+	taskArgsForCall []struct {
+		arg1 context.Context
+		arg2 string
+	}
+	taskReturns struct {
+		result1 *service.Task
+		result2 error
+	}
+	taskReturnsOnCall map[int]struct {
+		result1 *service.Task
+		result2 error
+	}
+	TaskHistoryStub        func(context.Context, string) (*service.Task, error)
+	taskHistoryMutex       sync.RWMutex
+	taskHistoryArgsForCall []struct {
+		arg1 context.Context
+		arg2 string
+	}
+	taskHistoryReturns struct {
+		result1 *service.Task
+		result2 error
+	}
+	taskHistoryReturnsOnCall map[int]struct {
+		result1 *service.Task
+		result2 error
+	}
+	TaskListStub        func(context.Context, string) (*service.TaskList, error)
+	taskListMutex       sync.RWMutex
+	taskListArgsForCall []struct {
+		arg1 context.Context
+		arg2 string
+	}
+	taskListReturns struct {
+		result1 *service.TaskList
+		result2 error
+	}
+	taskListReturnsOnCall map[int]struct {
+		result1 *service.TaskList
+		result2 error
+	}
+	TaskListHistoryStub        func(context.Context, string) (*service.TaskList, error)
+	taskListHistoryMutex       sync.RWMutex
+	taskListHistoryArgsForCall []struct {
+		arg1 context.Context
+		arg2 string
+	}
+	taskListHistoryReturns struct {
+		result1 *service.TaskList
+		result2 error
+	}
+	taskListHistoryReturnsOnCall map[int]struct {
+		result1 *service.TaskList
+		result2 error
+	}
+	TaskListTemplateStub        func(context.Context, string) (*service.Template, error)
+	taskListTemplateMutex       sync.RWMutex
+	taskListTemplateArgsForCall []struct {
+		arg1 context.Context
+		arg2 string
+	}
+	taskListTemplateReturns struct {
+		result1 *service.Template
+		result2 error
+	}
+	taskListTemplateReturnsOnCall map[int]struct {
+		result1 *service.Template
+		result2 error
+	}
+	TaskTemplateStub        func(context.Context, string) (*service.Task, error)
+	taskTemplateMutex       sync.RWMutex
+	taskTemplateArgsForCall []struct {
+		arg1 context.Context
+		arg2 string
+	}
+	taskTemplateReturns struct {
+		result1 *service.Task
+		result2 error
+	}
+	taskTemplateReturnsOnCall map[int]struct {
+		result1 *service.Task
+		result2 error
+	}
+	TaskTemplatesStub        func(context.Context, []string) (map[string]*service.Task, error)
+	taskTemplatesMutex       sync.RWMutex
+	taskTemplatesArgsForCall []struct {
+		arg1 context.Context
+		arg2 []string
+	}
+	taskTemplatesReturns struct {
+		result1 map[string]*service.Task
+		result2 error
+	}
+	taskTemplatesReturnsOnCall map[int]struct {
+		result1 map[string]*service.Task
+		result2 error
+	}
+	invocations      map[string][][]interface{}
+	invocationsMutex sync.RWMutex
+}
+
+func (fake *FakeStorage) EventTask(arg1 context.Context, arg2 string, arg3 string, arg4 string) (*service.EventTask, error) {
+	fake.eventTaskMutex.Lock()
+	ret, specificReturn := fake.eventTaskReturnsOnCall[len(fake.eventTaskArgsForCall)]
+	fake.eventTaskArgsForCall = append(fake.eventTaskArgsForCall, struct {
+		arg1 context.Context
+		arg2 string
+		arg3 string
+		arg4 string
+	}{arg1, arg2, arg3, arg4})
+	stub := fake.EventTaskStub
+	fakeReturns := fake.eventTaskReturns
+	fake.recordInvocation("EventTask", []interface{}{arg1, arg2, arg3, arg4})
+	fake.eventTaskMutex.Unlock()
+	if stub != nil {
+		return stub(arg1, arg2, arg3, arg4)
+	}
+	if specificReturn {
+		return ret.result1, ret.result2
+	}
+	return fakeReturns.result1, fakeReturns.result2
+}
+
+func (fake *FakeStorage) EventTaskCallCount() int {
+	fake.eventTaskMutex.RLock()
+	defer fake.eventTaskMutex.RUnlock()
+	return len(fake.eventTaskArgsForCall)
+}
+
+func (fake *FakeStorage) EventTaskCalls(stub func(context.Context, string, string, string) (*service.EventTask, error)) {
+	fake.eventTaskMutex.Lock()
+	defer fake.eventTaskMutex.Unlock()
+	fake.EventTaskStub = stub
+}
+
+func (fake *FakeStorage) EventTaskArgsForCall(i int) (context.Context, string, string, string) {
+	fake.eventTaskMutex.RLock()
+	defer fake.eventTaskMutex.RUnlock()
+	argsForCall := fake.eventTaskArgsForCall[i]
+	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4
+}
+
+func (fake *FakeStorage) EventTaskReturns(result1 *service.EventTask, result2 error) {
+	fake.eventTaskMutex.Lock()
+	defer fake.eventTaskMutex.Unlock()
+	fake.EventTaskStub = nil
+	fake.eventTaskReturns = struct {
+		result1 *service.EventTask
+		result2 error
+	}{result1, result2}
+}
+
+func (fake *FakeStorage) EventTaskReturnsOnCall(i int, result1 *service.EventTask, result2 error) {
+	fake.eventTaskMutex.Lock()
+	defer fake.eventTaskMutex.Unlock()
+	fake.EventTaskStub = nil
+	if fake.eventTaskReturnsOnCall == nil {
+		fake.eventTaskReturnsOnCall = make(map[int]struct {
+			result1 *service.EventTask
+			result2 error
+		})
+	}
+	fake.eventTaskReturnsOnCall[i] = struct {
+		result1 *service.EventTask
+		result2 error
+	}{result1, result2}
+}
+
+func (fake *FakeStorage) GetGroupTasks(arg1 context.Context, arg2 *service.Group) ([]*service.Task, error) {
+	fake.getGroupTasksMutex.Lock()
+	ret, specificReturn := fake.getGroupTasksReturnsOnCall[len(fake.getGroupTasksArgsForCall)]
+	fake.getGroupTasksArgsForCall = append(fake.getGroupTasksArgsForCall, struct {
+		arg1 context.Context
+		arg2 *service.Group
+	}{arg1, arg2})
+	stub := fake.GetGroupTasksStub
+	fakeReturns := fake.getGroupTasksReturns
+	fake.recordInvocation("GetGroupTasks", []interface{}{arg1, arg2})
+	fake.getGroupTasksMutex.Unlock()
+	if stub != nil {
+		return stub(arg1, arg2)
+	}
+	if specificReturn {
+		return ret.result1, ret.result2
+	}
+	return fakeReturns.result1, fakeReturns.result2
+}
+
+func (fake *FakeStorage) GetGroupTasksCallCount() int {
+	fake.getGroupTasksMutex.RLock()
+	defer fake.getGroupTasksMutex.RUnlock()
+	return len(fake.getGroupTasksArgsForCall)
+}
+
+func (fake *FakeStorage) GetGroupTasksCalls(stub func(context.Context, *service.Group) ([]*service.Task, error)) {
+	fake.getGroupTasksMutex.Lock()
+	defer fake.getGroupTasksMutex.Unlock()
+	fake.GetGroupTasksStub = stub
+}
+
+func (fake *FakeStorage) GetGroupTasksArgsForCall(i int) (context.Context, *service.Group) {
+	fake.getGroupTasksMutex.RLock()
+	defer fake.getGroupTasksMutex.RUnlock()
+	argsForCall := fake.getGroupTasksArgsForCall[i]
+	return argsForCall.arg1, argsForCall.arg2
+}
+
+func (fake *FakeStorage) GetGroupTasksReturns(result1 []*service.Task, result2 error) {
+	fake.getGroupTasksMutex.Lock()
+	defer fake.getGroupTasksMutex.Unlock()
+	fake.GetGroupTasksStub = nil
+	fake.getGroupTasksReturns = struct {
+		result1 []*service.Task
+		result2 error
+	}{result1, result2}
+}
+
+func (fake *FakeStorage) GetGroupTasksReturnsOnCall(i int, result1 []*service.Task, result2 error) {
+	fake.getGroupTasksMutex.Lock()
+	defer fake.getGroupTasksMutex.Unlock()
+	fake.GetGroupTasksStub = nil
+	if fake.getGroupTasksReturnsOnCall == nil {
+		fake.getGroupTasksReturnsOnCall = make(map[int]struct {
+			result1 []*service.Task
+			result2 error
+		})
+	}
+	fake.getGroupTasksReturnsOnCall[i] = struct {
+		result1 []*service.Task
+		result2 error
+	}{result1, result2}
+}
+
+func (fake *FakeStorage) SaveTaskHistory(arg1 context.Context, arg2 *service.Task) error {
+	fake.saveTaskHistoryMutex.Lock()
+	ret, specificReturn := fake.saveTaskHistoryReturnsOnCall[len(fake.saveTaskHistoryArgsForCall)]
+	fake.saveTaskHistoryArgsForCall = append(fake.saveTaskHistoryArgsForCall, struct {
+		arg1 context.Context
+		arg2 *service.Task
+	}{arg1, arg2})
+	stub := fake.SaveTaskHistoryStub
+	fakeReturns := fake.saveTaskHistoryReturns
+	fake.recordInvocation("SaveTaskHistory", []interface{}{arg1, arg2})
+	fake.saveTaskHistoryMutex.Unlock()
+	if stub != nil {
+		return stub(arg1, arg2)
+	}
+	if specificReturn {
+		return ret.result1
+	}
+	return fakeReturns.result1
+}
+
+func (fake *FakeStorage) SaveTaskHistoryCallCount() int {
+	fake.saveTaskHistoryMutex.RLock()
+	defer fake.saveTaskHistoryMutex.RUnlock()
+	return len(fake.saveTaskHistoryArgsForCall)
+}
+
+func (fake *FakeStorage) SaveTaskHistoryCalls(stub func(context.Context, *service.Task) error) {
+	fake.saveTaskHistoryMutex.Lock()
+	defer fake.saveTaskHistoryMutex.Unlock()
+	fake.SaveTaskHistoryStub = stub
+}
+
+func (fake *FakeStorage) SaveTaskHistoryArgsForCall(i int) (context.Context, *service.Task) {
+	fake.saveTaskHistoryMutex.RLock()
+	defer fake.saveTaskHistoryMutex.RUnlock()
+	argsForCall := fake.saveTaskHistoryArgsForCall[i]
+	return argsForCall.arg1, argsForCall.arg2
+}
+
+func (fake *FakeStorage) SaveTaskHistoryReturns(result1 error) {
+	fake.saveTaskHistoryMutex.Lock()
+	defer fake.saveTaskHistoryMutex.Unlock()
+	fake.SaveTaskHistoryStub = nil
+	fake.saveTaskHistoryReturns = struct {
+		result1 error
+	}{result1}
+}
+
+func (fake *FakeStorage) SaveTaskHistoryReturnsOnCall(i int, result1 error) {
+	fake.saveTaskHistoryMutex.Lock()
+	defer fake.saveTaskHistoryMutex.Unlock()
+	fake.SaveTaskHistoryStub = nil
+	if fake.saveTaskHistoryReturnsOnCall == nil {
+		fake.saveTaskHistoryReturnsOnCall = make(map[int]struct {
+			result1 error
+		})
+	}
+	fake.saveTaskHistoryReturnsOnCall[i] = struct {
+		result1 error
+	}{result1}
+}
+
+func (fake *FakeStorage) SaveTaskListHistory(arg1 context.Context, arg2 *service.TaskList) error {
+	fake.saveTaskListHistoryMutex.Lock()
+	ret, specificReturn := fake.saveTaskListHistoryReturnsOnCall[len(fake.saveTaskListHistoryArgsForCall)]
+	fake.saveTaskListHistoryArgsForCall = append(fake.saveTaskListHistoryArgsForCall, struct {
+		arg1 context.Context
+		arg2 *service.TaskList
+	}{arg1, arg2})
+	stub := fake.SaveTaskListHistoryStub
+	fakeReturns := fake.saveTaskListHistoryReturns
+	fake.recordInvocation("SaveTaskListHistory", []interface{}{arg1, arg2})
+	fake.saveTaskListHistoryMutex.Unlock()
+	if stub != nil {
+		return stub(arg1, arg2)
+	}
+	if specificReturn {
+		return ret.result1
+	}
+	return fakeReturns.result1
+}
+
+func (fake *FakeStorage) SaveTaskListHistoryCallCount() int {
+	fake.saveTaskListHistoryMutex.RLock()
+	defer fake.saveTaskListHistoryMutex.RUnlock()
+	return len(fake.saveTaskListHistoryArgsForCall)
+}
+
+func (fake *FakeStorage) SaveTaskListHistoryCalls(stub func(context.Context, *service.TaskList) error) {
+	fake.saveTaskListHistoryMutex.Lock()
+	defer fake.saveTaskListHistoryMutex.Unlock()
+	fake.SaveTaskListHistoryStub = stub
+}
+
+func (fake *FakeStorage) SaveTaskListHistoryArgsForCall(i int) (context.Context, *service.TaskList) {
+	fake.saveTaskListHistoryMutex.RLock()
+	defer fake.saveTaskListHistoryMutex.RUnlock()
+	argsForCall := fake.saveTaskListHistoryArgsForCall[i]
+	return argsForCall.arg1, argsForCall.arg2
+}
+
+func (fake *FakeStorage) SaveTaskListHistoryReturns(result1 error) {
+	fake.saveTaskListHistoryMutex.Lock()
+	defer fake.saveTaskListHistoryMutex.Unlock()
+	fake.SaveTaskListHistoryStub = nil
+	fake.saveTaskListHistoryReturns = struct {
+		result1 error
+	}{result1}
+}
+
+func (fake *FakeStorage) SaveTaskListHistoryReturnsOnCall(i int, result1 error) {
+	fake.saveTaskListHistoryMutex.Lock()
+	defer fake.saveTaskListHistoryMutex.Unlock()
+	fake.SaveTaskListHistoryStub = nil
+	if fake.saveTaskListHistoryReturnsOnCall == nil {
+		fake.saveTaskListHistoryReturnsOnCall = make(map[int]struct {
+			result1 error
+		})
+	}
+	fake.saveTaskListHistoryReturnsOnCall[i] = struct {
+		result1 error
+	}{result1}
+}
+
+func (fake *FakeStorage) Task(arg1 context.Context, arg2 string) (*service.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) (*service.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 *service.Task, result2 error) {
+	fake.taskMutex.Lock()
+	defer fake.taskMutex.Unlock()
+	fake.TaskStub = nil
+	fake.taskReturns = struct {
+		result1 *service.Task
+		result2 error
+	}{result1, result2}
+}
+
+func (fake *FakeStorage) TaskReturnsOnCall(i int, result1 *service.Task, result2 error) {
+	fake.taskMutex.Lock()
+	defer fake.taskMutex.Unlock()
+	fake.TaskStub = nil
+	if fake.taskReturnsOnCall == nil {
+		fake.taskReturnsOnCall = make(map[int]struct {
+			result1 *service.Task
+			result2 error
+		})
+	}
+	fake.taskReturnsOnCall[i] = struct {
+		result1 *service.Task
+		result2 error
+	}{result1, result2}
+}
+
+func (fake *FakeStorage) TaskHistory(arg1 context.Context, arg2 string) (*service.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) (*service.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 *service.Task, result2 error) {
+	fake.taskHistoryMutex.Lock()
+	defer fake.taskHistoryMutex.Unlock()
+	fake.TaskHistoryStub = nil
+	fake.taskHistoryReturns = struct {
+		result1 *service.Task
+		result2 error
+	}{result1, result2}
+}
+
+func (fake *FakeStorage) TaskHistoryReturnsOnCall(i int, result1 *service.Task, result2 error) {
+	fake.taskHistoryMutex.Lock()
+	defer fake.taskHistoryMutex.Unlock()
+	fake.TaskHistoryStub = nil
+	if fake.taskHistoryReturnsOnCall == nil {
+		fake.taskHistoryReturnsOnCall = make(map[int]struct {
+			result1 *service.Task
+			result2 error
+		})
+	}
+	fake.taskHistoryReturnsOnCall[i] = struct {
+		result1 *service.Task
+		result2 error
+	}{result1, result2}
+}
+
+func (fake *FakeStorage) TaskList(arg1 context.Context, arg2 string) (*service.TaskList, error) {
+	fake.taskListMutex.Lock()
+	ret, specificReturn := fake.taskListReturnsOnCall[len(fake.taskListArgsForCall)]
+	fake.taskListArgsForCall = append(fake.taskListArgsForCall, struct {
+		arg1 context.Context
+		arg2 string
+	}{arg1, arg2})
+	stub := fake.TaskListStub
+	fakeReturns := fake.taskListReturns
+	fake.recordInvocation("TaskList", []interface{}{arg1, arg2})
+	fake.taskListMutex.Unlock()
+	if stub != nil {
+		return stub(arg1, arg2)
+	}
+	if specificReturn {
+		return ret.result1, ret.result2
+	}
+	return fakeReturns.result1, fakeReturns.result2
+}
+
+func (fake *FakeStorage) TaskListCallCount() int {
+	fake.taskListMutex.RLock()
+	defer fake.taskListMutex.RUnlock()
+	return len(fake.taskListArgsForCall)
+}
+
+func (fake *FakeStorage) TaskListCalls(stub func(context.Context, string) (*service.TaskList, error)) {
+	fake.taskListMutex.Lock()
+	defer fake.taskListMutex.Unlock()
+	fake.TaskListStub = stub
+}
+
+func (fake *FakeStorage) TaskListArgsForCall(i int) (context.Context, string) {
+	fake.taskListMutex.RLock()
+	defer fake.taskListMutex.RUnlock()
+	argsForCall := fake.taskListArgsForCall[i]
+	return argsForCall.arg1, argsForCall.arg2
+}
+
+func (fake *FakeStorage) TaskListReturns(result1 *service.TaskList, result2 error) {
+	fake.taskListMutex.Lock()
+	defer fake.taskListMutex.Unlock()
+	fake.TaskListStub = nil
+	fake.taskListReturns = struct {
+		result1 *service.TaskList
+		result2 error
+	}{result1, result2}
+}
+
+func (fake *FakeStorage) TaskListReturnsOnCall(i int, result1 *service.TaskList, result2 error) {
+	fake.taskListMutex.Lock()
+	defer fake.taskListMutex.Unlock()
+	fake.TaskListStub = nil
+	if fake.taskListReturnsOnCall == nil {
+		fake.taskListReturnsOnCall = make(map[int]struct {
+			result1 *service.TaskList
+			result2 error
+		})
+	}
+	fake.taskListReturnsOnCall[i] = struct {
+		result1 *service.TaskList
+		result2 error
+	}{result1, result2}
+}
+
+func (fake *FakeStorage) TaskListHistory(arg1 context.Context, arg2 string) (*service.TaskList, error) {
+	fake.taskListHistoryMutex.Lock()
+	ret, specificReturn := fake.taskListHistoryReturnsOnCall[len(fake.taskListHistoryArgsForCall)]
+	fake.taskListHistoryArgsForCall = append(fake.taskListHistoryArgsForCall, struct {
+		arg1 context.Context
+		arg2 string
+	}{arg1, arg2})
+	stub := fake.TaskListHistoryStub
+	fakeReturns := fake.taskListHistoryReturns
+	fake.recordInvocation("TaskListHistory", []interface{}{arg1, arg2})
+	fake.taskListHistoryMutex.Unlock()
+	if stub != nil {
+		return stub(arg1, arg2)
+	}
+	if specificReturn {
+		return ret.result1, ret.result2
+	}
+	return fakeReturns.result1, fakeReturns.result2
+}
+
+func (fake *FakeStorage) TaskListHistoryCallCount() int {
+	fake.taskListHistoryMutex.RLock()
+	defer fake.taskListHistoryMutex.RUnlock()
+	return len(fake.taskListHistoryArgsForCall)
+}
+
+func (fake *FakeStorage) TaskListHistoryCalls(stub func(context.Context, string) (*service.TaskList, error)) {
+	fake.taskListHistoryMutex.Lock()
+	defer fake.taskListHistoryMutex.Unlock()
+	fake.TaskListHistoryStub = stub
+}
+
+func (fake *FakeStorage) TaskListHistoryArgsForCall(i int) (context.Context, string) {
+	fake.taskListHistoryMutex.RLock()
+	defer fake.taskListHistoryMutex.RUnlock()
+	argsForCall := fake.taskListHistoryArgsForCall[i]
+	return argsForCall.arg1, argsForCall.arg2
+}
+
+func (fake *FakeStorage) TaskListHistoryReturns(result1 *service.TaskList, result2 error) {
+	fake.taskListHistoryMutex.Lock()
+	defer fake.taskListHistoryMutex.Unlock()
+	fake.TaskListHistoryStub = nil
+	fake.taskListHistoryReturns = struct {
+		result1 *service.TaskList
+		result2 error
+	}{result1, result2}
+}
+
+func (fake *FakeStorage) TaskListHistoryReturnsOnCall(i int, result1 *service.TaskList, result2 error) {
+	fake.taskListHistoryMutex.Lock()
+	defer fake.taskListHistoryMutex.Unlock()
+	fake.TaskListHistoryStub = nil
+	if fake.taskListHistoryReturnsOnCall == nil {
+		fake.taskListHistoryReturnsOnCall = make(map[int]struct {
+			result1 *service.TaskList
+			result2 error
+		})
+	}
+	fake.taskListHistoryReturnsOnCall[i] = struct {
+		result1 *service.TaskList
+		result2 error
+	}{result1, result2}
+}
+
+func (fake *FakeStorage) TaskListTemplate(arg1 context.Context, arg2 string) (*service.Template, error) {
+	fake.taskListTemplateMutex.Lock()
+	ret, specificReturn := fake.taskListTemplateReturnsOnCall[len(fake.taskListTemplateArgsForCall)]
+	fake.taskListTemplateArgsForCall = append(fake.taskListTemplateArgsForCall, struct {
+		arg1 context.Context
+		arg2 string
+	}{arg1, arg2})
+	stub := fake.TaskListTemplateStub
+	fakeReturns := fake.taskListTemplateReturns
+	fake.recordInvocation("TaskListTemplate", []interface{}{arg1, arg2})
+	fake.taskListTemplateMutex.Unlock()
+	if stub != nil {
+		return stub(arg1, arg2)
+	}
+	if specificReturn {
+		return ret.result1, ret.result2
+	}
+	return fakeReturns.result1, fakeReturns.result2
+}
+
+func (fake *FakeStorage) TaskListTemplateCallCount() int {
+	fake.taskListTemplateMutex.RLock()
+	defer fake.taskListTemplateMutex.RUnlock()
+	return len(fake.taskListTemplateArgsForCall)
+}
+
+func (fake *FakeStorage) TaskListTemplateCalls(stub func(context.Context, string) (*service.Template, error)) {
+	fake.taskListTemplateMutex.Lock()
+	defer fake.taskListTemplateMutex.Unlock()
+	fake.TaskListTemplateStub = stub
+}
+
+func (fake *FakeStorage) TaskListTemplateArgsForCall(i int) (context.Context, string) {
+	fake.taskListTemplateMutex.RLock()
+	defer fake.taskListTemplateMutex.RUnlock()
+	argsForCall := fake.taskListTemplateArgsForCall[i]
+	return argsForCall.arg1, argsForCall.arg2
+}
+
+func (fake *FakeStorage) TaskListTemplateReturns(result1 *service.Template, result2 error) {
+	fake.taskListTemplateMutex.Lock()
+	defer fake.taskListTemplateMutex.Unlock()
+	fake.TaskListTemplateStub = nil
+	fake.taskListTemplateReturns = struct {
+		result1 *service.Template
+		result2 error
+	}{result1, result2}
+}
+
+func (fake *FakeStorage) TaskListTemplateReturnsOnCall(i int, result1 *service.Template, result2 error) {
+	fake.taskListTemplateMutex.Lock()
+	defer fake.taskListTemplateMutex.Unlock()
+	fake.TaskListTemplateStub = nil
+	if fake.taskListTemplateReturnsOnCall == nil {
+		fake.taskListTemplateReturnsOnCall = make(map[int]struct {
+			result1 *service.Template
+			result2 error
+		})
+	}
+	fake.taskListTemplateReturnsOnCall[i] = struct {
+		result1 *service.Template
+		result2 error
+	}{result1, result2}
+}
+
+func (fake *FakeStorage) TaskTemplate(arg1 context.Context, arg2 string) (*service.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) (*service.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 *service.Task, result2 error) {
+	fake.taskTemplateMutex.Lock()
+	defer fake.taskTemplateMutex.Unlock()
+	fake.TaskTemplateStub = nil
+	fake.taskTemplateReturns = struct {
+		result1 *service.Task
+		result2 error
+	}{result1, result2}
+}
+
+func (fake *FakeStorage) TaskTemplateReturnsOnCall(i int, result1 *service.Task, result2 error) {
+	fake.taskTemplateMutex.Lock()
+	defer fake.taskTemplateMutex.Unlock()
+	fake.TaskTemplateStub = nil
+	if fake.taskTemplateReturnsOnCall == nil {
+		fake.taskTemplateReturnsOnCall = make(map[int]struct {
+			result1 *service.Task
+			result2 error
+		})
+	}
+	fake.taskTemplateReturnsOnCall[i] = struct {
+		result1 *service.Task
+		result2 error
+	}{result1, result2}
+}
+
+func (fake *FakeStorage) TaskTemplates(arg1 context.Context, arg2 []string) (map[string]*service.Task, error) {
+	var arg2Copy []string
+	if arg2 != nil {
+		arg2Copy = make([]string, len(arg2))
+		copy(arg2Copy, arg2)
+	}
+	fake.taskTemplatesMutex.Lock()
+	ret, specificReturn := fake.taskTemplatesReturnsOnCall[len(fake.taskTemplatesArgsForCall)]
+	fake.taskTemplatesArgsForCall = append(fake.taskTemplatesArgsForCall, struct {
+		arg1 context.Context
+		arg2 []string
+	}{arg1, arg2Copy})
+	stub := fake.TaskTemplatesStub
+	fakeReturns := fake.taskTemplatesReturns
+	fake.recordInvocation("TaskTemplates", []interface{}{arg1, arg2Copy})
+	fake.taskTemplatesMutex.Unlock()
+	if stub != nil {
+		return stub(arg1, arg2)
+	}
+	if specificReturn {
+		return ret.result1, ret.result2
+	}
+	return fakeReturns.result1, fakeReturns.result2
+}
+
+func (fake *FakeStorage) TaskTemplatesCallCount() int {
+	fake.taskTemplatesMutex.RLock()
+	defer fake.taskTemplatesMutex.RUnlock()
+	return len(fake.taskTemplatesArgsForCall)
+}
+
+func (fake *FakeStorage) TaskTemplatesCalls(stub func(context.Context, []string) (map[string]*service.Task, error)) {
+	fake.taskTemplatesMutex.Lock()
+	defer fake.taskTemplatesMutex.Unlock()
+	fake.TaskTemplatesStub = stub
+}
+
+func (fake *FakeStorage) TaskTemplatesArgsForCall(i int) (context.Context, []string) {
+	fake.taskTemplatesMutex.RLock()
+	defer fake.taskTemplatesMutex.RUnlock()
+	argsForCall := fake.taskTemplatesArgsForCall[i]
+	return argsForCall.arg1, argsForCall.arg2
+}
+
+func (fake *FakeStorage) TaskTemplatesReturns(result1 map[string]*service.Task, result2 error) {
+	fake.taskTemplatesMutex.Lock()
+	defer fake.taskTemplatesMutex.Unlock()
+	fake.TaskTemplatesStub = nil
+	fake.taskTemplatesReturns = struct {
+		result1 map[string]*service.Task
+		result2 error
+	}{result1, result2}
+}
+
+func (fake *FakeStorage) TaskTemplatesReturnsOnCall(i int, result1 map[string]*service.Task, result2 error) {
+	fake.taskTemplatesMutex.Lock()
+	defer fake.taskTemplatesMutex.Unlock()
+	fake.TaskTemplatesStub = nil
+	if fake.taskTemplatesReturnsOnCall == nil {
+		fake.taskTemplatesReturnsOnCall = make(map[int]struct {
+			result1 map[string]*service.Task
+			result2 error
+		})
+	}
+	fake.taskTemplatesReturnsOnCall[i] = struct {
+		result1 map[string]*service.Task
+		result2 error
+	}{result1, result2}
+}
+
+func (fake *FakeStorage) Invocations() map[string][][]interface{} {
+	fake.invocationsMutex.RLock()
+	defer fake.invocationsMutex.RUnlock()
+	fake.eventTaskMutex.RLock()
+	defer fake.eventTaskMutex.RUnlock()
+	fake.getGroupTasksMutex.RLock()
+	defer fake.getGroupTasksMutex.RUnlock()
+	fake.saveTaskHistoryMutex.RLock()
+	defer fake.saveTaskHistoryMutex.RUnlock()
+	fake.saveTaskListHistoryMutex.RLock()
+	defer fake.saveTaskListHistoryMutex.RUnlock()
+	fake.taskMutex.RLock()
+	defer fake.taskMutex.RUnlock()
+	fake.taskHistoryMutex.RLock()
+	defer fake.taskHistoryMutex.RUnlock()
+	fake.taskListMutex.RLock()
+	defer fake.taskListMutex.RUnlock()
+	fake.taskListHistoryMutex.RLock()
+	defer fake.taskListHistoryMutex.RUnlock()
+	fake.taskListTemplateMutex.RLock()
+	defer fake.taskListTemplateMutex.RUnlock()
+	fake.taskTemplateMutex.RLock()
+	defer fake.taskTemplateMutex.RUnlock()
+	fake.taskTemplatesMutex.RLock()
+	defer fake.taskTemplatesMutex.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 _ service.Storage = new(FakeStorage)
diff --git a/internal/service/storage.go b/internal/service/storage.go
new file mode 100644
index 0000000000000000000000000000000000000000..c2babeb80a70b41247f35ab10ef03291667040d2
--- /dev/null
+++ b/internal/service/storage.go
@@ -0,0 +1,26 @@
+package service
+
+import (
+	"context"
+)
+
+//go:generate counterfeiter . Storage
+
+type Storage interface {
+	// Task related methods
+	Task(ctx context.Context, taskID string) (*Task, error)
+	TaskTemplate(ctx context.Context, taskName string) (*Task, error)
+	TaskHistory(ctx context.Context, taskID string) (*Task, error)
+	SaveTaskHistory(ctx context.Context, task *Task) error
+
+	// TaskList related methods
+	TaskList(ctx context.Context, taskListID string) (*TaskList, error)
+	TaskListTemplate(ctx context.Context, taskListName string) (*Template, error)
+	TaskTemplates(ctx context.Context, names []string) (map[string]*Task, error)
+	TaskListHistory(ctx context.Context, taskListID string) (*TaskList, error)
+	GetGroupTasks(ctx context.Context, group *Group) ([]*Task, error)
+	SaveTaskListHistory(ctx context.Context, task *TaskList) error
+
+	// EventTask related methods
+	EventTask(ctx context.Context, key, namespace, scope string) (*EventTask, error)
+}
diff --git a/internal/service/task/task.go b/internal/service/task.go
similarity index 99%
rename from internal/service/task/task.go
rename to internal/service/task.go
index ce52a2b85cf61b8973186a60c4a02ed2fe87c94d..783d7a5a470f9998b481d61369075e2b60d4a1e9 100644
--- a/internal/service/task/task.go
+++ b/internal/service/task.go
@@ -1,4 +1,4 @@
-package task
+package service
 
 import (
 	"strings"
diff --git a/internal/service/task/service.go b/internal/service/task/service.go
index 329c91934f1b2d0f44d46d1f8081cade0e409732..755f1aeb2d226dc4a5ecdc4a00003006eef259c8 100644
--- a/internal/service/task/service.go
+++ b/internal/service/task/service.go
@@ -11,41 +11,24 @@ import (
 
 	"gitlab.eclipse.org/eclipse/xfsc/tsa/golib/errors"
 	goatask "gitlab.eclipse.org/eclipse/xfsc/tsa/task/gen/task"
+	"gitlab.eclipse.org/eclipse/xfsc/tsa/task/internal/service"
 )
 
-//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)
-	Task(ctx context.Context, taskID string) (*Task, error)
-	TaskHistory(ctx context.Context, taskID string) (*Task, error)
-	EventTask(ctx context.Context, key, namespace, scope string) (*EventTask, error)
-}
-
-// Queue interface for retrieving, returning and removing tasks from Queue.
-type Queue interface {
-	Add(ctx context.Context, task *Task) error
-	Poll(ctx context.Context) (*Task, error)
-	Ack(ctx context.Context, task *Task) error
-	Unack(ctx context.Context, task *Task) error
-}
-
 type Cache interface {
 	Get(ctx context.Context, key, namespace, scope string) ([]byte, error)
 }
 
 type Service struct {
-	storage Storage
-	queue   Queue
+	storage service.Storage
+	queue   service.Queue
 	cache   Cache
 	logger  *zap.Logger
 }
 
 // New creates the task service.
-func New(template Storage, queue Queue, cache Cache, logger *zap.Logger) *Service {
+func New(template service.Storage, queue service.Queue, cache Cache, logger *zap.Logger) *Service {
 	return &Service{
 		storage: template,
 		queue:   queue,
@@ -76,7 +59,7 @@ func (s *Service) Create(ctx context.Context, req *goatask.CreateTaskRequest) (r
 	}
 
 	task.ID = uuid.NewString()
-	task.State = Created
+	task.State = service.Created
 	task.CreatedAt = time.Now()
 	task.Request = taskRequest
 
@@ -104,7 +87,7 @@ func (s *Service) TaskResult(ctx context.Context, req *goatask.TaskResultRequest
 
 	logger := s.logger.With(zap.String("taskID", req.TaskID))
 
-	var task *Task
+	var task *service.Task
 	task, err = s.storage.TaskHistory(ctx, req.TaskID)
 	if err != nil && !errors.Is(errors.NotFound, err) {
 		logger.Error("error getting task from history collection", zap.Error(err))
@@ -122,7 +105,7 @@ func (s *Service) TaskResult(ctx context.Context, req *goatask.TaskResultRequest
 		}
 	}
 
-	if task.State != Done && task.State != Failed {
+	if task.State != service.Done && task.State != service.Failed {
 		return nil, errors.New(errors.NotFound, "no result, task is not completed")
 	}
 
diff --git a/internal/service/task/service_test.go b/internal/service/task/service_test.go
index d30c843985b5e6dd87842c5bc4b33fdfdb0d4aab..c7b90ed0156d116f74ce3622f04a85a545245c75 100644
--- a/internal/service/task/service_test.go
+++ b/internal/service/task/service_test.go
@@ -10,6 +10,8 @@ import (
 	"gitlab.eclipse.org/eclipse/xfsc/tsa/golib/errors"
 	"gitlab.eclipse.org/eclipse/xfsc/tsa/golib/ptr"
 	goatask "gitlab.eclipse.org/eclipse/xfsc/tsa/task/gen/task"
+	"gitlab.eclipse.org/eclipse/xfsc/tsa/task/internal/service"
+	"gitlab.eclipse.org/eclipse/xfsc/tsa/task/internal/service/servicefakes"
 	"gitlab.eclipse.org/eclipse/xfsc/tsa/task/internal/service/task"
 	"gitlab.eclipse.org/eclipse/xfsc/tsa/task/internal/service/task/taskfakes"
 )
@@ -23,8 +25,8 @@ func TestService_Create(t *testing.T) {
 	tests := []struct {
 		name    string
 		req     *goatask.CreateTaskRequest
-		storage *taskfakes.FakeStorage
-		queue   *taskfakes.FakeQueue
+		storage *servicefakes.FakeStorage
+		queue   *servicefakes.FakeQueue
 		cache   *taskfakes.FakeCache
 
 		errkind errors.Kind
@@ -39,8 +41,8 @@ func TestService_Create(t *testing.T) {
 		{
 			name: "task template not found",
 			req:  &goatask.CreateTaskRequest{TaskName: "taskname"},
-			storage: &taskfakes.FakeStorage{
-				TaskTemplateStub: func(ctx context.Context, taskName string) (*task.Task, error) {
+			storage: &servicefakes.FakeStorage{
+				TaskTemplateStub: func(ctx context.Context, taskName string) (*service.Task, error) {
 					return nil, errors.New(errors.NotFound)
 				},
 			},
@@ -50,13 +52,13 @@ func TestService_Create(t *testing.T) {
 		{
 			name: "fail to add task to queue",
 			req:  &goatask.CreateTaskRequest{TaskName: "taskname"},
-			storage: &taskfakes.FakeStorage{
-				TaskTemplateStub: func(ctx context.Context, taskName string) (*task.Task, error) {
-					return &task.Task{}, nil
+			storage: &servicefakes.FakeStorage{
+				TaskTemplateStub: func(ctx context.Context, taskName string) (*service.Task, error) {
+					return &service.Task{}, nil
 				},
 			},
-			queue: &taskfakes.FakeQueue{
-				AddStub: func(ctx context.Context, t *task.Task) error {
+			queue: &servicefakes.FakeQueue{
+				AddStub: func(ctx context.Context, t *service.Task) error {
 					return errors.New("some error")
 				},
 			},
@@ -66,13 +68,13 @@ func TestService_Create(t *testing.T) {
 		{
 			name: "successfully add task to queue",
 			req:  &goatask.CreateTaskRequest{TaskName: "taskname"},
-			storage: &taskfakes.FakeStorage{
-				TaskTemplateStub: func(ctx context.Context, taskName string) (*task.Task, error) {
-					return &task.Task{}, nil
+			storage: &servicefakes.FakeStorage{
+				TaskTemplateStub: func(ctx context.Context, taskName string) (*service.Task, error) {
+					return &service.Task{}, nil
 				},
 			},
-			queue: &taskfakes.FakeQueue{
-				AddStub: func(ctx context.Context, t *task.Task) error {
+			queue: &servicefakes.FakeQueue{
+				AddStub: func(ctx context.Context, t *service.Task) error {
 					return nil
 				},
 			},
@@ -84,13 +86,13 @@ func TestService_Create(t *testing.T) {
 				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
+			storage: &servicefakes.FakeStorage{
+				TaskTemplateStub: func(ctx context.Context, taskName string) (*service.Task, error) {
+					return &service.Task{}, nil
 				},
 			},
-			queue: &taskfakes.FakeQueue{
-				AddStub: func(ctx context.Context, t *task.Task) error {
+			queue: &servicefakes.FakeQueue{
+				AddStub: func(ctx context.Context, t *service.Task) error {
 					return nil
 				},
 			},
@@ -121,7 +123,7 @@ func TestService_TaskResult(t *testing.T) {
 	tests := []struct {
 		name    string
 		req     *goatask.TaskResultRequest
-		storage *taskfakes.FakeStorage
+		storage *servicefakes.FakeStorage
 		cache   *taskfakes.FakeCache
 
 		res     interface{}
@@ -137,8 +139,8 @@ func TestService_TaskResult(t *testing.T) {
 		{
 			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) {
+			storage: &servicefakes.FakeStorage{
+				TaskHistoryStub: func(ctx context.Context, taskID string) (*service.Task, error) {
 					return nil, errors.New("some error")
 				},
 			},
@@ -148,11 +150,11 @@ func TestService_TaskResult(t *testing.T) {
 		{
 			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) {
+			storage: &servicefakes.FakeStorage{
+				TaskHistoryStub: func(ctx context.Context, taskID string) (*service.Task, error) {
 					return nil, errors.New(errors.NotFound)
 				},
-				TaskStub: func(ctx context.Context, taskID string) (*task.Task, error) {
+				TaskStub: func(ctx context.Context, taskID string) (*service.Task, error) {
 					return nil, errors.New("another error")
 				},
 			},
@@ -162,11 +164,11 @@ func TestService_TaskResult(t *testing.T) {
 		{
 			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) {
+			storage: &servicefakes.FakeStorage{
+				TaskHistoryStub: func(ctx context.Context, taskID string) (*service.Task, error) {
 					return nil, errors.New(errors.NotFound)
 				},
-				TaskStub: func(ctx context.Context, taskID string) (*task.Task, error) {
+				TaskStub: func(ctx context.Context, taskID string) (*service.Task, error) {
 					return nil, errors.New(errors.NotFound)
 				},
 			},
@@ -176,12 +178,12 @@ func TestService_TaskResult(t *testing.T) {
 		{
 			name: "task is not yet completed",
 			req:  &goatask.TaskResultRequest{TaskID: "123"},
-			storage: &taskfakes.FakeStorage{
-				TaskHistoryStub: func(ctx context.Context, taskID string) (*task.Task, error) {
+			storage: &servicefakes.FakeStorage{
+				TaskHistoryStub: func(ctx context.Context, taskID string) (*service.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
+				TaskStub: func(ctx context.Context, taskID string) (*service.Task, error) {
+					return &service.Task{State: service.Pending}, nil
 				},
 			},
 			errkind: errors.NotFound,
@@ -190,12 +192,12 @@ func TestService_TaskResult(t *testing.T) {
 		{
 			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) {
+			storage: &servicefakes.FakeStorage{
+				TaskHistoryStub: func(ctx context.Context, taskID string) (*service.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
+				TaskStub: func(ctx context.Context, taskID string) (*service.Task, error) {
+					return &service.Task{State: service.Done}, nil
 				},
 			},
 			cache: &taskfakes.FakeCache{
@@ -209,12 +211,12 @@ func TestService_TaskResult(t *testing.T) {
 		{
 			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) {
+			storage: &servicefakes.FakeStorage{
+				TaskHistoryStub: func(ctx context.Context, taskID string) (*service.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
+				TaskStub: func(ctx context.Context, taskID string) (*service.Task, error) {
+					return &service.Task{State: service.Done}, nil
 				},
 			},
 			cache: &taskfakes.FakeCache{
@@ -228,12 +230,12 @@ func TestService_TaskResult(t *testing.T) {
 		{
 			name: "get task result successfully",
 			req:  &goatask.TaskResultRequest{TaskID: "123"},
-			storage: &taskfakes.FakeStorage{
-				TaskHistoryStub: func(ctx context.Context, taskID string) (*task.Task, error) {
+			storage: &servicefakes.FakeStorage{
+				TaskHistoryStub: func(ctx context.Context, taskID string) (*service.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
+				TaskStub: func(ctx context.Context, taskID string) (*service.Task, error) {
+					return &service.Task{State: service.Done}, nil
 				},
 			},
 			cache: &taskfakes.FakeCache{
diff --git a/internal/service/task/taskfakes/fake_queue.go b/internal/service/task/taskfakes/fake_queue.go
deleted file mode 100644
index 614539dd673435c87e219b0549f776b1e43c0848..0000000000000000000000000000000000000000
--- a/internal/service/task/taskfakes/fake_queue.go
+++ /dev/null
@@ -1,345 +0,0 @@
-// Code generated by counterfeiter. DO NOT EDIT.
-package taskfakes
-
-import (
-	"context"
-	"sync"
-
-	"gitlab.eclipse.org/eclipse/xfsc/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)
diff --git a/internal/service/task/taskfakes/fake_storage.go b/internal/service/task/taskfakes/fake_storage.go
deleted file mode 100644
index 3d2dd83b9c6849760a534341b5c7a3dd73748aa1..0000000000000000000000000000000000000000
--- a/internal/service/task/taskfakes/fake_storage.go
+++ /dev/null
@@ -1,366 +0,0 @@
-// Code generated by counterfeiter. DO NOT EDIT.
-package taskfakes
-
-import (
-	"context"
-	"sync"
-
-	"gitlab.eclipse.org/eclipse/xfsc/tsa/task/internal/service/task"
-)
-
-type FakeStorage struct {
-	EventTaskStub        func(context.Context, string, string, string) (*task.EventTask, error)
-	eventTaskMutex       sync.RWMutex
-	eventTaskArgsForCall []struct {
-		arg1 context.Context
-		arg2 string
-		arg3 string
-		arg4 string
-	}
-	eventTaskReturns struct {
-		result1 *task.EventTask
-		result2 error
-	}
-	eventTaskReturnsOnCall map[int]struct {
-		result1 *task.EventTask
-		result2 error
-	}
-	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) EventTask(arg1 context.Context, arg2 string, arg3 string, arg4 string) (*task.EventTask, error) {
-	fake.eventTaskMutex.Lock()
-	ret, specificReturn := fake.eventTaskReturnsOnCall[len(fake.eventTaskArgsForCall)]
-	fake.eventTaskArgsForCall = append(fake.eventTaskArgsForCall, struct {
-		arg1 context.Context
-		arg2 string
-		arg3 string
-		arg4 string
-	}{arg1, arg2, arg3, arg4})
-	stub := fake.EventTaskStub
-	fakeReturns := fake.eventTaskReturns
-	fake.recordInvocation("EventTask", []interface{}{arg1, arg2, arg3, arg4})
-	fake.eventTaskMutex.Unlock()
-	if stub != nil {
-		return stub(arg1, arg2, arg3, arg4)
-	}
-	if specificReturn {
-		return ret.result1, ret.result2
-	}
-	return fakeReturns.result1, fakeReturns.result2
-}
-
-func (fake *FakeStorage) EventTaskCallCount() int {
-	fake.eventTaskMutex.RLock()
-	defer fake.eventTaskMutex.RUnlock()
-	return len(fake.eventTaskArgsForCall)
-}
-
-func (fake *FakeStorage) EventTaskCalls(stub func(context.Context, string, string, string) (*task.EventTask, error)) {
-	fake.eventTaskMutex.Lock()
-	defer fake.eventTaskMutex.Unlock()
-	fake.EventTaskStub = stub
-}
-
-func (fake *FakeStorage) EventTaskArgsForCall(i int) (context.Context, string, string, string) {
-	fake.eventTaskMutex.RLock()
-	defer fake.eventTaskMutex.RUnlock()
-	argsForCall := fake.eventTaskArgsForCall[i]
-	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4
-}
-
-func (fake *FakeStorage) EventTaskReturns(result1 *task.EventTask, result2 error) {
-	fake.eventTaskMutex.Lock()
-	defer fake.eventTaskMutex.Unlock()
-	fake.EventTaskStub = nil
-	fake.eventTaskReturns = struct {
-		result1 *task.EventTask
-		result2 error
-	}{result1, result2}
-}
-
-func (fake *FakeStorage) EventTaskReturnsOnCall(i int, result1 *task.EventTask, result2 error) {
-	fake.eventTaskMutex.Lock()
-	defer fake.eventTaskMutex.Unlock()
-	fake.EventTaskStub = nil
-	if fake.eventTaskReturnsOnCall == nil {
-		fake.eventTaskReturnsOnCall = make(map[int]struct {
-			result1 *task.EventTask
-			result2 error
-		})
-	}
-	fake.eventTaskReturnsOnCall[i] = struct {
-		result1 *task.EventTask
-		result2 error
-	}{result1, result2}
-}
-
-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.eventTaskMutex.RLock()
-	defer fake.eventTaskMutex.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)
diff --git a/internal/service/task_list.go b/internal/service/task_list.go
new file mode 100644
index 0000000000000000000000000000000000000000..8ad5ed7cea477071b9bb10bbcb8e7af228360e66
--- /dev/null
+++ b/internal/service/task_list.go
@@ -0,0 +1,40 @@
+package service
+
+import (
+	"time"
+)
+
+type Template struct {
+	Name           string          `json:"name"`
+	CacheNamespace string          `json:"cacheNamespace"`
+	CacheScope     string          `json:"cacheScope"`
+	Groups         []GroupTemplate `json:"groups"`
+}
+
+type GroupTemplate struct {
+	Execution   string   `json:"execution"`
+	FinalPolicy string   `json:"finalPolicy"`
+	Tasks       []string `json:"tasks"`
+}
+
+type TaskList struct {
+	ID             string    `json:"id"`
+	Name           string    `json:"name"`
+	State          State     `json:"state"`
+	Groups         []Group   `json:"groups"`
+	Request        []byte    `json:"request"`
+	CacheNamespace string    `json:"cacheNamespace"`
+	CacheScope     string    `json:"cacheScope"`
+	CreatedAt      time.Time `json:"createdAt"`
+	StartedAt      time.Time `json:"startedAt"`
+	FinishedAt     time.Time `json:"finishedAt"`
+}
+
+type Group struct {
+	ID          string   `json:"id"`
+	Execution   string   `json:"execution"`
+	Tasks       []string `json:"tasks"`
+	State       State    `json:"state"`
+	Request     []byte   `json:"request"`
+	FinalPolicy string   `json:"finalPolicy"`
+}
diff --git a/internal/service/tasklist/service.go b/internal/service/tasklist/service.go
index 51c585fdde6f1778874781e11377565e3a1c3ec6..4927ededc8d395c1d7d23b0ad0d8d6df2600d47c 100644
--- a/internal/service/tasklist/service.go
+++ b/internal/service/tasklist/service.go
@@ -12,24 +12,13 @@ import (
 	"gitlab.eclipse.org/eclipse/xfsc/tsa/golib/errors"
 	"gitlab.eclipse.org/eclipse/xfsc/tsa/golib/ptr"
 	goatasklist "gitlab.eclipse.org/eclipse/xfsc/tsa/task/gen/task_list"
-	"gitlab.eclipse.org/eclipse/xfsc/tsa/task/internal/service/task"
+	"gitlab.eclipse.org/eclipse/xfsc/tsa/task/internal/service"
 )
 
-//go:generate counterfeiter . Storage
-//go:generate counterfeiter . Queue
 //go:generate counterfeiter . Cache
 
-// Storage for retrieving predefined task templates.
-type Storage interface {
-	TaskListTemplate(ctx context.Context, taskListName string) (*Template, error)
-	TaskTemplates(ctx context.Context, names []string) (map[string]*task.Task, error)
-	TaskList(ctx context.Context, taskListID string) (*TaskList, error)
-	TaskListHistory(ctx context.Context, taskListID string) (*TaskList, error)
-	GetGroupTasks(ctx context.Context, group *Group) ([]*task.Task, error)
-}
-
 type Queue interface {
-	AddTaskList(ctx context.Context, taskList *TaskList, tasks []*task.Task) error
+	AddTaskList(ctx context.Context, taskList *service.TaskList, tasks []*service.Task) error
 }
 
 type Cache interface {
@@ -37,14 +26,14 @@ type Cache interface {
 }
 
 type Service struct {
-	storage Storage
+	storage service.Storage
 	queue   Queue
 	cache   Cache
 
 	logger *zap.Logger
 }
 
-func New(template Storage, queue Queue, cache Cache, logger *zap.Logger) *Service {
+func New(template service.Storage, queue Queue, cache Cache, logger *zap.Logger) *Service {
 	return &Service{
 		storage: template,
 		queue:   queue,
@@ -82,14 +71,14 @@ func (s *Service) Create(ctx context.Context, req *goatasklist.CreateTaskListReq
 		return nil, errors.New(errors.BadRequest, "error marshaling request data to JSON", err)
 	}
 
-	taskList := &TaskList{
+	taskList := &service.TaskList{
 		ID:             uuid.NewString(),
 		Groups:         createGroups(template, taskListRequest),
 		Name:           template.Name,
 		Request:        taskListRequest,
 		CacheScope:     template.CacheScope,
 		CacheNamespace: template.CacheNamespace,
-		State:          task.Created,
+		State:          service.Created,
 		CreatedAt:      time.Now(),
 	}
 
@@ -126,7 +115,7 @@ func (s *Service) TaskListStatus(ctx context.Context, req *goatasklist.TaskListS
 
 	logger := s.logger.With(zap.String("taskListID", req.TaskListID))
 
-	var list *TaskList
+	var list *service.TaskList
 	list, err = s.storage.TaskListHistory(ctx, req.TaskListID)
 	if err != nil && !errors.Is(errors.NotFound, err) {
 		logger.Error("error getting taskList from history collection", zap.Error(err))
@@ -145,7 +134,7 @@ func (s *Service) TaskListStatus(ctx context.Context, req *goatasklist.TaskListS
 	}
 
 	var result *goatasklist.TaskListStatusResponse
-	if list.State != task.Done && list.State != task.Failed {
+	if list.State != service.Done && list.State != service.Failed {
 		// taskList is not executed yet
 		result, err = s.calculateState(ctx, list)
 		if err != nil {
@@ -170,14 +159,14 @@ func (s *Service) TaskListStatus(ctx context.Context, req *goatasklist.TaskListS
 	return result, nil
 }
 
-func createGroups(t *Template, req []byte) []Group {
-	var groups []Group
+func createGroups(t *service.Template, req []byte) []service.Group {
+	var groups []service.Group
 	for _, group := range t.Groups {
-		g := Group{
+		g := service.Group{
 			ID:          uuid.NewString(),
 			Execution:   group.Execution,
 			Tasks:       group.Tasks,
-			State:       task.Created,
+			State:       service.Created,
 			Request:     req,
 			FinalPolicy: group.FinalPolicy,
 		}
@@ -189,8 +178,8 @@ func createGroups(t *Template, req []byte) []Group {
 
 // createTasks creates task.Task instances out of task templates
 // in order to be added to queue for execution
-func createTasks(t *TaskList, templates map[string]*task.Task) ([]*task.Task, error) {
-	var tasks []*task.Task
+func createTasks(t *service.TaskList, templates map[string]*service.Task) ([]*service.Task, error) {
+	var tasks []*service.Task
 	for _, group := range t.Groups {
 		for _, taskName := range group.Tasks {
 			template, ok := templates[taskName]
@@ -198,11 +187,11 @@ func createTasks(t *TaskList, templates map[string]*task.Task) ([]*task.Task, er
 				return nil, errors.New(errors.NotFound, "failed to find task template")
 			}
 
-			task := task.Task{
+			task := service.Task{
 				ID:             uuid.NewString(),
 				GroupID:        group.ID,
 				Name:           taskName,
-				State:          task.Created,
+				State:          service.Created,
 				URL:            template.URL,
 				Method:         template.Method,
 				RequestPolicy:  template.RequestPolicy,
@@ -228,7 +217,7 @@ func createTasks(t *TaskList, templates map[string]*task.Task) ([]*task.Task, er
 	return tasks, nil
 }
 
-func (s *Service) calculateState(ctx context.Context, list *TaskList) (*goatasklist.TaskListStatusResponse, error) {
+func (s *Service) calculateState(ctx context.Context, list *service.TaskList) (*goatasklist.TaskListStatusResponse, error) {
 	result := &goatasklist.TaskListStatusResponse{
 		ID:     list.ID,
 		Status: string(list.State),
@@ -260,7 +249,7 @@ func (s *Service) calculateState(ctx context.Context, list *TaskList) (*goataskl
 
 // taskNamesFromTaskListTemplate returns the names of all tasks within
 // one taskList template
-func taskNamesFromTaskListTemplate(template *Template) []string {
+func taskNamesFromTaskListTemplate(template *service.Template) []string {
 	var names []string
 	for _, group := range template.Groups {
 		names = append(names, group.Tasks...)
diff --git a/internal/service/tasklist/service_test.go b/internal/service/tasklist/service_test.go
index 72e66729ab9fe9cd41340371478194b7d67506ea..a22d9000d65065e7bd30656504d1d5d117d35de6 100644
--- a/internal/service/tasklist/service_test.go
+++ b/internal/service/tasklist/service_test.go
@@ -9,7 +9,8 @@ import (
 
 	"gitlab.eclipse.org/eclipse/xfsc/tsa/golib/errors"
 	goatasklist "gitlab.eclipse.org/eclipse/xfsc/tsa/task/gen/task_list"
-	"gitlab.eclipse.org/eclipse/xfsc/tsa/task/internal/service/task"
+	"gitlab.eclipse.org/eclipse/xfsc/tsa/task/internal/service"
+	"gitlab.eclipse.org/eclipse/xfsc/tsa/task/internal/service/servicefakes"
 	"gitlab.eclipse.org/eclipse/xfsc/tsa/task/internal/service/tasklist"
 	"gitlab.eclipse.org/eclipse/xfsc/tsa/task/internal/service/tasklist/tasklistfakes"
 )
@@ -23,8 +24,8 @@ func Test_Create(t *testing.T) {
 	tests := []struct {
 		name    string
 		req     *goatasklist.CreateTaskListRequest
-		storage *tasklistfakes.FakeStorage
-		queue   *tasklistfakes.FakeQueue
+		storage *servicefakes.FakeStorage
+		queue   *servicefakes.FakeQueue
 
 		errkind errors.Kind
 		errtext string
@@ -38,8 +39,8 @@ func Test_Create(t *testing.T) {
 		{
 			name: "taskList template not found",
 			req:  &goatasklist.CreateTaskListRequest{TaskListName: "taskList name"},
-			storage: &tasklistfakes.FakeStorage{
-				TaskListTemplateStub: func(ctx context.Context, s string) (*tasklist.Template, error) {
+			storage: &servicefakes.FakeStorage{
+				TaskListTemplateStub: func(ctx context.Context, s string) (*service.Template, error) {
 					return nil, errors.New(errors.NotFound)
 				},
 			},
@@ -49,11 +50,11 @@ func Test_Create(t *testing.T) {
 		{
 			name: "error getting task templates form storage",
 			req:  &goatasklist.CreateTaskListRequest{TaskListName: "taskList name"},
-			storage: &tasklistfakes.FakeStorage{
-				TaskListTemplateStub: func(ctx context.Context, s string) (*tasklist.Template, error) {
-					return &tasklist.Template{}, nil
+			storage: &servicefakes.FakeStorage{
+				TaskListTemplateStub: func(ctx context.Context, s string) (*service.Template, error) {
+					return &service.Template{}, nil
 				},
-				TaskTemplatesStub: func(ctx context.Context, strings []string) (map[string]*task.Task, error) {
+				TaskTemplatesStub: func(ctx context.Context, strings []string) (map[string]*service.Task, error) {
 					return nil, errors.New(errors.Internal, "internal error")
 				},
 			},
@@ -63,18 +64,18 @@ func Test_Create(t *testing.T) {
 		{
 			name: "error creating tasks for a taskList, task template not found",
 			req:  &goatasklist.CreateTaskListRequest{TaskListName: "taskList name"},
-			storage: &tasklistfakes.FakeStorage{
-				TaskListTemplateStub: func(ctx context.Context, s string) (*tasklist.Template, error) {
-					return &tasklist.Template{
-						Groups: []tasklist.GroupTemplate{
+			storage: &servicefakes.FakeStorage{
+				TaskListTemplateStub: func(ctx context.Context, s string) (*service.Template, error) {
+					return &service.Template{
+						Groups: []service.GroupTemplate{
 							{
 								Tasks: []string{"non-existent task template"},
 							},
 						},
 					}, nil
 				},
-				TaskTemplatesStub: func(ctx context.Context, strings []string) (map[string]*task.Task, error) {
-					return map[string]*task.Task{"template": &task.Task{}}, nil
+				TaskTemplatesStub: func(ctx context.Context, strings []string) (map[string]*service.Task, error) {
+					return map[string]*service.Task{"template": &service.Task{}}, nil
 				},
 			},
 			errkind: errors.NotFound,
@@ -83,16 +84,16 @@ func Test_Create(t *testing.T) {
 		{
 			name: "failed to add taskList and tasks to queue",
 			req:  &goatasklist.CreateTaskListRequest{TaskListName: "taskList name"},
-			storage: &tasklistfakes.FakeStorage{
-				TaskListTemplateStub: func(ctx context.Context, s string) (*tasklist.Template, error) {
-					return &tasklist.Template{}, nil
+			storage: &servicefakes.FakeStorage{
+				TaskListTemplateStub: func(ctx context.Context, s string) (*service.Template, error) {
+					return &service.Template{}, nil
 				},
-				TaskTemplatesStub: func(ctx context.Context, strings []string) (map[string]*task.Task, error) {
-					return map[string]*task.Task{"template": &task.Task{}}, nil
+				TaskTemplatesStub: func(ctx context.Context, strings []string) (map[string]*service.Task, error) {
+					return map[string]*service.Task{"template": &service.Task{}}, nil
 				},
 			},
-			queue: &tasklistfakes.FakeQueue{
-				AddTaskListStub: func(ctx context.Context, list *tasklist.TaskList, tasks []*task.Task) error {
+			queue: &servicefakes.FakeQueue{
+				AddTaskListStub: func(ctx context.Context, list *service.TaskList, tasks []*service.Task) error {
 					return errors.New("storage error")
 				},
 			},
@@ -102,16 +103,16 @@ func Test_Create(t *testing.T) {
 		{
 			name: "successfully add taskList and tasks to queue",
 			req:  &goatasklist.CreateTaskListRequest{TaskListName: "taskList name"},
-			storage: &tasklistfakes.FakeStorage{
-				TaskListTemplateStub: func(ctx context.Context, s string) (*tasklist.Template, error) {
-					return &tasklist.Template{}, nil
+			storage: &servicefakes.FakeStorage{
+				TaskListTemplateStub: func(ctx context.Context, s string) (*service.Template, error) {
+					return &service.Template{}, nil
 				},
-				TaskTemplatesStub: func(ctx context.Context, strings []string) (map[string]*task.Task, error) {
-					return map[string]*task.Task{"template": &task.Task{}}, nil
+				TaskTemplatesStub: func(ctx context.Context, strings []string) (map[string]*service.Task, error) {
+					return map[string]*service.Task{"template": &service.Task{}}, nil
 				},
 			},
-			queue: &tasklistfakes.FakeQueue{
-				AddTaskListStub: func(ctx context.Context, list *tasklist.TaskList, tasks []*task.Task) error {
+			queue: &servicefakes.FakeQueue{
+				AddTaskListStub: func(ctx context.Context, list *service.TaskList, tasks []*service.Task) error {
 					return nil
 				},
 			},
@@ -143,8 +144,8 @@ func Test_TaskListStatus(t *testing.T) {
 	tests := []struct {
 		name    string
 		req     *goatasklist.TaskListStatusRequest
-		storage *tasklistfakes.FakeStorage
-		queue   *tasklistfakes.FakeQueue
+		storage *servicefakes.FakeStorage
+		queue   *servicefakes.FakeQueue
 		cache   *tasklistfakes.FakeCache
 
 		errkind errors.Kind
@@ -159,8 +160,8 @@ func Test_TaskListStatus(t *testing.T) {
 		{
 			name: "error getting taskList form history collection",
 			req:  &goatasklist.TaskListStatusRequest{TaskListID: "d16996cd-1977-42a9-90b2-b4548a35c1b4"},
-			storage: &tasklistfakes.FakeStorage{
-				TaskListHistoryStub: func(ctx context.Context, taskListID string) (*tasklist.TaskList, error) {
+			storage: &servicefakes.FakeStorage{
+				TaskListHistoryStub: func(ctx context.Context, taskListID string) (*service.TaskList, error) {
 					return nil, errors.New("some error")
 				},
 			},
@@ -170,11 +171,11 @@ func Test_TaskListStatus(t *testing.T) {
 		{
 			name: "taskList not found",
 			req:  &goatasklist.TaskListStatusRequest{TaskListID: "d16996cd-1977-42a9-90b2-b4548a35c1b4"},
-			storage: &tasklistfakes.FakeStorage{
-				TaskListHistoryStub: func(ctx context.Context, taskListID string) (*tasklist.TaskList, error) {
+			storage: &servicefakes.FakeStorage{
+				TaskListHistoryStub: func(ctx context.Context, taskListID string) (*service.TaskList, error) {
 					return nil, errors.New(errors.NotFound)
 				},
-				TaskListStub: func(ctx context.Context, taskListID string) (*tasklist.TaskList, error) {
+				TaskListStub: func(ctx context.Context, taskListID string) (*service.TaskList, error) {
 					return nil, errors.New(errors.NotFound)
 				},
 			},
@@ -184,11 +185,11 @@ func Test_TaskListStatus(t *testing.T) {
 		{
 			name: "error getting taskList from taskLists collection",
 			req:  &goatasklist.TaskListStatusRequest{TaskListID: "d16996cd-1977-42a9-90b2-b4548a35c1b4"},
-			storage: &tasklistfakes.FakeStorage{
-				TaskListHistoryStub: func(ctx context.Context, taskListID string) (*tasklist.TaskList, error) {
+			storage: &servicefakes.FakeStorage{
+				TaskListHistoryStub: func(ctx context.Context, taskListID string) (*service.TaskList, error) {
 					return nil, errors.New(errors.NotFound)
 				},
-				TaskListStub: func(ctx context.Context, taskListID string) (*tasklist.TaskList, error) {
+				TaskListStub: func(ctx context.Context, taskListID string) (*service.TaskList, error) {
 					return nil, errors.New("some error")
 				},
 			},
@@ -198,11 +199,11 @@ func Test_TaskListStatus(t *testing.T) {
 		{
 			name: "error calculating taskList state",
 			req:  &goatasklist.TaskListStatusRequest{TaskListID: "d16996cd-1977-42a9-90b2-b4548a35c1b4"},
-			storage: &tasklistfakes.FakeStorage{
-				TaskListHistoryStub: func(ctx context.Context, taskListID string) (*tasklist.TaskList, error) {
+			storage: &servicefakes.FakeStorage{
+				TaskListHistoryStub: func(ctx context.Context, taskListID string) (*service.TaskList, error) {
 					return pendingTaskList, nil
 				},
-				GetGroupTasksStub: func(ctx context.Context, group *tasklist.Group) ([]*task.Task, error) {
+				GetGroupTasksStub: func(ctx context.Context, group *service.Group) ([]*service.Task, error) {
 					return nil, errors.New("some error")
 				},
 			},
@@ -212,8 +213,8 @@ func Test_TaskListStatus(t *testing.T) {
 		{
 			name: "error getting taskList from cache",
 			req:  &goatasklist.TaskListStatusRequest{TaskListID: "d16996cd-1977-42a9-90b2-b4548a35c1b4"},
-			storage: &tasklistfakes.FakeStorage{
-				TaskListHistoryStub: func(ctx context.Context, taskListID string) (*tasklist.TaskList, error) {
+			storage: &servicefakes.FakeStorage{
+				TaskListHistoryStub: func(ctx context.Context, taskListID string) (*service.TaskList, error) {
 					return doneTaskList, nil
 				},
 			},
@@ -228,20 +229,20 @@ func Test_TaskListStatus(t *testing.T) {
 		{
 			name: "successfully get taskList state on pending task",
 			req:  &goatasklist.TaskListStatusRequest{TaskListID: "d16996cd-1977-42a9-90b2-b4548a35c1b4"},
-			storage: &tasklistfakes.FakeStorage{
-				TaskListHistoryStub: func(ctx context.Context, taskListID string) (*tasklist.TaskList, error) {
+			storage: &servicefakes.FakeStorage{
+				TaskListHistoryStub: func(ctx context.Context, taskListID string) (*service.TaskList, error) {
 					return pendingTaskList, nil
 				},
-				GetGroupTasksStub: func(ctx context.Context, group *tasklist.Group) ([]*task.Task, error) {
-					return []*task.Task{}, nil
+				GetGroupTasksStub: func(ctx context.Context, group *service.Group) ([]*service.Task, error) {
+					return []*service.Task{}, nil
 				},
 			},
 		},
 		{
 			name: "successfully get taskList state on executed task",
 			req:  &goatasklist.TaskListStatusRequest{TaskListID: "d16996cd-1977-42a9-90b2-b4548a35c1b4"},
-			storage: &tasklistfakes.FakeStorage{
-				TaskListHistoryStub: func(ctx context.Context, taskListID string) (*tasklist.TaskList, error) {
+			storage: &servicefakes.FakeStorage{
+				TaskListHistoryStub: func(ctx context.Context, taskListID string) (*service.TaskList, error) {
 					return doneTaskList, nil
 				},
 			},
@@ -276,10 +277,10 @@ func Test_TaskListStatus(t *testing.T) {
 }
 
 //nolint:gosec
-var pendingTaskList = &tasklist.TaskList{
+var pendingTaskList = &service.TaskList{
 	ID:    "16996cd-1977-42a9-90b2-b4548a35c1b4",
 	State: "pending",
-	Groups: []tasklist.Group{
+	Groups: []service.Group{
 		{
 			ID:    "074076d5-c995-4d2d-8d38-da57360453d4",
 			Tasks: []string{"createdTask", "createdTask2"},
@@ -289,7 +290,7 @@ var pendingTaskList = &tasklist.TaskList{
 }
 
 //nolint:gosec
-var doneTaskList = &tasklist.TaskList{
+var doneTaskList = &service.TaskList{
 	ID:    "16996cd-1977-42a9-90b2-b4548a35c1b4",
 	State: "done",
 }
diff --git a/internal/service/tasklist/task_list.go b/internal/service/tasklist/task_list.go
deleted file mode 100644
index 320f2dfead9778f7da0bc64b312faf0198cc31cc..0000000000000000000000000000000000000000
--- a/internal/service/tasklist/task_list.go
+++ /dev/null
@@ -1,42 +0,0 @@
-package tasklist
-
-import (
-	"time"
-
-	"gitlab.eclipse.org/eclipse/xfsc/tsa/task/internal/service/task"
-)
-
-type Template struct {
-	Name           string          `json:"name"`
-	CacheNamespace string          `json:"cacheNamespace"`
-	CacheScope     string          `json:"cacheScope"`
-	Groups         []GroupTemplate `json:"groups"`
-}
-
-type GroupTemplate struct {
-	Execution   string   `json:"execution"`
-	FinalPolicy string   `json:"finalPolicy"`
-	Tasks       []string `json:"tasks"`
-}
-
-type TaskList struct {
-	ID             string     `json:"id"`
-	Name           string     `json:"name"`
-	State          task.State `json:"state"`
-	Groups         []Group    `json:"groups"`
-	Request        []byte     `json:"request"`
-	CacheNamespace string     `json:"cacheNamespace"`
-	CacheScope     string     `json:"cacheScope"`
-	CreatedAt      time.Time  `json:"createdAt"`
-	StartedAt      time.Time  `json:"startedAt"`
-	FinishedAt     time.Time  `json:"finishedAt"`
-}
-
-type Group struct {
-	ID          string     `json:"id"`
-	Execution   string     `json:"execution"`
-	Tasks       []string   `json:"tasks"`
-	State       task.State `json:"state"`
-	Request     []byte     `json:"request"`
-	FinalPolicy string     `json:"finalPolicy"`
-}
diff --git a/internal/service/tasklist/tasklistfakes/fake_queue.go b/internal/service/tasklist/tasklistfakes/fake_queue.go
deleted file mode 100644
index ea89ff4d28b72969fcb9159970dd64ca39b6bb8a..0000000000000000000000000000000000000000
--- a/internal/service/tasklist/tasklistfakes/fake_queue.go
+++ /dev/null
@@ -1,122 +0,0 @@
-// Code generated by counterfeiter. DO NOT EDIT.
-package tasklistfakes
-
-import (
-	"context"
-	"sync"
-
-	"gitlab.eclipse.org/eclipse/xfsc/tsa/task/internal/service/task"
-	"gitlab.eclipse.org/eclipse/xfsc/tsa/task/internal/service/tasklist"
-)
-
-type FakeQueue struct {
-	AddTaskListStub        func(context.Context, *tasklist.TaskList, []*task.Task) error
-	addTaskListMutex       sync.RWMutex
-	addTaskListArgsForCall []struct {
-		arg1 context.Context
-		arg2 *tasklist.TaskList
-		arg3 []*task.Task
-	}
-	addTaskListReturns struct {
-		result1 error
-	}
-	addTaskListReturnsOnCall map[int]struct {
-		result1 error
-	}
-	invocations      map[string][][]interface{}
-	invocationsMutex sync.RWMutex
-}
-
-func (fake *FakeQueue) AddTaskList(arg1 context.Context, arg2 *tasklist.TaskList, arg3 []*task.Task) error {
-	var arg3Copy []*task.Task
-	if arg3 != nil {
-		arg3Copy = make([]*task.Task, len(arg3))
-		copy(arg3Copy, arg3)
-	}
-	fake.addTaskListMutex.Lock()
-	ret, specificReturn := fake.addTaskListReturnsOnCall[len(fake.addTaskListArgsForCall)]
-	fake.addTaskListArgsForCall = append(fake.addTaskListArgsForCall, struct {
-		arg1 context.Context
-		arg2 *tasklist.TaskList
-		arg3 []*task.Task
-	}{arg1, arg2, arg3Copy})
-	stub := fake.AddTaskListStub
-	fakeReturns := fake.addTaskListReturns
-	fake.recordInvocation("AddTaskList", []interface{}{arg1, arg2, arg3Copy})
-	fake.addTaskListMutex.Unlock()
-	if stub != nil {
-		return stub(arg1, arg2, arg3)
-	}
-	if specificReturn {
-		return ret.result1
-	}
-	return fakeReturns.result1
-}
-
-func (fake *FakeQueue) AddTaskListCallCount() int {
-	fake.addTaskListMutex.RLock()
-	defer fake.addTaskListMutex.RUnlock()
-	return len(fake.addTaskListArgsForCall)
-}
-
-func (fake *FakeQueue) AddTaskListCalls(stub func(context.Context, *tasklist.TaskList, []*task.Task) error) {
-	fake.addTaskListMutex.Lock()
-	defer fake.addTaskListMutex.Unlock()
-	fake.AddTaskListStub = stub
-}
-
-func (fake *FakeQueue) AddTaskListArgsForCall(i int) (context.Context, *tasklist.TaskList, []*task.Task) {
-	fake.addTaskListMutex.RLock()
-	defer fake.addTaskListMutex.RUnlock()
-	argsForCall := fake.addTaskListArgsForCall[i]
-	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
-}
-
-func (fake *FakeQueue) AddTaskListReturns(result1 error) {
-	fake.addTaskListMutex.Lock()
-	defer fake.addTaskListMutex.Unlock()
-	fake.AddTaskListStub = nil
-	fake.addTaskListReturns = struct {
-		result1 error
-	}{result1}
-}
-
-func (fake *FakeQueue) AddTaskListReturnsOnCall(i int, result1 error) {
-	fake.addTaskListMutex.Lock()
-	defer fake.addTaskListMutex.Unlock()
-	fake.AddTaskListStub = nil
-	if fake.addTaskListReturnsOnCall == nil {
-		fake.addTaskListReturnsOnCall = make(map[int]struct {
-			result1 error
-		})
-	}
-	fake.addTaskListReturnsOnCall[i] = struct {
-		result1 error
-	}{result1}
-}
-
-func (fake *FakeQueue) Invocations() map[string][][]interface{} {
-	fake.invocationsMutex.RLock()
-	defer fake.invocationsMutex.RUnlock()
-	fake.addTaskListMutex.RLock()
-	defer fake.addTaskListMutex.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 _ tasklist.Queue = new(FakeQueue)
diff --git a/internal/service/tasklist/tasklistfakes/fake_storage.go b/internal/service/tasklist/tasklistfakes/fake_storage.go
deleted file mode 100644
index 387c2b083d3d25e10b9fabf47142c81c432ca69a..0000000000000000000000000000000000000000
--- a/internal/service/tasklist/tasklistfakes/fake_storage.go
+++ /dev/null
@@ -1,449 +0,0 @@
-// Code generated by counterfeiter. DO NOT EDIT.
-package tasklistfakes
-
-import (
-	"context"
-	"sync"
-
-	"gitlab.eclipse.org/eclipse/xfsc/tsa/task/internal/service/task"
-	"gitlab.eclipse.org/eclipse/xfsc/tsa/task/internal/service/tasklist"
-)
-
-type FakeStorage struct {
-	GetGroupTasksStub        func(context.Context, *tasklist.Group) ([]*task.Task, error)
-	getGroupTasksMutex       sync.RWMutex
-	getGroupTasksArgsForCall []struct {
-		arg1 context.Context
-		arg2 *tasklist.Group
-	}
-	getGroupTasksReturns struct {
-		result1 []*task.Task
-		result2 error
-	}
-	getGroupTasksReturnsOnCall map[int]struct {
-		result1 []*task.Task
-		result2 error
-	}
-	TaskListStub        func(context.Context, string) (*tasklist.TaskList, error)
-	taskListMutex       sync.RWMutex
-	taskListArgsForCall []struct {
-		arg1 context.Context
-		arg2 string
-	}
-	taskListReturns struct {
-		result1 *tasklist.TaskList
-		result2 error
-	}
-	taskListReturnsOnCall map[int]struct {
-		result1 *tasklist.TaskList
-		result2 error
-	}
-	TaskListHistoryStub        func(context.Context, string) (*tasklist.TaskList, error)
-	taskListHistoryMutex       sync.RWMutex
-	taskListHistoryArgsForCall []struct {
-		arg1 context.Context
-		arg2 string
-	}
-	taskListHistoryReturns struct {
-		result1 *tasklist.TaskList
-		result2 error
-	}
-	taskListHistoryReturnsOnCall map[int]struct {
-		result1 *tasklist.TaskList
-		result2 error
-	}
-	TaskListTemplateStub        func(context.Context, string) (*tasklist.Template, error)
-	taskListTemplateMutex       sync.RWMutex
-	taskListTemplateArgsForCall []struct {
-		arg1 context.Context
-		arg2 string
-	}
-	taskListTemplateReturns struct {
-		result1 *tasklist.Template
-		result2 error
-	}
-	taskListTemplateReturnsOnCall map[int]struct {
-		result1 *tasklist.Template
-		result2 error
-	}
-	TaskTemplatesStub        func(context.Context, []string) (map[string]*task.Task, error)
-	taskTemplatesMutex       sync.RWMutex
-	taskTemplatesArgsForCall []struct {
-		arg1 context.Context
-		arg2 []string
-	}
-	taskTemplatesReturns struct {
-		result1 map[string]*task.Task
-		result2 error
-	}
-	taskTemplatesReturnsOnCall map[int]struct {
-		result1 map[string]*task.Task
-		result2 error
-	}
-	invocations      map[string][][]interface{}
-	invocationsMutex sync.RWMutex
-}
-
-func (fake *FakeStorage) GetGroupTasks(arg1 context.Context, arg2 *tasklist.Group) ([]*task.Task, error) {
-	fake.getGroupTasksMutex.Lock()
-	ret, specificReturn := fake.getGroupTasksReturnsOnCall[len(fake.getGroupTasksArgsForCall)]
-	fake.getGroupTasksArgsForCall = append(fake.getGroupTasksArgsForCall, struct {
-		arg1 context.Context
-		arg2 *tasklist.Group
-	}{arg1, arg2})
-	stub := fake.GetGroupTasksStub
-	fakeReturns := fake.getGroupTasksReturns
-	fake.recordInvocation("GetGroupTasks", []interface{}{arg1, arg2})
-	fake.getGroupTasksMutex.Unlock()
-	if stub != nil {
-		return stub(arg1, arg2)
-	}
-	if specificReturn {
-		return ret.result1, ret.result2
-	}
-	return fakeReturns.result1, fakeReturns.result2
-}
-
-func (fake *FakeStorage) GetGroupTasksCallCount() int {
-	fake.getGroupTasksMutex.RLock()
-	defer fake.getGroupTasksMutex.RUnlock()
-	return len(fake.getGroupTasksArgsForCall)
-}
-
-func (fake *FakeStorage) GetGroupTasksCalls(stub func(context.Context, *tasklist.Group) ([]*task.Task, error)) {
-	fake.getGroupTasksMutex.Lock()
-	defer fake.getGroupTasksMutex.Unlock()
-	fake.GetGroupTasksStub = stub
-}
-
-func (fake *FakeStorage) GetGroupTasksArgsForCall(i int) (context.Context, *tasklist.Group) {
-	fake.getGroupTasksMutex.RLock()
-	defer fake.getGroupTasksMutex.RUnlock()
-	argsForCall := fake.getGroupTasksArgsForCall[i]
-	return argsForCall.arg1, argsForCall.arg2
-}
-
-func (fake *FakeStorage) GetGroupTasksReturns(result1 []*task.Task, result2 error) {
-	fake.getGroupTasksMutex.Lock()
-	defer fake.getGroupTasksMutex.Unlock()
-	fake.GetGroupTasksStub = nil
-	fake.getGroupTasksReturns = struct {
-		result1 []*task.Task
-		result2 error
-	}{result1, result2}
-}
-
-func (fake *FakeStorage) GetGroupTasksReturnsOnCall(i int, result1 []*task.Task, result2 error) {
-	fake.getGroupTasksMutex.Lock()
-	defer fake.getGroupTasksMutex.Unlock()
-	fake.GetGroupTasksStub = nil
-	if fake.getGroupTasksReturnsOnCall == nil {
-		fake.getGroupTasksReturnsOnCall = make(map[int]struct {
-			result1 []*task.Task
-			result2 error
-		})
-	}
-	fake.getGroupTasksReturnsOnCall[i] = struct {
-		result1 []*task.Task
-		result2 error
-	}{result1, result2}
-}
-
-func (fake *FakeStorage) TaskList(arg1 context.Context, arg2 string) (*tasklist.TaskList, error) {
-	fake.taskListMutex.Lock()
-	ret, specificReturn := fake.taskListReturnsOnCall[len(fake.taskListArgsForCall)]
-	fake.taskListArgsForCall = append(fake.taskListArgsForCall, struct {
-		arg1 context.Context
-		arg2 string
-	}{arg1, arg2})
-	stub := fake.TaskListStub
-	fakeReturns := fake.taskListReturns
-	fake.recordInvocation("TaskList", []interface{}{arg1, arg2})
-	fake.taskListMutex.Unlock()
-	if stub != nil {
-		return stub(arg1, arg2)
-	}
-	if specificReturn {
-		return ret.result1, ret.result2
-	}
-	return fakeReturns.result1, fakeReturns.result2
-}
-
-func (fake *FakeStorage) TaskListCallCount() int {
-	fake.taskListMutex.RLock()
-	defer fake.taskListMutex.RUnlock()
-	return len(fake.taskListArgsForCall)
-}
-
-func (fake *FakeStorage) TaskListCalls(stub func(context.Context, string) (*tasklist.TaskList, error)) {
-	fake.taskListMutex.Lock()
-	defer fake.taskListMutex.Unlock()
-	fake.TaskListStub = stub
-}
-
-func (fake *FakeStorage) TaskListArgsForCall(i int) (context.Context, string) {
-	fake.taskListMutex.RLock()
-	defer fake.taskListMutex.RUnlock()
-	argsForCall := fake.taskListArgsForCall[i]
-	return argsForCall.arg1, argsForCall.arg2
-}
-
-func (fake *FakeStorage) TaskListReturns(result1 *tasklist.TaskList, result2 error) {
-	fake.taskListMutex.Lock()
-	defer fake.taskListMutex.Unlock()
-	fake.TaskListStub = nil
-	fake.taskListReturns = struct {
-		result1 *tasklist.TaskList
-		result2 error
-	}{result1, result2}
-}
-
-func (fake *FakeStorage) TaskListReturnsOnCall(i int, result1 *tasklist.TaskList, result2 error) {
-	fake.taskListMutex.Lock()
-	defer fake.taskListMutex.Unlock()
-	fake.TaskListStub = nil
-	if fake.taskListReturnsOnCall == nil {
-		fake.taskListReturnsOnCall = make(map[int]struct {
-			result1 *tasklist.TaskList
-			result2 error
-		})
-	}
-	fake.taskListReturnsOnCall[i] = struct {
-		result1 *tasklist.TaskList
-		result2 error
-	}{result1, result2}
-}
-
-func (fake *FakeStorage) TaskListHistory(arg1 context.Context, arg2 string) (*tasklist.TaskList, error) {
-	fake.taskListHistoryMutex.Lock()
-	ret, specificReturn := fake.taskListHistoryReturnsOnCall[len(fake.taskListHistoryArgsForCall)]
-	fake.taskListHistoryArgsForCall = append(fake.taskListHistoryArgsForCall, struct {
-		arg1 context.Context
-		arg2 string
-	}{arg1, arg2})
-	stub := fake.TaskListHistoryStub
-	fakeReturns := fake.taskListHistoryReturns
-	fake.recordInvocation("TaskListHistory", []interface{}{arg1, arg2})
-	fake.taskListHistoryMutex.Unlock()
-	if stub != nil {
-		return stub(arg1, arg2)
-	}
-	if specificReturn {
-		return ret.result1, ret.result2
-	}
-	return fakeReturns.result1, fakeReturns.result2
-}
-
-func (fake *FakeStorage) TaskListHistoryCallCount() int {
-	fake.taskListHistoryMutex.RLock()
-	defer fake.taskListHistoryMutex.RUnlock()
-	return len(fake.taskListHistoryArgsForCall)
-}
-
-func (fake *FakeStorage) TaskListHistoryCalls(stub func(context.Context, string) (*tasklist.TaskList, error)) {
-	fake.taskListHistoryMutex.Lock()
-	defer fake.taskListHistoryMutex.Unlock()
-	fake.TaskListHistoryStub = stub
-}
-
-func (fake *FakeStorage) TaskListHistoryArgsForCall(i int) (context.Context, string) {
-	fake.taskListHistoryMutex.RLock()
-	defer fake.taskListHistoryMutex.RUnlock()
-	argsForCall := fake.taskListHistoryArgsForCall[i]
-	return argsForCall.arg1, argsForCall.arg2
-}
-
-func (fake *FakeStorage) TaskListHistoryReturns(result1 *tasklist.TaskList, result2 error) {
-	fake.taskListHistoryMutex.Lock()
-	defer fake.taskListHistoryMutex.Unlock()
-	fake.TaskListHistoryStub = nil
-	fake.taskListHistoryReturns = struct {
-		result1 *tasklist.TaskList
-		result2 error
-	}{result1, result2}
-}
-
-func (fake *FakeStorage) TaskListHistoryReturnsOnCall(i int, result1 *tasklist.TaskList, result2 error) {
-	fake.taskListHistoryMutex.Lock()
-	defer fake.taskListHistoryMutex.Unlock()
-	fake.TaskListHistoryStub = nil
-	if fake.taskListHistoryReturnsOnCall == nil {
-		fake.taskListHistoryReturnsOnCall = make(map[int]struct {
-			result1 *tasklist.TaskList
-			result2 error
-		})
-	}
-	fake.taskListHistoryReturnsOnCall[i] = struct {
-		result1 *tasklist.TaskList
-		result2 error
-	}{result1, result2}
-}
-
-func (fake *FakeStorage) TaskListTemplate(arg1 context.Context, arg2 string) (*tasklist.Template, error) {
-	fake.taskListTemplateMutex.Lock()
-	ret, specificReturn := fake.taskListTemplateReturnsOnCall[len(fake.taskListTemplateArgsForCall)]
-	fake.taskListTemplateArgsForCall = append(fake.taskListTemplateArgsForCall, struct {
-		arg1 context.Context
-		arg2 string
-	}{arg1, arg2})
-	stub := fake.TaskListTemplateStub
-	fakeReturns := fake.taskListTemplateReturns
-	fake.recordInvocation("TaskListTemplate", []interface{}{arg1, arg2})
-	fake.taskListTemplateMutex.Unlock()
-	if stub != nil {
-		return stub(arg1, arg2)
-	}
-	if specificReturn {
-		return ret.result1, ret.result2
-	}
-	return fakeReturns.result1, fakeReturns.result2
-}
-
-func (fake *FakeStorage) TaskListTemplateCallCount() int {
-	fake.taskListTemplateMutex.RLock()
-	defer fake.taskListTemplateMutex.RUnlock()
-	return len(fake.taskListTemplateArgsForCall)
-}
-
-func (fake *FakeStorage) TaskListTemplateCalls(stub func(context.Context, string) (*tasklist.Template, error)) {
-	fake.taskListTemplateMutex.Lock()
-	defer fake.taskListTemplateMutex.Unlock()
-	fake.TaskListTemplateStub = stub
-}
-
-func (fake *FakeStorage) TaskListTemplateArgsForCall(i int) (context.Context, string) {
-	fake.taskListTemplateMutex.RLock()
-	defer fake.taskListTemplateMutex.RUnlock()
-	argsForCall := fake.taskListTemplateArgsForCall[i]
-	return argsForCall.arg1, argsForCall.arg2
-}
-
-func (fake *FakeStorage) TaskListTemplateReturns(result1 *tasklist.Template, result2 error) {
-	fake.taskListTemplateMutex.Lock()
-	defer fake.taskListTemplateMutex.Unlock()
-	fake.TaskListTemplateStub = nil
-	fake.taskListTemplateReturns = struct {
-		result1 *tasklist.Template
-		result2 error
-	}{result1, result2}
-}
-
-func (fake *FakeStorage) TaskListTemplateReturnsOnCall(i int, result1 *tasklist.Template, result2 error) {
-	fake.taskListTemplateMutex.Lock()
-	defer fake.taskListTemplateMutex.Unlock()
-	fake.TaskListTemplateStub = nil
-	if fake.taskListTemplateReturnsOnCall == nil {
-		fake.taskListTemplateReturnsOnCall = make(map[int]struct {
-			result1 *tasklist.Template
-			result2 error
-		})
-	}
-	fake.taskListTemplateReturnsOnCall[i] = struct {
-		result1 *tasklist.Template
-		result2 error
-	}{result1, result2}
-}
-
-func (fake *FakeStorage) TaskTemplates(arg1 context.Context, arg2 []string) (map[string]*task.Task, error) {
-	var arg2Copy []string
-	if arg2 != nil {
-		arg2Copy = make([]string, len(arg2))
-		copy(arg2Copy, arg2)
-	}
-	fake.taskTemplatesMutex.Lock()
-	ret, specificReturn := fake.taskTemplatesReturnsOnCall[len(fake.taskTemplatesArgsForCall)]
-	fake.taskTemplatesArgsForCall = append(fake.taskTemplatesArgsForCall, struct {
-		arg1 context.Context
-		arg2 []string
-	}{arg1, arg2Copy})
-	stub := fake.TaskTemplatesStub
-	fakeReturns := fake.taskTemplatesReturns
-	fake.recordInvocation("TaskTemplates", []interface{}{arg1, arg2Copy})
-	fake.taskTemplatesMutex.Unlock()
-	if stub != nil {
-		return stub(arg1, arg2)
-	}
-	if specificReturn {
-		return ret.result1, ret.result2
-	}
-	return fakeReturns.result1, fakeReturns.result2
-}
-
-func (fake *FakeStorage) TaskTemplatesCallCount() int {
-	fake.taskTemplatesMutex.RLock()
-	defer fake.taskTemplatesMutex.RUnlock()
-	return len(fake.taskTemplatesArgsForCall)
-}
-
-func (fake *FakeStorage) TaskTemplatesCalls(stub func(context.Context, []string) (map[string]*task.Task, error)) {
-	fake.taskTemplatesMutex.Lock()
-	defer fake.taskTemplatesMutex.Unlock()
-	fake.TaskTemplatesStub = stub
-}
-
-func (fake *FakeStorage) TaskTemplatesArgsForCall(i int) (context.Context, []string) {
-	fake.taskTemplatesMutex.RLock()
-	defer fake.taskTemplatesMutex.RUnlock()
-	argsForCall := fake.taskTemplatesArgsForCall[i]
-	return argsForCall.arg1, argsForCall.arg2
-}
-
-func (fake *FakeStorage) TaskTemplatesReturns(result1 map[string]*task.Task, result2 error) {
-	fake.taskTemplatesMutex.Lock()
-	defer fake.taskTemplatesMutex.Unlock()
-	fake.TaskTemplatesStub = nil
-	fake.taskTemplatesReturns = struct {
-		result1 map[string]*task.Task
-		result2 error
-	}{result1, result2}
-}
-
-func (fake *FakeStorage) TaskTemplatesReturnsOnCall(i int, result1 map[string]*task.Task, result2 error) {
-	fake.taskTemplatesMutex.Lock()
-	defer fake.taskTemplatesMutex.Unlock()
-	fake.TaskTemplatesStub = nil
-	if fake.taskTemplatesReturnsOnCall == nil {
-		fake.taskTemplatesReturnsOnCall = make(map[int]struct {
-			result1 map[string]*task.Task
-			result2 error
-		})
-	}
-	fake.taskTemplatesReturnsOnCall[i] = struct {
-		result1 map[string]*task.Task
-		result2 error
-	}{result1, result2}
-}
-
-func (fake *FakeStorage) Invocations() map[string][][]interface{} {
-	fake.invocationsMutex.RLock()
-	defer fake.invocationsMutex.RUnlock()
-	fake.getGroupTasksMutex.RLock()
-	defer fake.getGroupTasksMutex.RUnlock()
-	fake.taskListMutex.RLock()
-	defer fake.taskListMutex.RUnlock()
-	fake.taskListHistoryMutex.RLock()
-	defer fake.taskListHistoryMutex.RUnlock()
-	fake.taskListTemplateMutex.RLock()
-	defer fake.taskListTemplateMutex.RUnlock()
-	fake.taskTemplatesMutex.RLock()
-	defer fake.taskTemplatesMutex.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 _ tasklist.Storage = new(FakeStorage)
diff --git a/internal/storage/storage.go b/internal/storage/storage.go
index 533b8e6aeb86ff37eeb734734f165581a319d039..d529bc69093ca82fab558414ec6974ec7edab2d3 100644
--- a/internal/storage/storage.go
+++ b/internal/storage/storage.go
@@ -4,14 +4,14 @@ import (
 	"context"
 	"strings"
 
+	"gitlab.eclipse.org/eclipse/xfsc/tsa/task/internal/service"
+
 	"github.com/cenkalti/backoff/v4"
 	"go.mongodb.org/mongo-driver/bson"
 	"go.mongodb.org/mongo-driver/mongo"
 	"go.mongodb.org/mongo-driver/mongo/options"
 
 	"gitlab.eclipse.org/eclipse/xfsc/tsa/golib/errors"
-	"gitlab.eclipse.org/eclipse/xfsc/tsa/task/internal/service/task"
-	"gitlab.eclipse.org/eclipse/xfsc/tsa/task/internal/service/tasklist"
 )
 
 const (
@@ -47,7 +47,7 @@ func New(db *mongo.Client) *Storage {
 	}
 }
 
-func (s *Storage) TaskTemplate(ctx context.Context, taskName string) (*task.Task, error) {
+func (s *Storage) TaskTemplate(ctx context.Context, taskName string) (*service.Task, error) {
 	result := s.taskTemplates.FindOne(ctx, bson.M{
 		"name": taskName,
 	})
@@ -59,7 +59,7 @@ func (s *Storage) TaskTemplate(ctx context.Context, taskName string) (*task.Task
 		return nil, result.Err()
 	}
 
-	var task task.Task
+	var task service.Task
 	if err := result.Decode(&task); err != nil {
 		return nil, err
 	}
@@ -67,7 +67,7 @@ func (s *Storage) TaskTemplate(ctx context.Context, taskName string) (*task.Task
 	return &task, nil
 }
 
-func (s *Storage) Add(ctx context.Context, task *task.Task) error {
+func (s *Storage) Add(ctx context.Context, task *service.Task) error {
 	_, err := s.tasks.InsertOne(ctx, task)
 	return err
 }
@@ -76,14 +76,14 @@ func (s *Storage) Add(ctx context.Context, task *task.Task) error {
 // with the older ones being retrieved first (FIFO). It updates the state
 // of the task to "pending", so that consequent calls to Poll would
 // not retrieve the same task.
-func (s *Storage) Poll(ctx context.Context) (*task.Task, error) {
+func (s *Storage) Poll(ctx context.Context) (*service.Task, error) {
 	opts := options.
 		FindOneAndUpdate().
 		SetSort(bson.M{"createdAt": 1}).
 		SetReturnDocument(options.After)
 
-	filter := bson.M{"state": task.Created, "groupid": ""}
-	update := bson.M{"$set": bson.M{"state": task.Pending}}
+	filter := bson.M{"state": service.Created, "groupid": ""}
+	update := bson.M{"$set": bson.M{"state": service.Pending}}
 	result := s.tasks.FindOneAndUpdate(
 		ctx,
 		filter,
@@ -98,7 +98,7 @@ func (s *Storage) Poll(ctx context.Context) (*task.Task, error) {
 		return nil, result.Err()
 	}
 
-	var task task.Task
+	var task service.Task
 	if err := result.Decode(&task); err != nil {
 		return nil, err
 	}
@@ -107,22 +107,22 @@ func (s *Storage) Poll(ctx context.Context) (*task.Task, error) {
 }
 
 // Ack removes a task from the `tasks` collection.
-func (s *Storage) Ack(ctx context.Context, task *task.Task) error {
+func (s *Storage) Ack(ctx context.Context, task *service.Task) error {
 	_, err := s.tasks.DeleteOne(ctx, bson.M{"id": task.ID})
 	return err
 }
 
 // Unack changes the "pending" state of a task to "created", so that
 // it can be retrieved for processing again.
-func (s *Storage) Unack(ctx context.Context, t *task.Task) error {
+func (s *Storage) Unack(ctx context.Context, t *service.Task) error {
 	filter := bson.M{"id": t.ID}
-	update := bson.M{"$set": bson.M{"state": task.Created, "retries": t.Retries + 1}}
+	update := bson.M{"$set": bson.M{"state": service.Created, "retries": t.Retries + 1}}
 	_, err := s.tasks.UpdateOne(ctx, filter, update)
 	return err
 }
 
 // SaveTaskHistory saves a task to the `tasksHistory` collection.
-func (s *Storage) SaveTaskHistory(ctx context.Context, task *task.Task) error {
+func (s *Storage) SaveTaskHistory(ctx context.Context, task *service.Task) error {
 	insert := func() error {
 		_, err := s.tasksHistory.InsertOne(ctx, task)
 		return err
@@ -132,7 +132,7 @@ func (s *Storage) SaveTaskHistory(ctx context.Context, task *task.Task) error {
 	return backoff.Retry(insert, b)
 }
 
-func (s *Storage) Task(ctx context.Context, taskID string) (*task.Task, error) {
+func (s *Storage) Task(ctx context.Context, taskID string) (*service.Task, error) {
 	result := s.tasks.FindOne(ctx, bson.M{
 		"id": taskID,
 	})
@@ -144,7 +144,7 @@ func (s *Storage) Task(ctx context.Context, taskID string) (*task.Task, error) {
 		return nil, result.Err()
 	}
 
-	var task task.Task
+	var task service.Task
 	if err := result.Decode(&task); err != nil {
 		return nil, err
 	}
@@ -152,7 +152,7 @@ func (s *Storage) Task(ctx context.Context, taskID string) (*task.Task, error) {
 	return &task, nil
 }
 
-func (s *Storage) TaskHistory(ctx context.Context, taskID string) (*task.Task, error) {
+func (s *Storage) TaskHistory(ctx context.Context, taskID string) (*service.Task, error) {
 	result := s.tasksHistory.FindOne(ctx, bson.M{
 		"id": taskID,
 	})
@@ -164,7 +164,7 @@ func (s *Storage) TaskHistory(ctx context.Context, taskID string) (*task.Task, e
 		return nil, result.Err()
 	}
 
-	var task task.Task
+	var task service.Task
 	if err := result.Decode(&task); err != nil {
 		return nil, err
 	}
@@ -173,7 +173,7 @@ func (s *Storage) TaskHistory(ctx context.Context, taskID string) (*task.Task, e
 }
 
 // TaskListTemplate retrieves one taskList definition by name from storage
-func (s *Storage) TaskListTemplate(ctx context.Context, taskListName string) (*tasklist.Template, error) {
+func (s *Storage) TaskListTemplate(ctx context.Context, taskListName string) (*service.Template, error) {
 	result := s.taskListTemplates.FindOne(ctx, bson.M{
 		"name": taskListName,
 	})
@@ -185,7 +185,7 @@ func (s *Storage) TaskListTemplate(ctx context.Context, taskListName string) (*t
 		return nil, result.Err()
 	}
 
-	var tasklist tasklist.Template
+	var tasklist service.Template
 	if err := result.Decode(&tasklist); err != nil {
 		return nil, err
 	}
@@ -196,7 +196,7 @@ func (s *Storage) TaskListTemplate(ctx context.Context, taskListName string) (*t
 // TaskTemplates retrieves task definitions from storage by names.
 //
 // The result is a map where 'key' is the task name and 'value' is the task definition
-func (s *Storage) TaskTemplates(ctx context.Context, names []string) (map[string]*task.Task, error) {
+func (s *Storage) TaskTemplates(ctx context.Context, names []string) (map[string]*service.Task, error) {
 	cursor, err := s.taskTemplates.Find(ctx, bson.M{
 		"name": bson.M{"$in": names},
 	})
@@ -205,9 +205,9 @@ func (s *Storage) TaskTemplates(ctx context.Context, names []string) (map[string
 	}
 	defer cursor.Close(ctx)
 
-	res := make(map[string]*task.Task)
+	res := make(map[string]*service.Task)
 	for cursor.Next(ctx) {
-		var task task.Task
+		var task service.Task
 		if err := cursor.Decode(&task); err != nil {
 			return nil, err
 		}
@@ -217,7 +217,7 @@ func (s *Storage) TaskTemplates(ctx context.Context, names []string) (map[string
 	return res, nil
 }
 
-func (s *Storage) AddTaskList(ctx context.Context, taskList *tasklist.TaskList, tasks []*task.Task) error {
+func (s *Storage) AddTaskList(ctx context.Context, taskList *service.TaskList, tasks []*service.Task) error {
 	_, err := s.taskLists.InsertOne(ctx, taskList)
 	if err != nil {
 		return err
@@ -240,7 +240,7 @@ func (s *Storage) AddTaskList(ctx context.Context, taskList *tasklist.TaskList,
 }
 
 // AckList removes a taskList from the `tasksLists` collection.
-func (s *Storage) AckList(ctx context.Context, taskList *tasklist.TaskList) error {
+func (s *Storage) AckList(ctx context.Context, taskList *service.TaskList) error {
 	_, err := s.taskLists.DeleteOne(ctx, bson.M{"id": taskList.ID})
 	return err
 }
@@ -249,14 +249,14 @@ func (s *Storage) AckList(ctx context.Context, taskList *tasklist.TaskList) erro
 // with the older ones being retrieved first (FIFO). It updates the state
 // of the task to "pending", so that consequent calls to PollList would
 // not retrieve the same task.
-func (s *Storage) PollList(ctx context.Context) (*tasklist.TaskList, error) {
+func (s *Storage) PollList(ctx context.Context) (*service.TaskList, error) {
 	opts := options.
 		FindOneAndUpdate().
 		SetSort(bson.M{"createdAt": 1}).
 		SetReturnDocument(options.After)
 
-	filter := bson.M{"state": task.Created}
-	update := bson.M{"$set": bson.M{"state": task.Pending}}
+	filter := bson.M{"state": service.Created}
+	update := bson.M{"$set": bson.M{"state": service.Pending}}
 	result := s.taskLists.FindOneAndUpdate(
 		ctx,
 		filter,
@@ -271,7 +271,7 @@ func (s *Storage) PollList(ctx context.Context) (*tasklist.TaskList, error) {
 		return nil, result.Err()
 	}
 
-	var list tasklist.TaskList
+	var list service.TaskList
 	if err := result.Decode(&list); err != nil {
 		return nil, err
 	}
@@ -280,7 +280,7 @@ func (s *Storage) PollList(ctx context.Context) (*tasklist.TaskList, error) {
 }
 
 // GetGroupTasks fetches all tasks by a groupID
-func (s *Storage) GetGroupTasks(ctx context.Context, group *tasklist.Group) ([]*task.Task, error) {
+func (s *Storage) GetGroupTasks(ctx context.Context, group *service.Group) ([]*service.Task, error) {
 	filter := bson.M{"groupid": group.ID}
 	opts := options.Find().SetSort(bson.M{"createdAt": 1})
 
@@ -290,9 +290,9 @@ func (s *Storage) GetGroupTasks(ctx context.Context, group *tasklist.Group) ([]*
 	}
 	defer cursor.Close(ctx)
 
-	var tasks []*task.Task
+	var tasks []*service.Task
 	for cursor.Next(ctx) {
-		var task task.Task
+		var task service.Task
 		if err := cursor.Decode(&task); err != nil {
 			return nil, err
 		}
@@ -303,13 +303,13 @@ func (s *Storage) GetGroupTasks(ctx context.Context, group *tasklist.Group) ([]*
 }
 
 // AckGroupTasks removes tasks from tasks collection by groupID
-func (s *Storage) AckGroupTasks(ctx context.Context, group *tasklist.Group) error {
+func (s *Storage) AckGroupTasks(ctx context.Context, group *service.Group) error {
 	_, err := s.tasks.DeleteMany(ctx, bson.M{"groupid": group.ID})
 	return err
 }
 
 // SaveTaskListHistory adds a tasklist to the taskListHistory collection
-func (s *Storage) SaveTaskListHistory(ctx context.Context, taskList *tasklist.TaskList) error {
+func (s *Storage) SaveTaskListHistory(ctx context.Context, taskList *service.TaskList) error {
 	insert := func() error {
 		_, err := s.taskListHistory.InsertOne(ctx, taskList)
 		return err
@@ -320,7 +320,7 @@ func (s *Storage) SaveTaskListHistory(ctx context.Context, taskList *tasklist.Ta
 }
 
 // TaskList retrieves a tasklist.TaskList from taskLists collection by ID
-func (s *Storage) TaskList(ctx context.Context, taskListID string) (*tasklist.TaskList, error) {
+func (s *Storage) TaskList(ctx context.Context, taskListID string) (*service.TaskList, error) {
 	result := s.taskLists.FindOne(ctx, bson.M{
 		"id": taskListID,
 	})
@@ -332,7 +332,7 @@ func (s *Storage) TaskList(ctx context.Context, taskListID string) (*tasklist.Ta
 		return nil, result.Err()
 	}
 
-	var list tasklist.TaskList
+	var list service.TaskList
 	if err := result.Decode(&list); err != nil {
 		return nil, err
 	}
@@ -341,7 +341,7 @@ func (s *Storage) TaskList(ctx context.Context, taskListID string) (*tasklist.Ta
 }
 
 // TaskListHistory retrieves a tasklist.TaskList from taskListHistory collection by ID
-func (s *Storage) TaskListHistory(ctx context.Context, taskListID string) (*tasklist.TaskList, error) {
+func (s *Storage) TaskListHistory(ctx context.Context, taskListID string) (*service.TaskList, error) {
 	result := s.taskListHistory.FindOne(ctx, bson.M{
 		"id": taskListID,
 	})
@@ -353,7 +353,7 @@ func (s *Storage) TaskListHistory(ctx context.Context, taskListID string) (*task
 		return nil, result.Err()
 	}
 
-	var list tasklist.TaskList
+	var list service.TaskList
 	if err := result.Decode(&list); err != nil {
 		return nil, err
 	}
@@ -361,7 +361,7 @@ func (s *Storage) TaskListHistory(ctx context.Context, taskListID string) (*task
 	return &list, nil
 }
 
-func (s *Storage) EventTask(ctx context.Context, key, namespace, scope string) (*task.EventTask, error) {
+func (s *Storage) EventTask(ctx context.Context, key, namespace, scope string) (*service.EventTask, error) {
 	result := s.eventTasks.FindOne(ctx, bson.M{
 		"key":       key,
 		"namespace": namespace,
@@ -375,7 +375,7 @@ func (s *Storage) EventTask(ctx context.Context, key, namespace, scope string) (
 		return nil, result.Err()
 	}
 
-	var eventTask task.EventTask
+	var eventTask service.EventTask
 	if err := result.Decode(&eventTask); err != nil {
 		return nil, err
 	}