Esempio n. 1
0
 private Task UpateOwnerReputationAsync(Vote vote, Vote existingVote, Account owner) {
     if (existingVote != null) {
         owner.Reputation -= CalculateRepScore(existingVote);
     }
     owner.Reputation += CalculateRepScore(vote);
     return _accountRepository.UpdateAsync(owner);
 }
Esempio n. 2
0
        public async Task GetRequestWithCountdownIdAndAuthenticatedUser_ReturnsCommentListViewModelWithCorrectResults() {
            const int countdownId = 123;

            var currentAccount = new Account {Id = 1337};

            var mockCommentRepository = new Mock<ICommentRepository>();
            mockCommentRepository
                .Setup(x => x.GetCountdownCommentsAsync(countdownId, currentAccount.Id))
                .Returns(
                    Task.FromResult<IEnumerable<CommentAggregate>>(new List<CommentAggregate> {
                        new CommentAggregate(),
                        new CommentAggregate(),
                        new CommentAggregate()
                    }));

            var mockContextService = new Mock<IContextService>();
            mockContextService
                .Setup(x => x.GetCurrentAccountAsync())
                .Returns(Task.FromResult(currentAccount));

            var commentController = new CommentController(mockCommentRepository.Object, new Mock<IVoteService>().Object, mockContextService.Object);

            dynamic result = (await commentController.GetAll(countdownId)).Data;
            var model = result as CommentListViewModel;

            Assert.IsNotNull(model);
            Assert.AreEqual(3, model.Comments.Count());
        }
Esempio n. 3
0
        public async Task GetRequest_ReturnsCorrectlyPopulatedViewModel() {
            var currentAccount = new Account { Id = 12345 };
            var countdownController = TestableCountdownController.Create();
            var fakeResults = TestableCountdownController.CreateFakeCountdownResult(10);

            countdownController.MockCountdownRepository
                               .Setup(x => x.GetTotalActiveCountAsync(currentAccount.Id))
                               .Returns(Task.FromResult(15));

            countdownController.MockCountdownRepository
                               .Setup(x => x.GetMineAsync(1, 10, currentAccount.Id))
                               .Returns(Task.FromResult(fakeResults));

            countdownController.MockContextService
                               .Setup(x => x.GetCurrentAccountAsync())
                               .Returns(Task.FromResult(currentAccount));

            var result = (await countdownController.Mine()) as ViewResult;

            Assert.IsNotNull(result);
            var model = result.Model as CountdownListViewModel;
            Assert.IsNotNull(model);
            Assert.AreEqual(15, model.Total);
            Assert.AreEqual(10, model.Countdowns.Count());
            Assert.AreEqual(1, model.Page);
        }
Esempio n. 4
0
        public async Task CurrentUserIsAuthenticated_ReturnsAccount() {
            const string accountId = "123";
            var account = new Account {
                Id = 123,
                DisplayName = "fakeDisplayName",
                Email = "fakeEmailAddress",
                AccountLogins = new List<AccountLogin> {
                    new AccountLogin {
                        Id = Guid.NewGuid(),
                        ProviderName = "fakeProviderName",
                        ProviderUserId = "fakeProviderUserId"
                    }
                }
            };

            var mockPrincipal = new Mock<IIdentity>();
            mockPrincipal.Setup(x => x.IsAuthenticated).Returns(true);
            mockPrincipal.Setup(x => x.Name).Returns(accountId);

            var contextService = TestableContextService.Create();
            contextService.MockHttpContextWrapper
                          .Setup(x => x.GetCurrentIdentity())
                          .Returns(mockPrincipal.Object);

            contextService.MockAccountRepository
                          .Setup(x => x.GetAsync(int.Parse(accountId)))
                          .Returns(Task.FromResult(account));

            Account result = await contextService.GetCurrentAccountAsync();

            Assert.IsNotNull(result);
            Assert.AreEqual(account, result);
        }
