示例#1
0
        public void TestNegativeSCPSubmission()
        {
            var userName = "******";

            //Create user
            TestDataInitializer.CreateUser(userName, DateTime.UtcNow.AddDays(-450));
            //Add submission with negatives directly to db
            using (var context = new VoatDataContext())
            {
                var s = context.Submission.Add(new Submission()
                {
                    CreationDate = DateTime.UtcNow.AddHours(-12),
                    Subverse     = SUBVERSES.Unit,
                    Title        = "Test Negative SCP",
                    Url          = "https://www.youtube.com/watch?v=pnbJEg9r1o8",
                    Type         = 2,
                    UpCount      = 2,
                    DownCount    = 13,
                    UserName     = userName
                });
                context.SaveChanges();
            }



            var user           = TestHelper.SetPrincipal(userName);
            var userSubmission = new Domain.Models.UserSubmission()
            {
                Subverse = SUBVERSES.Unit, Title = "Le Censorship!", Content = "Will this work?"
            };
            var cmd = new CreateSubmissionCommand(userSubmission).SetUserContext(user);
            var r   = cmd.Execute().Result;

            VoatAssert.IsValid(r);
        }
示例#2
0
        public async Task UserData_Information_SubscriptionTests()
        {
            //ensure users with no subscriptions don't error out
            var noSubUserName = "******";

            TestDataInitializer.CreateUser(noSubUserName);

            var userData = new Domain.UserData(noSubUserName);

            //var userData = new Domain.UserData(noSubUserName);
            Assert.AreEqual(0, userData.SubverseSubscriptions.Count());
            Assert.AreEqual(false, userData.HasSubscriptions());
            Assert.AreEqual(false, userData.HasSubscriptions(DomainType.Subverse));

            //test subscription
            var subUserName = "******";

            TestDataInitializer.CreateUser(subUserName);

            var user = TestHelper.SetPrincipal(subUserName);
            var cmd  = new SubscribeCommand(new DomainReference(DomainType.Subverse, SUBVERSES.Unit), Domain.Models.SubscriptionAction.Subscribe).SetUserContext(user);
            var x    = await cmd.Execute();

            VoatAssert.IsValid(x);

            userData = new Domain.UserData(subUserName);

            Assert.AreEqual(1, userData.SubverseSubscriptions.Count());
            Assert.AreEqual(SUBVERSES.Unit, userData.SubverseSubscriptions.First());
            Assert.AreEqual(true, userData.HasSubscriptions());
            Assert.AreEqual(true, userData.HasSubscriptions(DomainType.Subverse));
            Assert.AreEqual(true, userData.IsUserSubverseSubscriber(SUBVERSES.Unit));
        }
示例#3
0
        public void TestLogin()
        {
            var userName = "******";

            TestDataInitializer.CreateUser("TestLoginUser");
            using (var m = VoatUserManager.Create())
            {
                var r = m.Find(userName, userName);
                Assert.IsNotNull(r, "Did not find user");

                r = m.Find(userName, userName.ToUpper());
                Assert.IsNull(r, "Incorrect password works");
            }
        }
示例#4
0
        public async Task DeleteAccount_Failures()
        {
            var userName = "******";

            TestDataInitializer.CreateUser(userName);

            var user = TestHelper.SetPrincipal(userName);
            //username doesnt match
            var cmd = new DeleteAccountCommand(
                new Domain.Models.DeleteAccountOptions()
            {
                UserName        = userName,
                ConfirmUserName = "******"
            });
            var result = await cmd.Execute();

            Assert.IsFalse(result.Success, result.Message);

            //password doesn't match
            cmd = new DeleteAccountCommand(
                new Domain.Models.DeleteAccountOptions()
            {
                UserName        = userName,
                ConfirmUserName = userName,
                CurrentPassword = "******"
            });
            result = await cmd.Execute();

            Assert.IsFalse(result.Success, result.Message);

            //wrong user
            user = TestHelper.SetPrincipal("TestUser01");

            cmd = new DeleteAccountCommand(
                new Domain.Models.DeleteAccountOptions()
            {
                UserName        = userName,
                ConfirmUserName = userName,
                CurrentPassword = userName
            });
            result = await cmd.Execute();

            Assert.IsFalse(result.Success, result.Message);
        }
