public void IndexPost_AvecViewModelValideEtUtilisateur_AppelleBienAjoutVoteEtRenvoiBonneAction()
{
Mock <IDal> mock = new Mock <IDal>();
mock.Setup(m => m.ObtenirUtilisateur("1")).Returns(new Utilisateur {
Id = 1, Prenom = "Nico"
});
Mock <ControllerContext> controllerContext = new Mock <ControllerContext>();
controllerContext.Setup(p => p.HttpContext.User.Identity.Name).Returns("1");
controleur = new VoteController(mock.Object);
controleur.ControllerContext = controllerContext.Object;
RestaurantVoteViewModel viewModel = new RestaurantVoteViewModel
{
ListeDesResto = new List <RestaurantCheckBoxViewModel>
{
new RestaurantCheckBoxViewModel {
EstSelectionne = true, Id = 2, NomEtTelephone = "Resto pinière (0102030405)"
},
new RestaurantCheckBoxViewModel {
EstSelectionne = false, Id = 3, NomEtTelephone = "Resto toro (0102030405)"
},
}
};
controleur.ValideLeModele(viewModel);
RedirectToRouteResult resultat = (RedirectToRouteResult)controleur.Index(viewModel, idSondage);
mock.Verify(m => m.AjouterVote(idSondage, 2, 1));
Assert.AreEqual("AfficheResultat", resultat.RouteValues["action"]);
Assert.AreEqual(idSondage, resultat.RouteValues["id"]);
}
public async void Patch_No_Errors()
{
VoteControllerMockFacade mock = new VoteControllerMockFacade();
var mockResult = new Mock <UpdateResponse <ApiVoteResponseModel> >();
mockResult.SetupGet(x => x.Success).Returns(true);
mock.ServiceMock.Setup(x => x.Update(It.IsAny <int>(), It.IsAny <ApiVoteRequestModel>()))
.Callback <int, ApiVoteRequestModel>(
(id, model) => model.BountyAmount.Should().Be(1)
)
.Returns(Task.FromResult <UpdateResponse <ApiVoteResponseModel> >(mockResult.Object));
mock.ServiceMock.Setup(x => x.Get(It.IsAny <int>())).Returns(Task.FromResult <ApiVoteResponseModel>(new ApiVoteResponseModel()));
VoteController controller = new VoteController(mock.ApiSettingsMoc.Object, mock.LoggerMock.Object, mock.TransactionCoordinatorMock.Object, mock.ServiceMock.Object, new ApiVoteModelMapper());
controller.ControllerContext = new ControllerContext();
controller.ControllerContext.HttpContext = new DefaultHttpContext();
var patch = new JsonPatchDocument <ApiVoteRequestModel>();
patch.Replace(x => x.BountyAmount, 1);
IActionResult response = await controller.Patch(default(int), patch);
response.Should().BeOfType <OkObjectResult>();
(response as OkObjectResult).StatusCode.Should().Be((int)HttpStatusCode.OK);
mock.ServiceMock.Verify(x => x.Update(It.IsAny <int>(), It.IsAny <ApiVoteRequestModel>()));
}
public async void BulkInsert_No_Errors()
{
VoteControllerMockFacade mock = new VoteControllerMockFacade();
var mockResponse = new CreateResponse <ApiVoteResponseModel>(new FluentValidation.Results.ValidationResult());
mockResponse.SetRecord(new ApiVoteResponseModel());
mock.ServiceMock.Setup(x => x.Create(It.IsAny <ApiVoteRequestModel>())).Returns(Task.FromResult <CreateResponse <ApiVoteResponseModel> >(mockResponse));
VoteController controller = new VoteController(mock.ApiSettingsMoc.Object, mock.LoggerMock.Object, mock.TransactionCoordinatorMock.Object, mock.ServiceMock.Object, mock.ModelMapperMock.Object);
controller.ControllerContext = new ControllerContext();
controller.ControllerContext.HttpContext = new DefaultHttpContext();
var records = new List <ApiVoteRequestModel>();
records.Add(new ApiVoteRequestModel());
IActionResult response = await controller.BulkInsert(records);
response.Should().BeOfType <OkObjectResult>();
(response as OkObjectResult).StatusCode.Should().Be((int)HttpStatusCode.OK);
var result = (response as OkObjectResult).Value as List <ApiVoteResponseModel>;
result.Should().NotBeEmpty();
mock.ServiceMock.Verify(x => x.Create(It.IsAny <ApiVoteRequestModel>()));
}
public async Task Vote([Remainder] string text)
{
Context.Message.DeleteAsync();
VoteController vc = VoteControllerManager.GetVoteController(Context.Channel);
vc.SetOptions(text);
if (vc.GetOptions().Count == 0)
{
vc.ResetOptions();
}
Poll vote = vc.NewPoll();
foreach (string option in vc.GetOptions())
{
RestUserMessage message = Context.Channel.SendMessageAsync(option).Result;
vote.AddOptionMessage(message);
message.AddReactionAsync(new Emoji("👌"));
}
await Task.Delay(1000 *ResourceController.GetVoteDelay());
if (!vc.CurrentPoll.IsClosed)
{
await vc.ClosePoll(Context);
}
}
public void TestGetReturns200_IfEverythingIsOk()
{
this.businessValidation.Setup(validation => validation.IsValidGetNews(this.mockNewsRepository.Object, It.IsAny <string>(), It.IsAny <DateTime>(), It.IsAny <Guid>())).Returns(Task.FromResult(true));
this.businessValidation.Setup(validation => validation.IsValidGetVote(this.mockVoteRepository.Object, It.IsAny <string>(), It.IsAny <DateTime>(), It.IsAny <Guid>(), It.IsAny <string>())).Returns(Task.FromResult(true));
this.mockVoteRepository.Setup(
repository =>
repository.GetVote(It.IsAny <string>(), It.IsAny <DateTime>(), It.IsAny <Guid>(), It.IsAny <string>()))
.Returns(Task.FromResult(new VoteBll {
Value = 5
}));
var voteController = new VoteController(this.mockNewsRepository.Object, this.mockVoteRepository.Object, this.inputValidation.Object, this.businessValidation.Object);
var request = new HttpRequestMessage(HttpMethod.Get, GOUriBuilder.BuildAbsoluteVoteUri(Scheme, Host, Port, City, Date, Id.ToString()));
request.Headers.Referrer = new Uri(GOUriBuilder.BuildAbsoluteVoteUri(Scheme, Host, Port, City, Date, Id.ToString()));
voteController.ConfigureForTesting(request, "GetVote", new HttpRoute(GOUriBuilder.NewsVoteTemplate));
voteController.User = new GenericPrincipal(new GenericIdentity(DefaultNickname), null);
HttpResponseMessage response = voteController.Get(City, Date, Id.ToString()).Result;
HttpContent content = response.Content;
string jsonContent = content.ReadAsStringAsync().Result;
var actualVote = JsonConvert.DeserializeObject <Vote>(jsonContent);
Assert.AreEqual(HttpStatusCode.OK, response.StatusCode);
Assert.AreEqual(5, actualVote.Value);
}
public void Init()
{
sutMock = new Mock <IRepository>();
sutMock.Setup(m => m.Table).Returns(new Person[]
{
new Person {
PersonId = 1, Name = "P1", Category = "1", Price = 10
},
new Person {
PersonId = 2, Name = "P2", Category = "2", Price = 10
},
new Person {
PersonId = 3, Name = "P3", Category = "1", Price = 10
},
new Person {
PersonId = 4, Name = "P4", Category = "2", Price = 10
},
new Person {
PersonId = 5, Name = "P5", Category = "1", Price = 10
}
}.AsQueryable());
sutUserProvider = new Mock <IUserProvider>();
sutUserProvider.Setup(m => m.GetUserName(It.IsAny <Controller>()))
.Returns("Test");
sutWeekProvider = new Mock <IWeekProvider>();
sutWeekProvider.Setup(m => m.GetWeek())
.Returns(1);
sutController = new VoteController(sutMock.Object, sutUserProvider.Object, sutWeekProvider.Object);
}
static void Main(string[] args)
{
HttpListener listener = new HttpListener();
RegisterEnviroment();
IDataBase dataBase = serviceLocator.Resolve(typeof(IDataBase)) as IDataBase;
listener.Prefixes.Add("http://localhost:8881/");
listener.Start();
while (listener.IsListening)
{
HttpListenerContext context = listener.GetContext();
HttpListenerRequest request = context.Request;
BaseController targetController;
if (request.Url.LocalPath.Contains("vote"))
{
targetController = new VoteController(dataBase);
}
else if (request.Url.LocalPath.Contains("participant"))
{
targetController = new Participant(dataBase);
}
else
{
targetController = new IndexController();
}
targetController.Handle(context);
}
}
public void WhitAllArgumentsShouldReturnInstanceOfAccountController()
{
var moqVoteService = new Mock <IVoteService>();
var sut = new VoteController(moqVoteService.Object);
Assert.IsInstanceOfType(sut, typeof(VoteController));
}
private void button1_Click(object sender, EventArgs e)
{
VoteController cVote = new VoteController();
MessageBox.Show(cVote.Vote(calendar.SelectionRange.Start.Date, this.user.getLogin(), tbVote.Text));
this.UpdateRestaurantOfDay(calendar.SelectionRange.Start.Date);
}
// Token: 0x060020F4 RID: 8436 RVA: 0x0009AE1C File Offset: 0x0009901C
public bool IsClientReady()
{
int num = 0;
if (!PreGameController.instance)
{
return(false);
}
VoteController component = PreGameController.instance.GetComponent <VoteController>();
if (!component)
{
return(false);
}
int i = 0;
int voteCount = component.GetVoteCount();
while (i < voteCount)
{
VoteController.UserVote vote = component.GetVote(i);
if (vote.networkUserObject && vote.receivedVote)
{
NetworkUser component2 = vote.networkUserObject.GetComponent <NetworkUser>();
if (component2 && component2.isLocalPlayer)
{
num++;
}
}
i++;
}
return(num == NetworkUser.readOnlyLocalPlayersList.Count);
}
private static async Task Listen()
{
HttpListener listener = new HttpListener();
listener.Prefixes.Add("http://localhost:8881/");
listener.Start();
Console.WriteLine("Ожидание подключений...");
while (listener.IsListening)
{
HttpListenerContext context = await listener.GetContextAsync();
HttpListenerRequest request = context.Request;
BaseController targetController;
if (request.Url.LocalPath.Contains("vote"))
{
targetController = new VoteController(Service, Logger);
}
else
{
if (request.Url.LocalPath.Contains("participants"))
{
targetController = new ParticipantsController(Service, Logger);
}
else
{
targetController = new IndexController(Logger);
}
}
targetController.Handle(context);
}
}
public VoteControllerTest()
{
_gameDataService = Substitute.For <IGameDataService>();
_gameStateProvider = Substitute.For <IGameStateProvider>();
sut = new VoteController(_gameDataService, _gameStateProvider);
}
public async Task Toggle()
{
Context.Message.DeleteAsync();
VoteController vc = VoteControllerManager.GetVoteController(Context.Channel);
vc.MultipleVotesAllowed = true;
await Context.Channel.SendFileAsync(TRUE_MESSAGE);
}
public void ShouldReturnBadRequestIfModelisNull()
{
var mockVoteService = new Mock <IVoteService>();
var sut = new VoteController(mockVoteService.Object);
sut
.WithCallTo(c => c.Like(null))
.ShouldGiveHttpStatus(HttpStatusCode.BadRequest);
}
public void Can_View_Cart_Contents()
{
votes = new VoteResults();
VoteController target = new VoteController(null, null, null);
VotesViewModel result = (VotesViewModel)target.Index(votes, "myUrl").ViewData.Model;
// Assert
Assert.AreSame(result.Votes, votes);
Assert.AreEqual(result.ReturnUrl, "myUrl");
}
public async Task Add(string text)
{
Context.Message.DeleteAsync();
VoteController vc = VoteControllerManager.GetVoteController(Context.Channel);
foreach (string option in Utils.SeparateOptions(text))
{
vc.Options.Add(option);
}
}
public void Article()
{
// Arrange
VoteController controller = new VoteController();
// Act
ViewResult result = controller.Article() as ViewResult;
// Assert
Assert.IsNotNull(result);
}
public void Vote()
{
// Arrange
VoteController controller = new VoteController();
// Act
ViewResult result = controller.Home() as ViewResult;
// Assert
Assert.AreEqual("Modify this template to jump-start your ASP.NET MVC application.", result.ViewBag.Message);
}
public void TestConstructor_PassEverythingCorrectly_ShouldInitializeCorrectly()
{
// Arrange
var mockedService = new Mock <IVoteService>();
var mockedProvider = new Mock <IAuthenticationProvider>();
// Act
var controller = new VoteController(mockedService.Object, mockedProvider.Object);
// Assert
Assert.IsNotNull(controller);
}
public void Init()
{
dal = new DalEnDur();
idSondage = dal.CreerUnSondage();
Mock <ControllerContext> controllerContext = new Mock <ControllerContext>();
controllerContext.Setup(p => p.HttpContext.User.Identity.Name).Returns("1");
controleur = new VoteController(dal);
controleur.ControllerContext = controllerContext.Object;
}
public void ShouldReturnBadRequestIfUserNameIsNull()
{
VoteViewModel model = new VoteViewModel();
model.MovieId = new Guid();
var mockVoteService = new Mock <IVoteService>();
var sut = new VoteController(mockVoteService.Object);
sut
.WithCallTo(c => c.Like(model))
.ShouldGiveHttpStatus(HttpStatusCode.BadRequest);
}
private void UpdateRestaurantOfDay(DateTime date)
{
lDay.Text = date.DayOfWeek.ToString();
VoteController cVote = new VoteController();
lRestaurant.Text = cVote.RestaurantOfDay(date);
lVotes.Text = cVote.VotesOfRestaurantOnDay(date, lRestaurant.Text).ToString();
listRestaurant.Items.Clear();
foreach (string rest in cVote.GetAllRestaurant())
{
listRestaurant.Items.Add(rest);
}
}
public void Listen()
{
var context = HttpListener.GetContext();
var request = context.Request;
var response = context.Response;
var logger = new Logger();
var repository = new ParticipantsRepository();
var service = new ParticipantsService(repository);
var indexController = new IndexController(service, logger);
var voteController = new VoteController(service, logger);
var participantsController = new ParticipantsController(service, logger);
if (context.Request.IsWebSocketRequest)
{
HandleWebsocket(context);
}
else
{
try
{
var fileName = request.RawUrl.Substring(1);
fileName = string.IsNullOrWhiteSpace(fileName) ? "index.html" : fileName;
Console.WriteLine($"Client is looking for {fileName}");
switch (fileName)
{
case "index.html":
indexController.Handle(context);
break;
case "vote.html":
voteController.Handle(context);
break;
case "participants.html":
participantsController.Handle(context);
break;
default:
HandleStaticFile(context);
break;
}
}
finally
{
response.OutputStream.Close();
}
}
}
public void TestVote_ShouldCallAuthenticationProviderCurrentUserId(int logId, int currentVoteCount)
{
// Arrange
var mockedService = new Mock <IVoteService>();
var mockedProvider = new Mock <IAuthenticationProvider>();
var controller = new VoteController(mockedService.Object, mockedProvider.Object);
// Act
controller.Vote(logId, currentVoteCount);
// Assert
mockedProvider.Verify(p => p.CurrentUserId, Times.Once);
}
public void TestVote_ShouldReturnPartialView(int logId, int currentVoteCount, string userId)
{
// Arrange
var mockedService = new Mock <IVoteService>();
var mockedProvider = new Mock <IAuthenticationProvider>();
var controller = new VoteController(mockedService.Object, mockedProvider.Object);
// Act
var result = controller.Vote(logId, currentVoteCount);
// Assert
Assert.IsInstanceOf <PartialViewResult>(result);
}
public void TestVote_ModelStateIsNotValid_ShouldNotCallAuthenticationProviderCurrentUserId(int logId, int currentVoteCount)
{
// Arrange
var mockedService = new Mock <IVoteService>();
var mockedProvider = new Mock <IAuthenticationProvider>();
var controller = new VoteController(mockedService.Object, mockedProvider.Object);
controller.ModelState.AddModelError("", "");
// Act
controller.Vote(logId, currentVoteCount);
// Assert
mockedProvider.Verify(p => p.CurrentUserId, Times.Never);
}
public void TestVote_ShouldCallServiceVoteLog(int logId, int currentVoteCount, string userId)
{
// Arrange
var mockedService = new Mock <IVoteService>();
var mockedProvider = new Mock <IAuthenticationProvider>();
mockedProvider.Setup(p => p.CurrentUserId).Returns(userId);
var controller = new VoteController(mockedService.Object, mockedProvider.Object);
// Act
controller.Vote(logId, currentVoteCount);
// Assert
mockedService.Verify(p => p.VoteLog(logId, userId), Times.Once);
}
private void AssertDeleteFails(HttpStatusCode resultCode)
{
var voteController = new VoteController(this.mockNewsRepository.Object, this.mockVoteRepository.Object, this.inputValidation.Object, this.businessValidation.Object);
var request = new HttpRequestMessage(HttpMethod.Delete, GOUriBuilder.BuildAbsoluteVoteUri(Scheme, Host, Port, City, Date, Id.ToString()));
request.Headers.Referrer = new Uri(GOUriBuilder.BuildAbsoluteVoteUri(Scheme, Host, Port, City, Date, Id.ToString()));
voteController.ConfigureForTesting(request, "DeleteVote", new HttpRoute(GOUriBuilder.NewsVoteTemplate));
voteController.User = new GenericPrincipal(new GenericIdentity(DefaultNickname), null);
HttpResponseMessage response = voteController.Delete(City, Date, Id.ToString()).Result;
Assert.AreEqual(resultCode, response.StatusCode);
this.mockVoteRepository.Verify(storage => storage.DeleteVote(It.IsAny <string>(), It.IsAny <DateTime>(), It.IsAny <Guid>(), It.IsAny <string>()), Times.Never());
}
public async void Get_Not_Exists()
{
VoteControllerMockFacade mock = new VoteControllerMockFacade();
mock.ServiceMock.Setup(x => x.Get(It.IsAny <int>())).Returns(Task.FromResult <ApiVoteResponseModel>(null));
VoteController controller = new VoteController(mock.ApiSettingsMoc.Object, mock.LoggerMock.Object, mock.TransactionCoordinatorMock.Object, mock.ServiceMock.Object, mock.ModelMapperMock.Object);
controller.ControllerContext = new ControllerContext();
controller.ControllerContext.HttpContext = new DefaultHttpContext();
IActionResult response = await controller.Get(default(int));
response.Should().BeOfType <StatusCodeResult>();
(response as StatusCodeResult).StatusCode.Should().Be((int)HttpStatusCode.NotFound);
mock.ServiceMock.Verify(x => x.Get(It.IsAny <int>()));
}
public void Send_vote()
{
using (var loggerFactory = CreateLoggerFactory())
{
var node = new Mock <INode>();
var controller = new VoteController(node.Object, loggerFactory.CreateLogger <VoteController>());
var vote = new Vote {
ChoiceId = Guid.NewGuid()
};
var response = controller.Post(vote);
Assert.AreEqual((int)HttpStatusCode.Accepted, response.StatusCode);
node.Verify(n => n.Add(It.IsAny <Vote>()), Times.Once);
}
}