Esempio n. 5
0
        public async Task PostCommentViewModelCurrentUserIsAuthenticated_ReturnsJsonResulACommentViewModel() {
            var repository = new FakeCommentRepository();

            var contextService = new Mock<IContextService>();
            var account = new Account {Id = 12345, DisplayName = "TestDisplayName", Email = "*****@*****.**"};
            contextService
                .Setup(x => x.GetCurrentAccountAsync())
                .Returns(Task.FromResult(account));

            var commentController = new CommentController(repository, new Mock<IVoteService>().Object, contextService.Object);
            var commentViewModel = new CommentViewModel {
                CountdownId = 123,
                Text = "Comment content..."
            };

            dynamic result = (await commentController.Create(commentViewModel)).Data;

            var model = result as CommentViewModel;
            Assert.IsNotNull(model);
            Assert.AreEqual(account.DisplayName, model.CreatedByName);
            Assert.AreEqual(account.Email, model.CreatedByEmail);

            DateTime localTime = DateTime.UtcNow.ToLocalTime();
            Assert.AreEqual(localTime.Date, model.CreatedOn.Date);
            Assert.AreEqual(localTime.Hour, model.CreatedOn.Hour);
            Assert.AreEqual(localTime.Minute, model.CreatedOn.Minute);
            Assert.AreEqual(localTime.Second, model.CreatedOn.Second);

            Assert.AreEqual(commentViewModel.Text, model.Text);
            Assert.AreEqual(commentViewModel.CountdownId, model.CountdownId);
        }
Esempio n. 6
0
 private async Task CreateNotification(Vote vote, Account owner) {
     var notification = new Notification {
         AccountId = owner.Id,
         Read = false,
         CreatedOn = DateTime.UtcNow,
         Type = NotificationType.Vote,
         Content = await GenerateNotificationContentAsync(vote)
     };
     _notificationDispatcher.Dispatch(notification);
 }
Esempio n. 7
0
 public async Task CreateAsync(Account account) {
     using (SqlConnection connection = Connection) {
         const string sql =
             "INSERT INTO Accounts (DisplayName, Email, CreatedOn, Reputation) " +
             "OUTPUT INSERTED.Id " +
             "VALUES (@DisplayName, @Email, @CreatedOn, @Reputation)";
         account.Id = (await connection.QueryAsync<int>(sql, account)).Single();
         await CreateAccountLoginsAsync(account, connection);
     }
 }
Esempio n. 8
0
 public async Task UpdateAsync(Account account) {
     using (SqlConnection connection = Connection) {
         const string sql =
             "UPDATE Accounts SET " +
                 "DisplayName = @DisplayName, " +
                 "Email = @Email, " +
                 "CreatedOn = @CreatedOn, " +
                 "Reputation = @Reputation " +
             "WHERE Id = @Id";
         await connection.ExecuteAsync(sql, account);
     }
 }
Esempio n. 9
0
        public async Task GetRequest_ReturnsCorrectlyMappedViewModel() {
            var currentAccount = new Account { Id = 12345 };
            var countdownController = TestableCountdownController.Create();
            var fakeResults = new List<CountdownAggregate> {
                new CountdownAggregate {
                    Id = 1,
                    Description = "Test Counter Description",
                    EndsOn = new DateTime(2013, 01, 01, 12, 35, 10),
                    CreatedOn = DateTime.UtcNow,
                    VoteScore = 1,
                    IsCreatedByCurrentUser = false,
                    CreatedByName = "DisplayName",
                    CreatedByEmail = "*****@*****.**"
                }
            };

            countdownController.MockCountdownRepository
                               .Setup(x => x.GetMineAsync(1, 10, currentAccount.Id))
                               .Returns(Task.FromResult<IEnumerable<CountdownAggregate>>(fakeResults));

            countdownController.MockContextService
                               .Setup(x => x.GetCurrentAccountAsync())
                               .Returns(Task.FromResult(currentAccount));

            var result = (await countdownController.Mine()) as ViewResult;
            Assert.IsNotNull(result);
            var model = result.Model as CountdownListViewModel;

            Assert.IsNotNull(model);
            CountdownViewModel firstCountdownViewModel = model.Countdowns.First();
            Assert.AreEqual(fakeResults[0].Id, firstCountdownViewModel.Id);
            Assert.AreEqual(fakeResults[0].Description, firstCountdownViewModel.Description);
            Assert.AreEqual(fakeResults[0].EndsOn, firstCountdownViewModel.EndsOn);
            Assert.AreEqual(fakeResults[0].CreatedOn, firstCountdownViewModel.CreatedOn);
            Assert.AreEqual(fakeResults[0].IsCreatedByCurrentUser, firstCountdownViewModel.IsCreatedByCurrentUser);
            Assert.AreEqual(fakeResults[0].CreatedByName, firstCountdownViewModel.CreatedByName);
            Assert.AreEqual(fakeResults[0].CreatedByEmail, firstCountdownViewModel.CreatedByEmail);
            Assert.AreEqual(1, firstCountdownViewModel.VoteScore);
        }