示例#5
0
        public async Task UserSaves()
        {
            var userName = "******";

            //var userName = "******" + Guid.NewGuid().ToString().Substring(0, 5);

            TestDataInitializer.CreateUser(userName);

            var bio  = Guid.NewGuid().ToString();
            var user = TestHelper.SetPrincipal(userName);

            //save start test data
            using (var repo = new Voat.Data.Repository(user))
            {
                var r = await repo.Save(Domain.Models.ContentType.Submission, 1);

                VoatAssert.IsValid(r);

                var submissionSaves = await repo.GetUserSavedItems(Domain.Models.ContentType.Submission, user.Identity.Name);

                Assert.AreEqual(1, submissionSaves.Count());
                Assert.IsTrue(submissionSaves.Any(x => x == 1), "Submission not saved");

                r = await repo.Save(Domain.Models.ContentType.Comment, 1);

                VoatAssert.IsValid(r);

                var commentSaves = await repo.GetUserSavedItems(Domain.Models.ContentType.Comment, user.Identity.Name);

                Assert.AreEqual(1, commentSaves.Count());
                Assert.IsTrue(commentSaves.Any(x => x == 1), "Comment not saved");
            }

            var q = new QueryUserSaves(Domain.Models.ContentType.Submission).SetUserContext(user);
            var d = await q.ExecuteAsync();

            Assert.AreEqual(1, d.Count);
            Assert.AreEqual(true, d.Contains(1));
            Assert.AreEqual(true, CacheHandler.Instance.Exists(CachingKey.UserSavedItems(Domain.Models.ContentType.Submission, userName)));

            q = new QueryUserSaves(Domain.Models.ContentType.Comment).SetUserContext(user);
            d = await q.ExecuteAsync();

            Assert.AreEqual(1, d.Count);
            Assert.AreEqual(true, d.Contains(1));
            Assert.AreEqual(true, CacheHandler.Instance.Exists(CachingKey.UserSavedItems(Domain.Models.ContentType.Comment, userName)));

            //check helper object
            Assert.AreEqual(true, UserHelper.IsSaved(user, Domain.Models.ContentType.Submission, 1));
            Assert.AreEqual(true, UserHelper.IsSaved(user, Domain.Models.ContentType.Comment, 1));

            Assert.AreEqual(false, UserHelper.IsSaved(user, Domain.Models.ContentType.Submission, 2));
            Assert.AreEqual(false, UserHelper.IsSaved(user, Domain.Models.ContentType.Comment, 2));

            var cmd      = new SaveCommand(Domain.Models.ContentType.Submission, 2).SetUserContext(user);
            var response = await cmd.Execute();

            VoatAssert.IsValid(response);

            cmd      = new SaveCommand(Domain.Models.ContentType.Comment, 2).SetUserContext(user);
            response = await cmd.Execute();

            VoatAssert.IsValid(response);

            Assert.AreEqual(true, UserHelper.IsSaved(user, Domain.Models.ContentType.Submission, 2));
            Assert.AreEqual(true, UserHelper.IsSaved(user, Domain.Models.ContentType.Comment, 2));

            cmd      = new SaveCommand(Domain.Models.ContentType.Submission, 1).SetUserContext(user);;
            response = await cmd.Execute();

            VoatAssert.IsValid(response);

            cmd      = new SaveCommand(Domain.Models.ContentType.Comment, 1).SetUserContext(user);
            response = await cmd.Execute();

            VoatAssert.IsValid(response);

            Assert.AreEqual(false, UserHelper.IsSaved(user, Domain.Models.ContentType.Submission, 1));
            Assert.AreEqual(false, UserHelper.IsSaved(user, Domain.Models.ContentType.Comment, 1));
        }
