public void Check_Level_Equals_Error(string title, string details, int sourceId, Level level)
        {
            ErrorCreateDTO errorCreateDTO = CreateErrorDTO(title, details, sourceId, level);

            Assert.IsTrue(errorCreateDTO.Valid);
            Assert.AreEqual("Error", errorCreateDTO.Level.ToString());
        }
        public ResultDTO Create(ErrorCreateDTO logErroDTO, ClaimsPrincipal user)
        {
            if (logErroDTO == null)
            {
                throw new ArgumentNullException();
            }

            if (!_context.Sources.Where(x => x.Deleted == false).Any(x => x.Id == logErroDTO.SourceId))
            {
                return(new ResultDTO(false, "Invalid Source Id.", null));
            }

            var userId = user.Claims.FirstOrDefault().Value;

            logErroDTO.AddUserId(userId);

            var logErro = _mapper.Map <Error>(logErroDTO);

            _context.Add(logErro);

            if (SaveChanges() == true)
            {
                return(new ResultDTO(true, "Succesfully registred the error.", logErro));
            }

            return(new ResultDTO(false, "Fail", null));
        }
        public void Check_SourceId_Equals_1(string title, string details, int sourceId, Level level)
        {
            ErrorCreateDTO errorCreateDTO = CreateErrorDTO(title, details, sourceId, level);

            Assert.IsTrue(errorCreateDTO.Valid);

            Assert.AreEqual(1, errorCreateDTO.SourceId);
        }
        public void Check_Title_Equals_Title(string title, string details, int sourceId, Level level)
        {
            ErrorCreateDTO errorCreateDTO = new ErrorCreateDTO
            {
                Title    = title,
                Details  = details,
                SourceId = sourceId,
                Level    = level
            };

            Assert.AreEqual("Title", errorCreateDTO.Title);
        }
        public void Null_Token_Throws_ArgumentNullException(string title, string details, int sourceId, Level level, string token)
        {
            ErrorCreateDTO errorCreateDTO = new ErrorCreateDTO
            {
                Title    = title,
                Details  = details,
                SourceId = sourceId,
                Level    = level
            };


            errorCreateDTO.AddUserId(token);
        }
        private static ErrorCreateDTO CreateErrorDTO(string title, string details, int sourceId, Level level)
        {
            var newErrorCreateDTO = new ErrorCreateDTO
            {
                Title    = title,
                Details  = details,
                SourceId = sourceId,
                Level    = level
            };

            newErrorCreateDTO.Validate();
            return(newErrorCreateDTO);
        }
        public void Check_Title_Bigger_Than_3_Chars(string title, string details, int sourceId, Level level)
        {
            var newErrorCreateDTO = new ErrorCreateDTO
            {
                Title    = title,
                Details  = details,
                SourceId = sourceId,
                Level    = level
            };

            newErrorCreateDTO.Validate();

            Assert.IsTrue(newErrorCreateDTO.Invalid);
        }
        public void Check_Token_Equals_Token(string title, string details, int sourceId, Level level, string userId)
        {
            ErrorCreateDTO errorCreateDTO = new ErrorCreateDTO
            {
                Title    = title,
                Details  = details,
                SourceId = sourceId,
                Level    = level
            };

            errorCreateDTO.AddUserId(userId);

            Assert.AreEqual("UserId", errorCreateDTO.UserId);
        }
        public ActionResult <Error> Register(
            [FromServices] IErrorRepository _errorRepository,
            ErrorCreateDTO logErroDTO)
        {
            logErroDTO.Validate();
            if (logErroDTO.Invalid)
            {
                return(BadRequest(new ResultDTO(false, "An error ocurred.", logErroDTO.Notifications)));
            }

            var result = _errorRepository.Create(logErroDTO, User);

            if (result.Success == true)
            {
                return(CreatedAtRoute(nameof(GetErrorById), new { Id = logErroDTO.Title }, result));
            }

            return(BadRequest(result));
        }
        public void Deve_EstaR_Ok_ao_realizar_post(string title, string details, int sourceId, Level level)
        {
            IErrorRepository fakeService;
            ErrorController  controller;

            CreateController(out fakeService, out controller);

            var newError = new ErrorCreateDTO {
                Title = title, Details = details, SourceId = sourceId, Level = level
            };

            var result = controller.Register(fakeService, newError);

            Assert.IsInstanceOfType(result.Result, typeof(CreatedAtRouteResult));

            var actual = (result.Result as CreatedAtRouteResult).Value as ResultDTO;

            Assert.AreEqual(true, actual.Success);
            Assert.AreEqual("Succesfully registred the error.", actual.Message);
            Assert.IsNotNull(actual.Data);
        }
        public void Deve_Falhar_ao_realizar_post_De_Source_Inexistente(string title, string details, int sourceId, Level level, string token)
        {
            IErrorRepository fakeService;
            ErrorController  controller;

            CreateController(out fakeService, out controller);

            var newError = new ErrorCreateDTO {
                Title = title, Details = details, SourceId = sourceId, Level = level
            };

            var result = controller.Register(fakeService, newError);

            Assert.IsInstanceOfType(result.Result, typeof(BadRequestObjectResult));

            var actual = (result.Result as BadRequestObjectResult).Value as ResultDTO;

            Assert.AreEqual(false, actual.Success);
            Assert.AreEqual("Invalid Source Id.", actual.Message);
            Assert.IsNull(actual.Data);
        }