Esempio n. 10
0
        public async Task PostCommentViewModelCurrentUserIsAuthenticated_CreatesTheCommentWithTheCorrectValues() {
            var repository = new FakeCommentRepository();

            var contextService = new Mock<IContextService>();
            var account = new Account {Id = 123};
            contextService
                .Setup(x => x.GetCurrentAccountAsync())
                .Returns(Task.FromResult(account));

            var commentController = new CommentController(repository, new Mock<IVoteService>().Object, contextService.Object);
            var commentViewModel = new CommentViewModel {
                CountdownId = 123,
                Text = "Comment content..."
            };

            await commentController.Create(commentViewModel);

            Assert.AreEqual(1, repository.InMemoryComments.Count);
            Comment comment = repository.InMemoryComments[0];
            Assert.AreEqual(commentViewModel.Text, comment.Text);
            Assert.AreEqual(commentViewModel.CountdownId, comment.CountdownId);
            Assert.AreEqual(account, comment.Account);
            Assert.AreEqual(DateTime.UtcNow.Date, comment.CreatedOn.Date);
        }
Esempio n. 11
0
 private async Task CreateVoteAsync(Vote vote, Account owner) {
     await _voteRepository.CreateAsync(vote);
     await CreateNotification(vote, owner);
 }
Esempio n. 12
0
        private static async Task CreateAccountLoginsAsync(Account account, IDbConnection connection) {
            const string query = 
                "INSERT INTO AccountLogins (AccountId, ProviderUserId, ProviderName) " +
                "OUTPUT INSERTED.Id " +
                "VALUES (@AccountId, @ProviderUserId, @ProviderName)";

            foreach (AccountLogin accountLogin in account.AccountLogins) {
                var loginParams = new {
                    AccountId = account.Id,
                    accountLogin.ProviderUserId,
                    accountLogin.ProviderName
                };
                accountLogin.Id = (await connection.QueryAsync<Guid>(query, loginParams)).Single();
            }
        }
Esempio n. 13
0
 public static Comment ToComment(this CommentViewModel commentViewModel, Account currentAccount) {
     Comment comment = commentViewModel.ToComment();
     comment.Account = currentAccount;
     comment.CreatedById = currentAccount.Id;
     return comment;
 }
Esempio n. 14
0
 public static Countdown ToCountdown(this CountdownViewModel countdownViewModel, Account currentAccount) {
     Countdown countdown = countdownViewModel.ToCountdown();
     countdown.Account = currentAccount;
     countdown.CreatedById = currentAccount.Id;
     return countdown;
 }
