def pomodoro_in_progress_with_breaks_and_pauses(task_instance): pomodoro_date_frame = factory.create(klass=DateFrameFactory, task=task_instance, end=None, frame_type=0) factory.create(klass=InnerDateFrameFactory, task=task_instance, frame_type=1, start=get_time_delta({'minutes': 2}), end=get_time_delta({'minutes': 4})) factory.create(klass=InnerDateFrameFactory, task=task_instance, frame_type=1, start=get_time_delta({'minutes': 5}), end=get_time_delta({'minutes': 7})) factory.create(klass=InnerDateFrameFactory, task=task_instance, frame_type=2, start=get_time_delta({'minutes': 10}), end=get_time_delta({'minutes': 12})) factory.create(klass=InnerDateFrameFactory, task=task_instance, frame_type=2, start=get_time_delta({'minutes': 15}), end=get_time_delta({'minutes': 19})) return pomodoro_date_frame
def test_finish_date_frame_with_start_greater_than_end(self, mock_datetime_now, tested_date_frame, task_instance): mock_datetime_now.now.return_value = get_time_delta({'minutes': 20}, ahead=False) with pytest.raises(ValidationError) as exc: finish_date_frame(date_frame_id=tested_date_frame.id) assert exc.value.messages[0] == DateFrameException.messages[DateFrameException.start_greater_than_end]
def date_frame_in_progress_for_yesterday(task_instance): date_frame_instance = factory.create(klass=DateFrameFactory, task=task_instance, start=get_time_delta({'days': 1}, ahead=False), end=None) return date_frame_instance
class TestTodayValidator: @pytest.mark.parametrize('tested_date', [ get_time_delta({'days': 0}), get_time_delta({'days': 1}), get_time_delta({'days': 5}), ]) def test_validate_today_with_valid_dates(self, tested_date): today_validator(value=tested_date) @pytest.mark.parametrize('tested_date', [ get_time_delta({'days': 1}, ahead=False), get_time_delta({'days': 5}, ahead=False), ]) def test_validate_today_with_invalid_dates(self, tested_date): with pytest.raises(ValidationError): today_validator(value=tested_date)
def test_finish_date_frame_with_breaks_and_pauses_saves_proper_duration(self, mock_timezone, pomodoro_in_progress_with_breaks_and_pauses): mock_timezone.now.return_value = get_time_delta({'minutes': 25}, ahead=True) finish_date_frame(date_frame_id=pomodoro_in_progress_with_breaks_and_pauses.id) pomodoro_in_progress_with_breaks_and_pauses.refresh_from_db() break_frames = get_breaks_inside_date_frame( date_frame_object=pomodoro_in_progress_with_breaks_and_pauses, end=pomodoro_in_progress_with_breaks_and_pauses.end).values('start', 'end') breaks_duration = reduce(operator.add, (break_frame['end'] - break_frame['start'] for break_frame in break_frames), timedelta(0)) pause_frames = get_pauses_inside_date_frame( date_frame_object=pomodoro_in_progress_with_breaks_and_pauses, end=pomodoro_in_progress_with_breaks_and_pauses.end).values('start', 'end') pauses_duration = reduce(operator.add, (pause_frame['end'] - pause_frame['start'] for pause_frame in pause_frames), timedelta(0)) breaks_and_pauses_duration = breaks_duration + pauses_duration expected_duration = math.trunc( (pomodoro_in_progress_with_breaks_and_pauses.end - pomodoro_in_progress_with_breaks_and_pauses.start - breaks_and_pauses_duration).seconds / 60) assert round(breaks_and_pauses_duration.seconds) // 60 == 10 assert pomodoro_in_progress_with_breaks_and_pauses.end is not None assert pomodoro_in_progress_with_breaks_and_pauses.duration == timedelta(minutes=expected_duration)
def test_update_form_blocked_until_invalid_datetime(user_model, user_data, active_user): user_data["blocked_until"] = get_time_delta({"days": 1}, ahead=False) user_data["date_joined"] = active_user.date_joined form = AdminSiteUserUpdateForm(instance=active_user, data=user_data) assert not form.is_valid() assert "blocked_until" in form.errors assert form.errors["blocked_until"][ 0] == "This datetime value cannot be lower than the actual date and time."
def test_create_form_blocked_until_invalid_datetime(user_model, user_registration_data): user_registration_data["blocked_until"] = get_time_delta({"days": 1}, ahead=False) form = AdminSiteUserCreationForm(user_registration_data) assert not form.is_valid() assert "blocked_until" in form.errors assert form.errors["blocked_until"][ 0] == "This datetime value cannot be lower than the actual date and time."
def obsolete_date_frames(task_instance): obsolete_pomodoro = factory.create(klass=DateFrameFactory, task=task_instance, start=get_time_delta({'days': 8}, ahead=False), frame_type=0, end=None) obsolete_break = factory.create(klass=DateFrameFactory, task=task_instance, start=get_time_delta({'days': 8}, ahead=False), frame_type=1, end=None) obsolete_pause = factory.create(klass=DateFrameFactory, task=task_instance, start=get_time_delta({'days': 8}, ahead=False), frame_type=2, end=None) return obsolete_pomodoro, obsolete_break, obsolete_pause
def test_jwt_verify_serializer_with_blocked_user(json_web_token, active_user): active_user.blocked_until = get_time_delta({"days": 1}) active_user.save() serializer = CustomVerificationBaseSerializer(data={ 'token': json_web_token }) assert serializer.is_valid() is False assert serializer.errors['non_field_errors'][0] == \ 'User account is currently blocked.'
def test_authentication_fails_for_blocked_user(json_web_token, active_user): active_user.blocked_until = get_time_delta({"days": 1}) active_user.save() payload = jwt_decode_handler(json_web_token) jwt_authentication_class = CustomJWTWebTokenAuthentication() with pytest.raises(AuthenticationFailed) as exc: jwt_authentication_class.authenticate_credentials(payload=payload) assert exc.value.args[0] == 'User account is currently blocked.'
def test_create_form_blocked_until_valid_datetime(user_model, user_registration_data): user_registration_data["blocked_until"] = get_time_delta({"days": 1}) form = AdminSiteUserCreationForm(user_registration_data) assert form.is_valid() user_instance = form.save() assert user_instance.blocked_until is not None assert user_instance in user_model.objects.blocked_standard_users()
def test_custom_refresh_and_verify_jwt_token_with_blocked_user( self, view_url, json_web_token, request_factory, active_user): active_user.blocked_until = get_time_delta({"days": 1}) active_user.save() request = request_factory.post(view_url, {'token': json_web_token}) response = custom_verify_jwt_token(request) assert response.status_code == 400 assert response.data['non_field_errors'][0] == \ "User account is currently blocked."
def test_update_form_blocked_until_valid_datetime(user_model, user_data, active_user): user_data["blocked_until"] = get_time_delta({"days": 1}) user_data["date_joined"] = active_user.date_joined form = AdminSiteUserUpdateForm(instance=active_user, data=user_data) assert form.is_valid() user_instance = form.save() assert user_instance.blocked_until is not None assert user_instance in user_model.objects.blocked_standard_users()
def test_get_breaks_inside_date_frame(self, pomodoro_in_progress_with_breaks): finish_date = get_time_delta({'minutes': 25}) selector_method_result = get_breaks_inside_date_frame( date_frame_object=pomodoro_in_progress_with_breaks, end=finish_date) assert selector_method_result.count() == 2 assert all(date_frame.start > pomodoro_in_progress_with_breaks.start for date_frame in selector_method_result) assert all(date_frame.end < finish_date for date_frame in selector_method_result)
class TestStartDateFrame: @pytest.mark.parametrize( 'date_frame_type', [0, 1, 2] ) def test_start_date_frame_with_valid_start_datetime(self, date_frame_type, task_instance): assert task_instance.frames.count() == 0 start_date_frame(task_id=task_instance.id, frame_type=date_frame_type) assert task_instance.frames.count() == 1 @pytest.mark.parametrize( 'date_frame_type, started_date_frame, nearest_possible_date', [ (0, lazy_fixture('pomodoro_in_progress'), get_time_delta({'minutes': 26})), (0, lazy_fixture('break_in_progress'), get_time_delta({'minutes': 16})), (0, lazy_fixture('pause_in_progress'), get_time_delta({'minutes': 1})), (1, lazy_fixture('pomodoro_in_progress'), get_time_delta({'minutes': 26})), (1, lazy_fixture('break_in_progress'), get_time_delta({'minutes': 16})), (1, lazy_fixture('pause_in_progress'), get_time_delta({'minutes': 1})) ] ) @patch('pomodorr.frames.services.date_frame_service.timezone') def test_start_date_frame_finishes_current_date_frame(self, mock_timezone, date_frame_type, started_date_frame, nearest_possible_date, task_instance): mock_timezone.now.return_value = nearest_possible_date assert started_date_frame.end is None assert task_instance.frames.count() == 1 start_date_frame(task_id=task_instance.id, frame_type=date_frame_type) started_date_frame.refresh_from_db() assert started_date_frame.end is not None assert task_instance.frames.count() == 2 @pytest.mark.parametrize( 'date_frame_type', [0, 1, 2] ) def test_start_date_frame_on_completed_task(self, date_frame_type, completed_task_instance): with pytest.raises(ValidationError) as exc: start_date_frame(task_id=completed_task_instance.id, frame_type=date_frame_type) assert exc.value.messages[0] == DateFrameException.messages[DateFrameException.task_already_completed]
def get_obsolete_date_frames(): # Returns date frames that have been created at least one week ago return models.DateFrame.objects.filter(is_finished=False, start__date__lt=get_time_delta({'days': 7}, ahead=False))
class TestFinishDateFrame: @pytest.mark.parametrize( 'tested_date_frame', [ lazy_fixture('pomodoro_in_progress'), lazy_fixture('break_in_progress'), lazy_fixture('pause_in_progress') ] ) def test_finish_date_frame_with_valid_end_datetime(self, tested_date_frame): finish_date_frame(date_frame_id=tested_date_frame.id) tested_date_frame.refresh_from_db() assert tested_date_frame.end is not None and tested_date_frame.duration is not None @pytest.mark.parametrize( 'tested_date_frame', [ lazy_fixture('pomodoro_in_progress'), lazy_fixture('break_in_progress'), lazy_fixture('pause_in_progress') ] ) @patch('pomodorr.frames.services.date_frame_service.timezone') def test_finish_date_frame_with_start_greater_than_end(self, mock_datetime_now, tested_date_frame, task_instance): mock_datetime_now.now.return_value = get_time_delta({'minutes': 20}, ahead=False) with pytest.raises(ValidationError) as exc: finish_date_frame(date_frame_id=tested_date_frame.id) assert exc.value.messages[0] == DateFrameException.messages[DateFrameException.start_greater_than_end] @pytest.mark.parametrize( 'tested_date_frame', [ lazy_fixture('pomodoro_in_progress'), lazy_fixture('break_in_progress'), lazy_fixture('pause_in_progress') ] ) def test_finish_date_frame_on_completed_task(self, tested_date_frame, task_instance): task_instance.status = 1 task_instance.save() with pytest.raises(ValidationError) as exc: finish_date_frame(date_frame_id=tested_date_frame.id) assert exc.value.messages[0] == DateFrameException.messages[DateFrameException.task_already_completed] @patch('pomodorr.frames.services.date_frame_service.timezone') def test_finish_date_frame_with_breaks_saves_proper_duration(self, mock_timezone, pomodoro_in_progress_with_breaks): mock_timezone.now.return_value = get_time_delta({'minutes': 25}) finish_date_frame(date_frame_id=pomodoro_in_progress_with_breaks.id) pomodoro_in_progress_with_breaks.refresh_from_db() break_frames = get_breaks_inside_date_frame( date_frame_object=pomodoro_in_progress_with_breaks, end=pomodoro_in_progress_with_breaks.end).values('start', 'end') breaks_duration = reduce(operator.add, (break_frame['end'] - break_frame['start'] for break_frame in break_frames), timedelta(0)) expected_duration = math.trunc( (pomodoro_in_progress_with_breaks.end - pomodoro_in_progress_with_breaks.start - breaks_duration).seconds / 60) assert pomodoro_in_progress_with_breaks.end is not None assert pomodoro_in_progress_with_breaks.duration == timedelta(minutes=expected_duration) @patch('pomodorr.frames.services.date_frame_service.timezone') def test_finish_date_frame_with_pauses_saves_proper_duration(self, mock_timezone, pomodoro_in_progress_with_pauses, task_instance): mock_timezone.now.return_value = get_time_delta({'minutes': 25}, ahead=True) finish_date_frame(date_frame_id=pomodoro_in_progress_with_pauses.id) pomodoro_in_progress_with_pauses.refresh_from_db() pause_frames = get_pauses_inside_date_frame( date_frame_object=pomodoro_in_progress_with_pauses, end=pomodoro_in_progress_with_pauses.end).values('start', 'end') pauses_duration = reduce(operator.add, (break_frame['end'] - break_frame['start'] for break_frame in pause_frames), timedelta(0)) expected_duration = math.trunc( (pomodoro_in_progress_with_pauses.end - pomodoro_in_progress_with_pauses.start - pauses_duration).seconds / 60) assert pomodoro_in_progress_with_pauses.end is not None assert pomodoro_in_progress_with_pauses.duration == timedelta(minutes=expected_duration) @patch('pomodorr.frames.services.date_frame_service.timezone') def test_finish_date_frame_with_breaks_and_pauses_saves_proper_duration(self, mock_timezone, pomodoro_in_progress_with_breaks_and_pauses): mock_timezone.now.return_value = get_time_delta({'minutes': 25}, ahead=True) finish_date_frame(date_frame_id=pomodoro_in_progress_with_breaks_and_pauses.id) pomodoro_in_progress_with_breaks_and_pauses.refresh_from_db() break_frames = get_breaks_inside_date_frame( date_frame_object=pomodoro_in_progress_with_breaks_and_pauses, end=pomodoro_in_progress_with_breaks_and_pauses.end).values('start', 'end') breaks_duration = reduce(operator.add, (break_frame['end'] - break_frame['start'] for break_frame in break_frames), timedelta(0)) pause_frames = get_pauses_inside_date_frame( date_frame_object=pomodoro_in_progress_with_breaks_and_pauses, end=pomodoro_in_progress_with_breaks_and_pauses.end).values('start', 'end') pauses_duration = reduce(operator.add, (pause_frame['end'] - pause_frame['start'] for pause_frame in pause_frames), timedelta(0)) breaks_and_pauses_duration = breaks_duration + pauses_duration expected_duration = math.trunc( (pomodoro_in_progress_with_breaks_and_pauses.end - pomodoro_in_progress_with_breaks_and_pauses.start - breaks_and_pauses_duration).seconds / 60) assert round(breaks_and_pauses_duration.seconds) // 60 == 10 assert pomodoro_in_progress_with_breaks_and_pauses.end is not None assert pomodoro_in_progress_with_breaks_and_pauses.duration == timedelta(minutes=expected_duration) @pytest.mark.parametrize( 'tested_date_frame, tested_date_frame_length, expected_error_code', [ (lazy_fixture('pomodoro_in_progress'), get_time_delta({'minutes': 55}), DateFrameException.invalid_pomodoro_length), (lazy_fixture('break_in_progress'), get_time_delta({'minutes': 35}), DateFrameException.invalid_break_length) ] ) @patch('pomodorr.frames.services.date_frame_service.timezone') def test_finish_date_frame_with_longer_than_specified_duration(self, mock_timezone, tested_date_frame, expected_error_code, tested_date_frame_length): mock_timezone.now.return_value = tested_date_frame_length with pytest.raises(ValidationError) as exc: finish_date_frame(date_frame_id=tested_date_frame.id) assert exc.value.messages[0] == DateFrameException.messages[expected_error_code] @pytest.mark.parametrize( 'tested_date_frame, tested_date_frame_length, normalized_date_frame_duration', [ (lazy_fixture('pomodoro_in_progress'), get_time_delta({'minutes': 25, 'seconds': 40}), timedelta(minutes=25)), (lazy_fixture('break_in_progress'), get_time_delta({'minutes': 15, 'seconds': 40}), timedelta(minutes=15)) ] ) @patch('pomodorr.frames.services.date_frame_service.timezone') def test_finish_date_frame_fits_within_length_error_margin(self, mock_timezone, tested_date_frame, normalized_date_frame_duration, tested_date_frame_length): mock_timezone.now.return_value = tested_date_frame_length finish_date_frame(date_frame_id=tested_date_frame.id) tested_date_frame.refresh_from_db() assert tested_date_frame.end is not None assert tested_date_frame.duration == normalized_date_frame_duration @pytest.mark.parametrize( 'tested_date_frame, end_date', [ (lazy_fixture('pomodoro_in_progress'), get_time_delta({'minutes': 23})), (lazy_fixture('break_in_progress'), get_time_delta({'minutes': 12})) ] ) @patch('pomodorr.frames.services.date_frame_service.timezone') def test_force_finish_date_frame_with_proper_end_date(self, mock_timezone, tested_date_frame, end_date): mock_timezone.now.return_value = end_date finished_date_frame = force_finish_date_frame(date_frame=tested_date_frame) assert finished_date_frame.end == end_date @pytest.mark.parametrize( 'tested_date_frame, end_date', [ (lazy_fixture('pomodoro_in_progress'), get_time_delta({'minutes': 51})), (lazy_fixture('break_in_progress'), get_time_delta({'minutes': 31})) ] ) @patch('pomodorr.frames.services.date_frame_service.timezone') def test_force_finish_date_frame_with_end_date_exceeding_estimated_date(self, mock_timezone, tested_date_frame, end_date): mock_timezone.now.return_value = end_date finished_date_frame = force_finish_date_frame(date_frame=tested_date_frame) assert finished_date_frame.end < end_date def test_force_finish_pause_finishes_related_pomodoro(self, pause_in_progress_with_ongoing_pomodoro): pause, pomodoro = pause_in_progress_with_ongoing_pomodoro force_finish_date_frame(date_frame=pause) pause.refresh_from_db() pomodoro.refresh_from_db() assert pause.end is not None assert pomodoro.end is not None assert pause.end < pomodoro.end
def test_get_negative_time_delta(mock_timezone): mock_timezone.now.return_value = datetime(2020, 1, 15, tzinfo=timezone.utc) utc_time_tomorrow = get_time_delta({'days': 1}, ahead=False) assert utc_time_tomorrow == datetime(2020, 1, 14, tzinfo=timezone.utc)
def ready_to_unblock_user(): return UserFactory.create(is_active=True, blocked_until=get_time_delta({"days": 1}, ahead=False))
def blocked_user(blocked_user_data): return UserFactory.create(is_active=True, blocked_until=get_time_delta({"days": 1}), **blocked_user_data)
class TestTaskSerializer: serializer_class = TaskSerializer def test_serialize_many_tasks(self, task_model, task_instance, completed_task_instance): serializer = self.serializer_class(instance=task_model.objects.all(), many=True) assert serializer.data is not None assert len(serializer.data) == 2 def test_serializer_single_task(self, task_instance): serializer = self.serializer_class(instance=task_instance) assert serializer.data is not None assert serializer.data['id'] == str(task_instance.id) def test_save_task_with_valid_data(self, task_data, request_mock, project_instance, priority_instance): task_data['project'] = project_instance.id task_data['priority'] = priority_instance.id serializer = self.serializer_class(data=task_data) serializer.context['request'] = request_mock assert serializer.is_valid() assert serializer.validated_data is not None @pytest.mark.parametrize( 'invalid_field_key, invalid_field_value, get_field', [ ('name', factory.Faker('pystr', max_chars=129).generate(), None), ('name', lazy_fixture('repeatable_task_instance'), 'name'), ('name', '', None), ('user_defined_ordering', random.randint(-999, -1), None), ('user_defined_ordering', '', None), ('pomodoro_number', 'xyz', None), ('pomodoro_number', '', None), ('repeat_duration', timedelta(minutes=5), None), ('repeat_duration', timedelta(days=5, minutes=5), None), ('due_date', get_time_delta({'days': 1}, ahead=False), None), ('due_date', get_time_delta({ 'days': 1 }, ahead=False).strftime('%Y-%m-%d'), None), ('priority', lazy_fixture('priority_instance_for_random_user'), 'id'), ('project', lazy_fixture('project_instance_for_random_user'), 'id'), ('project', '', None), ('status', '', None), ('status', 3, None), ('status', 1, None) # you can create only active tasks ]) def test_save_task_with_invalid_data(self, invalid_field_key, invalid_field_value, get_field, task_data, request_mock, project_instance, priority_instance): task_data['project'] = project_instance.id task_data['priority'] = priority_instance.id if get_field is not None: task_data[invalid_field_key] = getattr(invalid_field_value, get_field) else: task_data[invalid_field_key] = invalid_field_value serializer = self.serializer_class(data=task_data) serializer.context['request'] = request_mock assert serializer.is_valid() is False assert invalid_field_key in serializer.errors def test_update_task_with_valid_data(self, task_data, task_instance, priority_instance, project_instance, request_mock): task_data['project'] = project_instance.id task_data['priority'] = priority_instance.id serializer = self.serializer_class(instance=task_instance, data=task_data) serializer.context['request'] = request_mock assert serializer.is_valid() assert serializer.validated_data is not None @pytest.mark.parametrize( 'invalid_field_key, invalid_field_value, get_field', [('name', factory.Faker('pystr', max_chars=129).generate(), None), ('name', lazy_fixture('repeatable_task_instance'), 'name'), ('name', '', None), ('user_defined_ordering', random.randint(-999, -1), None), ('user_defined_ordering', '', None), ('pomodoro_number', 'xyz', None), ('pomodoro_number', '', None), ('repeat_duration', timedelta(minutes=5), None), ('repeat_duration', timedelta(days=5, minutes=5), None), ('due_date', get_time_delta({'days': 1}, ahead=False), None), ('due_date', get_time_delta({ 'days': 1 }, ahead=False).strftime('%Y-%m-%d'), None), ('priority', lazy_fixture('priority_instance_for_random_user'), 'id'), ('project', lazy_fixture('project_instance_for_random_user'), 'id'), ('project', '', None), ('status', '', None), ('status', 3, None)]) def test_update_task_with_invalid_data(self, invalid_field_key, invalid_field_value, get_field, task_data, task_instance, priority_instance, project_instance, request_mock): task_data['project'] = project_instance.id task_data['priority'] = priority_instance.id if get_field is not None: task_data[invalid_field_key] = getattr(invalid_field_value, get_field) else: task_data[invalid_field_key] = invalid_field_value serializer = self.serializer_class(instance=task_instance, data=task_data) serializer.context['request'] = request_mock assert serializer.is_valid() is False assert invalid_field_key in serializer.errors @pytest.mark.parametrize('changed_field, field_value', [ ('name', 'xyz'), ('status', 1), ('priority', None), ('user_defined_ordering', 5), ('pomodoro_number', 14), ('pomodoro_length', timedelta(minutes=30)), ('due_date', get_time_delta({'days': 1})), ('due_date', None), ('reminder_date', None), ('repeat_duration', None), ]) def test_partial_update_task(self, changed_field, field_value, task_instance, request_mock): task_data = {changed_field: field_value} serializer = self.serializer_class(instance=task_instance, data=task_data, partial=True) serializer.context['request'] = request_mock assert serializer.is_valid() assert all(value in serializer.validated_data for value in task_data) def test_pin_task_to_new_project_with_unique_name_for_new_project( self, task_instance, project_create_batch, request_mock): new_project = project_create_batch[0] task_data = {'project': new_project.id} serializer = self.serializer_class(instance=task_instance, data=task_data, partial=True) serializer.context['request'] = request_mock assert serializer.is_valid() pinned_task = serializer.save() assert pinned_task.project == new_project def test_pin_task_to_new_project_with_colliding_name_for_new_project( self, task_instance, request_mock, duplicate_task_instance_in_second_project): new_project = duplicate_task_instance_in_second_project.project task_data = {'project': new_project.id} serializer = self.serializer_class(instance=task_instance, data=task_data, partial=True) serializer.context['request'] = request_mock assert serializer.is_valid() with pytest.raises(ValidationError) as exc: serializer.save() assert exc.value.messages[0] == TaskException.messages[ TaskException.task_duplicated] def test_complete_one_time_task(self, task_model, task_instance, request_mock): task_data = {'status': task_model.status_completed} serializer = self.serializer_class(instance=task_instance, data=task_data, partial=True) serializer.context['request'] = request_mock assert serializer.is_valid() completed_task = serializer.save() assert completed_task.status == task_model.status_completed def test_complete_repeatable_task_create_new_task_for_next_due_date( self, task_model, request_mock, repeatable_task_instance_without_due_date): task_data = {'status': task_model.status_completed} serializer = self.serializer_class( instance=repeatable_task_instance_without_due_date, data=task_data, partial=True) serializer.context['request'] = request_mock assert serializer.is_valid() completed_task = serializer.save() assert completed_task.status == task_model.status_completed next_task = get_active_tasks(project=completed_task.project, name=completed_task.name)[0] assert next_task.due_date is not None and next_task.due_date.date( ) == timezone.now().date() def test_complete_task_force_finishes_current_pomodoros( self, task_model, task_instance, date_frame_in_progress, request_mock): task_data = {'status': task_model.status_completed} serializer = self.serializer_class(instance=task_instance, data=task_data, partial=True) serializer.context['request'] = request_mock assert date_frame_in_progress.end is None assert serializer.is_valid() completed_task = serializer.save() date_frame_in_progress.refresh_from_db() assert completed_task.status == task_model.status_completed assert date_frame_in_progress.end is not None @pytest.mark.parametrize('completed_task', [ lazy_fixture('completed_task_instance'), lazy_fixture('completed_repeatable_task_instance') ]) def test_reactivate_task(self, completed_task, task_model, request_mock): task_data = {'status': task_model.status_active} serializer = self.serializer_class(instance=completed_task, data=task_data, partial=True) serializer.context['request'] = request_mock assert serializer.is_valid() reactivated_task = serializer.save() assert reactivated_task.status == task_model.status_active @pytest.mark.parametrize('completed_task', [ lazy_fixture('completed_task_instance'), lazy_fixture('completed_repeatable_task_instance') ]) def test_reactivate_task_with_existing_active_duplicate( self, completed_task, task_model, task_instance, request_mock): task_instance.name = completed_task.name task_instance.save() task_data = {'status': task_model.status_active} serializer = self.serializer_class(instance=completed_task, data=task_data, partial=True) serializer.context['request'] = request_mock assert serializer.is_valid() with pytest.raises(ValidationError) as exc: serializer.save() assert exc.value.messages[0] == TaskException.messages[ TaskException.task_duplicated]