Example #1
0
        public void AddAsync_should_handle_null_reference_exception()
        {
            // Arrange
            MotivationModificatorData request = null;

            BaseResponse expectedResponse = new()
            {
                Code         = Code.DataError,
                ErrorMessage = "Motificator cannot be empty"
            };

            LogData expectedLog = new()
            {
                CallSide         = nameof(MotivationModificatorsService),
                CallerMethodName = nameof(_motivationModificatorsService.AddAsync),
                CreatedOn        = _dateTimeUtil.GetCurrentDateTime(),
                Request          = request,
                Response         = new Exception(expectedResponse.ErrorMessage)
            };

            // Act
            BaseResponse actual = _motivationModificatorsService.AddAsync(request, null).Result;

            // Assert
            Assert.AreEqual(expectedResponse, actual, "Response as expected");
            _loggerMock.Verify(m => m.AddErrorLog(expectedLog), Times.Once);
        }

        [Test]
Example #2
0
 public IActionResult Update([FromBody] MotivationModificatorData request)
 {
     try
     {
         BaseResponse response = _motivationModificatorsClient.UpdateAsync(request);
         LogData      logData  = new()
         {
             CallSide         = nameof(MotivationModificatorController),
             CallerMethodName = nameof(Update),
             CreatedOn        = _dateTimeUtil.GetCurrentDateTime(),
             Request          = request,
             Response         = response
         };
         _logger.AddLog(logData);
         return(Ok(response));
     }
     catch (Exception ex)
     {
         LogData logData = new()
         {
             CallSide         = nameof(MotivationModificatorController),
             CallerMethodName = nameof(Update),
             CreatedOn        = _dateTimeUtil.GetCurrentDateTime(),
             Request          = request,
             Response         = ex
         };
         _logger.AddErrorLog(logData);
         return(InternalServerError());
     }
 }
Example #3
0
 private static MotivationModificator FromRpcModel(MotivationModificatorData motivationModificator)
 {
     return(new MotivationModificator
     {
         Id = motivationModificator.Id,
         StaffId = motivationModificator.StaffId,
         ModValue = motivationModificator.ModValue,
         CreatedOn = motivationModificator.CreatedOn == null ? DateTime.MinValue :  motivationModificator.CreatedOn.ToDateTime()
     });
 }
Example #4
0
        public void GetByStaffId_should_return_response_from_grpc_client()
        {
            // Arrange
            ByStaffIdRequest request = new()
            {
                StaffId = 1
            };

            MotivationModificatorResponse response = new()
            {
                Status = new BaseResponse
                {
                    Code         = Code.Success,
                    ErrorMessage = string.Empty
                },
                Data = new MotivationModificatorData
                {
                    Id        = 1,
                    ModValue  = 1,
                    CreatedOn = Timestamp.FromDateTime(_dateTimeUtil.GetCurrentDateTime()),
                    StaffId   = 1
                }
            };

            BaseMock.Response = response;

            LogData expectedLog = new()
            {
                CallSide         = nameof(MotivationModificatorController),
                CallerMethodName = nameof(_motivationModificatorController.GetBystaffId),
                CreatedOn        = _dateTimeUtil.GetCurrentDateTime(),
                Request          = request,
                Response         = response
            };

            // Act
            ObjectResult actual = _motivationModificatorController.GetBystaffId(request.StaffId) as ObjectResult;
            MotivationModificatorResponse actualData = actual.Value as MotivationModificatorResponse;

            // Assert
            Assert.AreEqual(200, actual.StatusCode, "StatusCode as expected");
            Assert.AreEqual(response, actualData, "Response data as expected");
            _loggerMock.Verify(m => m.AddLog(expectedLog), Times.Once);
            _motivationModificatorsClientMock.Verify(m => m.GetByStaffId(request, null, null, new CancellationToken()), Times.Once);
        }

        [Test]