Esempio n. 15
0
        public async void PostCountdownViewModel_CorrectlyCreatesCountdown() {
            var fakeRepository = new FakeCountdownRepository();
            var fakeAccount = new Account {
                Id = 123,
                DisplayName = "TestDisplayName"
            };
            var mockVoteService = new Mock<IVoteService>();
            var mockUserContextService = new Mock<IContextService>();
            mockUserContextService
                .Setup(x => x.GetCurrentAccountAsync())
                .Returns(Task.FromResult(fakeAccount));
            
            var countdownController = new CountdownController(fakeRepository, mockVoteService.Object, mockUserContextService.Object);
            ControllerContextHelper.SetupMockContext(countdownController);

            var fakeCountdownViewModel1 = new CountdownViewModel {
                Id = 12,
                Description = "Test description 1",
                SelectedCountdownType = CountdownViewModel.CountdownType.Duration,
                SelectedDurationType = CountdownViewModel.DurationType.Minutes,
                Duration = 10
            };

            var fakeCountdownViewModel2 = new CountdownViewModel {
                Id = 123,
                Description = "Test description 2",
                EndsOnYear = 2013,
                EndsOnMonth = 11,
                EndsOnDay = 14,
                EndsOnHour = 21,
                EndsOnMinute = 39,
                SelectedCountdownType = CountdownViewModel.CountdownType.Date
            };

            var expectedEndDate = new DateTime(
                fakeCountdownViewModel2.EndsOnYear, 
                fakeCountdownViewModel2.EndsOnMonth,
                fakeCountdownViewModel2.EndsOnDay,
                (int) fakeCountdownViewModel2.EndsOnHour,
                (int) fakeCountdownViewModel2.EndsOnMinute, 0).ToUniversalTime();

            await countdownController.Create(fakeCountdownViewModel1);
            await countdownController.Create(fakeCountdownViewModel2);

            IEnumerable<CountdownAggregate> countdowns = (await fakeRepository.GetLatestAsync(0, 10)).ToList();

            Assert.AreEqual(2, countdowns.Count());
            CountdownAggregate dateCountdown = countdowns.First(x => x.Id == 123);
            CountdownAggregate durationCountdown = countdowns.First(x => x.Id == 12);

            // Date countdown verification
            Assert.AreEqual(fakeCountdownViewModel2.Description, dateCountdown.Description);
            Assert.AreEqual(expectedEndDate, dateCountdown.EndsOn);
            Assert.IsTrue(dateCountdown.IsCreatedByCurrentUser);
            Assert.AreEqual(fakeAccount.DisplayName, dateCountdown.CreatedByName);
            Assert.AreEqual(DateTime.Today.Date, dateCountdown.CreatedOn.Date);

            // Duration countdown verification
            Assert.AreEqual(fakeCountdownViewModel1.Description, durationCountdown.Description);
            // difference of 10 min
            Assert.AreEqual(DateTimeOffset.UtcNow.AddMinutes(10).Minute, durationCountdown.EndsOn.Minute);
        }
Esempio n. 16
0
        public async void PostCountdownViewModel_RedirectsToIndexContainingTheCountdownIdInUrlHash() {
            var fakeAccount = new Account {
                Id = 123,
                DisplayName = "TestDisplayName"
            };
            const long fakeId = 12345;
            var fakeCountdownViewModel = new CountdownViewModel {
                Description = "Test description",
                EndsOnYear = 2013,
                EndsOnMonth = 12,
                EndsOnDay = 15,
                EndsOnHour = 22,
                EndsOnMinute = 37
            };

            var countdownController = TestableCountdownController.Create();
            countdownController.MockContextService
                .Setup(x => x.GetCurrentAccountAsync())
                .Returns(Task.FromResult(fakeAccount));

            countdownController.MockCountdownRepository
                .Setup(x => x.CreateAsync(It.IsAny<Countdown>()))
                .Returns((Countdown c) => {
                    c.Id = fakeId;
                    return Task.FromResult(c);
                });

            var result = await countdownController.Create(fakeCountdownViewModel) as RedirectResult;

            Assert.IsNotNull(result);
            StringAssert.EndsWith(string.Format("/Countdown/{0}", fakeId), result.Url);
        }
Esempio n. 17
0
 private Task RegisterAccount(ExternalLoginViewModel viewModel, ProviderLoginData providerLoginData) {
     var account = new Account {
         DisplayName = viewModel.DisplayName,
         Email = viewModel.Email,
         CreatedOn = DateTime.UtcNow,
         AccountLogins = new List<AccountLogin> {
             new AccountLogin {
                 Id = Guid.NewGuid(),
                 ProviderName = providerLoginData.ProviderName,
                 ProviderUserId = providerLoginData.ProviderUserId
             }
         }
     };
     account.AccountLogins.First().Account = account;
     return _accountRepository.CreateAsync(account);
 }