public void Should_Execute_Query_With_Performance_Info()
        {
            //Arrange
            var consoleOutLogger = new ConsoleOutLogger("Performance", LogLevel.All, true, true, true, "");
            var context = new TestDataContext(Settings.Default.Connection, new FooMappingConfiguration(),
                                              consoleOutLogger);
            List<Foo> nullResult = context.AsQueryable<Foo>().ToList();

            //Act
            IEnumerable<Foo> result = null;

            result = new FindFoo().RunPerformanceTest(context, consoleOutLogger, false);


            //Assert
            Assert.IsNotNull(result);
        }
        public void Should_Add_log_messages_for_add()
        {
            //Arrange
            Database.SetInitializer(new DropCreateInitializer<TestDataContext>());
            var logger = MockRepository.GenerateMock<ILog>();
            logger.Expect(x => x.TraceFormat(Arg<string>.Is.Anything, Arg<object[]>.Is.Anything)).IgnoreArguments().
                Repeat.Once();
            logger.Expect(x => x.DebugFormat(Arg<string>.Is.Anything, Arg<object[]>.Is.Anything)).IgnoreArguments().
                Repeat.Once();
            var context = new TestDataContext(Settings.Default.Connection, new FooMappingConfiguration(), logger);

            //Act
            context.Add(new Foo());

            //Assert
            logger.VerifyAllExpectations();
        }
        public void ShouldReturnFoo()
        {
            //Arrange
            var context = new TestDataContext(Settings.Default.Connection, new FooMappingConfiguration(),
                                              new ConsoleOutLogger("Test", LogLevel.All, true, true, true, string.Empty));

            var item = new Foo();
            context.Add(item);
            context.Commit();

            var target = Queries.GetById<Foo>(item.Id);

            //Act
            var result = target.Execute(context);

            //Assert
            Assert.AreEqual(item.Id, result.Id);
            context.Remove(result);
            context.Commit();
        }
        public void ShouldReturnFoo()
        {
            //Arrange
            var context = new TestDataContext(Settings.Default.Connection, new FooMappingConfiguration(),
                                              new ConsoleOutLogger("Test", LogLevel.All, true, true, true, string.Empty));

            var item = new Foo();

            context.Add(item);
            context.Commit();

            var target = Queries.GetById <Foo>(item.Id);

            //Act
            var result = target.Execute(context);

            //Assert
            Assert.AreEqual(item.Id, result.Id);
            context.Remove(result);
            context.Commit();
        }
        public void Should_Throw_An_Error_When_Query_Is_To_Slow()
        {
            //Arrange
            var consoleOutLogger = new ConsoleOutLogger("Performance", LogLevel.All, true, true, true, "");
            var context = new TestDataContext(Settings.Default.Connection, new FooMappingConfiguration(),
                                              consoleOutLogger);

            //Act
            IEnumerable<Foo> result = null;
            try
            {
                result = new FindFoo().RunPerformanceTest(context, consoleOutLogger, maxAllowableMilliseconds: -1);
            }
            catch (Exception e)
            {
                Assert.IsTrue(e.Message.Contains("Query FindFoo"));
            }


            //Assert
            Assert.IsNull(result);
        }
        public void Should_Run_Compilation_Test_For_Context()
        {
            //Arrange
            var consoleOutLogger = new ConsoleOutLogger("Performance", LogLevel.All, true, true, true, "");
            var context = new TestDataContext(Settings.Default.Connection, new FooMappingConfiguration(),
                                              consoleOutLogger);

            //Act
            IEnumerable<Foo> result = null;
            try
            {
                var query = new FindFoo();
                context.RunStartUpPerformanceTest(query, consoleOutLogger, maxAllowableMilliseconds: -1);
            }
            catch (Exception e)
            {
                Assert.IsTrue(e.Message.Contains("Context Compilation in"));
            }


            //Assert
            Assert.IsNull(result);
        }
        public void ShouldReturnAllFoos()
        {
            //Arrange
            var context = new TestDataContext(Settings.Default.Connection, new FooMappingConfiguration(),
                                             new ConsoleOutLogger("Test", LogLevel.All, true, true, true, string.Empty));

            var item = new Foo();
            var item2 = new Foo();
            context.Add(item);
            context.Add(item2);
            context.Commit();
            var expectedCount = context.AsQueryable<Foo>().Count();

            var target = Queries.FindAll<Foo>();

            //Act
            var results = target.Execute(context);

            //Assert
            Assert.AreEqual(results.Count(), expectedCount);
            context.Remove(item);
            context.Remove(item2);
            context.Commit();
        }