Example #5
0
        public void GetByStaffId_should_return_modificator_by_staff_id()
        {
            // Arrange
            MotivationModificatorResponse expectedResponse = new()
            {
                Status = new BaseResponse {
                    Code = Code.Success, ErrorMessage = string.Empty
                },
                Data = new MotivationModificatorData {
                    Id = _motivationModificator1.Id, ModValue = _motivationModificator1.ModValue, StaffId = _motivationModificator1.StaffId, CreatedOn = Timestamp.FromDateTime(_dateTimeUtil.GetCurrentDateTime())
                }
            };

            ByStaffIdRequest request = new()
            {
                StaffId = _motivationModificator1.StaffId
            };

            LogData expectedLog = new()
            {
                CallSide         = nameof(MotivationModificatorsService),
                CallerMethodName = nameof(_motivationModificatorsService.GetByStaffId),
                CreatedOn        = _dateTimeUtil.GetCurrentDateTime(),
                Request          = request,
                Response         = expectedResponse
            };

            // Act
            MotivationModificatorResponse actual = _motivationModificatorsService.GetByStaffId(request, null).Result;

            // Assert
            Assert.AreEqual(expectedResponse, actual, "Response as expected");
            _loggerMock.Verify(mocks => mocks.AddLog(expectedLog), Times.Once);
        }

        [Test]
Example #6
0
        public override async Task <BaseResponse> AddAsync(MotivationModificatorData request, ServerCallContext context)
        {
            try
            {
                if (request is null)
                {
                    await _motivationModificatorRepository.AddAsync(null);
                }

                MotivationModificator motivationModificator = FromRpcModel(request);
                int result = await _motivationModificatorRepository.AddAsync(motivationModificator);

                if (result == 0)
                {
                    throw new Exception("Motivation modificator has not been saved");
                }

                BaseResponse response = new()
                {
                    Code         = Code.Success,
                    DataId       = motivationModificator.Id,
                    ErrorMessage = string.Empty
                };

                LogData logData = new()
                {
                    CallSide         = nameof(MotivationModificatorsService),
                    CallerMethodName = nameof(AddAsync),
                    CreatedOn        = _dateTimeUtil.GetCurrentDateTime(),
                    Request          = request,
                    Response         = response
                };
                _logger.AddLog(logData);
                return(response);
            }
            catch (NullReferenceException nrex)
            {
                LogData logData = new()
                {
                    CallSide         = nameof(MotivationModificatorsService),
                    CallerMethodName = nameof(AddAsync),
                    CreatedOn        = _dateTimeUtil.GetCurrentDateTime(),
                    Request          = request,
                    Response         = nrex
                };
                _logger.AddErrorLog(logData);
                return(new BaseResponse
                {
                    Code = Code.DataError,
                    ErrorMessage = nrex.Message
                });
            }
            catch (ArgumentException aex)
            {
                LogData logData = new()
                {
                    CallSide         = nameof(MotivationModificatorsService),
                    CallerMethodName = nameof(AddAsync),
                    CreatedOn        = _dateTimeUtil.GetCurrentDateTime(),
                    Request          = request,
                    Response         = aex
                };
                _logger.AddErrorLog(logData);
                return(new BaseResponse
                {
                    Code = Code.DataError,
                    ErrorMessage = aex.Message
                });
            }
            catch (InvalidOperationException ioex)
            {
                LogData logData = new()
                {
                    CallSide         = nameof(MotivationModificatorsService),
                    CallerMethodName = nameof(AddAsync),
                    CreatedOn        = _dateTimeUtil.GetCurrentDateTime(),
                    Request          = request,
                    Response         = ioex
                };
                _logger.AddErrorLog(logData);
                return(new BaseResponse
                {
                    Code = Code.DataError,
                    ErrorMessage = ioex.Message
                });
            }
            catch (DbUpdateException duex)
            {
                LogData logData = new()
                {
                    CallSide         = nameof(MotivationModificatorsService),
                    CallerMethodName = nameof(AddAsync),
                    CreatedOn        = _dateTimeUtil.GetCurrentDateTime(),
                    Request          = request,
                    Response         = duex
                };
                _logger.AddErrorLog(logData);
                return(new BaseResponse
                {
                    Code = Code.DbError,
                    ErrorMessage = "An error occured while saving motivation modificator"
                });
            }
            catch (Exception ex)
            {
                LogData logData = new()
                {
                    CallSide         = nameof(MotivationModificatorsService),
                    CallerMethodName = nameof(AddAsync),
                    CreatedOn        = _dateTimeUtil.GetCurrentDateTime(),
                    Request          = request,
                    Response         = ex
                };
                _logger.AddErrorLog(logData);
                return(new BaseResponse
                {
                    Code = Code.UnknownError,
                    ErrorMessage = ex.Message
                });
            }
        }