public void InsertUserTest()
 {
     EFRepository<GazallionMigraineDataDbContext> repo = new EFRepository<GazallionMigraineDataDbContext>();
     User test = repo.Insert<User>(new User
     {
         FirstName = "John",
         LastName = "Nystrom",
         Addresses = new List<Address>
         {
             new Address
             {
                 City = "Alpharetta",
                 Region = "GA",
                 ZipCode = "30004",
                 StreetName = "Montgomery Ave",
                 StreetNumber = "123"
             }
         },
         EmailAddress = "[email protected]",
         UserConditions = new List<UserCondition>
         {
             new UserCondition
             {
                 Condition = new Condition
                 {
                     Name = "Migraine",
                     Description = "bad headaches"
                 },
                 IncidentThreshold = 9,
                 ThresholdTimePeriod = (int)ThresholdTimePeriod.Monthly
             }
         }
     });
 }

        public void addElement()
        {
            var repository = new EFRepository<User>(new SystemOfFinancialContext());
            repository.Insert(new User(){FirstName = "Flyagin"});

            Assert.NotNull(repository.Get(x=>x.FirstName=="Flyagin"));
        }

 public void ReadMessageTest()
 {
     IRepository repo = new EFRepository();
     MessageService ms = new MessageService(repo);
     var message = ms.ReadMessage(new Guid("c085ce65-9fd8-e011-813c-206a8a339500"), new Guid("37519c07-acd4-e011-ad03-206a8a339500"));
     Assert.IsNotNull(message);
 }

 public void ReadMessage_With_Invalid_MessageID()
 {
     IRepository repo = new EFRepository();
     MessageService ms = new MessageService(repo);
     var message = ms.ReadMessage(new Guid("11111111-1111-1111-1111-111111111111"), new Guid("37519c07-acd4-e011-ad03-206a8a339500"));
     Assert.IsNotNull(message);
 }

 public void Setup()
 {
     var mockDbSet = new MockDbSet<FakeEntity>(TestData.GetFakeEntities());
     _mockDbContext = new Mock<IDbContext>();
     _mockDbContext.Setup(m => m.Set<FakeEntity>()).Returns(mockDbSet);
     _testRepository = new EFRepository<FakeEntity>(_mockDbContext.Object);
 }

 public void ReadMessage_With_Invalid_TravelerID()
 {
     IRepository repo = new EFRepository();
     MessageService ms = new MessageService(repo);
     var message = ms.ReadMessage(new Guid("c085ce65-9fd8-e011-813c-206a8a339500"), new Guid("11111111-1111-1111-1111-111111111111"));
     Assert.IsNotNull(message);
 }

        public void Can_attach_modified_entity()
        {
            var customer = new Customer
            {
                FirstName = "John",
                LastName = "Doe"
            };

            var context = (OrderEntities) OrdersContextProvider();
            context.AddToCustomers(customer);
            #if EF_1_0
            context.SaveChanges(true);
            #else
            context.SaveChanges(SaveOptions.AcceptAllChangesAfterSave);
            #endif
            context.Detach(customer);
            context.Dispose();

            using (var scope = new UnitOfWorkScope())
            {
                customer.LastName = "Changed";
                var repository = new EFRepository<Customer>();
                repository.Attach(customer);
                scope.Commit();
            }

            using (var testData = new EFTestData(OrdersContextProvider()))
            {
                Customer savedCustomer = null;
                testData.Batch(x => savedCustomer = x.GetCustomerById(customer.CustomerID));
                Assert.That(savedCustomer, Is.Not.Null);
                Assert.That(savedCustomer.LastName, Is.EqualTo("Changed"));
            }
        }

 public void Can_fetch_after_a_many_fetch()
 {
     var repository = new EFRepository<Order,int>();
     var fetchingRepo = repository
         .FetchMany(x => x.OrderItems)
         .ThenFetch(x => x.Product);
     Assert.AreEqual("OrderItems.Product", fetchingRepo.FetchingPath);
 }

 public void TestMethod1()
 {
     IRepository repo = new EFRepository<GazallionMigraineDataDbContext>();
     IUserService userService = new UserService(repo);
     var users = userService.GetUsers();
     Assert.IsNotNull(users);
     Assert.IsTrue(users.Any());
 }

        static void Main(string[] args)
        {
            EFRepository<Product> productRepository = new EFRepository<Product>();

            LoggingRepositoryDecorator<Product> updateDeleteLoggingDecorator =
                new LoggingRepositoryDecorator<Product>(productRepository);

            SendRequestRepositoryDecorator<Product> updateDeleteRequestDecorator =
                new SendRequestRepositoryDecorator<Product>(updateDeleteLoggingDecorator);

            UpdateDataWareHouseRepositoryDecorator<Product> updateDataWareHouseDecorator =
                new UpdateDataWareHouseRepositoryDecorator<Product>(updateDeleteRequestDecorator);

            SecurityRepositoryDecorator<Product> securityDecorator =
                new SecurityRepositoryDecorator<Product>(updateDataWareHouseDecorator);


            #region Select işlemi

            Console.WriteLine("--------------------------------------------");

            securityDecorator.Get(3);

            Console.WriteLine("---------------------------------------------\n");

            #endregion

            #region Add işlemi

            Console.WriteLine("--------------------------------------------");

            Product p=new Product(){ ProductId=1, ProductName="Ürünüm 1" };

            securityDecorator.Add(p);

            Console.WriteLine("---------------------------------------------\n");

            #endregion

            #region Update ve Delete İşlemi

            
            Console.WriteLine("---------------------------------------------");

            securityDecorator.Delete(p);

            Console.WriteLine("---------------------------------------------\n");

            Console.WriteLine("---------------------------------------------");

            securityDecorator.Update(p);

            Console.WriteLine("---------------------------------------------\n");

            #endregion

            Console.ReadLine();
        }

   public void Test_QueryByUnifieldId()
   {
       IDbContext db = new R2DisasterContext();
       IRepository<Comprehensive> re = new EFRepository<Comprehensive>(db);
 
       IComprehensiveService service = new ComprehensiveService(re);
       string id = "370101060001";
       Comprehensive c=service.GetByUnifiedID(id);
   }

        public void Can_fectch_many_on_association()
        {
            var repository = new EFRepository<Order,int>();
            var fetchingRepo = repository
                .Fetch(order => order.Customer)
                .ThenFetchMany(customer => customer.Orders);

            Assert.AreEqual("Customer.Orders", fetchingRepo.FetchingPath);
        }

 public void TestGetByUIdCanNotBeNull()
 {
     IDbContext db = new R2DisasterContext();
     IRepository<Comprehensive> re = new EFRepository<Comprehensive>(db);
     IComprehensiveService s = new ComprehensiveService(re);
     InvestigationController c = new InvestigationController(s);
     string a=null;
     c.GetCompleteByUId(a);
 }

 public void Reload()
 {
     _context = new TMPHWEntities();
     EMP = new EFRepository<EMP>(_context);
     DEPT = new EFRepository<DEPT>(_context);
     DEMO_CUSTOMERS = new EFRepository<DEMO_CUSTOMERS>(_context);
     DEMO_ORDERS = new EFRepository<DEMO_ORDERS>(_context);
     DEMO_ORDER_ITEMS = new EFRepository<DEMO_ORDER_ITEMS>(_context);
     DEMO_PRODUCT_INFO = new EFRepository<DEMO_PRODUCT_INFO>(_context);
 }

        public static bool AddEmployee(Employees NewEmployee)
        {
            EFRepository<Employees> EmployeesRepo = new EFRepository<Employees>();

            EmployeesRepo.Add(NewEmployee);

            GlobalUnitOfWork.Commit();
            return true;

        }

        public void SendMessageTest()
        {
            IRepository repo = new EFRepository();
            MessageService ms = new MessageService(repo);
            Guid author = new Guid("37519c07-acd4-e011-ad03-206a8a339500");
            Guid[] recipients = new Guid[] {
                new Guid("d0293215-1dd7-e011-ae1d-206a8a339500"),
                new Guid("45d03989-9fd8-e011-813c-206a8a339500") };

            ms.SendMessage("blablabla", "blablablbla?", author, recipients);
        }

        public void SendMessage_With_Invalid_AuthorID()
        {
            IRepository repo = new EFRepository();
            MessageService ms = new MessageService(repo);
            Guid author = new Guid("11111111-1111-1111-1111-111111111111");
            Guid[] recipients = new Guid[] {
                new Guid("d0293215-1dd7-e011-ae1d-206a8a339500"),
                new Guid("45d03989-9fd8-e011-813c-206a8a339500") };

            ms.SendMessage("blablabla", "blablablbla?", author, recipients);
        }

        public void CreateNews_WithIncorrectData_ShouldThrow()
        {
            // Arrange
            this.CleanUpDatabase();
            var listWithNews = new List<News>();
            var repo = new EFRepository<News>(this.dbcontext);
            var new1 = new News() { Content = null, Title = null, PublishedAt = DateTime.Now };

            // Act
            repo.Add(new1);
            repo.SaveChanges();
        }

        public void ListMessagesTest()
        {
            IRepository repo = new EFRepository();
            MessageService ms = new MessageService(repo);
            Guid traveler = new Guid("d0293215-1dd7-e011-ae1d-206a8a339500");
            var msgs = ms.ListMessages(traveler, FolderType.Inbox, 0, 5);
            foreach (var item in msgs)
            {
                Trace.WriteLine(String.Format("{0} {1} {2}", item.Message.Subject, item.Message.Author.Fullname, item.Message.SentDate));

            }
        }

        public void Delete_Deletes_Record()
        {
            var newCustomer = new Customer
            {
                FirstName = ("John_DELETE_ME_" + DateTime.Now),
                LastName = ("Doe_DELETE_ME_" + DateTime.Now),
                StreetAddress1 = "This record was inserted for deletion",
                City = "Fictional city",
                State = "LA",
                ZipCode = "12345"
            };

            //Re-usable query to query for the matching record.
            var queryForCustomer = new Func<EFRepository<Customer>, Customer>
                (
                x => (from cust in x
                      where cust.FirstName == newCustomer.FirstName && cust.LastName == newCustomer.LastName
                      select cust).FirstOrDefault()
                );

            using (var scope = new UnitOfWorkScope())
            {
                var customerRepository = new EFRepository<Customer>();
                var recordCheckResult = queryForCustomer(customerRepository);
                Assert.That(recordCheckResult, Is.Null);

                customerRepository.Add(newCustomer);
                scope.Commit();
            }

            //Retrieve the record for deletion.
            using (var scope = new UnitOfWorkScope())
            {
                var customerRepository = new EFRepository<Customer>();
                var customerToDelete = queryForCustomer(customerRepository);
                Assert.That(customerToDelete, Is.Not.Null);
                customerRepository.Delete(customerToDelete);
                scope.Commit();
            }

            //Ensure customer record is deleted.
            using (new UnitOfWorkScope())
            {
                var customerRepository = new EFRepository<Customer>();
                var recordCheckResult = queryForCustomer(customerRepository);
                Assert.That(recordCheckResult, Is.Null);
            }
        }