public void AddEntityTest()
        {
            var servicio = new Servicio();

            _repositoryServicio.Create(servicio);
            Assert.AreEqual(1, _repositoryServicio.Find(s => s.Id == servicio.Id).Count);
        }
        public void CanRunPostMappingEvents()
        {
            IRepository <Product> repo = new RepositoryInMemory <Product>()
            {
                OnRowsMappedCallBack = (products) =>
                {
                    foreach (var product in products)
                    {
                        product.Model = "after mapped " + product.Model;
                    }
                }
            };

            Action <IList <Product> > reset = (products) =>
            {
                foreach (var p in products)
                {
                    p.Model = p.Model.Replace("after mapped ", "");
                }
            };

            var allproducts = GetSampleProducts();

            foreach (var product in allproducts)
            {
                repo.Create(product);
            }

            var first = repo.Get(1);

            Assert.IsTrue(first.Model.StartsWith("after mapped"));
            reset(allproducts);

            var all = repo.GetAll();

            foreach (var item in all)
            {
                Assert.IsTrue(item.Model.StartsWith("after mapped"));
            }
            reset(allproducts);

            var lookup = repo.ToLookUp();

            foreach (var pair in lookup)
            {
                Assert.IsTrue(pair.Value.Model.StartsWith("after mapped"));
            }
            reset(allproducts);

            var matches = repo.Find(Query <Product> .New().Where(p => p.Cost).Is(15));

            foreach (var match in matches)
            {
                Assert.IsTrue(match.Model.StartsWith("after mapped"));
            }
        }
        /// <summary>
        /// Run the application.
        /// </summary>
        public override BoolMessageItem Execute()
        {
            // Create In-Memory repository.
            IRepository <Product> repo = new RepositoryInMemory <Product>("Id,Name,Model,IsInStock,Cost");
            var products = GetSampleProducts();

            products.ForEach(p => repo.Create(p));

            // NOTE: I will not show the Sum, Min, Max, Distinct methods here, please refer to base class
            //       example Example_Repository1_Queryable.
            Product product = new Product("Porsche", "boxster", 10, true);

            // 1. Create
            repo.Create(product);

            // 2. Get
            product = repo.Get(product.Id);

            // 3. Update
            product.Name = "Ford2";
            repo.Update(product);

            // 4. Delete
            repo.Delete(product.Id);

            // 5. Get all
            IList <Product> all = repo.GetAll();

            // 6. Get first using filter.
            Product prod = repo.First("name = 'Honda'");

            // 7. Get by page using sql
            PagedList <Product> page = repo.Find("cost = 20", 1, 3);

            // 8. Get by page using criteria.
            var criteria1 = Query <Product> .New().Where("cost").Is(20);

            PagedList <Product> page2 = repo.Find(criteria1, 1, 3);

            // 9. Delete using criteria.
            var criteria2 = Query <Product> .New().Where(p => p.Name).Is("Skateboard");

            repo.Delete(criteria2);

            // 10. Aggregate using column name, expression, and filter.
            var t = repo.Count(Query <Product> .New().Where(p => p.Name).Null());

            // GROUPING
            var groups1 = repo.Group <int>(e => e.Cost);

            // DISTINCT
            var names = repo.Distinct <string>(e => e.Name);

            // MIN, MAX, AVG, SUM using the Entity properties.
            double min = repo.Min(e => e.Cost);
            double max = repo.Max(e => e.Cost);
            double sum = repo.Sum(e => e.Cost);
            double avg = repo.Avg(e => e.Cost);

            return(BoolMessageItem.True);
        }