def test_fail_having_more_than_one_task_overlapping(self):
cpu = Cpu('Cpu A')
Task('A', cpu, deadline=5, period=5, cpu_time=5)
Task('B', cpu, deadline=5, period=5, cpu_time=5)
with self.assertRaises(Exception):
for x in range(20):
cpu.update()
def setUp(self):
self.service = KanbanBoardService()
with patch('sqlalchemy.orm.query.Query') as MockQuery:
self.mock_query = MockQuery.return_value
self.mock_query.all.return_value = [
Task(**{
'id': 1,
'title': 'mock-title-1',
'start_time': None,
'end_time': None,
'status': 0,
'payment': 0
}),
Task(**{
'id': 2,
'title': 'mock-title-2',
'start_time': None,
'end_time': None,
'status': 0,
'payment': 0
})
]
with patch('sqlalchemy.orm.session.Session') as MockSession:
self.mock_session = MockSession.return_value
self.mock_session.add.return_value = None
self.mock_session.commit.return_value = None
self.mock_session.close.return_value = None
self.mock_session.query.return_value = self.mock_query
with patch('utils.DBDriver.DBDriver') as MockDBDriver:
self.service.dbms = MockDBDriver.return_value
self.service.dbms.get_session.return_value = self.mock_session
def test_updated_task_after_cpu_udpate(self):
cpu_a = Cpu('Cpu A')
deadline = period = 10
cpu_time = 5
Task('A', cpu_a, deadline, period, cpu_time)
Task('B', cpu_a, deadline, period, cpu_time)
cpu_a.update()
def test_correct_simulation_1(self):
cpu = Cpu('Cpu A')
Task('A', cpu, deadline=10, period=10, cpu_time=5)
Task('B', cpu, deadline=10, period=10, cpu_time=3)
Task('C', cpu, deadline=10, period=20, cpu_time=1)
Task('D', cpu, deadline=10, period=20, cpu_time=1)
for x in range(40):
cpu.update()
def update_task(task_id):
taskdb = TaskDB(g.mysql_db, g.mysql_cursor)
task = Task(request.json['description'])
taskdb.update_task(task_id, task)
return jsonify({"status": "success", "id": task_id}), 200
def add_task():
taskdb = TaskDB(g.mysql_db, g.mysql_cursor)
task = Task(request.json['description'])
result = taskdb.insert_task(task)
return jsonify({"status": "success", "id": result['task_id']}), 200
def create_task(self, event):
result = {
'data': {},
'status': 201 # Created.
}
fields = {'title': ['is_set', 'is_empty']}
errors = self.validator.validate(event, result, fields)
if not errors:
body = event['body']
task = Task(title=body['title'])
session = self.dbms.get_session()
try:
session.add(task)
session.commit()
result['data'] = self.map_to_json(task)
except Exception as ex:
session.rollback()
result['status'] = 500
result['data'] = {'errors': {'db': 'session.commit error'}}
print(ex)
finally:
session.close()
else:
result['data'] = {'errors': errors}
return result
def create_task(self, task, headers):
try:
# Checking if the token is valid or not
payload = JwtHandler.decode_auth_token(headers['Authorization'])
if (payload):
# Creating a task object
task_obj = Task()
task_obj.title = task['title']
task_obj.laneId = task['laneId']
task_obj.description = task['description']
task_obj.userId = payload['sub']
task_obj.position = task['position']
task_obj.notificationTimeMinutes = task[
'notificationTimeMinutes']
# Storing the task in tasks collection
task_collection = self.__get_task_collection()
saved_task = task_collection.insert_one(task_obj.__dict__)
# Storing the task_id in the object and returning
task_obj.id = str(saved_task.inserted_id)
# Closing the DB connection
self.mongo_db.disconnect()
return task_obj
else:
return "Invalid Authorization"
except Exception as exception:
raise exception
def create_task():
description = request.form["description"]
user_id = request.form["user_id"]
duration = request.form["duration"]
completed = request.form["completed"]
user = user_repository.select(user_id)
task = Task(description, user, duration, completed)
task_repository.save(task)
return redirect('/tasks')
# SHOW # for showing one thing in detail. {{task.description}} in the html can be placed inside an <a></a> tag
# GET '/tasks/<id>'
# EDIT # slightly harder code
# GET '/tasks/<id>/edit'
# UPDATE # slightly harder code
# PUT '/tasks/<id>'
# DELETE
# DELETE '/tasks/<id>'
def post(self):
data = ApiTask.parser.parse_args()
print('you are here')
if (len(data) == 0):
task = Task('default', 0, 0, 0)
else:
task = Task(data['name'], data['weekday'], data['hour'],
data['grabber_id'])
if data['url_id']:
task.setUrl(data['url_id'])
try:
task.save_to_db()
except:
return {'message': 'Failed to save'}, 500
return {'id': task.id}, 201
def new(following_id):
follower = User.get_by_id(current_user.id)
following = User.get_by_id(following_id)
if following.is_public:
r = Relationship(follower=follower,
following=following,
is_approved=True)
else:
r = Relationship(follower=follower,
following=following,
is_approved=False)
if r.save():
if following.is_public:
flash(f"You are now following {following.name}.")
return redirect(url_for('users.show', username=following.username))
else:
flash(f"A follow request has been sent to {following.name}.")
rq_job = app.task_queue.enqueue(
'tasks.' + 'send_follow_request_email', following, follower,
url_for('relationships.index'))
task = Task(redis_job_id=rq_job.get_id(),
name='send_follow_request_email',
description='Send user a follow request email.',
relationship=r)
task.save()
return redirect(url_for('users.show', username=following.username))
else:
return render_template(
'users/show.html',
user=following,
photos=Image.select().where(Image.user_id == following.id),
errors=r.errors)
def add_task():
task_title = request.form['title']
task_desc = request.form['description']
new_task = Task(task_title, task_desc, False)
print(request.form)
add_new_task(new_task)
return render_template('index.html', title="Home", tasks=tasks)
def get_tasks(self, project, limit=5):
"""
Arbitrarily narrow down to only one workspace
:param project_id: PHID of Phabricator project
"""
task_list = []
tasks = self.client.maniphest.search(
queryKey="open", constraints={"projects": [project.id]}, limit=limit
)["data"]
# Parse JSON into Task objects
for task in tasks:
task_list.append(
Task(
id=task["id"],
title=task["fields"]["name"],
link="{}".format(Config.PHABRICATOR_URI.replace("/api/", ""))
+ "/T"
+ str(task["id"]),
is_completed=("Completed" == task["fields"]["status"]["value"]),
created_at=datetime.strftime(
datetime.fromtimestamp(task["fields"]["dateCreated"]),
"%Y-%m-%d %H:%m:%S",
),
priority=task["fields"]["priority"]["value"],
project=project,
)
)
return task_list
def test_update_task_error_status_is_incorrect(self):
"""Test: update_task(self, event).
Error: status is incorrect."""
status = Task.Statuses.IN_PROGRESS.value
self.mock_query.get.return_value = Task(**{
'id': 3,
'title': 'mock-title-3',
'start_time': None,
'end_time': None,
'status': status,
'payment': 0
})
status = Task.Statuses.TODO.value
event = {
'body': f'{{"status": {status}}}',
'pathParameters': {
'id': '3'
}
}
actual = self.service.update_task(event)
self.assertEqual(409, actual['status'])
self.assertEqual(
'status is incorrect', actual['data']['errors']['status']
)
def get_any_created_or_killed_task(self, host):
try:
if not self._tasks_collection:
self.reload_collection()
if self._tasks_collection:
task_json = self._tasks_collection.find_one_and_update(
filter={
"$or": [{
'state': TaskStates().CREATED
}, {
'state': TaskStates().KILLED
}]
},
update={
'$set': {
'state': TaskStates().RUNNING,
'host': host
}
},
return_document=ReturnDocument.AFTER)
if task_json:
self._m_logger.info(
'Running task {task}'.format(task=task_json))
return Task().convert_json_to_task(task_json=task_json)
except Exception as e:
self._m_logger.exception(
'Encountered exception while getting task. {e}'.format(e=e))
self.get_completion_stats()
return None
def test_update_task_success_status_done(self):
"""Test: update_task(self, event).
Status: DONE."""
start_dt = datetime.now(tz=pytz.UTC)
start_dt = start_dt - timedelta(days=1)
start_dt = start_dt.replace(
hour=14, minute=0, second=0, microsecond=0
)
self.mock_query.get.return_value = Task(**{
'id': 3,
'title': 'mock-title-3',
'start_time': start_dt,
'end_time': None,
'status': Task.Statuses.IN_PROGRESS.value,
'payment': 0
})
status = Task.Statuses.DONE.value
event = {
'body': f'{{"status": {status}}}',
'pathParameters': {
'id': '3'
}
}
actual = self.service.update_task(event)
self.assertEqual(205, actual['status'])
self.assertEqual(status, actual['data']['status'])
def add_task():
taskTitle = request.form['title']
taskDesc = request.form['description']
newTask = Task(title=taskTitle, description=taskDesc, done=False)
add_new_task(newTask)
return render_template('index.html', title='Home', tasks=tasks)
def get_stat():
task_id = ''.join([random.choice(string.digits) for _ in range(16)])
Task(task_id).create_task()
async_task = AsyncTask(task_id=task_id)
async_task.start()
url_for('task_status', task_id=task_id)
return task_id
def handle(self):
# check if user has admin permissions
if not is_admin(self.user_entity):
return self.abort(401, detail="Admin permissions required")
# populate form with POST data (if available)
form = TaskForm(self.request.POST)
# check if form was POSTed and that user input validates
if self.request.method == 'POST' and form.validate():
# create new project
task = Task()
# populate task from form
form.populate_obj(task)
# add user to project's user list and assign to self
task.users.append(self.user_entity.key)
task.assigned_to = self.user_entity.key
# store task in datastore
task.put()
# record history item
history_text = 'Project added'
add_to_history(task, self.user_entity, history_text)
self.session.add_flash(history_text)
# redirect to task view on succesful save
redirect_url = self.uri_for('task-view', task_id=task.key.urlsafe())
return self.redirect(redirect_url)
# render form and display
context = {'form': form, 'task_or_project': 'project', 'add_or_edit': 'Add new'}
return self.render_response('task_form.html', context)
def handle(self, task_id):
# create new task (with parent)
parent_task_key = ndb.Key(urlsafe=task_id)
task = Task(parent=parent_task_key)
# check if user is authed to add task
if not authed_for_task(parent_task_key.get(), self.user_entity):
return self.abort(401)
# init form object with POST data
form = TaskForm(self.request.POST)
# if form was posted and it validates
if self.request.method == 'POST' and form.validate():
# build task from form and save
form.populate_obj(task)
task.put()
# add history record for this task
history_text = 'Task added'
add_to_history(task, self.user_entity, history_text)
self.session.add_flash(history_text)
# build url to redirect to and issue 302 to browser
redirect_url = self.uri_for('task-view', task_id=task.key.urlsafe())
return self.redirect(redirect_url)
# render form and return (rendering errors if necessary)
context = {'form': form, 'task_or_project': 'task'}
return self.render_response('task_form.html', context)
def test_update_task_exception(self):
"""Test: update_task(self, event)
session.query(Task).all() throws Exception"""
self.mock_query.get.return_value = Task(**{
'id': 3,
'title': 'mock-title-3',
'start_time': None,
'end_time': None,
'status': 0,
'payment': 0
})
status = Task.Statuses.IN_PROGRESS.value
event = {
'body': f'{{"status": {status}}}',
'pathParameters': {
'id': '3'
}
}
self.mock_session.commit.side_effect = Mock(side_effect=Exception())
actual = self.service.update_task(event)
self.assertEqual(500, actual['status'])
self.assertEqual(
'session.commit error', actual['data']['errors']['db']
)
class TestTask(TestCase):
_item = Item()
_task = Task()
_db = SqlitePersistence(":memory:")
def setUp(self):
self._item.rig = "X01"
self._item.description = "Something to handover"
self._item.case = "CAS-12345"
self._db.save(self._item)
self._task.description = "Some update"
self._task.item_id = 1
self._db.save(self._task)
def test_a_task_has_a_description(self):
task = self._db.find(Task, 1)
self.assertEqual(task.description, "Some update")
def test_a_task_has_an_item(self):
task = self._db.find(Task, 1)
self.assertEqual(task.item.description, self._item.description)
def test_a_saved_task_has_a_created_by_timestamp(self):
task = self._db.find(Task, 1)
self.assertIsNotNone(task.created_by)
def test_a_saved_task_has_an_updated_by_timestamp(self):
task = self._db.find(Task, 1)
self.assertIsNotNone(task.updated_by)
def test_a_saved_task_has_a_created_by(self):
task = self._db.find(Task, 1)
self.assertEqual(task.created_by, os.getlogin())
def test_a_saved_task_has_an_updated_by(self):
task = self._db.find(Task, 1)
self.assertEqual(task.updated_by, os.getlogin())
def test_a_completed_task_has_a_completed_at_timestamp(self):
task = self._db.find(Task, 1)
self._db.complete(Task, task.id)
task = self._db.find(Task, 1)
self.assertIsNotNone(task.completed_at)
def test_an_incomplete_task_does_not_have_a_completed_at_timestamp(self):
task = self._db.find(Task, 1)
self._db.incomplete(Task, task.id)
task = self._db.find(Task, 1)
self.assertIsNone(task.completed_at)
def test_a_task_can_be_edited(self):
task = self._db.find(Task, 1)
data = {"description": "a task"}
self._db.edit(Task, task.id, data)
edited = self._db.find(Task, task.id)
self.assertEqual(data["description"], edited.description)
def create(task, completed, task_due_date, task_goal, user_first_name):
user = UserRepository.read(first_name=user_first_name)
task = Task(task=task,
completed=completed,
task_goal=task_goal,
task_due_date=task_due_date,
assigne=user)
return task.put()
def add_task():
if request.method == 'POST':
data = request.json
new_task = Task(data['task'], data['category'], data['completed'])
session.add(new_task)
session.commit()
print(new_task, 'New task was added.')
return 'New task was added.'
def get_task(self, task_id):
"""
:param task_id:
:return: task object
"""
url = "{}/tasks/{}/".format(BASE_URL, task_id)
results = self.r.get(url, headers=self._get_auth_header()).json()
return Task(**results['tasks'])
def select(id):
task = None
sql = "SELECT * FROM tasks WHERE id = %s"
values = [id]
result = run_sql(sql, values)[0]
if result is not None:
task = Task(result['description'], result['assignee'], result['duration'], result['completed'], result['id'] )
return task
def update(id):
description = request.form["description"]
duration = request.form["duration"]
completed = request.form["completed"]
user_id = request.form["user_id"]
user = user_repository.select(user_id)
updated_task =Task(description, user, duration, completed, id)
task_repository.update(updated_task)
return redirect("/tasks")
def add_task():
task_description = request.form.get("task_description")
new_task = Task(task_description)
database = TaskDB(g.mysql_db, g.mysql_cursor)
database.insert_task(new_task)
return redirect('/')
def create():
description = request.form['description']
duration = request.form['duration']
completed = request.form['completed']
user_id = request.form['user_id']
user = user_repository.select(user_id)
new_task = Task(description, user, duration, completed)
task_repository.save(new_task)
return redirect("/tasks")
def update_task(id):
description = request.form['description']
user_id = request.form['user_id']
duration = request.form['duration']
completed = request.form['completed']
user = user_repository.select(user_id)
task = Task(description, user, duration, completed, id)
task_repository.update(task)
return redirect('/tasks')