示例#6
0
        public async Task DeleteAccount_Basic()
        {
            //EnsureBadges
            using (var db = new VoatDataContext())
            {
                if (!db.Badge.Any(x => x.ID == "deleted"))
                {
                    db.Badge.Add(new Badge()
                    {
                        ID = "deleted", Name = "Account Deleted", Graphic = "deleted.png", Title = "deleted"
                    });
                }
                if (!db.Badge.Any(x => x.ID == "deleted2"))
                {
                    db.Badge.Add(new Badge()
                    {
                        ID = "deleted2", Name = "Account Deleted", Graphic = "deleted2.png", Title = "deleted"
                    });
                }
                if (!db.Badge.Any(x => x.ID == "donor_upto_30"))
                {
                    db.Badge.Add(new Badge()
                    {
                        ID = "donor_upto_30", Name = "Donor Up To Thirty", Graphic = "donor30.png", Title = "Donor"
                    });
                }


                db.SaveChanges();
            }


            var userName = "******";

            TestDataInitializer.CreateUser(userName);
            var user = TestHelper.SetPrincipal(userName);
            DeleteAccountCommand cmd;
            CommandResponse      result;

            var options = new Domain.Models.DeleteAccountOptions()
            {
                UserName        = userName,
                ConfirmUserName = userName,
                CurrentPassword = userName,
                Comments        = Domain.Models.DeleteOption.Anonymize,
                LinkSubmissions = Domain.Models.DeleteOption.Anonymize,
                TextSubmissions = Domain.Models.DeleteOption.Anonymize
            };

            var submission = TestHelper.ContentCreation.CreateSubmission(options.UserName, new Domain.Models.UserSubmission()
            {
                Subverse = SUBVERSES.Unit,
                Title    = "Test Submission Yeah",
                Content  = "Test Submission Content"
            });

            var comment = TestHelper.ContentCreation.CreateComment(options.UserName, submission.ID, "This is a test comment");

            //Anon it all
            cmd    = new DeleteAccountCommand(options).SetUserContext(user);
            result = await cmd.Execute();

            VoatAssert.IsValid(result);
            VerifyDelete(options);


            userName = "******";

            TestDataInitializer.CreateUser(userName);
            user = TestHelper.SetPrincipal(userName);

            using (var db = new VoatDataContext())
            {
                //Trying to trap a bug with a user not getting delete badge
                db.UserBadge.Add(new Voat.Data.Models.UserBadge()
                {
                    BadgeID = "donor_upto_30", CreationDate = DateTime.UtcNow, UserName = userName
                });
                db.SaveChanges();
            }

            options = new Domain.Models.DeleteAccountOptions()
            {
                UserName        = userName,
                ConfirmUserName = userName,
                CurrentPassword = userName,
                Comments        = Domain.Models.DeleteOption.Delete,
                LinkSubmissions = Domain.Models.DeleteOption.Delete,
                TextSubmissions = Domain.Models.DeleteOption.Delete
            };

            submission = TestHelper.ContentCreation.CreateSubmission(options.UserName, new Domain.Models.UserSubmission()
            {
                Subverse = SUBVERSES.Unit,
                Title    = "Test Submission Yeah",
                Content  = "Test Submission Content"
            });

            comment = TestHelper.ContentCreation.CreateComment(options.UserName, submission.ID, "This is a test comment");

            //Delete
            cmd    = new DeleteAccountCommand(options).SetUserContext(user);
            result = await cmd.Execute();

            VoatAssert.IsValid(result);

            VerifyDelete(options);



            userName = "******";

            TestDataInitializer.CreateUser(userName);
            user = TestHelper.SetPrincipal(userName);

            //Need to ensure delete clears preferences
            var prefUpdate = new UpdateUserPreferencesCommand(new Domain.Models.UserPreferenceUpdate()
            {
                Bio = "My Bio"
            }).SetUserContext(user);
            var p = await prefUpdate.Execute();

            VoatAssert.IsValid(p);

            using (var db = new VoatDataContext())
            {
                var prefs = db.UserPreference.FirstOrDefault(x => x.UserName == userName);
                Assert.IsNotNull(prefs, "Expected user to have preference record at this stage");
                prefs.Avatar = userName + ".jpg";

                //Add badges to prevent duplicates
                db.UserBadge.Add(new Voat.Data.Models.UserBadge()
                {
                    BadgeID = "deleted", CreationDate = DateTime.UtcNow, UserName = userName
                });
                db.UserBadge.Add(new Voat.Data.Models.UserBadge()
                {
                    BadgeID = "deleted2", CreationDate = DateTime.UtcNow, UserName = userName
                });

                db.SaveChanges();
            }

            options = new Domain.Models.DeleteAccountOptions()
            {
                UserName                    = userName,
                ConfirmUserName             = userName,
                CurrentPassword             = userName,
                Comments                    = Domain.Models.DeleteOption.Delete,
                LinkSubmissions             = Domain.Models.DeleteOption.Delete,
                TextSubmissions             = Domain.Models.DeleteOption.Delete,
                RecoveryEmailAddress        = "*****@*****.**",
                ConfirmRecoveryEmailAddress = "*****@*****.**",
                Reason = "I need a break from the racialists"
            };

            submission = TestHelper.ContentCreation.CreateSubmission(options.UserName, new Domain.Models.UserSubmission()
            {
                Subverse = SUBVERSES.Unit,
                Title    = "Test Submission Yeah",
                Content  = "Test Submission Content"
            });

            comment = TestHelper.ContentCreation.CreateComment(options.UserName, submission.ID, "This is a test comment");

            //Delete
            cmd    = new DeleteAccountCommand(options).SetUserContext(user);
            result = await cmd.Execute();

            VoatAssert.IsValid(result);
            VerifyDelete(options);
        }
