public void TestShouldUpdatePerson()
        {
            // Arrange
            var options = SetDbContextOptions();

            SeedDatabase(options);

            int id;

            using (var context = new ExampleContext(options))
            {
                var sut = CreateEfRepository(context);

                id = sut.GetPersons("Second", true).Single().Id;

                // Act
                sut.UpdatePerson(SamplePersons.CreatePerson(id, "Updated", "Human"));
            }

            // Assert
            using (var context = new ExampleContext(options))
            {
                var result = context.Persons.ToList();

                Assert.Equal(3, result.Count);
                Assert.Equal("Updated Human", result.Single(p => p.Id == id).Name);
            }
        }
        public void TestShouldInsertPersontWhenThereAreSomeAlready()
        {
            // Arrange
            var options = SetDbContextOptions();

            SeedDatabase(options);

            using (var context = new ExampleContext(options))
            {
                var sut = CreateEfRepository(context);

                // Act
                var result = sut.AddPerson(SamplePersons.CreatePerson(0, "Fourth", "Human"));

                // Assert
                Assert.True(result.Id > 0);
                Assert.Equal("Fourth Human", result.Name);
            }

            using (var context = new ExampleContext(options))
            {
                var result = context.Persons.ToList();

                Assert.Equal(4, result.Count);
                Assert.Equal("Fourth Human", result.Single(p => p.FirstName == "Fourth").Name);
            }
        }
        public void TestShouldInsertPersonWhenThereAreNone()
        {
            // Arrange
            var options = SetDbContextOptions();

            using (var context = new ExampleContext(options))
            {
                var sut = CreateEfRepository(context);

                // Act
                var result = sut.AddPerson(SamplePersons.CreatePerson());

                // Assert
                Assert.True(result.Id > 0);
                Assert.Equal("First Person", result.Name);
            }

            using (var context = new ExampleContext(options))
            {
                var result = context.Persons.ToList();

                Assert.Equal(1, result.Count);
                Assert.Equal("First Person", result.Single().Name);
            }
        }
        public void TestShouldUpdatePersonWithProductRelations()
        {
            // Arrange
            SeedDatabase(_options);

            int id;

            using (var context = new ExampleContext(_options))
            {
                var sut = CreateEfRepository(context);

                id = CreateEfQueries(context).GetPersons("Second", true).Single().Id;
                int productid = CreateEfQueries(context).GetProducts("No2").Single().Id;

                // Act
                sut.UpdatePerson(SamplePersons.CreatePersonWithProducts(id, "Updated", "Human", productid, Role.Producer));
            }

            // Assert
            using (var context = new ExampleContext(_options))
            {
                var result = CreateEfQueries(context).GetPersons().ToList();

                Assert.AreEqual(3, result.Count);
                Assert.AreEqual("Updated Human", result.Single(p => p.Id == id).Name);
                Assert.AreEqual(1, result.Single(p => p.Id == id).Products.Count);
                Assert.AreEqual(Role.Producer, result.Single(p => p.Id == id).Products.Single().Role);
            }
        }
        public void TestShouldAddPersonToProductAndNotFindProduct()
        {
            _queries.GetPerson(1)
                .Returns(SamplePersons.CreatePerson(1));

            // Arrange
            var sut = CreateProductInteractor();

            // Act & Assert
            Assert.ThrowsException<ArgumentNullException>(() => sut.AddPersonToProduct(1, 1, Role.Actor));
        }
Example #6
0
        public void TestShouldGetName()
        {
            // Arrange

            var sut = SamplePersons.CreatePerson();

            // Act
            string result = sut.Name;

            // Assert
            Assert.AreEqual("First Person", result);
        }
Example #7
0
        public void TestShouldSearchPersonFromName()
        {
            // Arrange
            var allPersons = SamplePersons.CreatePersons();

            // Act
            var result = Entity.Search <Person>("Sec");

            // Assert
            var persons = allPersons.Where(result.Compile());

            Assert.AreEqual(2, persons.Single().Id);
        }
        public void TestShouldAddPersonToProductAndPersonAlreadyExist()
        {
            _queries.GetPerson(1)
                .Returns(SamplePersons.CreatePerson(1));

            _queries.GetProduct(1)
                .Returns(SampleProducts.CreateProductWithPersons(1, "", "", 1));

            // Arrange
            var sut = CreateProductInteractor();

            // Act & Assert
            Assert.ThrowsException<TooManyFoundException>(() => sut.AddPersonToProduct(1, 1, Role.Actor));
        }
Example #9
0
        public void TestShouldMapUpdate()
        {
            // Arrange
            var sut = CreatePerson();

            // Act
            var result = sut.MapUpdate(SamplePersons.CreatePerson(33, "Second", "Human"), SamplePersons.CreatePerson(2));

            // Assert
            Assert.AreEqual(2, result.Id);
            Assert.AreEqual("Second Human", result.Name);
            Assert.AreEqual("Second", result.FirstName);
            Assert.AreEqual("Human", result.LastName);
        }
Example #10
0
        public void TestShouldGetPersonFromName()
        {
            // Arrange
            var persons = SamplePersons.CreatePersons();

            // Act
            var result = Entity.Get <Person>("Second Person");

            // Assert
            var person = persons.SingleOrDefault(result.Compile());

            Assert.IsNotNull(person);
            Assert.AreEqual(2, person.Id);
        }
        public void TestShouldAddPersonToProduct()
        {
            // Arrange
            _queries.GetPerson(1)
                .Returns(SamplePersons.CreatePerson(1));

            _queries.GetProduct(1)
                .Returns(SampleProducts.CreateProduct(1));

            _repository.UpdateProduct(SampleProducts.CreateProduct(1));

            var sut = CreateProductInteractor();

            // Act
            sut.AddPersonToProduct(1, 1, Role.Actor);

            // Assert
            Assert.IsTrue(true);
        }