def test_finishTasksAfterAssigningTasksToWorkers(self):
workers = [
Worker(workerID="W1",
begin=tHour(0, 00),
end=tHour(23, 59),
multitask=1),
Worker(workerID="W2",
begin=tHour(0, 00),
end=tHour(23, 59),
multitask=1),
Worker(workerID="W3",
begin=tHour(0, 00),
end=tHour(23, 59),
multitask=1)
]
taskManager = TaskManager(period=self.tPeriod(), multitask=1)
taskManager.addTask(self.tasks[0])
taskManager.addTask(self.tasks[1])
taskManager.addWorkers(workers)
taskManager.assignTasksToWorkers()
self.assertEqual(len(taskManager.workers), 3)
taskManager.finishTask(self.tasks[0].taskID)
self.assertEqual(len(workers[0].assignedTasks), 0)
self.assertEqual(len(taskManager.workers), 3)
taskManager.finishTask(self.tasks[1].taskID) # test with id too.
self.assertEqual(len(workers[1].assignedTasks), 0)
self.assertEqual(len(taskManager.workers), 3)
def test_removeWorker(self):
workers = [
Worker(workerID="W1",
begin=tHour(0, 00),
end=tHour(23, 59),
multitask=1),
Worker(workerID="W2",
begin=tHour(0, 00),
end=tHour(23, 59),
multitask=1),
Worker(workerID="W3",
begin=tHour(0, 00),
end=tHour(23, 59),
multitask=1),
Worker(workerID="W4",
begin=tHour(0, 00),
end=tHour(23, 59),
multitask=1)
]
workerQ = WorkerQueue()
workerQ.put(workers)
workerQ.removeWorker(workers[2])
self.assertEqual(workerQ.nextWorker(), workers[0])
self.assertEqual(workerQ.nextWorker(), workers[1])
self.assertEqual(workerQ.nextWorker(), workers[3])
self.assertEqual(workerQ.size(), 3)
def test_putList(self):
workers1 = [
Worker(workerID="W1",
begin=tHour(0, 00),
end=tHour(23, 59),
multitask=2),
Worker(workerID="W2",
begin=tHour(0, 00),
end=tHour(23, 59),
multitask=2),
]
workers2 = [
Worker(workerID="W3",
begin=tHour(0, 00),
end=tHour(23, 59),
multitask=1),
Worker(workerID="W4",
begin=tHour(0, 00),
end=tHour(23, 59),
multitask=1),
]
workerQ = WorkerQueue()
workerQ.put(workers1)
self.assertEqual(workerQ.nextWorker(), workers1[0])
self.assertEqual(workerQ.nextWorker(), workers1[1])
workerQ.put(workers2)
self.assertEqual(workerQ.nextWorker(), workers1[0])
self.assertEqual(workerQ.nextWorker(), workers1[1])
self.assertEqual(workerQ.nextWorker(), workers2[0])
self.assertEqual(workerQ.nextWorker(), workers2[1])
def test_maxTasksAchievable(self):
workers = [
Worker(workerID="W1",
begin=tHour(0, 00),
end=tHour(23, 59),
multitask=2),
Worker(workerID="W2",
begin=tHour(0, 00),
end=tHour(23, 59),
multitask=2)
]
worker3 = Worker(workerID="W3",
begin=tHour(0, 00),
end=tHour(23, 59),
multitask=1)
worker4 = Worker(workerID="W4",
begin=tHour(0, 00),
end=tHour(23, 59),
multitask=1)
workerQ = WorkerQueue()
workerQ.put(workers)
self.assertEqual(workerQ.maxTasksAchievable(), 4)
workerQ.put(worker3)
self.assertEqual(workerQ.maxTasksAchievable(), 5)
workerQ.put(worker4)
self.assertEqual(workerQ.maxTasksAchievable(), 6)
def test_removeWorkerAfterAssigningTasks(self):
workers = [
Worker(workerID="W1",
begin=tHour(0, 00),
end=tHour(23, 59),
multitask=1),
Worker(workerID="W2",
begin=tHour(0, 00),
end=tHour(23, 59),
multitask=1)
]
taskManager = TaskManager(self.tPeriod(), multitask=1)
taskManager.addTasks([self.tasks[0], self.tasks[1]])
taskManager.addWorkers(workers)
taskManager.assignTasksToWorkers()
# make sure the exception is thrown as the tasks are not finished yet.
with self.assertRaises(UnfinishedTasksHeldByWorkerException):
taskManager.removeWorker(workers[0].workerID)
# finish the tasks and remove workers
taskManager.finishTask(self.tasks[0].taskID)
taskManager.removeWorker(workers[0].workerID)
self.assertEqual(len(taskManager.workers), 1)
taskManager.finishTask(self.tasks[1].taskID)
taskManager.removeWorker(workers[1].workerID)
self.assertEqual(len(taskManager.workers), 0)
def test_putWorkers(self):
worker1 = Worker(workerID="W1",
begin=tHour(0, 00),
end=tHour(23, 59),
multitask=2)
worker2 = Worker(workerID="W2",
begin=tHour(0, 00),
end=tHour(23, 59),
multitask=2),
worker3 = Worker(workerID="W3",
begin=tHour(0, 00),
end=tHour(23, 59),
multitask=1),
worker4 = Worker(workerID="W4",
begin=tHour(0, 00),
end=tHour(23, 59),
multitask=1),
workerQ = WorkerQueue()
workerQ.put(worker1)
self.assertEqual(workerQ.nextWorker(), worker1)
workerQ.put(worker2)
self.assertEqual(workerQ.nextWorker(), worker1)
self.assertEqual(workerQ.nextWorker(), worker2)
workerQ.put(worker3)
self.assertEqual(workerQ.nextWorker(), worker1)
self.assertEqual(workerQ.nextWorker(), worker2)
self.assertEqual(workerQ.nextWorker(), worker3)
workerQ.put(worker4)
self.assertEqual(workerQ.nextWorker(), worker1)
self.assertEqual(workerQ.nextWorker(), worker2)
self.assertEqual(workerQ.nextWorker(), worker3)
self.assertEqual(workerQ.nextWorker(), worker4)
def test_canAssignTasks(self): worker = Worker(workerID="W1", begin=tHour(0, 00), end=tHour(23, 59), multitask=2) self.assertFalse(worker.hasReachedTaskLimit()) worker.assignTask(self.task1) self.assertFalse(worker.hasReachedTaskLimit()) worker.assignTask(self.task2) self.assertTrue(worker.hasReachedTaskLimit())
def test_addWorkers(self):
workers = [
Worker(workerID="W1",
begin=tHour(0, 00),
end=tHour(23, 59),
multitask=1),
Worker(workerID="W2",
begin=tHour(0, 00),
end=tHour(23, 59),
multitask=1)
]
taskManager = TaskManager(self.tPeriod(), multitask=1)
taskManager.addWorkers(workers)
self.assertEqual(len(taskManager.workers), 2)
def test_assignTaskToWorkersThatNeedsToBeSwapped(self, isProcessing):
# mock task unit so its isProcessing method always returns true
# as it is time dependent, and will fail if this test if run at certain times
isProcessing.return_value = False
task1 = TaskUnit(createdAt=tHour(0, 0),
deadline=tHour(10, 00),
profit=0,
processing=0,
release=tHour(9, 30),
taskID="t1")
task2 = TaskUnit(createdAt=tHour(0, 0),
deadline=tHour(11, 00),
profit=0,
processing=0,
release=tHour(9, 40),
taskID="t2")
task3 = TaskUnit(createdAt=tHour(0, 0),
deadline=tHour(12, 00),
profit=0,
processing=0,
release=tHour(11, 30),
taskID="t3")
workers = [
Worker(workerID="W4",
begin=tHour(0, 00),
end=tHour(23, 59),
multitask=1),
Worker(workerID="W1",
begin=tHour(0, 00),
end=tHour(23, 59),
multitask=1)
]
taskManager = TaskManager(period=self.tPeriod(), multitask=1)
taskManager.addTask(task2)
taskManager.addTask(task3)
taskManager.addWorkers(workers)
taskManager.assignTasksToWorkers()
self.assertEqual(task2, workers[0].assignedTasks[0])
self.assertEqual(task3, workers[1].assignedTasks[0])
taskManager.addTask(
task1) # earlier release, therfore should be swapped.
taskManager.assignTasksToWorkers()
self.assertEqual(
task1, workers[0].assignedTasks[0]) # should be assigned to worker
self.assertIsNone(
task3.assignedWorker) # workers for task3 should be None
def test_assignTasksToWorkers(self):
initialWorkers = [
Worker(workerID="W1",
begin=tHour(0, 00),
end=tHour(23, 59),
multitask=1),
Worker(workerID="W2",
begin=tHour(0, 00),
end=tHour(23, 59),
multitask=1),
Worker(workerID="W3",
begin=tHour(0, 00),
end=tHour(23, 59),
multitask=1)
]
extraWorkers = [
Worker(workerID="W4",
begin=tHour(0, 00),
end=tHour(23, 59),
multitask=1),
Worker(workerID="W1",
begin=tHour(0, 00),
end=tHour(23, 59),
multitask=1)
]
taskManager = TaskManager(self.tPeriod(), multitask=1)
taskManager.addTasks(self.tasks)
taskManager.addWorkers(initialWorkers)
taskManager.assignTasksToWorkers()
self.assertEqual(self.tasks[0],
initialWorkers[0].assignedTasks[0]) #check w1
self.assertEqual(self.tasks[1],
initialWorkers[1].assignedTasks[0]) #check w2
self.assertEqual(self.tasks[2],
initialWorkers[2].assignedTasks[0]) #check w3
self.assertEqual(taskManager.unassignedTasks[0], self.tasks[3])
self.assertEqual(taskManager.unassignedTasks[1], self.tasks[4])
self.assertEqual(taskManager.unassignedTasks[2], self.tasks[5])
#add more tasks and make sure they were assigned to the new workers.
taskManager.addWorkers(extraWorkers)
taskManager.assignTasksToWorkers()
self.assertEqual(self.tasks[3],
extraWorkers[0].assignedTasks[0]) #check w4
self.assertEqual(self.tasks[4],
extraWorkers[1].assignedTasks[0]) #check w5
self.assertEqual(taskManager.unassignedTasks[0], self.tasks[5])
def test_addWorkersAfterInitialAssignment(self):
workers = [
Worker(workerID="W1",
begin=tHour(0, 00),
end=tHour(23, 59),
multitask=1),
Worker(workerID="W2",
begin=tHour(0, 00),
end=tHour(23, 59),
multitask=1)
]
taskManager = TaskManager(self.tPeriod(), multitask=1)
taskManager.addTasks(self.tasks)
taskManager.addWorkers(workers)
taskManager.assignTasksToWorkers()
self.assertEqual(self.tasks[0], workers[0].assignedTasks[0])
self.assertEqual(self.tasks[1], workers[1].assignedTasks[0])
def test_availableWorkersInPeriod(self):
worker1 = Worker(workerID="W1",
begin=tHour(0, 00),
end=tHour(23, 59),
multitask=2)
worker2 = Worker(workerID="W2",
begin=tHour(0, 00),
end=tHour(23, 59),
multitask=2)
workerQ = WorkerQueue()
workerQ.put(worker1)
workerQ.put(worker2)
availableWorkers = workerQ.availableWorkersDuringPeriod(
tHour(00, 00), tHour(23, 59))
self.assertEqual(availableWorkers[0], worker1)
self.assertEqual(availableWorkers[1], worker2)
self.assertEqual(len(availableWorkers), 2)
def test_analyseWorkersNeededTaskSet(self):
workers = [
Worker(workerID="W1",
begin=tHour(0, 00),
end=tHour(23, 59),
multitask=2),
Worker(workerID="W2",
begin=tHour(0, 00),
end=tHour(23, 59),
multitask=2),
]
taskManager = TaskManager(period=self.tPeriod(), multitask=2)
taskManager.addWorkers(workers)
taskManager.addTasks(self.tasks)
taskManager.assignTasksToWorkers()
conflicts, nonConflicts = taskManager.analyseWorkersForNeededTaskSet()
self.assertEqual(len(conflicts), 2)
self.assertEqual(len(nonConflicts), 1)
def test_removeUnkownWorker(self):
worker = Worker(workerID="W1",
begin=tHour(0, 00),
end=tHour(23, 59),
multitask=1)
taskManager = TaskManager(self.tPeriod(), multitask=1)
taskManager.addWorker(worker)
with self.assertRaises(UnkownWorkerException):
taskManager.removeWorker("thisworkerdoesnotexists")
def test_assignedTasksCountAndUnassignedTasksCount(self):
workers = [
Worker(workerID="W1",
begin=tHour(0, 00),
end=tHour(23, 59),
multitask=1),
Worker(workerID="W2",
begin=tHour(0, 00),
end=tHour(23, 59),
multitask=1)
]
taskManager = TaskManager(period=self.tPeriod(), multitask=1)
taskManager.addTask(self.tasks[0])
taskManager.addTask(self.tasks[1])
taskManager.addTask(self.tasks[2])
taskManager.addWorkers(workers)
taskManager.assignTasksToWorkers()
self.assertEqual(len(taskManager.assignedTasks), 2)
self.assertEqual(len(taskManager.unassignedTasks), 1)
def transormWorkerObject(obj):
# change to datetime format
beginHour, beginMinute = obj["begin"].split(".")
endHour, endMinute = obj["end"].split(".")
obj["begin"] = tHour(int(beginHour), int(beginMinute))
obj["end"] = tHour(int(endHour), int(endMinute))
return Worker(
workerID=obj["id"],
begin=obj["begin"],
end=obj["end"],
multitask=int(obj["multitask"])
)
def test_assignedWorker(self):
taskUnit = TaskUnit(createdAt=self.createdAt,
deadline=self.deadline,
profit=self.profit,
processing=self.processing,
taskID=self.taskID)
worker = Worker(workerID="W1",
begin=tHour(0, 00),
end=tHour(23, 59),
multitask=2)
taskUnit.assignWorker(worker)
self.assertEqual(taskUnit.assignedWorker, worker)
def test_noConflictsAfterAllTasksRemoved(self):
workers = [
Worker(workerID="W1",
begin=tHour(0, 00),
end=tHour(23, 59),
multitask=1),
Worker(workerID="W2",
begin=tHour(0, 00),
end=tHour(23, 59),
multitask=1),
]
taskManager = TaskManager(period=self.tPeriod(), multitask=1)
taskManager.addWorkers(workers)
taskManager.addTask(self.tasks[0])
taskManager.addTask(self.tasks[1])
taskManager.assignTasksToWorkers()
conflicts = taskManager.analyseWorkersForNeededTaskSet()[0]
self.assertEqual(conflicts[0].workersNeeded, 2)
taskManager.finishTask(self.tasks[0].taskID)
taskManager.finishTask(self.tasks[1].taskID)
conflicts = taskManager.analyseWorkersForNeededTaskSet()[0]
self.assertEqual(len(conflicts), 0) # there should be not conflicts
def setUp(self):
self.createdAt = datetime.now()
self.taskID = "test1234"
self.deadline = 500
self.profit = 2.56
self.processing = 100
self.worker = Worker(workerID="W1",
begin=tHour(0, 00),
end=tHour(23, 59),
multitask=2)
self.globalTask = TaskUnit(createdAt=self.createdAt,
deadline=self.deadline,
profit=self.profit,
processing=self.processing,
taskID="test1")
def test_workerGetsAssignedAnotherTaskAfterFinishing(self):
workers = [
Worker(workerID="W1",
begin=tHour(0, 00),
end=tHour(23, 59),
multitask=1),
Worker(workerID="W2",
begin=tHour(0, 00),
end=tHour(23, 59),
multitask=1),
]
taskManager = TaskManager(period=self.tPeriod(), multitask=1)
taskManager.addWorkers(workers)
taskManager.addTasks(self.tasks)
taskManager.assignTasksToWorkers()
self.assertEqual(len(workers[0].assignedTasks), 1)
self.assertEqual(len(workers[1].assignedTasks), 1)
# check that task was unnasigned from worker.
assignedTask = workers[0].assignedTasks[0]
taskManager.finishTask(assignedTask.taskID)
self.assertEqual(len(workers[0].assignedTasks), 0)
# now assign tasks if theres any more.
taskManager.assignTasksToWorkers()
self.assertEqual(len(workers[0].assignedTasks), 1)
def test_maxTasksLimit(self):
worker = Worker(workerID="W1", begin=tHour(0, 00), end=tHour(23, 59), multitask=2)
worker.assignTask(self.task1)
worker.assignTask(self.task2)
with self.assertRaises(MaxTaskLimitReachedException):
worker.assignTask(self.task3)
def test_exactTaskLimit(self): worker = Worker(workerID="W1", begin=tHour(0, 00), end=tHour(23, 59), multitask=2) worker.assignTask(self.task1) worker.assignTask(self.task2) self.assertEqual(len(worker.assignedTasks), 2)
def test_unnasignTask(self): worker = Worker(workerID="W1", begin=tHour(0, 00), end=tHour(23, 59), multitask=2) worker.assignTask(self.task1) worker.unassignTask(self.task1.taskID) self.assertEqual(len(worker.assignedTasks), 0)
def test_availableInPeriod(self): worker = Worker(workerID="W1", begin=tHour(0, 00), end=tHour(23, 59), multitask=2) available = worker.availableInPeriod(begin=tHour(12, 00), end=tHour(13, 00)) self.assertTrue(available)
