def check_for_overlapping_shifts(self, shift_queryset): """ Check the given Queryset for possible overlapping shifts and raise a Validation error with pairs of overlapping shifts. :param shift_queryset: :return: """ e = [] for early_shift, late_shift in pairwise( shift_queryset.order_by("started")): if late_shift.started < early_shift.stopped: e.append([ ShiftSerializer(early_shift).data, ShiftSerializer(late_shift).data, ]) if e: raise serializers.ValidationError({ "message": _("An export of the worktime-sheet is not possible due to overlapping shifts." ), "shifts": e, })
def test_shift_in_future_was_reviewed_fails( self, shift_starting_in_future_was_reviewed_querydict, plain_request_object): with pytest.raises(serializers.ValidationError): ShiftSerializer( data=shift_starting_in_future_was_reviewed_querydict, context={ "request": plain_request_object }, ).is_valid(raise_exception=True)
def test_shift_in_past_as_planned_fails( self, shift_is_planned_but_started_in_past_json_querydict, plain_request_object): with pytest.raises(serializers.ValidationError): ShiftSerializer( data=shift_is_planned_but_started_in_past_json_querydict, context={ "request": plain_request_object }, ).is_valid(raise_exception=True)
def get_shifts_list(self, request, *args, **kwargs): """ Custom endpoint which retrieves all shifts corresponding to the issued Contract object. :param request: :param args: :param kwargs: :return: """ instance = self.get_object() serializer = ShiftSerializer(instance.shifts, many=True) return Response(serializer.data)
def test_validate_correct_data(self, valid_shift_querydict, plain_request_object): """ The ShiftSerializer is tested if a valid JSON passes validation. :param valid_shift_querydict: :param plain_request_object: :return: """ ShiftSerializer(data=valid_shift_querydict, context={ "request": plain_request_object }).is_valid(raise_exception=True)
def test_type_validation(self, wrong_type_querydict, plain_request_object): """ The ShiftSerializer is tested whether it raises a Validation if the provided shift type is incorrect. :param wrong_type_querydict: :param plain_request_object: :return: """ with pytest.raises(serializers.ValidationError) as e_info: ShiftSerializer(data=wrong_type_querydict, context={ "request": plain_request_object }).is_valid(raise_exception=True)
def construct_json_object(self, user): user_data = UserSerializer(user).data contract_data = ContractSerializer(Contract.objects.filter(user=user), many=True).data shift_data = ShiftSerializer(Shift.objects.filter(user=user), many=True).data report_data = ReportSerializer(Report.objects.filter(user=user), many=True).data return { "user_data": user_data, "contracts_data": contract_data, "shifts_data": shift_data, "reports_data": report_data, }
def test_tags_validation(self, tags_not_string_querydict, plain_request_object): """ The ShiftSerializer is tested whether it raises a Validation if the tags are incorrect. :param tags_not_string_querydict: :param plain_request_object: :return: """ with pytest.raises(serializers.ValidationError) as e_info: ShiftSerializer( data=tags_not_string_querydict, context={ "request": plain_request_object }, ).is_valid(raise_exception=True)
def test_stopped_before_started_validation( self, stopped_before_started_querydict, plain_request_object): """ The ShiftSerializer is tested whether it raises a Validation if the started and ended datetimes are causally incorrect. :param stopped_before_started_querydict: :param plain_request_object: :return: """ with pytest.raises(serializers.ValidationError) as e_info: ShiftSerializer( data=stopped_before_started_querydict, context={ "request": plain_request_object }, ).is_valid(raise_exception=True)
def test_contract_not_belonging_to_user_validation( self, clockedinshift_invalid_contract_json, plain_request_object): """ The ClockedInShiftSerializer is tested whether it raises a Validation if the provided contract does not belong to the provided user. :param clockedinshift_invalid_contract_json: :param plain_request_object: :return: """ with pytest.raises(serializers.ValidationError): ShiftSerializer( data=clockedinshift_invalid_contract_json, context={ "request": plain_request_object }, ).is_valid(raise_exception=True)
def test_contract_not_belonging_to_user_validation( self, contract_not_belonging_to_user_querydict, plain_request_object): """ The ShiftSerializer is tested whether it raises a Validation if the provided contract does not belong to the provided user. :param contract_not_belonging_to_user_querydict: :param plain_request_object: :return: """ with pytest.raises(serializers.ValidationError) as e_info: ShiftSerializer( data=contract_not_belonging_to_user_querydict, context={ "request": plain_request_object }, ).is_valid(raise_exception=True)
def test_shift_starts_ends_after_contract_validation( self, shift_starts_ends_after_contract_json_querydict, plain_request_object): """ The ShiftSerializer is tested whether it raises a Validation if the shift ends after the contract ends. :param shift_starts_ends_after_contract_json_querydict: :param plain_request_object: :return: """ with pytest.raises(serializers.ValidationError) as e_info: ShiftSerializer( data=shift_starts_ends_after_contract_json_querydict, context={ "request": plain_request_object }, ).is_valid(raise_exception=True)
def test_stopped_on_next_day_validation(self, stopped_on_next_day_querydict, plain_request_object): """ The ShiftSerializer is tested whether it raises a Validation if the shift ends on a different day. :param stopped_on_next_day_querydict: :param plain_request_object: :return: """ with pytest.raises(serializers.ValidationError) as e_info: ShiftSerializer( data=stopped_on_next_day_querydict, context={ "request": plain_request_object }, ).is_valid(raise_exception=True)
def test_shift_started_before_contract_validation( self, shift_starts_before_contract_querydict, plain_request_object): """ The ShiftSerializer is tested whether it raises a Validation if the shift starts before the contract started. :param shift_starts_before_contract_querydict: :param plain_request_object: :return: """ with pytest.raises(serializers.ValidationError): ShiftSerializer( data=shift_starts_before_contract_querydict, context={ "request": plain_request_object }, ).is_valid(raise_exception=True)
def test_shift_not_createable_if_allready_exported_exist( self, valid_shift_querydict, plain_request_object, test_shift_creation_if_allready_exported, ): """ Test that we can not create a Shift if allready exported Shifts exist for this month. :param valid_shift_querydict: :param plain_request_object: :param test_shift_creation_if_allready_exported: :return: """ with pytest.raises(exceptions.PermissionDenied): ShiftSerializer(data=valid_shift_querydict, context={ "request": plain_request_object }).is_valid(raise_exception=True)
def test_report_update_called_on_update(self, plain_request_object, test_contract_change): """ Test if we change the contract of a shift wether the reports of both contracts are updated. We start with fresh 00:00 Reports :param test_contract_change: :return: """ shift = Shift.objects.get(contract=test_contract_change[0]) ShiftSerializer().update(shift, {"contract": test_contract_change[1]}) assert Report.objects.get( contract=test_contract_change[0], month_year=datetime.date(2019, 1, 1)).worktime == datetime.timedelta(0) assert Report.objects.get( contract=test_contract_change[1], month_year=datetime.date( 2019, 1, 1)).worktime == datetime.timedelta(hours=2)