public void Contact_SendMail()
{
// Arrange
var mockContactMessages = new Mock <ContactMessages>();
mockContactMessages.Object.AreaOfInterest = 1;
mockContactMessages.Object.ContactMessage = "test";
mockContactMessages.Object.Email = "test";
mockContactMessages.Object.FirstName = "tes";
mockContactMessages.Object.LastName = "test";
var areaOfInterestNavigation = new Mock <MessagesAreaOfInterest>();
areaOfInterestNavigation.Object.AreaOfInterest = "1";
areaOfInterestNavigation.Object.Id = 1;
areaOfInterestNavigation.Object.ContactMessages = null;
mockContactMessages.Object.AreaOfInterestNavigation = areaOfInterestNavigation.Object;
// Act
var result = _controller.Create(mockContactMessages.Object);
// Assert
Assert.AreEqual(true, result.IsCompleted);
}
public async Task ShouldReturnBadRequestIfModelStateIsInvalid()
{
_contactController.ModelState.AddModelError("Title", "Title should not be empty");
var result = await _contactController.Create(new Contact());
Assert.IsType <BadRequestObjectResult>(result);
}
public void ShouldReturnNewlyCreatedContact()
{
///ARRANGE
//ACT
contactController.Create(new ContactDTO {
Name = "Jim", Number = "3333333"
});
//ASSERT
IEnumerable <Contact> contacts = dbUtil.GetAllData();
Assert.IsTrue(contacts.Any(x => x.ContactName.Equals("Jim")));
}
public void CanViewCreate()
{
//ACT
var viewResult = _contactController.Create(1) as ViewResult;
//ASSERT
Assert.NotNull(viewResult);
var model = viewResult.Model;
Assert.NotNull(model);
Assert.IsInstanceOf <Contact>(model);
Assert.IsInstanceOf <Int32>(viewResult.ViewBag.FDPID);
Assert.IsInstanceOf <string>(viewResult.ViewBag.FDPName);
}
public void Valid_Contact_Create()
{
//Arrange
ContactViewModel c = new ContactViewModel()
{
FirstName = "test1", LastName = "LName1", Email = "*****@*****.**"
};
//Act
var result = (RedirectToRouteResult)objController.Create(c);
//Assert
_ContactServiceMock.Verify(m => m.Add(c), Times.Once);
Assert.AreEqual("Index", result.RouteValues["action"]);
}
public void Create()
{
ContactController obj = new ContactController();
obj.BaseAddress = ContactApiBaseAddress;
Contact newContact = new Contact();
newContact.firstName = "New_Sachin";
newContact.lastName = "New_Erande";
newContact.phoneNumber = "+91-1234078900";
newContact.email = "*****@*****.**";
newContact.status = status.Active;
var vr = obj.Create(newContact);
if (!(vr is RedirectToRouteResult))
{
Assert.Fail("Creation Failed.");
}
Assert.IsNotNull(vr);
//Get the latest created record..verify if properties are successfully created..
var createdItem = GetAllContactsFromRepository().OrderByDescending(x => x.Id).FirstOrDefault();
Assert.IsNotNull(createdItem);
Assert.AreEqual(newContact.firstName, createdItem.firstName);
Assert.AreEqual(newContact.lastName, createdItem.lastName);
Assert.AreEqual(newContact.phoneNumber, createdItem.phoneNumber);
Assert.AreEqual(newContact.email, createdItem.email);
Assert.AreEqual(newContact.status, createdItem.status);
}
public void Create()
{
// Arrange
ContactController controller = new ContactController();
ContactRepository _contact = new ContactRepository();
Contact contact = new Contact
{
FirstName = "Test First Name",
LastName = "Test Last Name",
EMail = "*****@*****.**",
PhoneNumber = "123456789",
};
// Act
ViewResult result = controller.Create(contact) as ViewResult;
Contact createcontact = _contact.GetAllContacts().First(model => model.FirstName == contact.FirstName);
// Assert
Assert.IsNotNull(createcontact, "Failed to add new Contact");
// Assert
Assert.AreEqual(contact.FirstName, createcontact.FirstName);
}
public void TestEditPost()
{
var db = new CsK23T2bEntities();
var model = new CONTACT
{
idContact = db.CONTACTs.AsNoTracking().First().idContact,
tenContact = "789"
};
var controller = new ContactController();
using (var scope = new TransactionScope())
{
var result = controller.Create(model);
var view = result as ViewResult;
controller = new ContactController();
result = controller.Edit(model);
var redirect = result as RedirectToRouteResult;
Assert.IsNotNull(redirect);
Assert.AreEqual("Index", redirect.RouteValues["action"]);
var item = db.CONTACTs.Find(model.idContact);
Assert.IsNotNull(item);
Assert.AreEqual(model.tenContact, item.tenContact);
}
}
public void TestCreatePost()
{
var db = new CsK23T2bEntities();
var model = new CONTACT
{
tenNguoidung = "Nguyen",
tenContact = "123",
sdt = 123456,
noidungContact = "khong co"
};
var controller = new ContactController();
using (var scope = new TransactionScope()){
var result = controller.Create(model);
var redirect = result as RedirectToRouteResult;
Assert.IsNotNull(redirect);
Assert.AreEqual("Index", redirect.RouteValues["action"]);
var item = db.CONTACTs.Find(model.idContact);
Assert.IsNotNull(item);
Assert.AreEqual(model.tenNguoidung, item.tenNguoidung);
Assert.AreEqual(model.tenContact, item.tenContact);
Assert.AreEqual(model.sdt, item.sdt);
Assert.AreEqual(model.noidungContact, item.noidungContact);
}
}
public void TestCreateGet()
{
var controller = new ContactController();
var result = controller.Create();
Assert.IsInstanceOfType(result, typeof(ViewResult));
}
public async Task Create_BadRequest_ListDoesntExist()
{
//Arrange
int nonExistingList = 10;
var contactDTO = new CreateContactDTO()
{
FirstName = "test",
LastName = "test",
Email = "*****@*****.**",
Active = true,
ListIds = new List <int>()
{
nonExistingList
}
};
//Act
var controller = new ContactController(_serviceBusMock.Object, _contactContext.Object);
var actionResult = await controller.Create(contactDTO);
//Assert
var result = Assert.IsType <BadRequestResult>(actionResult);
Assert.Equal((int)System.Net.HttpStatusCode.BadRequest, result.StatusCode);
}
public async Task Create_Created()
{
//Arrange
var firstName = "Elizabeth";
var lastName = "Johnson";
var email = "*****@*****.**";
var phone = "0635555";
var active = true;
var contactDTO = new CreateContactDTO()
{
FirstName = firstName,
LastName = lastName,
Email = email,
Phone = phone,
Active = active
};
//Act
var contactController = new ContactController(_serviceBusMock.Object, _contactContext.Object);
var actionResult = await contactController.Create(contactDTO);
//Assert
var result = Assert.IsType <CreatedAtActionResult>(actionResult);
Assert.Equal((int)System.Net.HttpStatusCode.Created, result.StatusCode);
var returnValue = Assert.IsType <int>(result.Value);
}
public void Create_InvalidItem_IsResponseBadRequest()
{
ContactController controller = GetController();
IActionResult result = controller.Create(null);
Assert.IsInstanceOfType(result, typeof(BadRequestResult));
}
public async Task PostCreateShouldReturnViewValidModel()
{
//Arrange
const string nameValue = "Name";
const string emailValue = "*****@*****.**";
const string subjectValue = "Olelele";
const string messageValue = "Some Message";
string modelName = null;
string modelEmail = null;
string modelSubject = null;
string modelMessage = null;
string successMessage = null;
var contactService = new Mock <IContactService>();
contactService.Setup
(d => d.CreateAsync(
It.IsAny <string>(),
It.IsAny <string>(),
It.IsAny <string>(),
It.IsAny <string>()))
.Callback((string name,
string email, string subject, string message) =>
{
modelName = name;
modelEmail = email;
modelSubject = subject;
modelMessage = message;
})
.Returns(Task.CompletedTask);
var tempData = new Mock <ITempDataDictionary>();
tempData
.SetupSet(t => t[WebConstants.TempDataSuccessMessageKey] = It.IsAny <string>())
.Callback((string key, object message) => successMessage = message as string);
var controller = new ContactController(contactService.Object);
controller.TempData = tempData.Object;
// Act
var result = await controller.Create(new ContactFormServiceModel
{
Name = nameValue,
Email = emailValue,
Subject = subjectValue,
Message = messageValue
});
// Assert
modelName.Should().Be(nameValue);
modelEmail.Should().Be(emailValue);
modelSubject.Should().Be(subjectValue);
modelMessage.Should().Be(messageValue);
result.Should().BeOfType <ViewResult>();
}
public void Post()
{
Contact cnt = GetFirstContact();
_mockContactService.Setup(m => m.AddContact(cnt));
// Act
controller.Create(cnt);
// Assert
}
public void Test_To_Create_Post_Contact_Repository()
{
InMemoryContactRepository contactrepository = new InMemoryContactRepository();
ContactController contactcontroller = GetContactController(contactrepository);
tbl_contact contact = GetContactID();
contactcontroller.Create(contact);
IEnumerable <tbl_contact> contactList = contactrepository.GetAllContact();
//Assert.IsTrue(contactList.Contains(contact));
}
public void GetCreateShouldReturnView()
{
//Arrange
var controller = new ContactController(null);
// Act
var result = controller.Create();
// Assert
result.Should().BeOfType <ViewResult>();
}
void CreateGet_Always_ReturnsCorrectView()
{
//act
var result = (ViewResult)_sut.Create();
//assert
Assert.NotNull(result);
Assert.IsType <ViewResult>(result);
Assert.Equal("Create", result.ViewName);
}
public void When_InvalidContact_Expect_BlankView()
{
// Arrange
var contact = new Contact();
_service.Expect(s => s.CreateContact(contact)).Returns(false);
var controller = new ContactController(_service.Object);
// Act
var result = (ViewResult)controller.Create(contact);
// Assert
Assert.AreEqual("Create", result.ViewName);
}
//When_MyCondition_Then_ExpectedREsult
public void When_ValidContact_Then_IndexAction()
{
// Arrange
var contact = new Contact();
_service.Expect(s => s.CreateContact(contact)).Returns(true);
var controller = new ContactController(_service.Object);
// Act
var result = (RedirectToRouteResult)controller.Create(contact);
// Assert
Assert.AreEqual("Index", result.RouteValues["action"]);
}
public void Create_ValidItem_IsResponseCreated()
{
ContactController controller = GetController();
Contact newContact = new Contact
{
Name = "Gabriel",
DateOfBirth = new DateTime(1998, 11, 23),
Gender = Gender.Male
};
IActionResult result = controller.Create(newContact);
Assert.IsInstanceOfType(result, typeof(CreatedAtRouteResult));
}
public void Should_Return_BadRequest_for_invalid_Contact_Save()
{
//arrange
var contactrepository = A.Fake <IContactRepository>();
//act
ContactController ctrl = new ContactController(contactrepository);
ctrl.ModelState.AddModelError("Email", "Invalid Email");
var badRequest = ctrl.Create(new Contact()
{
Email = "55"
});
//assert
Assert.IsInstanceOfType(badRequest, typeof(BadRequestObjectResult));
}
public void Create_ValidItem_IsItemPersisted()
{
ContactController controller = GetController();
Contact newContact = new Contact
{
Name = "Gabriel",
DateOfBirth = new DateTime(1998, 11, 23),
Gender = Gender.Male
};
CreatedAtRouteResult result = controller.Create(newContact) as CreatedAtRouteResult;
Contact createdContact = result.Value as Contact;
Assert.AreEqual(newContact.Name, createdContact.Name);
Assert.AreEqual(newContact.DateOfBirth, createdContact.DateOfBirth);
Assert.AreEqual(newContact.Gender, createdContact.Gender);
}
public void WhenAddActionRequested_ResultIsNotNullAndAdditionIsSuccess()
{
// arrange
var controller = new ContactController(_mockRepository);
var newContact = new Contact {
FirstName = "Arnoldo", LastName = "Fake", Email = "*****@*****.**"
};
int countBeforeAddition = _mockRepository.GetAll().Count();
// Act
var viewResult = controller.Create(newContact) as RedirectToRouteResult;
// Assert
Assert.IsNotNull(viewResult);
int counterAfterAdition = _mockRepository.GetAll().Count();
Assert.AreEqual(countBeforeAddition + 1, counterAfterAdition);
}
public async Task Create_BadRequest_InvalidModel()
{
//Arrange
var emailThatAlreadyExists = "*****@*****.**";
var model = new CreateContactDTO()
{
FirstName = "test",
LastName = "test",
Email = emailThatAlreadyExists,
Active = true
};
//Act
var controller = new ContactController(_serviceBusMock.Object, _contactContext.Object);
var actionResult = await controller.Create(model);
//Assert
var result = Assert.IsType <BadRequestObjectResult>(actionResult);
}