Beispiel #12
0
        public void Deve_Falhar_Ao_Postar_Error_Com_Source_Invalido(string title, string details, int sourceId, Level level)
        {
            FakeContext fakeContext = CreateAndFillContextWithError();

            using (var context = new CentralDeErrorContext(fakeContext.FakeOptions))
            {
                var newSource = new ErrorCreateDTO {
                    Title = title, Details = details, SourceId = sourceId, Level = level
                };
                var service = CreateService(fakeContext, context);

                Assert.IsNotNull(newSource);
                var user = context.Users.FirstOrDefault();

                var identity = new[] { new Claim("Name", user.Id) };
                var result   = service.Create(newSource, new ClaimsPrincipal(new ClaimsIdentity(identity)));

                Assert.AreEqual(false, result.Success);
                Assert.AreEqual("Invalid Source Id.", result.Message);
                Assert.AreEqual(null, result.Data);
            }
        }
        public void Novo_Erro_Deve_Ser_Valido(string title, string details, int sourceId, Level level, string userId)
        {
            ErrorCreateDTO errorCreateDTO = new ErrorCreateDTO
            {
                Title    = title,
                Details  = details,
                SourceId = sourceId,
                Level    = level
            };

            Assert.IsNotNull(errorCreateDTO);

            errorCreateDTO.Validate();

            Assert.IsTrue(errorCreateDTO.Valid);

            errorCreateDTO.AddUserId(userId);
            errorCreateDTO.Validate();

            Assert.IsTrue(errorCreateDTO.Valid);

            Assert.AreEqual(userId, errorCreateDTO.UserId);
        }
Beispiel #14
0
        public void Deve_Realizar_Post(string title, string details, int sourceId, Level level)
        {
            FakeContext fakeContext = CreateAndFillContextWithError();

            using (var context = new CentralDeErrorContext(fakeContext.FakeOptions))
            {
                var service = CreateService(fakeContext, context);

                var newError = new ErrorCreateDTO {
                    Title = title, Details = details, SourceId = sourceId, Level = level
                };

                Assert.IsNotNull(newError);

                Assert.IsNull(service.Get().Where(x => x.Id == newError.Id).FirstOrDefault());

                var user = context.Users.FirstOrDefault();

                var identity = new[] { new Claim("id", user.Id) };

                var savedError = service.Create(newError, new ClaimsPrincipal(new ClaimsIdentity(identity)));

                if (savedError.Success == false)
                {
                    Assert.AreEqual(false, savedError.Success);
                    Assert.AreEqual("Fail", savedError.Message);
                    Assert.IsNull(savedError.Data);
                }
                else
                {
                    Assert.AreEqual(true, savedError.Success);
                    Assert.AreEqual("Succesfully registred the error.", savedError.Message);
                    Assert.IsNotNull(savedError.Data);
                }
            }
        }
        public void Check_Detail_Bigger_Than_6_Chars(string title, string details, int sourceId, Level level)
        {
            ErrorCreateDTO newErrorCreateDTO = CreateErrorDTO(title, details, sourceId, level);

            Assert.IsTrue(newErrorCreateDTO.Invalid);
        }