public async Task DeleteAsync_given_existing_voteId_deletes_it()
{
using (var connection = await CreateConnectionAsync())
using (var context = await CreateContextAsync(connection))
{
var entity = new Vote
{
EventStockId = 1,
Score = 5
};
context.Votes.Add(entity);
await context.SaveChangesAsync();
var id = entity.Id;
var repository = new VoteRepository(context);
var deleted = await repository.DeleteAsync(id);
Assert.True(deleted);
var deletedEntity = await context.Votes.FindAsync(id);
Assert.Null(deletedEntity);
}
}
public async Task Read_returns_mapped_VoteDTO()
{
using (var connection = await CreateConnectionAsync())
using (var context = await CreateContextAsync(connection))
{
var entity = new Vote
{
EventStockId = 1,
Score = 5
};
context.Votes.Add(entity);
await context.SaveChangesAsync();
var id = entity.Id;
var repository = new VoteRepository(context);
var votes = await repository.ReadAsync();
var vote = votes.FirstOrDefault();
Assert.Equal(1, votes.Count);
Assert.Equal(entity.EventStockId, vote.EventStockId);
Assert.Equal(entity.Score, vote.Score);
}
}
public bool DeleteAccount(int usuarioId)
{
bool result = false;
using (TransactionScope scope = new TransactionScope())
{
IDataQuery query = new DataQuery();
query.Where = string.Format("userId={0}", usuarioId);
IList <IProfile> collection = _repositoryProfile.Find(query);
if (collection.Count > 0)
{
VoteRepository voteRepository = new VoteRepository(_dataBase);
query.Where = string.Format("profileId={0}", collection[0].ProfileId);
IList <IVote> votes = voteRepository.Find(query);
foreach (IVote vote in votes)
{
voteRepository.Remove(vote.VoteId);
}
_repositoryProfile.Remove(collection[0].ProfileId);
result = _repository.Remove(usuarioId);
}
}
return(result);
}
public async Task Vote(VoteType type, RequestType request)
{
VoteSettings.Setup(x => x.GetSettingsAsync()).ReturnsAsync(new VoteSettings
{
Enabled = true,
MovieVoteMax = 10
});
var votes = F.CreateMany <Votes>().ToList();
VoteRepository.Setup(x => x.GetAll()).Returns(new EnumerableQuery <Votes>(votes)
.AsQueryable()
.BuildMock().Object);
var result = new VoteEngineResult();
if (type == VoteType.Downvote)
{
result = await Engine.DownVote(1, request);
}
else
{
result = await Engine.UpVote(1, request);
}
Assert.That(result.Result, Is.True);
VoteRepository.Verify(x => x.Add(It.Is <Votes>(c => c.UserId == "abc" && c.VoteType == type)), Times.Once);
VoteRepository.Verify(x => x.Delete(It.IsAny <Votes>()), Times.Never);
MovieRequestEngine.Verify(x => x.ApproveMovieById(1), Times.Never);
}
public IPostResponse PlaceVote([FromContent] Vote vote)
{
_logger.Trace($"Request to register {vote.GetLogString()}");
var serverVote = new ServerRecordedVote()
{
ClientId = vote.Id,
BallotId = vote.BallotId,
MachineIPAddress = vote.MachineIPAddress,
MachineId = vote.MachineId,
MachineName = vote.MachineName,
RecordedTime = vote.RecordedTime,
ServerRegsiteredMachinedId = vote.ServerRegsiteredMachinedId,
VoteOption = vote.VoteOption,
ServerRecordedTime = DateTime.Now
};
var success = VoteRepository.Save(serverVote);
if (success)
{
_logger.Trace($"Vote recorded with vote ID {serverVote.Id}");
}
return(success ?
new PostResponse(PostResponse.ResponseStatus.Created, "", new { ID = serverVote.Id, SetLock = true })
: new PostResponse(PostResponse.ResponseStatus.Conflict, "", new { ID = -1, Error = "Unable to save vote, please try again" }));
}
public async Task VoteRepository_CRD_Tests()
{
const int firstWarId = 1234;
const int secondWarId = 5678;
var sqlServerConnectionString = System.Configuration.ConfigurationManager.ConnectionStrings["WarDb"].ConnectionString;
var repository = new VoteRepository(sqlServerConnectionString);
var firstVote = await CreateVote(repository, firstWarId);
var firstVoteWrongWarId = await repository.Get(secondWarId, firstVote.MatchId);
firstVoteWrongWarId.Should().BeNullOrEmpty();
var secondVote = await CreateVote(repository, firstWarId);
var thirdVote = await CreateVote(repository, secondWarId);
var firstWarCollection = await repository.GetAll(firstWarId);
VerifyVoteInCollection(firstWarCollection, firstVote);
VerifyVoteInCollection(firstWarCollection, secondVote);
VerifyVoteNotInCollection(firstWarCollection, thirdVote);
var secondWarCollection = await repository.GetAll(secondWarId);
VerifyVoteNotInCollection(secondWarCollection, firstVote);
VerifyVoteNotInCollection(secondWarCollection, secondVote);
VerifyVoteInCollection(secondWarCollection, thirdVote);
await VerifyVoteDelete(repository, firstWarId, firstVote.MatchId);
await VerifyVoteDelete(repository, firstWarId, secondVote.MatchId);
await VerifyVoteDelete(repository, secondWarId, thirdVote.MatchId);
}
public VoteController(RestaurantRepository restaurantRepository, VoteRepository voteRepository, UsersRepository usersRepository, Services services)
{
this.restaurantRepository = restaurantRepository;
this.voteRepository = voteRepository;
this.usersRepository = usersRepository;
this.services = services;
}
public async Task UpdateAsync_given_vote_updates_it()
{
using (var connection = await CreateConnectionAsync())
using (var context = await CreateContextAsync(connection))
{
var entity = new Vote
{
EventStockId = 1,
Score = 5
};
context.Votes.Add(entity);
await context.SaveChangesAsync();
var id = entity.Id;
var repository = new VoteRepository(context);
var vote = new VoteDTO
{
Id = id,
EventStockId = 1,
Score = 4
};
var updated = await repository.UpdateAsync(vote);
Assert.True(updated);
var updatedEntity = await context.Votes.FindAsync(id);
Assert.Equal(1, updatedEntity.EventStockId);
Assert.Equal(4, updatedEntity.Score);
}
}
public Dashboard GetDashboard()
{
var hasVotingStarted = VoteRepository.HasVotingStarted();
var dashboard = new Dashboard
{
FaceOff = ChiliRepository.GetFaceOffChiliCards(),
LadderClimbers = ChiliRepository.GetLadderClimbers(),
TotalVotes = VoteRepository.Get().Count,
ChiliChart = new ChiliChart
{
Columns = ChiliRepository.GetChiliChartColumns()
},
VotingStarted = hasVotingStarted
};
if (!hasVotingStarted)
{
dashboard.Contenders = ChiliRepository.GetChilis().Select(chili => new ChiliCard
{
Description = chili.Description,
ImageUrl = chili.ImageUrl,
Subtitle = chili.Contestant,
Title = chili.Name,
Votes = 0
}).ToList();
}
return(dashboard);
}
public ActionResult Vote(string key)
{
var repo = new VoteRepository();
repo.AddVote(key);
return(RedirectToAction("Index", "Home"));
}
public void Should_AddVote_Return_Zero_When_Vote_Is_Null()
{
var voteRepository = new VoteRepository(null, null);
var updateCount = voteRepository.InsertVote(null);
Assert.AreEqual(0, updateCount);
}
private static async Task VerifyVoteDelete(VoteRepository repository, int warId, Guid matchId)
{
await repository.Delete(warId, matchId);
var afterDelete = await repository.Get(warId, matchId);
afterDelete.Should().BeNullOrEmpty();
}
public void Add_Normal_Conditions()
{
var repo = new VoteRepository();
var vote = new Vote();
vote.OptionId = 2;
vote.SurveyId = 3;
repo.Add(vote);
}
public void InitializeTests()
{
AppDataContext _context = new AppDataContext();
IChoiceHistoryRepository _repository = new ChoiceHistoryRepository(_context);
IVoteRepository _voteRepository = new VoteRepository(_context);
IRestaurantRepository _restaurantRepository = new RestaurantRepository(_context);
_service = new ChoiceHistoryService(_repository, _voteRepository, _restaurantRepository);
}
public void Add_Survey_Null()
{
var repo = new VoteRepository();
Assert.Throws <ArgumentNullException>(() =>
{
var option = new Option();
var vote = new Vote(DateTime.Now, null, option);
});
}
private static async Task <Vote> CreateVote(VoteRepository repository, int warId)
{
var request = CreateTestVote();
await repository.Add(warId, request);
var votes = await repository.Get(warId, request.MatchId);
VerifyRequestInVotesCollection(votes, request);
return(votes.Single(x => x.MatchId == request.MatchId));
}
public void Add_Option_Null()
{
var repo = new VoteRepository();
Assert.Throws <ArgumentNullException>(() =>
{
var survey = new Survey();
var vote = new Vote(DateTime.Now, survey, null);
});
}
public void InitializeTests()
{
AppDataContext _context = new AppDataContext();
IVoteRepository _repository = new VoteRepository(_context);
IUserRepository _userRepository = new UserRepository(_context);
IUserService _userService = new UserService(_userRepository);
IRestaurantRepository _restaurantRepository = new RestaurantRepository(_context);
IRestaurantService _restaurantService = new RestaurantService(_restaurantRepository);
_service = new VoteService(_repository, _userService, _restaurantService);
}
public void Run()
{
voteRepository = new VoteRepository();
Console.WriteLine("TerminationService Thread Startup");
Console.WriteLine("Initialize RabbitMQ");
Consumer consumer = new Consumer();
consumer.Setup("Vote");
}
public DebateServices()
{
_debateRepository = new DebateRepository();
_categoryDebateRepository = new CategoryDebateRepository();
_categoryRepository = new CategoryRepository();
_userDebateRepository = new UserDebateRepository();
_roundStateRepository = new RoundStateRepository();
_contentRepository = new ContentRepository();
_userRepository = new UserRepository();
_voteRepository = new VoteRepository();
_commentaryRepository = new CommentaryRepository();
}
public async Task FindAsync_given_non_existing_id_returns_null()
{
using (var connection = await CreateConnectionAsync())
using (var context = await CreateContextAsync(connection))
{
var repository = new VoteRepository(context);
var vote = await repository.FindAsync(42);
Assert.Null(vote);
}
}
public async Task DeleteAsync_given_non_existing_voteId_returns_false()
{
using (var connection = await CreateConnectionAsync())
using (var context = await CreateContextAsync(connection))
{
var repository = new VoteRepository(context);
var success = await repository.DeleteAsync(42);
Assert.False(success);
}
}
private void Vote_OnClick(object sender, RoutedEventArgs e)
{
var vote = new Vote();
var confirmVote = MessageBox.Show("Please confirm your vote.", "VOTE", MessageBoxButton.YesNo, MessageBoxImage.Question);
if (confirmVote == MessageBoxResult.No)
{
return;
}
var block = new BlockedJsonData().GetAll();
if (block == null)
{
ErrorMessage.ShowError("Error blocked pesel data.");
return;
}
if (block.Contains(_voter.Pesel))
{
vote.ValidVote = false;
vote.WithoutRight = true;
MessageBox.Show("You do not have the right to vote. Your vote will not be valid.", "Warning",
MessageBoxButton.OK);
}
if (_voteViewModel.Candidates.Count(x => x.Vote) != 1)
{
vote.ValidVote = false;
}
else
{
vote.Candidate = _voteViewModel.Candidates.SingleOrDefault(x => x.Vote);
}
vote.Voters = _voter;
var votersRepository = new VotersRepository();
if (votersRepository.IsExist(_voter))
{
MessageBox.Show("You can't vote. You have already cast your vote.", "Warning",
MessageBoxButton.OK);
return;
}
votersRepository.Save(_voter);
var voteRepository = new VoteRepository();
voteRepository.Save(vote);
new StatisticWindow().Show();
Close();
}
public async Task Voting_Disabled(RequestType type)
{
VoteSettings.Setup(x => x.GetSettingsAsync()).ReturnsAsync(new VoteSettings
{
Enabled = false,
MovieVoteMax = 10
});
var result = await Engine.UpVote(1, type);
Assert.That(result.Result, Is.True);
VoteRepository.Verify(x => x.Add(It.IsAny <Votes>()), Times.Never);
}
public void Delete_Normal_Conditions()
{
var repo = new VoteRepository();
var vote = new Vote();
vote.OptionId = 2;
vote.SurveyId = 3;
var count = repo.GetAll().Count();
repo.Add(vote);
repo.Delete(vote);
Assert.IsTrue(repo.GetAll().Count() == count);
}
public void Should_AddVote_Add_Vote_When_Is_Correct()
{
var options = new DbContextOptionsBuilder <CatMashDbContext>()
.UseInMemoryDatabase(databaseName: "Should_AddVote_Add_Vote_When_Is_Correct")
.Options;
using (var context = new CatMashDbContext(options))
{
context.TCatPicture.Add(new TCatPicture {
Id = 1, Url = "test.com/test1"
});
context.TCatPicture.Add(new TCatPicture {
Id = 2, Url = "test.com/test2"
});
context.TCatPicture.Add(new TCatPicture {
Id = 3, Url = "test.com/test3"
});
context.TCatPicture.Add(new TCatPicture {
Id = 4, Url = "test.com/test4"
});
context.TCatPicture.Add(new TCatPicture {
Id = 5, Url = "test.com/test5"
});
context.TCatPicture.Add(new TCatPicture {
Id = 6, Url = "test.com/test6"
});
var updateCount = context.SaveChanges();
Assert.AreEqual(6, updateCount);
}
using (var context = new CatMashDbContext(options))
{
var mock = new Mock <ILogger <VoteRepository> >();
ILogger <VoteRepository> logger = mock.Object;
logger = Mock.Of <ILogger <VoteRepository> >();
var catRepository = new VoteRepository(context, logger);
var vote = new TVote {
CatId = 1
};
var updateCount = catRepository.InsertVote(vote);
Assert.AreEqual(1, updateCount);
}
}
public async Task UpdateAsync_given_non_existing_vote_returns_false()
{
using (var connection = await CreateConnectionAsync())
using (var context = await CreateContextAsync(connection))
{
var repository = new VoteRepository(context);
var vote = new VoteDTO {
Id = 42
};
var updated = await repository.UpdateAsync(vote);
Assert.False(updated);
}
}
private bool VoteSong(Vote vote)
{
bool retorno = false;
vote.Votes = 1;
Database db = Microsoft.Practices.EnterpriseLibrary.Data.DatabaseFactory.CreateDatabase();
IRepository <IVote> dal = new VoteRepository(db);
IRepositoryBLL <IVote> votelRepoBll = new VoteRepositoryBLL(dal);
IVoteBLL voteBLL = new VoteBLL(votelRepoBll);
retorno = (voteBLL.VoteOnArtist(vote).VoteId > 0);
return(retorno);
}
public UnitOfWork(DatabaseContext context)
{
_context = context;
AccountRepository = new AccountRepository(_context);
ImageRepository = new ImageRepository(_context);
BracketRepository = new BracketRepository(_context);
CreatureSubmissionRepository = new CreatureSubmissionRepository(_context);
UserBracketRepository = new UserBracketRepository(_context);
ChatMessageRepository = new ChatMessageRepository(_context);
RegistryRepository = new RegistryRepository(_context);
RoundRepository = new RoundRepository(_context);
MatchupRepository = new MatchupRepository(_context);
VoteRepository = new VoteRepository(_context);
CreatureRepository = new CreatureRepository(_context);
}
public Estoria1Steps(ScenarioContext scenarioContext)
{
_scenarioContext = scenarioContext;
string dbName = Guid.NewGuid().ToString();
DbContextOptionsBuilder <LunchDbContext> contextOptionsBuilder = new DbContextOptionsBuilder <LunchDbContext>().UseInMemoryDatabase(dbName);
LunchDbContextInMemory dbContext = new LunchDbContextInMemory(contextOptionsBuilder.Options);
IRestaurantRepository restaurantRepository = new RestaurantRepository(dbContext);
IUserRepository userRepository = new UserRepository(dbContext);
IVoteRepository voteRepository = new VoteRepository(dbContext);
IPoolRepository poolRepository = new PoolRepository(dbContext);
restaurantAppService = new RestaurantService(restaurantRepository);
userAppService = new UserService(userRepository);
poolAppService = new PoolService(poolRepository, voteRepository, restaurantAppService, userAppService);
}
private bool VoteSong( Vote vote )
{
bool retorno = false;
vote.Votes = 1;
Database db = Microsoft.Practices.EnterpriseLibrary.Data.DatabaseFactory.CreateDatabase();
IRepository<IVote> dal = new VoteRepository(db);
IRepositoryBLL<IVote> votelRepoBll = new VoteRepositoryBLL(dal);
IVoteBLL voteBLL = new VoteBLL(votelRepoBll);
retorno = (voteBLL.VoteOnArtist(vote).VoteId > 0);
return retorno;
}
public bool DeleteAccount(int usuarioId)
{
bool result = false;
using (TransactionScope scope = new TransactionScope())
{
IDataQuery query = new DataQuery();
query.Where = string.Format("userId={0}", usuarioId);
IList<IProfile> collection = _repositoryProfile.Find(query);
if (collection.Count > 0)
{
VoteRepository voteRepository = new VoteRepository(_dataBase);
query.Where = string.Format("profileId={0}", collection[0].ProfileId);
IList<IVote> votes = voteRepository.Find(query);
foreach (IVote vote in votes)
{
voteRepository.Remove(vote.VoteId);
}
_repositoryProfile.Remove(collection[0].ProfileId);
result = _repository.Remove(usuarioId);
}
}
return result;
}
