public void CreateApplication()
        {
            VolatileDataset store = new VolatileDataset();

            Mock <IErrorsReportingService> mockService = new Mock <IErrorsReportingService>();

            mockService.Setup(s => s.CreateApplication(It.IsAny <string>(), It.IsAny <string>()))
            .Callback <string, string>((name, version) =>
            {
                store.Applications.Add(new ErrorReportApplication
                {
                    Id           = store.Applications.Count + 1,
                    Name         = name,
                    Version      = version,
                    FirstRunDate = DateTime.Now,
                    RowVersion   = new byte[] { 0, 0, 0, 0, 0, 0, 0, 1 },
                    Exceptions   = new List <ErrorReportException>()
                });
            })
            .Returns <string, string>((name, version) => store.Applications.Last());

            IErrorsReportingService service     = mockService.Object;
            ErrorReportApplication  application = service.CreateApplication("TestApplication", "1.0.0.0");

            Assert.AreEqual(5, store.Applications.Count);
            Assert.AreEqual(store.Applications.Last().Id, application.Id);
            Assert.AreEqual(store.Applications.Last().FirstRunDate, application.FirstRunDate);
            Assert.AreEqual(store.Applications.Last().Name, application.Name);
        }
        public void AddApplication()
        {
            VolatileDataset store = new VolatileDataset();
            Mock <IErrorsReportingContext> context = new Mock <IErrorsReportingContext>();
            Mock <GenericRepository <ErrorReportApplication> > mockApplicationRepository = new Mock <GenericRepository <ErrorReportApplication> >(context.Object);

            mockApplicationRepository.Setup(r => r.Insert(It.IsAny <ErrorReportApplication>()))
            .Callback <ErrorReportApplication>((app) =>
            {
                app.Id         = 5;
                app.RowVersion = new byte[] { 0, 0, 0, 0, 0, 0, 0, 1 };
                store.Applications.Add(app);
            }).Verifiable();
            this.repository = mockApplicationRepository.Object;

            ErrorReportApplication application = new ErrorReportApplication
            {
                Name         = "Application 3",
                Version      = "1.0.0.0",
                FirstRunDate = new DateTime(2017, 1, 1)
            };

            this.repository.Insert(application);

            mockApplicationRepository.Verify(r => r.Insert(It.IsAny <ErrorReportApplication>()), Times.Once());
            Assert.AreEqual(5, store.Applications.Count);
            Assert.AreEqual(5, store.Applications.Last().Id);
        }
        public void GetApplicationById_DoesntExist()
        {
            VolatileDataset store = new VolatileDataset();
            Mock <IErrorsReportingContext> context = new Mock <IErrorsReportingContext>();
            Mock <GenericRepository <ErrorReportApplication> > mockApplicationRepository = new Mock <GenericRepository <ErrorReportApplication> >(context.Object);

            mockApplicationRepository.Setup(r => r.GetByID(It.IsNotIn <int>(1, 2, 3, 4)))
            .Returns <ErrorReportApplication>(null);
            this.repository = mockApplicationRepository.Object;

            ErrorReportApplication application = this.repository.GetByID(10);

            Assert.AreEqual(null, application);
        }
        public void GetApplication()
        {
            VolatileDataset store = new VolatileDataset();

            Mock <IErrorsReportingService> mockService = new Mock <IErrorsReportingService>();

            mockService.Setup(s => s.GetApplication(It.IsAny <string>(), It.IsAny <string>()))
            .Returns <string, string>((name, version) => store.Applications.Single(a => a.Name == name && a.Version == version));

            IErrorsReportingService service     = mockService.Object;
            ErrorReportApplication  application = service.GetApplication("TestApplicationAlreadyExisting", "1.0.0.0");

            Assert.AreEqual(1, application.Id);
            Assert.AreEqual(new DateTime(2000, 1, 1), application.FirstRunDate);
        }
        public void GetApplications_MinimumIdFiltered()
        {
            VolatileDataset store = new VolatileDataset();
            Mock <IErrorsReportingContext> context = new Mock <IErrorsReportingContext>();
            Mock <GenericRepository <ErrorReportApplication> > mockApplicationRepository = new Mock <GenericRepository <ErrorReportApplication> >(context.Object);

            mockApplicationRepository.Setup(r => r.Get(It.IsAny <Expression <Func <ErrorReportApplication, bool> > >(), null, string.Empty))
            .Returns((Expression <Func <ErrorReportApplication, bool> > filter,
                      Func <IQueryable <ErrorReportApplication>, IOrderedQueryable <ErrorReportApplication> > orderBy,
                      string includeProperties) => store.Applications.Where(filter.Compile()));
            this.repository = mockApplicationRepository.Object;

            var result = this.repository.Get(filter: app => app.Id > 2);

            Assert.AreEqual(2, result.Count());
        }
        public void LogException()
        {
            VolatileDataset store = new VolatileDataset();

            Mock <IErrorsReportingService> mockService = new Mock <IErrorsReportingService>();

            mockService.Setup(s => s.LogException(It.IsIn <int>(store.Applications.Select(a => a.Id)),
                                                  It.IsAny <Exception>(),
                                                  It.IsAny <string>()))
            .Callback <int, Exception, string>((idApplicaton, exception, errorCore) =>
            {
                store.Exceptions.Add(new ErrorReportException
                {
                    Id              = 1,
                    IdApplication   = idApplicaton,
                    Type            = exception.GetType().ToString(),
                    Message         = exception.Message,
                    Source          = exception.Source,
                    SiteModule      = (exception.TargetSite != null && exception.TargetSite.Module != null) ? exception.TargetSite.Module.Name : null,
                    SiteName        = exception.TargetSite.Name,
                    StackTrace      = exception.StackTrace,
                    HelpLink        = exception.HelpLink,
                    Date            = DateTime.Now,
                    CustomErrorType = errorCore,
                });
            })
            .Returns((int?)1);

            IErrorsReportingService service = mockService.Object;

            try
            {
                ExceptionGenerator.ThrowsOne();
            }
            catch (Exception exception)
            {
                int?id = null;
                Assert.That(() =>
                {
                    id = service.LogException(store.Applications.First().Id, exception, "ErrorType.Specific");
                }, Throws.Nothing);

                Assert.IsNotNull(id);

                Assert.AreEqual("One", store.Exceptions.First().Message);
            }
        }
        public void GetApplicationById()
        {
            VolatileDataset store = new VolatileDataset();
            Mock <IErrorsReportingContext> context = new Mock <IErrorsReportingContext>();
            Mock <GenericRepository <ErrorReportApplication> > mockApplicationRepository = new Mock <GenericRepository <ErrorReportApplication> >(context.Object);

            mockApplicationRepository.Setup(r => r.GetByID(It.IsInRange <int>(1, 4, Range.Inclusive)))
            .Returns <int>(id => store.Applications.Find(el => el.Id == id));
            this.repository = mockApplicationRepository.Object;

            ErrorReportApplication application       = this.repository.GetByID(1);
            ErrorReportApplication storedApplication = store.Applications.Single(el => el.Id == 1);

            Assert.AreEqual(application.Name, storedApplication.Name);
            Assert.AreEqual(application.Version, storedApplication.Version);
            Assert.AreEqual(application.FirstRunDate, storedApplication.FirstRunDate);
        }
        public void LogError()
        {
            VolatileDataset store = new VolatileDataset();

            Mock <IErrorsReportingManager> mockManager = new Mock <IErrorsReportingManager>();

            mockManager.Setup(m => m.LogError(It.IsAny <Exception>(),
                                              It.IsAny <AssemblyName>(),
                                              It.IsAny <string>()))
            .Callback <Exception, AssemblyName, string>((exception, assemblyName, errorCode) =>
            {
                store.Exceptions.Add(new ErrorReportException
                {
                    Id              = 1,
                    IdApplication   = store.Applications.First().Id,
                    Type            = exception.GetType().ToString(),
                    Message         = exception.Message,
                    Source          = exception.Source,
                    SiteModule      = (exception.TargetSite != null && exception.TargetSite.Module != null) ? exception.TargetSite.Module.Name : null,
                    SiteName        = exception.TargetSite.Name,
                    StackTrace      = exception.StackTrace,
                    HelpLink        = exception.HelpLink,
                    Date            = DateTime.Now,
                    CustomErrorType = errorCode
                });
            }).Verifiable();
            this.errorsReportingManager = mockManager.Object;

            try
            {
                ExceptionGenerator.ThrowsOne();
            }
            catch (Exception exception)
            {
                Assert.That(() =>
                {
                    this.errorsReportingManager.LogError(exception,
                                                         Assembly.GetExecutingAssembly().GetName(),
                                                         "ErrorType.Specific");
                }, Throws.Nothing);

                mockManager.Verify(m => m.LogError(It.IsAny <Exception>(), It.IsAny <AssemblyName>(), It.IsAny <string>()), Times.Once());
                Assert.AreEqual(1, store.Exceptions.Count);
            }
        }
        public void GetApplications_Ordered()
        {
            VolatileDataset store = new VolatileDataset();
            Mock <IErrorsReportingContext> context = new Mock <IErrorsReportingContext>();
            Mock <GenericRepository <ErrorReportApplication> > mockApplicationRepository = new Mock <GenericRepository <ErrorReportApplication> >(context.Object);

            mockApplicationRepository.Setup(r => r.Get(null, It.IsAny <Func <IQueryable <ErrorReportApplication>, IOrderedQueryable <ErrorReportApplication> > >(), string.Empty))
            .Returns((Expression <Func <ErrorReportApplication, bool> > filter,
                      Func <IQueryable <ErrorReportApplication>, IOrderedQueryable <ErrorReportApplication> > orderBy,
                      string includeProperties) => orderBy.Invoke(store.Applications.AsQueryable()));
            this.repository = mockApplicationRepository.Object;

            var result = this.repository.Get(orderBy: q => q.OrderByDescending(a => a.Id));

            Assert.AreEqual(4, result.Count());
            Assert.AreEqual(1, result.Last().Id);
            Assert.AreEqual(4, result.First().Id);
        }
        public void CreateApplication_AlreadyExisting()
        {
            VolatileDataset store = new VolatileDataset();

            Mock <IErrorsReportingService> mockService = new Mock <IErrorsReportingService>();

            mockService.Setup(s => s.CreateApplication(It.IsIn <string>(store.Applications.Select(a => a.Name)), It.IsAny <string>()))
            .Throws(new DalException(DalErrorType.SqlUniqueConstraintViolation, "Application already exists"));

            IErrorsReportingService service = mockService.Object;

            DalException ex = Assert.Throws <DalException>(() =>
            {
                service.CreateApplication("TestApplicationAlreadyExisting", "1.0.0.0");
            });

            Assert.That(ex.errorType, Is.EqualTo(DalErrorType.SqlUniqueConstraintViolation));
        }
        public void DeleteApplicationById()
        {
            VolatileDataset store = new VolatileDataset();
            Mock <IErrorsReportingContext> context = new Mock <IErrorsReportingContext>();
            Mock <GenericRepository <ErrorReportApplication> > mockApplicationRepository = new Mock <GenericRepository <ErrorReportApplication> >(context.Object);

            mockApplicationRepository.Setup(r => r.Delete(It.IsAny <int>()))
            .Callback((object id) =>
            {
                var index = store.Applications.FindIndex(el => el.Id == (int)id);
                store.Applications.RemoveAt(index);
            }).Verifiable();
            this.repository = mockApplicationRepository.Object;

            this.repository.Delete(1);

            mockApplicationRepository.Verify(r => r.Delete(It.IsAny <int>()), Times.Once());
            Assert.AreEqual(3, store.Applications.Count);
        }
        public void DeleteApplication()
        {
            VolatileDataset store = new VolatileDataset();
            Mock <IErrorsReportingContext> context = new Mock <IErrorsReportingContext>();
            Mock <GenericRepository <ErrorReportApplication> > mockApplicationRepository = new Mock <GenericRepository <ErrorReportApplication> >(context.Object);

            mockApplicationRepository.Setup(r => r.Delete(It.IsAny <ErrorReportApplication>()))
            .Callback((ErrorReportApplication app) =>
            {
                store.Applications.Remove(app);
            }).Verifiable();
            this.repository = mockApplicationRepository.Object;

            ErrorReportApplication application = store.Applications.ElementAt(3);

            this.repository.Delete(application);

            mockApplicationRepository.Verify(r => r.Delete(It.IsAny <ErrorReportApplication>()), Times.Once());
            Assert.AreEqual(3, store.Applications.Count);
        }
        public void GetApplication_NotExisting()
        {
            VolatileDataset store = new VolatileDataset();

            Mock <IErrorsReportingService> mockService = new Mock <IErrorsReportingService>();

            mockService.Setup(s => s.GetApplication(It.IsNotIn <string>(store.Applications.Select(a => a.Name)), It.IsAny <string>()))
            .Returns <string, string>(null);

            IErrorsReportingService service = mockService.Object;

            ErrorReportApplication application = null;

            Assert.That(() =>
            {
                application = service.GetApplication("TestApplicationNotExisting", "1.0.0.0");
            }, Throws.Nothing);

            Assert.IsNull(application);
        }
        public void UpdateApplication()
        {
            VolatileDataset store = new VolatileDataset();
            Mock <IErrorsReportingContext> context = new Mock <IErrorsReportingContext>();
            Mock <GenericRepository <ErrorReportApplication> > mockApplicationRepository = new Mock <GenericRepository <ErrorReportApplication> >(context.Object);

            mockApplicationRepository.Setup(r => r.Update(It.IsAny <ErrorReportApplication>()))
            .Callback <ErrorReportApplication>((app) =>
            {
                var index = store.Applications.FindIndex(el => el.Id == app.Id);
                store.Applications[index] = app;
            }).Verifiable();
            this.repository = mockApplicationRepository.Object;

            ErrorReportApplication application = store.Applications.ElementAt(2);
            string newName    = application.Name = "Application 4";
            string newVersion = application.Version = "1.0.0.0";

            this.repository.Update(application);

            mockApplicationRepository.Verify(r => r.Update(It.IsAny <ErrorReportApplication>()), Times.Once());
            Assert.AreEqual(newName, store.Applications.ElementAt(2).Name);
            Assert.AreEqual(newVersion, store.Applications.ElementAt(2).Version);
        }