示例#7
0
        public async Task Block_Lifecycle_Tests()
        {
            var userName = "******";
            var subName  = SUBVERSES.Unit;

            TestDataInitializer.CreateUser(userName);
            var user = TestHelper.SetPrincipal(userName);

            //Verify No Front / Blocked Sets
            var userBlockQuery   = new QueryUserBlocks(userName).SetUserContext(user);
            var userBlockResults = await userBlockQuery.ExecuteAsync();

            Assert.IsNotNull(userBlockResults, "Old McDonald had a farm ee i ee i o. And on that farm he shot some guys. Badda boom badda bing bang boom.");
            Assert.AreEqual(0, userBlockResults.Count(), "He is supposed to be Turkish. Some say his father was German. Nobody believed he was real.");

            var userSetQuery   = new QueryUserSets(userName).SetUserContext(user);
            var userSetResults = await userSetQuery.ExecuteAsync();

            Assert.IsNotNull(userSetResults, "One cannot be betrayed if one has no people.");
            Assert.AreEqual(0, userSetResults.Count(), "A man can convince anyone he's somebody else, but never himself.");

            var currentSubscriberCount = 0;

            using (var db = new VoatDataContext())
            {
                var count = db.Subverse.First(x => x.Name == subName).SubscriberCount;
                currentSubscriberCount = count.HasValue ? count.Value : 0;
            }

            //Sub a user to front
            var domainReference = new DomainReference(DomainType.Subverse, subName);
            var blockCmd        = new BlockCommand(domainReference.Type, domainReference.Name, true).SetUserContext(user);
            var blockResult     = await blockCmd.Execute();

            //Verify Front is created
            userBlockQuery   = new QueryUserBlocks(userName).SetUserContext(user);
            userBlockResults = await userBlockQuery.ExecuteAsync();

            Assert.IsNotNull(userBlockResults, "What about it, pretzel man? What's your story?");
            Assert.AreEqual(1, userBlockResults.Count(), "First day on the job, you know what I learned? How to spot a murderer.");
            Assert.IsTrue(userBlockResults.Any(x => x.Type == DomainType.Subverse && x.Name == subName), "It was Keyser Soze, Agent Kujan. I mean the Devil himself. How do you shoot the Devil in the back? What if you miss?");

            userSetQuery   = new QueryUserSets(userName).SetUserContext(user);
            userSetResults = await userSetQuery.ExecuteAsync();

            Assert.IsNotNull(userSetResults, "What the cops never figured out, and what I know now, was that these men would never break, never lie down, never bend over for anybody");
            Assert.AreEqual(1, userSetResults.Count(x => x.Type == SetType.Blocked), "Is it Friday already? ");
            var set = userSetResults.First(x => x.Type == SetType.Blocked);

            Assert.AreEqual(SetType.Blocked, set.Type, "I got a whole new problem when I post bail.");
            Assert.AreEqual(1, set.SubscriberCount, "I got a whole new problem when I post bail.");

            //Ensure Subverse Subscriber Count Updated
            using (var db = new VoatDataContext())
            {
                var tc    = db.Subverse.First(x => x.Name == subName).SubscriberCount;
                var count = tc.HasValue ? tc.Value : 0;
                Assert.AreEqual(currentSubscriberCount, count, "");
                currentSubscriberCount = count;
            }

            //verify FRONT set has sub
            using (var repo = new Voat.Data.Repository())
            {
                var setList = await repo.GetSetListDescription(SetType.Blocked.ToString(), userName);

                Assert.IsTrue(setList.Any(x => x.Name == subName));
            }

            //Unsubscribe
            blockCmd    = new BlockCommand(domainReference.Type, domainReference.Name, true).SetUserContext(user);
            blockResult = await blockCmd.Execute();

            VoatAssert.IsValid(blockResult);

            //Ensure Subverse Subscriber Count Updated
            using (var db = new VoatDataContext())
            {
                var count = db.Subverse.First(x => x.Name == subName).SubscriberCount;
                Assert.AreEqual(currentSubscriberCount, count.HasValue ? count.Value : 0, "");
            }

            //verify FRONT set has not sub
            using (var repo = new Voat.Data.Repository())
            {
                var setList = await repo.GetSetListDescription(SetType.Blocked.ToString(), userName);

                Assert.IsFalse(setList.Any(x => x.Name == subName));
            }
        }
