public void Create_ContactRecord_ExpectedSuccessfulCreationFlag()
        {
            mockDataContext.Setup((item) => item.Context).Returns(mockAddressBook.Object);

            var contactRepository = new DataRepository.ContactRepository(mockLogger.Object, mockDatabaseSettings.Object, mockDataContext.Object);

            List <DataModel.Contact> contactList = contactModelList.ToList();

            DataModel.Contact newContactModel = new DataModel.Contact()
            {
                Id = 10, FirstName = "FirstName", LastName = "LastName", Type = contactTypeModelList.First()
            };

            contactList.Add(newContactModel);

            mockedContactDBSet = GetQueryableMockDbSet <DataModel.Contact>(contactList.ToList());

            mockAddressBook.Setup((item) => item.SaveChanges()).Returns(1);
            mockAddressBook.Setup((item) => item.ContactTypes).Returns(mockedContactTypeDBSet.Object);
            mockAddressBook.Setup((item) => item.Contacts).Returns(mockedContactDBSet.Object);
            mockAddressBook.Setup((item) => item.AddressList).Returns(mockedAddressDBSet.Object);

            Assert.IsTrue(contactRepository.Create(newContactModel));
            Assert.IsTrue(mockAddressBook.Object.Contacts.SingleOrDefault((item) => item.Id == newContactModel.Id).Id == newContactModel.Id);
        }
        public void ReadById_ContactRecord_ExpectedContactRecordForProvidedContactId()
        {
            int contactId = 1;

            DataModel.Contact contact = new DataModel.Contact()
            {
                Id        = 1,
                FirstName = "FirstName",
                LastName  = "LastName",
                Type      = new DataModel.ContactType()
                {
                    Id   = 1,
                    Type = "PERSON"
                }
            };

            mockContactRepository.Setup((item) => item.Read(contactId)).Returns(
                contact
                );

            var contactRepository = new BusinessRepository.ContactRepository(mockLogger.Object,
                                                                             mockContactRepository.Object
                                                                             );

            var result = contactRepository.Read(contactId);

            Assert.IsNotNull(result);
            Assert.IsTrue(result.FullName == GetFullName(contact));
            Assert.IsTrue(result.ContactType == contact.Type.Id);
        }
        public void ReadById_AddressRecord_ExpectedAddressRecordForProvidedAddressId()
        {
            int addressId = 1;

            DataModel.Address address;
            DataModel.Contact contact = new DataModel.Contact()
            {
                Id        = 1,
                FirstName = "FirstName",
                LastName  = "LastName",
                Type      = new DataModel.ContactType()
                {
                    Id   = 1,
                    Type = "PERSON"
                }
            };

            mockAddressRepository.Setup((item) => item.Read(addressId)).Returns(
                address = new DataModel.Address()
            {
                Id = 1, Street = "Street", Contact = contact
            }
                );

            var addressRepository = new BusinessRepository.AddressRepository(mockLogger.Object,
                                                                             mockAddressRepository.Object
                                                                             );

            var result = addressRepository.Read(addressId);

            Assert.IsNotNull(result);
            Assert.IsTrue(result.FullAddress == GetFullAddress(address));
            Assert.IsTrue(result.ContactId == contact.Id);
        }
        public void ReadByContactId_AddressRecord_ExpectedNoRecordsProvidedContactId()
        {
            DataModel.Contact contact = new DataModel.Contact()
            {
                Id        = 1,
                FirstName = "FirstName",
                LastName  = "LastName",
                Type      = new DataModel.ContactType()
                {
                    Id   = 1,
                    Type = "PERSON"
                }
            };

            mockAddressRepository.Setup((item) => item.ReadByContactId(contact.Id)).Returns(new DataModel.Address[] { });

            var addressRepository = new BusinessRepository.AddressRepository(mockLogger.Object,
                                                                             mockAddressRepository.Object
                                                                             );

            var result = addressRepository.ReadByContactId(contact.Id);

            Assert.IsNotNull(result);
            Assert.IsEmpty(result);
            Assert.IsNull(result.SingleOrDefault((item) => item.Id == 1));
            Assert.IsNull(result.SingleOrDefault((item) => item.Street == "Street1"));
        }
        public void Update_ContactRecord_ExpectedSuccessfulUpdateFlag()
        {
            mockDataContext.Setup((item) => item.Context).Returns(mockAddressBook.Object);

            var contactRepository = new DataRepository.ContactRepository(mockLogger.Object, mockDatabaseSettings.Object, mockDataContext.Object);

            List <DataModel.Contact> contactList = contactModelList.ToList();

            DataModel.Contact updateContactModel = contactModelList.First();

            DateTime oldUpdatedTime = updateContactModel.Updated;

            mockAddressBook.Setup((item) => item.SaveChanges()).Returns(1);
            mockAddressBook.Setup((item) => item.ContactTypes).Returns(mockedContactTypeDBSet.Object);
            mockAddressBook.Setup((item) => item.Contacts).Returns(mockedContactDBSet.Object);
            mockAddressBook.Setup((item) => item.AddressList).Returns(mockedAddressDBSet.Object);

            Assert.IsTrue(contactRepository.Update(updateContactModel));
            Assert.AreNotEqual(updateContactModel.Updated, oldUpdatedTime);
            Assert.IsTrue(mockAddressBook.Object.Contacts.SingleOrDefault((item) => item.Id == updateContactModel.Id).Id == updateContactModel.Id);
        }
        public void ReadByContactId_AddressRecord_ExpectedAddressRecordForProvidedContactId()
        {
            DataModel.Address address1, address2;
            DataModel.Contact contact = new DataModel.Contact()
            {
                Id        = 1,
                FirstName = "FirstName",
                LastName  = "LastName",
                Type      = new DataModel.ContactType()
                {
                    Id   = 1,
                    Type = "PERSON"
                }
            };

            mockAddressRepository.Setup((item) => item.ReadByContactId(contact.Id)).Returns(new DataModel.Address[] {
                address1 = new DataModel.Address()
                {
                    Id = 1, Street = "Street", Contact = contact
                },
                address2 = new DataModel.Address()
                {
                    Id = 2, Street = "Street1", Contact = contact
                }
            });

            var addressRepository = new BusinessRepository.AddressRepository(mockLogger.Object,
                                                                             mockAddressRepository.Object
                                                                             );

            var result = addressRepository.ReadByContactId(contact.Id);

            Assert.IsNotNull(result);
            Assert.IsNotEmpty(result);
            Assert.IsTrue(result.SingleOrDefault((item) => item.Id == 1).FullAddress == GetFullAddress(address1));
            Assert.IsTrue(result.SingleOrDefault((item) => item.Street == "Street1").ContactId == contact.Id);
        }
        public void Update_Contact_ExpectedFailedUpdateFlag()
        {
            mockDataContext.Setup((item) => item.Context).Returns(mockAddressBook.Object);

            var contactRepository = new DataRepository.ContactRepository(mockLogger.Object, mockDatabaseSettings.Object, mockDataContext.Object);

            List <DataModel.Contact> contactList = contactModelList.ToList();

            DataModel.Contact updateContactModel = new DataModel.Contact()
            {
                Id = 10, FirstName = "Street", LastName = "City", Type = contactTypeModelList.First()
            };

            DateTime oldUpdatedTime = updateContactModel.Updated;

            mockAddressBook.Setup((item) => item.SaveChanges()).Returns(0);
            mockAddressBook.Setup((item) => item.ContactTypes).Returns(mockedContactTypeDBSet.Object);
            mockAddressBook.Setup((item) => item.Contacts).Returns(mockedContactDBSet.Object);
            mockAddressBook.Setup((item) => item.AddressList).Returns(mockedAddressDBSet.Object);

            Assert.IsFalse(contactRepository.Update(updateContactModel));
            Assert.AreEqual(updateContactModel.Updated, oldUpdatedTime);
            Assert.IsNull(mockAddressBook.Object.Contacts.SingleOrDefault((item) => item.Id == updateContactModel.Id));
        }
        public void Create_ContactRecord_ExpectedFailedCreationFlag()
        {
            mockDataContext.Setup((item) => item.Context).Returns(mockAddressBook.Object);

            var contactRepository = new DataRepository.ContactRepository(mockLogger.Object, mockDatabaseSettings.Object, mockDataContext.Object);

            List <DataModel.Contact> contactList = contactModelList.ToList();

            DataModel.Contact newContactModel = new DataModel.Contact()
            {
                Id = 10, FirstName = "FirstName", LastName = "LastName", Type = contactTypeModelList.First()
            };

            contactList.Add(newContactModel);

            mockAddressBook.Setup((item) => item.Add(newContactModel)).Throws(new Exception("Unexpected"));
            mockAddressBook.Setup((item) => item.SaveChanges()).Returns(0);
            mockAddressBook.Setup((item) => item.ContactTypes).Returns(mockedContactTypeDBSet.Object);
            mockAddressBook.Setup((item) => item.Contacts).Returns(mockedContactDBSet.Object);
            mockAddressBook.Setup((item) => item.AddressList).Returns(mockedAddressDBSet.Object);

            Assert.IsFalse(contactRepository.Create(newContactModel));
            Assert.IsNull(mockAddressBook.Object.Contacts.SingleOrDefault((item) => item.Id == newContactModel.Id));
        }
 private string GetFullName(DataModel.Contact contact)
 {
     return(contact.FirstName + " " + contact.LastName);
 }
 public void Setup()
 {
     mockContactRepository = new Mock <DataInterface.IContactRepository>();
     mockLogger            = new Mock <ILogger <BusinessRepository.ContactRepository> >();
     contactModel          = new DataModel.Contact();
 }
        public void Setup()
        {
            mockDatabaseSettings = new Mock <DataInterface.IDatabaseSetting>();
            mockLogger           = new Mock <ILogger <DataRepository.AddressRepository> >();
            mockDataContext      = new Mock <DataInterface.IDBContext <DataContext.AddressBook> >();
            mockAddressBook      = new Mock <DataContext.AddressBook>();

            contactTypeModelList = new DataModel.ContactType[] {
                new DataModel.ContactType()
                {
                    Id = 1, Type = "PERSON"
                },
                new DataModel.ContactType()
                {
                    Id = 2, Type = "BUSINESS"
                },
                new DataModel.ContactType()
                {
                    Id = 3, Type = "OTHER"
                },
            };

            contactModelList = new DataModel.Contact[] {
                new DataModel.Contact()
                {
                    Id = 1, FirstName = "FirstName", LastName = "LastName", Type = contactTypeModelList.Single((item) => item.Id == 1)
                },
                new DataModel.Contact()
                {
                    Id = 2, FirstName = "FirstName1", LastName = "LastName1", Type = contactTypeModelList.Single((item) => item.Id == 2)
                },
                new DataModel.Contact()
                {
                    Id = 3, FirstName = "FirstName1", LastName = "LastName1", Type = contactTypeModelList.Single((item) => item.Id == 3)
                }
            };

            addressModelList = new DataModel.Address[] {
                new DataModel.Address()
                {
                    Id = 1, Street = "Street", City = "City", State = "State", Contact = contactModelList.First()
                },
                new DataModel.Address()
                {
                    Id = 2, Street = "Street1", City = "City1", State = "State1", Contact = contactModelList.First()
                },
                new DataModel.Address()
                {
                    Id = 3, Street = "Street", City = "City", State = "State", Contact = contactModelList.Last()
                },
                new DataModel.Address()
                {
                    Id = 4, Street = "Street1", City = "City1", State = "State1", Contact = contactModelList.Last()
                }
            };

            mockedContactDBSet     = GetQueryableMockDbSet <DataModel.Contact>(contactModelList.ToList());
            mockedAddressDBSet     = GetQueryableMockDbSet <DataModel.Address>(addressModelList.ToList());
            mockedContactTypeDBSet = GetQueryableMockDbSet <DataModel.ContactType>(contactTypeModelList.ToList());

            contactModel = contactModelList.First();
            addressModel = addressModelList.First();
        }