Refactoring and task queue tests

src/Queue/Args.ts

@@ -1,6 +1,6 @@
-import { TaskId } from './TaskQueue';
 import { ResourcesInterface } from '../Core/Resources';
 import { CoordinatesInterface } from '../Core/Village';
+import { TaskId } from './TaskProvider';
 
 export interface Args {
     taskId?: TaskId;

src/Queue/ArrayTaskProvider.ts

@@ -0,0 +1,17 @@
+import { TaskList, TaskProvider } from './TaskProvider';
+
+export class ArrayTaskProvider implements TaskProvider {
+    private tasks: TaskList;
+
+    constructor(tasks: TaskList) {
+        this.tasks = tasks;
+    }
+
+    getTasks(): TaskList {
+        return this.tasks;
+    }
+
+    setTasks(tasks: TaskList): void {
+        this.tasks = tasks;
+    }
+}

src/Queue/DataStorageTaskProvider.ts

@@ -0,0 +1,36 @@
+import { DataStorage } from '../DataStorage';
+import { uniqId } from '../utils';
+import { Task, TaskList, TaskProvider } from './TaskProvider';
+
+const NAMESPACE = 'tasks:v1';
+const QUEUE_NAME = 'queue';
+
+export class DataStorageTaskProvider implements TaskProvider {
+    private storage: DataStorage;
+
+    constructor(storage: DataStorage) {
+        this.storage = storage;
+    }
+
+    static create() {
+        return new DataStorageTaskProvider(new DataStorage(NAMESPACE));
+    }
+
+    getTasks(): TaskList {
+        const serialized = this.storage.get(QUEUE_NAME);
+        if (!Array.isArray(serialized)) {
+            return [];
+        }
+
+        const storedItems = serialized as Array<{ [key: string]: any }>;
+
+        return storedItems.map(i => {
+            const task = new Task(uniqId(), 0, '', {});
+            return Object.assign(task, i);
+        });
+    }
+
+    setTasks(tasks: TaskList): void {
+        this.storage.set(QUEUE_NAME, tasks);
+    }
+}

src/Queue/TaskProvider.ts

@@ -0,0 +1,41 @@
+import { Args } from './Args';
+import { uniqId } from '../utils';
+
+export type TaskId = string;
+
+let idSequence = 1;
+let lastTimestamp: number | null = null;
+
+export function uniqTaskId(): TaskId {
+    const ts = Math.floor(Date.now() / 1000);
+    if (ts === lastTimestamp) {
+        ++idSequence;
+    } else {
+        idSequence = 1;
+    }
+    lastTimestamp = ts;
+    return 'tid.' + ts + '.' + String(idSequence).padStart(4, '0') + '.' + uniqId('');
+}
+
+export class Task {
+    readonly id: TaskId;
+    readonly ts: number;
+    readonly name: string;
+    readonly args: Args;
+
+    constructor(id: TaskId, ts: number, name: string, args: Args) {
+        this.id = id;
+        this.ts = ts;
+        this.name = name;
+        this.args = args;
+    }
+}
+
+export type TaskList = Array<Task>;
+export type ImmutableTaskList = ReadonlyArray<Task>;
+
+export interface TaskProvider {
+    getTasks(): TaskList;
+
+    setTasks(tasks: TaskList): void;
+}

src/Queue/TaskQueue.ts

@@ -1,78 +1,6 @@
-import { uniqId } from '../utils';
 import { Logger } from '../Logger';
-import { DataStorage } from '../DataStorage';
 import { Args } from './Args';
-
-const NAMESPACE = 'tasks:v1';
-const QUEUE_NAME = 'queue';
-
-export type TaskId = string;
-
-let idSequence = 1;
-let lastTimestamp: number | null = null;
-
-function uniqTaskId(): TaskId {
-    const ts = Math.floor(Date.now() / 1000);
-    if (ts === lastTimestamp) {
-        ++idSequence;
-    } else {
-        idSequence = 1;
-    }
-    lastTimestamp = ts;
-    return 'tid.' + ts + '.' + String(idSequence).padStart(4, '0') + '.' + uniqId('');
-}
-
-export class Task {
-    readonly id: TaskId;
-    readonly ts: number;
-    readonly name: string;
-    readonly args: Args;
-    constructor(id: TaskId, ts: number, name: string, args: Args) {
-        this.id = id;
-        this.ts = ts;
-        this.name = name;
-        this.args = args;
-    }
-}
-
-type TaskList = Array<Task>;
-
-export type ImmutableTaskList = ReadonlyArray<Task>;
-
-export interface TaskProvider {
-    getTasks(): TaskList;
-    setTasks(tasks: TaskList): void;
-}
-
-export class DataStorageTaskProvider implements TaskProvider {
-    private storage: DataStorage;
-
-    constructor(storage: DataStorage) {
-        this.storage = storage;
-    }
-
-    static create() {
-        return new DataStorageTaskProvider(new DataStorage(NAMESPACE));
-    }
-
-    getTasks(): TaskList {
-        const serialized = this.storage.get(QUEUE_NAME);
-        if (!Array.isArray(serialized)) {
-            return [];
-        }
-
-        const storedItems = serialized as Array<{ [key: string]: any }>;
-
-        return storedItems.map(i => {
-            const task = new Task(uniqId(), 0, '', {});
-            return Object.assign(task, i);
-        });
-    }
-
-    setTasks(tasks: TaskList): void {
-        this.storage.set(QUEUE_NAME, tasks);
-    }
-}
+import { ImmutableTaskList, Task, TaskId, TaskList, TaskProvider, uniqTaskId } from './TaskProvider';
 
 export class TaskQueue {
     private provider: TaskProvider;