示例#8
0
        public async Task MentionUser_Anon_Block_Test()
        {
            string user1 = "UnitTestUser13";
            string user2 = "BlocksAnonTestUser01";

            TestDataInitializer.CreateUser(user2);

            var user    = TestHelper.SetPrincipal(user2);
            var prefCmd = new UpdateUserPreferencesCommand(new Domain.Models.UserPreferenceUpdate()
            {
                BlockAnonymized = true
            }).SetUserContext(user);
            var prefResult = await prefCmd.Execute();

            VoatAssert.IsValid(prefResult);

            //Submission Mention - NO NO
            user = TestHelper.SetPrincipal(user1);
            var anonSubmission = TestHelper.ContentCreation.CreateSubmission(user1, new Domain.Models.UserSubmission()
            {
                Title = $"I'm harrassing @{user2}!", Content = $"Hey everyone isn't /u/{user2} a shill tornado?", Subverse = SUBVERSES.Anon
            });

            Assert.IsNotNull(anonSubmission, "Couldn't create test submission");
            Assert.AreNotEqual(0, anonSubmission.ID, "Doesn't appear we have a valid submission id");

            using (var db = new VoatDataContext())
            {
                var count = db.Message.Where(x =>
                                             x.Sender == user1 &&
                                             x.Recipient == user2 &&
                                             x.SubmissionID == anonSubmission.ID &&
                                             x.IsAnonymized == true &&
                                             x.Type == (int)Domain.Models.MessageType.SubmissionMention
                                             ).Count();
                Assert.AreEqual(0, count, "Expecting No Submission Mentions!");
            }

            //Comment Mention - NO NO
            string commentContent = $"Hello @{user2}, I am mentioning you in an anon thread because I want to make you feel scared";
            var    cmd            = new CreateCommentCommand(anonSubmission.ID, null, commentContent).SetUserContext(user);
            var    result         = await cmd.Execute();

            VoatAssert.IsValid(result);

            using (var db = new VoatDataContext())
            {
                var count = db.Message.Where(x =>
                                             x.Sender == user1 &&
                                             x.Recipient == user2 &&
                                             x.CommentID == result.Response.ID &&
                                             x.IsAnonymized == true &&
                                             x.Type == (int)Domain.Models.MessageType.CommentMention
                                             ).Count();
                Assert.AreEqual(0, count, "Received duplicates and now users are annoyed and burning down the village! Run!");
            }

            //Comment Reply - YES YES
            user           = TestHelper.SetPrincipal(user2);
            commentContent = $"I'm {user2} won't someone reply to me so I can see if reply notifications work?";
            cmd            = new CreateCommentCommand(anonSubmission.ID, null, commentContent).SetUserContext(user);
            result         = await cmd.Execute();

            VoatAssert.IsValid(result);


            user           = TestHelper.SetPrincipal(user1);
            commentContent = $"I'm following you!";
            cmd            = new CreateCommentCommand(anonSubmission.ID, result.Response.ID, commentContent).SetUserContext(user);
            result         = await cmd.Execute();

            VoatAssert.IsValid(result);

            using (var db = new VoatDataContext())
            {
                var count = db.Message.Where(x =>
                                             x.Sender == user1 &&
                                             x.Recipient == user2 &&
                                             x.CommentID == result.Response.ID &&
                                             x.IsAnonymized == true &&
                                             x.Type == (int)Domain.Models.MessageType.CommentReply
                                             ).Count();

                Assert.AreEqual(1, count, "Replies should work!!!!!!");
            }

            //Submission Reply - YES YES
            user           = TestHelper.SetPrincipal(user2);
            anonSubmission = TestHelper.ContentCreation.CreateSubmission(user2, new Domain.Models.UserSubmission()
            {
                Title = $"Is this working?", Content = $"Someeone, anyone, am I alone?", Subverse = SUBVERSES.Anon
            });
            Assert.IsNotNull(anonSubmission, "Couldn't create test submission");
            Assert.AreNotEqual(0, anonSubmission.ID, "Doesn't appear we have a valid submission id");

            user           = TestHelper.SetPrincipal(user1);
            commentContent = $"I know who you are and I've been following you this entire unit test. I might be in love with you, if stalking is a form of love.";
            cmd            = new CreateCommentCommand(anonSubmission.ID, null, commentContent).SetUserContext(user);
            result         = await cmd.Execute();

            VoatAssert.IsValid(result);

            using (var db = new VoatDataContext())
            {
                var count = db.Message.Where(x =>
                                             x.Sender == user1 &&
                                             x.Recipient == user2 &&
                                             x.SubmissionID == anonSubmission.ID &&
                                             x.IsAnonymized == true &&
                                             x.Type == (int)Domain.Models.MessageType.SubmissionReply
                                             ).Count();

                Assert.AreEqual(1, count, "Replies should work!!!!!!");
            }
        }