public async Task UpdateClient_ShouldReturnUnathorized_IfThereIsNoClaims()
{
//arrange
int mockCustId = 1;
Client c1 = new Client {
Id = mockCustId
};
//faked claims:
var xd = new ClaimsIdentity();
var mockRepo = new Mock <ICustomerRepository>();
var mockMapper = new Mock <IMapper>();
var mockContr = new Mock <ProductsController>();
ClientDetailedDto cd1 = new ClientDetailedDto();
mockRepo.Setup(repo => repo.GetCustomer(mockCustId)).ReturnsAsync(c1);
mockRepo.Setup(repo => repo.SaveAll());
var controller = new ClientsController(mockRepo.Object, mockMapper.Object);
var mocked = controller.User;
var res = await controller.UpdateClient(mockCustId, cd1);
Assert.IsType <UnauthorizedResult>(res);
}
public async Task Get()
{
var client = new ClientEdit()
{
Id = Guid.NewGuid(),
FirstName = "1",
LastName = "2",
DateOfBirth = new DateTime(1982, 10, 3),
IdNumber = "3",
Initials = "4",
MaidenName = "5",
MarriageDate = new DateTime(2010, 03, 25),
MarritalStatusId = Guid.NewGuid(),
AlternateIdNumber = "6",
PreferredName = "7",
TaxNumber = "8",
ClientTypeId = Guid.NewGuid()
};
var service = new Mock <IClientService>();
var authService = TestHelper.MockAuthenticationService(Scope.Branch);
service.Setup(c => c.GetClient(It.IsAny <ScopeOptions>(), It.Is <Guid>(m => m == client.Id.Value)))
.ReturnsAsync(client);
var controller = new ClientsController(service.Object, authService.Object);
var result = await controller.Get(client.Id.Value);
var okResult = Assert.IsType <OkObjectResult>(result);
var returnValue = Assert.IsType <ClientEdit>(okResult.Value);
Assert.Same(client, returnValue);
}
public async Task Delete()
{
var clientId = Guid.NewGuid();
var service = new Mock <IClientService>();
var authService = TestHelper.MockAuthenticationService(Scope.Branch);
var result = new Result()
{
Success = true
};
ScopeOptions options = null;
Guid deleted = Guid.Empty;
service.Setup(c => c.DeleteClient(It.IsAny <ScopeOptions>(), It.Is <Guid>(m => m == clientId)))
.Callback((ScopeOptions o, Guid d) =>
{
deleted = d;
options = o;
})
.ReturnsAsync(result);
var controller = new ClientsController(service.Object, authService.Object);
var actual = await controller.Delete(clientId);
Assert.Equal(clientId, deleted);
Assert.Equal(Scope.Branch, options.Scope);
var okResult = Assert.IsType <OkObjectResult>(actual);
var returnValue = Assert.IsType <Result>(okResult.Value);
Assert.Same(result, returnValue);
}
public async void GetClientByIdAsync_Returns_One_Client(int id)
{
//get the first Client and map it to its DTO
var client = _clients.First(cl => cl.Id == id);
var expectedClientDto = _mapper.Map <ClientDTO>(client);
//specify the mockRepo return
_mockRepository.Setup(repo => repo.GetOneByAsync(cl => cl.Id == id)).ReturnsAsync(client);
//instantiate the controller, and call the method
var controller = new ClientsController(_mockRepository.Object, _mapper, _logger);
//Create Custom ControllerContext and add it to Controller for vars req and user in ClientsController.GetClientByIdAsync()
controller.ControllerContext = new ControllerContextModel();
//Call the SUT method
var actionResult = await controller.GetClientByIdAsync(id);
//Assert the result
Assert.NotNull(actionResult);
//convert ActionResult to OkObjectResult to get its Value: a Client type
var result = Assert.IsType <OkObjectResult>(actionResult.Result);
//get the ObjectResult.Value
var actualClientDto = result.Value as ClientDTO;
//use FluentAssertions to compare Reference types
actualClientDto.Should().BeEquivalentTo(expectedClientDto, options => options.ComparingByMembers <ClientDTO>());
}
public void DeleteAll_ReturnsCorrectActionType_RedirectToActionResult()
{
ClientsController controller = new ClientsController();
IActionResult view = controller.DeleteAll();
Assert.IsInstanceOfType(view, typeof(RedirectToActionResult));
}
public async void UpdateClientAsync_Updates_One_Client_Returns_200_And_Client_Updated(int id)
{
//declare a Client
var expectedClient = ClientsData.getTestClients().First <Client>(cl => cl.Id == id);
ClientDTO expectedDTO = _mapper.Map <ClientDTO>(expectedClient);
//set repo return for getting the object to update
_mockRepository.Setup(repo => repo.GetOneByAsync(cl => cl.Id == expectedClient.Id))
.ReturnsAsync(expectedClient);
//set mockRepo return for Update action
_mockRepository.Setup(repo => repo.UpdateTAsync(expectedClient)).ReturnsAsync(1);
//instantiate the controller, passing the repo object
var controller = new ClientsController(_mockRepository.Object, _mapper, _logger);
//Call the SUT method - returns ActionResult<Client> type
var actionResult = await controller.UpdateClientAsync(expectedClient.Id, expectedClient);
//Get the int result from the posted ActionResult
var okObjectResult = actionResult.Result as OkObjectResult;
var statusCode = okObjectResult.StatusCode;
ClientDTO actualDTO = okObjectResult.Value as ClientDTO;
//Assert the result
Assert.NotNull(actionResult);
//Validate StatusCode
Assert.Equal(200, statusCode);
//Validate the actual Client
actualDTO.Should().BeEquivalentTo(expectedDTO, options => options.ComparingByMembers <ClientDTO>());
}
public async void DeleteClientAsync_Deletes_One_Client_And_Returns_Number_Of_Deletions(int id)
{
//declare a Client
var expectedClient = ClientsData.getTestClients().First(cl => cl.Id == id);
ClientDTO expectedDTO = _mapper.Map <ClientDTO>(expectedClient);
//set repo return for getting the object to delete
_mockRepository.Setup(repo => repo.GetOneByAsync(cl => cl.Id == id))
.ReturnsAsync(expectedClient);
//set mockRepo return for Delete action
_mockRepository.Setup(repo => repo.DeleteTAsync(expectedClient)).ReturnsAsync(1);
//instantiate the controller, passing the repo object
var controller = new ClientsController(_mockRepository.Object, _mapper, _logger);
//Call the controller method
var actionResult = await controller.DeleteClientAsync(id);
//Get the int result
var okObjectResult = actionResult.Result as OkObjectResult;
var statusCode = okObjectResult.StatusCode;
int actualDeleted = (int)okObjectResult.Value;
//Assert the result
Assert.NotNull(actionResult);
//Validate StatusCode
Assert.Equal(200, statusCode);
//Validate the number of BAs deleted
Assert.Equal(1, actualDeleted);
}
public void RegisterMethod_CompleteRequest_Correct()
{
var dbLayer = new EfAdvertDbService(new s19191Context());
var configuration = new ConfigurationBuilder();
configuration.AddJsonFile("D:/APBD/AdvertApi/AdvertApiTests/TestSecret.json");
var cont = new ClientsController(configuration.Build(), dbLayer);
var result = cont.Register(new RegisterRequest
{
FirstName = "John",
LastName = "Kowalski",
Email = "*****@*****.**",
Phone = "454-232-222",
//zmień login na inny, jak chcesz żeby było dobrze, albo usuń clienta o podanym loginie
Login = "******",
Password = "******"
});
Assert.IsNotNull(result);
Assert.IsTrue(result is ObjectResult);
var vr = (ObjectResult)result;
Assert.IsNotNull(vr.Value);
var vm = (RegisterResponse)vr.Value;
Assert.IsNotNull(vm.TokensReponse);
}
public void RegisterMethod_CompleteRequest_InCorrect()
{
var dbLayer = new EfAdvertDbService(new s19191Context());
var configuration = new ConfigurationBuilder();
configuration.AddJsonFile("D:/APBD/AdvertApi/AdvertApiTests/TestSecret.json");
var cont = new ClientsController(configuration.Build(), dbLayer);
var result = cont.Register(new RegisterRequest
{
FirstName = "John",
LastName = "Kowalski",
Email = "*****@*****.**",
Phone = "454-232-222",
Login = "******",
Password = "******"
});
Assert.IsNotNull(result);
Assert.IsTrue(result is ObjectResult);
var vr = (ObjectResult)result;
Assert.IsNotNull(vr.Value);
//nie działa to tak jak myślałem
// var vm = (LoginOccupiedException) vr.Value;
// Assert.IsNotNull(vm);
// Assert.IsTrue(vm.Message.Equals("Podany login jest już zajęty, spróbuj inny"));
}
public void PostClient_WithException_ReturnsBadRequest()
{
var client = new Client();
//fake request
HttpRequestMessage reqFake = new HttpRequestMessage();
reqFake.Properties.Add(HttpPropertyKeys.HttpConfigurationKey, new HttpConfiguration());
var expectedRes = reqFake.CreateResponse(HttpStatusCode.BadRequest, client);
//mock repository
Mock <IClientsRepository> repo = new Mock <IClientsRepository>();
repo.Setup(m => m.Update(It.IsAny <Client>())).Throws(new InvalidOperationException());
//api request
ClientsController api = new ClientsController(repo.Object);
api.Request = new HttpRequestMessage();
api.Request.Properties.Add(HttpPropertyKeys.HttpConfigurationKey, new HttpConfiguration());
var res = api.PostClient(client);
//assert status code
Assert.AreEqual(expectedRes.StatusCode, res.StatusCode);
}
public void SetUp()
{
controller = new ClientsController();
referer = "http://ya.ru";
Prepare(controller);
client = DataMother.CreateTestClientWithUser();
}
public async Task GivenAPersistedClientModel_WhenUpdatingWithNewAttributes_ThePersistedModelIsUpdated()
{
var originalModel = new ClientModel {
Id = Guid.NewGuid(),
Surname = "Bloggs",
FirstNames = "Joe Peter",
IdentityType = ClientIdentityType.Passport,
IdentityNumber = "7202025074084",
DateOfBirth = new DateTime(1972, 2, 2)
};
var repository = new Mock <ClientRepository>();
var controller = new ClientsController(repository.Object);
var result = await controller.Put(originalModel.Id, new ClientModel {
Id = Guid.NewGuid(),
Surname = "Bloggs1",
FirstNames = "Joe Peters",
IdentityType = ClientIdentityType.Passport,
IdentityNumber = "7302025074084",
DateOfBirth = new DateTime(1973, 2, 2)
});
Assert.IsInstanceOfType(result, typeof(OkResult));
repository.Verify(r => r.UpdateClient(originalModel.Id, It.IsAny <ClientModel>()), Times.Once);
}
public async Task GivenAListOfClientModels_WhenQuerying_TheClientModelsAreReturned()
{
var model1 = new ClientModel {
Id = Guid.NewGuid(),
Surname = "Bloggs",
FirstNames = "Joe Peter",
IdentityType = ClientIdentityType.Passport,
IdentityNumber = "7202025074084",
DateOfBirth = new DateTime(1972, 2, 2)
};
var model2 = new ClientModel {
Id = Guid.NewGuid(),
Surname = "Bloggs1",
FirstNames = "Joe Peter1",
IdentityType = ClientIdentityType.Passport,
IdentityNumber = "7302025074084",
DateOfBirth = new DateTime(1973, 2, 2)
};
var repository = new Mock <ClientRepository>();
var controller = new ClientsController(repository.Object);
repository.Setup(r => r.QueryClients()).Returns(Task.FromResult((IEnumerable <ClientModel>) new ClientModel[] { model1, model2 }));
var result = await controller.Get();
Assert.IsInstanceOfType(result, typeof(OkObjectResult));
var typedResult = (OkObjectResult)result;
var modelList = typedResult.Value as IEnumerable <ClientModel>;
Assert.AreEqual(2, modelList.Count());
Assert.AreEqual(model1.Id, modelList.ToArray()[0].Id);
}
public void Should_ReturnMailingHistoryOfSpecifiedPerson_WhenRequested()
{
// arrange
var person = Builder <Person> .CreateNew()
.With(x => x.Id = 7777).Build();
var mails = Builder <MailMessage> .CreateListOfSize(25)
.All().With(x => x.Date = GetRandom.DateTime())
.With(x => x.Sender = Builder <Person> .CreateNew().Build())
.With(x => x.Receivers = Builder <Person> .CreateListOfSize(3).Build())
.TheFirst(7).With(x => x.Sender = person)
.TheLast(7).With(x => x.Receivers = new List <Person> {
person
})
.Build();
var repository = Substitute.For <IRepository>();
repository.Query <MailMessage>().ReturnsForAnyArgs(mails.AsQueryable());
var clientController = new ClientsController(repository);
// act
var viewResult = (IList <MailMessage>)clientController.MailingHistory(7777).Model;
// assert
viewResult.Count().Should().Be(14);
for (int i = 1; i < viewResult.Count; i++)
{
viewResult[i].Date.Should().BeOnOrAfter(viewResult[i - 1].Date);
}
}
[InlineData(4)] //Client with id 4 has related Contacts
public async void GetClientByIdWithContactsAsync_Returns_One_Client_With_Related_Contacts(int id)
{
//get the Client with id 4 (that has related Contacts) and map it to its DTO
var client = _clients.First <Client>(cl => cl.Id == id);
client.Contacts = ContactsData.getTestContacts() as ICollection <Contact>;
var expectedClientDto = _mapper.Map <ClientWithContactsDTO>(client);
//specify the mockRepo return
_mockRepository.Setup(repo => repo.GetOneByWithRelatedDataAsync(cl => cl.Id == id, cl => cl.Contacts)).ReturnsAsync(client);
//instantiate the controller, and call the method
var controller = new ClientsController(_mockRepository.Object, _mapper, _logger);
//Call the SUT method
var actionResult = await controller.GetClientByIdWithContactsAsync(id);
//Assert the result
Assert.NotNull(actionResult);
//convert ActionResult to OkObjectResult to get its Value: a Client type
var result = Assert.IsType <OkObjectResult>(actionResult.Result);
//get the ObjectResult.Value
var actualClientDto = result.Value as ClientWithContactsDTO;
//use FluentAssertions to compare Reference types
actualClientDto.Should().BeEquivalentTo(expectedClientDto, options => options.ComparingByMembers <ClientWithContactsDTO>());
}
public async void Get_ForId_ReturnClientResponse()
{
// Arrange
var guid = Guid.NewGuid();
var name = "Client0";
var status = Status.GetActive();
var domainClient = Client.Create(guid, name);
var clientResponse = new ClientResponse { Id = guid, Name = name, Status = status };
var clientController = new ClientsController(
new LoggerMock<ClientsController>().Object,
new MapperMock().MockDomainClientToClientResponseMapping().Object,
new CommandDispatcherMock().Object,
new QueryDispatcherMock().MockGetById(domainClient).Object);
// Act
var result = await clientController.Get(guid);
// Assert
result
.Should().BeOfType<OkObjectResult>().Which.Value.As<ClientResponse>()
.Should().BeEquivalentTo(clientResponse);
}
public async void AddClientAsync_Returns_NotFound_404_When_Create_With_null_Client()
{
//Configure Repository Mock
_mockRepository.Setup(repo => repo.AddTAsync(null)).ReturnsAsync(0);
//instantiate the controller, and call the method
var controller = new ClientsController(_mockRepository.Object, _mapper, _logger);
//Create Custom ControllerContext and add it to Controller for logging in the Controller in case of error
controller.ControllerContext = new ControllerContextModel();
//Call the SUT method - returns ActionResult<Client> type
var actionResult = await controller.AddClientAsync(null); // (new Client());
//Assert the result
Assert.NotNull(actionResult);
var result = actionResult.Result as NotFoundObjectResult;
var statusCode = result.StatusCode;
var message = result.Value;
//Assert message
Assert.Equal("No Client was created", message);
//Assert StatusCode
Assert.Equal(404, statusCode);
}
public void DeleteClient()
{
// Arrange.
var testData = GetTestData();
var testId = 2;
var mockDbSet = new Mock <DbSet <Client> >();
mockDbSet
.As <IQueryable <Client> >()
.Setup(m => m.GetEnumerator())
.Returns(testData.AsQueryable().GetEnumerator);
mockDbSet
.Setup(m => m.Find(It.IsAny <object[]>()))
.Returns <object[]>(ids => testData.FirstOrDefault(d => d.Id == (int)ids[0]));
mockDbSet
.Setup(m => m.Remove(It.IsAny <Client>()))
.Callback <Client>(entity => testData.Remove(entity));
var mockDbContext = new Mock <BankDbContext>();
mockDbContext
.Setup(m => m.Clients)
.Returns(mockDbSet.Object);
var clientsController = new ClientsController(mockDbContext.Object);
// Act.
var actionResult = clientsController.DeleteClient(testId) as OkResult;
// Assert.
Assert.IsNotNull(actionResult);
Assert.IsInstanceOfType(actionResult, typeof(OkResult));
}
public async void UpdateClientAsync_Returns_NotFound_404_When_Update_With_null_Client(int id)
{
//declare a Client
Client expectedClient = null;
//expected return error message
string expectedResponseMessage = "No Client was updated";
///set mockRepo return for Update action
_mockRepository.Setup(repo => repo.UpdateTAsync(expectedClient)).ReturnsAsync(id);
//instantiate the controller, and call the method
var controller = new ClientsController(_mockRepository.Object, _mapper, _logger);
//Create Custom ControllerContext and add it to Controller for logging in the Controller in case of error
controller.ControllerContext = new ControllerContextModel();
//Call the SUT method
//returns ActionResult<Client> type
var actionResult = await controller.UpdateClientAsync(0, expectedClient);
//Get the int result from the posted ActionResult
var notFoundObjectResult = actionResult.Result as NotFoundObjectResult;
var statusCode = notFoundObjectResult.StatusCode;
string actualResponseMessage = (string)notFoundObjectResult.Value;
//Assert the result
Assert.NotNull(actionResult);
//Validate the return status code
Assert.Equal(404, statusCode);
//Validate the actual Client
Assert.Equal(expectedResponseMessage, actualResponseMessage);
}
public void GetAllClients()
{
// Arrange.
var testData = GetTestData();
var mockDbSet = new Mock <DbSet <Client> >();
mockDbSet
.As <IQueryable <Client> >()
.Setup(m => m.GetEnumerator())
.Returns(testData.AsQueryable().GetEnumerator);
var mockDbContext = new Mock <BankDbContext>();
mockDbContext
.Setup(m => m.Clients)
.Returns(mockDbSet.Object);
var clientsController = new ClientsController(mockDbContext.Object);
// Act.
var actionResult = clientsController.GetClients() as OkNegotiatedContentResult <DbSet <Client> >;
// Assert.
Assert.IsNotNull(actionResult);
Assert.IsNotNull(actionResult.Content);
Assert.IsInstanceOfType(actionResult, typeof(OkNegotiatedContentResult <DbSet <Client> >));
Assert.AreEqual(testData.Count, actionResult.Content.ToList().Count);
}
public async void GetAllClientsAsync_Returns_All_Clients()
{
//map Clients test data to DTOs
var _clients = ClientsData.getTestClients();
var expectedDTOs = _mapper.Map <IEnumerable <ClientDTO> >(_clients);
//specify the mockRepo return
_mockRepository.Setup(repo => repo.GetAllPagedAsync(cl => cl.Id, parameters)).ReturnsAsync(_clients);
//instantiate the controller
var controller = new ClientsController(_mockRepository.Object, _mapper, _logger);
//Call the SUT method
var result = await controller.GetAllClientsAsync(parameters);
//Assert the result
Assert.NotNull(result);
var actionResult = Assert.IsType <ActionResult <IEnumerable <ClientDTO> > >(result);
var objResult = Assert.IsType <OkObjectResult>(result.Result);
var actualClients = objResult.Value;
IEnumerable <ClientDTO> dtos = _mapper.Map <IEnumerable <ClientDTO> >(actualClients);
//use FluentAssertions to compare Collections of Reference types
dtos.Should().BeEquivalentTo(expectedDTOs, options => options.ComparingByMembers <ClientDTO>());
}
public void GetClientById()
{
// Arrange.
var testData = GetTestData();
var testEntity = testData.FirstOrDefault(e => e.Id == 2);
var mockDbSet = new Mock <DbSet <Client> >();
mockDbSet
.As <IQueryable <Client> >()
.Setup(m => m.GetEnumerator())
.Returns(testData.AsQueryable().GetEnumerator);
mockDbSet
.Setup(m => m.Find(It.IsAny <object[]>()))
.Returns <object[]>(ids => testData.FirstOrDefault(d => d.Id == (int)ids[0]));
var mockDbContext = new Mock <BankDbContext>();
mockDbContext
.Setup(m => m.Clients)
.Returns(mockDbSet.Object);
var clientsController = new ClientsController(mockDbContext.Object);
// Act.
var actionResult = clientsController.GetClient(testEntity.Id) as OkNegotiatedContentResult <Client>;
// Assert.
Assert.IsNotNull(actionResult);
Assert.IsNotNull(actionResult.Content);
Assert.IsInstanceOfType(actionResult, typeof(OkNegotiatedContentResult <Client>));
Assert.AreEqual(testEntity, actionResult.Content);
}
public void Details_Test()
{
CC.Data.Tests.Helper.PrepareTestData();
ClientsController target = new ClientsController(); // TODO: Initialize to an appropriate value
User ccUser = CC.Data.Tests.Helper.GetAdminUser();
var mocks = new ContextMocks(target, true, false);
target.CcUser = ccUser;
Client cc = CC.Data.Tests.Helper.GetClient("Client1");
Nullable <int> id = cc.Id;
Nullable <bool> newClient = false;
ViewResult actual = target.Details(id, newClient);
Assert.IsNotNull(actual, " view result can not be null");
System.Web.Mvc.ViewResultBase viewResult = (System.Web.Mvc.ViewResultBase)actual;
ViewDataDictionary data = viewResult.ViewData;
Assert.IsNotNull(data.Keys.Count() == 3, "must be 3 dataitems: client data, agencies, permissions");
Client cl = (Client)data.Model;
Assert.IsTrue(cl.Id == cc.Id && cl.FirstName == "Client1", " must open detail of client with name " + cc.FirstName);
//now write the same test for user, that not have permissions for this client"
}
public async Task Update_ReturnSelf_With_ClientReturnedFromRepo_OfType_UpdateIdSrvClientDTO_When_PassingClientId()
{
var clientId = Guid.NewGuid();
var client = new IdSrvClientDto()
{
Id = Guid.NewGuid(),
Name = "n",
Secret = "s",
Uri = "u"
};
this.ClientServiceMock
.Setup(v => v.GetClientByIdAsync(clientId))
.ReturnsAsync(client);
var controller = new ClientsController(this.ClientServiceMock.Object);
ActionResult result = await controller.Update(clientId);
Assert.IsInstanceOf <ViewResult>(result);
var viewResult = result as ViewResult;
Assert.NotNull(viewResult);
Assert.AreEqual(string.Empty, viewResult.ViewName);
Assert.IsInstanceOf <UpdateIdSrvClientDto>(controller.ViewData.Model);
var model = controller.ViewData.Model as UpdateIdSrvClientDto;
Assert.AreEqual(client.Id, model.Id);
Assert.AreEqual(client.Name, model.Name);
Assert.AreEqual(client.Secret, model.Secret);
Assert.AreEqual(client.Uri, model.Uri);
}
public void Index_ReturnsCorrectView_True()
{
ClientsController controller = new ClientsController();
ActionResult indexView = controller.Index();
Assert.IsInstanceOfType(indexView, typeof(ViewResult));
}
public async Task Update_ReturnSelf_With_InvalidModel_When_PassingInvalidModel()
{
var model = new UpdateIdSrvClientDto()
{
Id = Guid.NewGuid()
};
this.ClientServiceMock.Setup(v => v.UpdateClientAsync(It.IsAny <UpdateIdSrvClientDto>())).ReturnsAsync(true);
var controller = new ClientsController(this.ClientServiceMock.Object);
controller.ModelState.AddModelError(string.Empty, string.Empty);
ActionResult result = await controller.Update(model);
Assert.IsInstanceOf <ViewResult>(result);
var viewResult = result as ViewResult;
Assert.NotNull(viewResult);
Assert.IsEmpty(viewResult.ViewName);
object modelFromController = controller.ViewData.Model;
Assert.IsInstanceOf <UpdateIdSrvClientDto>(modelFromController);
var actualModel = modelFromController as UpdateIdSrvClientDto;
Assert.AreEqual(actualModel, model);
Assert.IsFalse(controller.ModelState.IsValid);
}
public async Task GetPreview()
{
var client = new ClientPreview()
{
Id = Guid.NewGuid(),
FirstName = "1",
LastName = "2",
DateOfBirth = new DateTime(1982, 10, 3),
IdNumber = "3",
AlternateIdNumber = "4",
ContactCount = 5,
PolicyCount = 6
};
var service = new Mock <IClientService>();
var authService = TestHelper.MockAuthenticationService(Scope.Branch);
service.Setup(c => c.GetClientPreview(It.IsAny <ScopeOptions>(), It.Is <Guid>(m => m == client.Id)))
.ReturnsAsync(client);
var controller = new ClientsController(service.Object, authService.Object);
var result = await controller.GetPreview(client.Id);
var okResult = Assert.IsType <OkObjectResult>(result);
var returnValue = Assert.IsType <ClientPreview>(okResult.Value);
Assert.Same(client, returnValue);
}
public void Create_ReturnNotNullViewResult_When_NoArgs()
{
var controller = new ClientsController(this.ClientServiceMock.Object);
ViewResult viewResult = controller.Create();
Assert.NotNull(viewResult);
}
public ActionResult ScanAndImportCfsFiles()
{
var clientsController = new ClientsController();
clientsController.ScanAndImportCfsFiles();
return(this.RedirectToAction(f => f.Index(null)));
}
private void modBtnSaveClientChanges_Click(object sender, EventArgs e)
{
this.controller = new ClientsController();
Dictionary <string, dynamic> data = new Dictionary <string, dynamic>();
Cliente modifiedClient = new Cliente()
{
IdCliente = registeredClient.IdCliente,
Descripcion = txtDescription.Text.TrimStart().TrimEnd(),
FechaAgrega = registeredClient.FechaAgrega,
FechaElimina = registeredClient.FechaElimina,
UsuarioAgrega = registeredClient.UsuarioAgrega,
Eliminado = registeredClient.Eliminado,
IdEstado = (int)modDropClientStatus.SelectedValue
};
data["user"] = Session.getInstance().session["identification"];
controller.data = data;
Dictionary <Object, dynamic> result = controller.modifyClient(registeredClient, modifiedClient);
if (result["code"] == Result.Processed)
{
this.loadCombos();
}
MessageBox.Show(result["msg"]);
}
