public void Fetch()
        {
            var data = new List <PollSearchResultsData> {
                EntityCreator.Create <PollSearchResultsData>()
            };

            var pollSearchResultsFactory = new Mock <IObjectFactory <ReadOnlySwitchList <IPollSearchResult> > >(MockBehavior.Strict);

            pollSearchResultsFactory.Setup(_ => _.FetchChild()).Returns(DataPortal.FetchChild <ReadOnlySwitchList <IPollSearchResult> >());

            var pollSearchResultFactory = new Mock <IObjectFactory <IPollSearchResult> >(MockBehavior.Strict);

            pollSearchResultFactory.Setup(_ => _.FetchChild(It.IsAny <object[]>()))
            .Returns <object[]>(_ => DataPortal.FetchChild <PollSearchResult>(_[0] as PollSearchResultsData));

            var builder = new ContainerBuilder();

            builder.RegisterInstance(Mock.Of <IEntities>()).As <IEntities>();
            builder.Register <IObjectFactory <ReadOnlySwitchList <IPollSearchResult> > >(_ => pollSearchResultsFactory.Object);
            builder.Register <IObjectFactory <IPollSearchResult> >(_ => pollSearchResultFactory.Object);

            using (new ObjectActivator(builder.Build(), new ActivatorCallContext())
                   .Bind(() => ApplicationContext.DataPortalActivator))
            {
                var result = DataPortal.FetchChild <PollSearchResultsByCategory>(data);

                Assert.AreEqual(data[0].Category, result.Category, nameof(result.Category));
                Assert.AreEqual(1, result.SearchResults.Count, nameof(result.SearchResults));
            }

            pollSearchResultsFactory.VerifyAll();
            pollSearchResultFactory.VerifyAll();
        }
예제 #2
0
        public void Fetch()
        {
            var entity = EntityCreator.Create <MVPollOption>();

            var entities = new Mock <IEntities>(MockBehavior.Strict);

            entities.Setup(_ => _.Dispose());

            var builder = new ContainerBuilder();

            builder.Register <IEntities>(_ => entities.Object);

            using (new ObjectActivator(builder.Build(), new ActivatorCallContext())
                   .Bind(() => ApplicationContext.DataPortalActivator))
            {
                var pollOption = DataPortal.FetchChild <PollOption>(entity);

                Assert.AreEqual(entity.OptionPosition, pollOption.OptionPosition, nameof(pollOption.OptionPosition));
                Assert.AreEqual(entity.OptionText, pollOption.OptionText, nameof(pollOption.OptionText));
                Assert.AreEqual(entity.PollID, pollOption.PollID, nameof(pollOption.PollID));
                Assert.AreEqual(entity.PollOptionID, pollOption.PollOptionID, nameof(pollOption.PollOptionID));
            }

            entities.VerifyAll();
        }
예제 #3
0
        public void Fetch()
        {
            var entity = EntityCreator.Create <MVCategory>();

            var context = new Mock <IEntities>(MockBehavior.Strict);

            context.Setup(_ => _.MVCategories).Returns(new InMemoryDbSet <MVCategory> {
                entity
            });
            context.Setup(_ => _.Dispose());

            var categoryFactory = new Mock <IObjectFactory <ICategory> >(MockBehavior.Strict);

            categoryFactory.Setup(_ => _.FetchChild(It.IsAny <object[]>()))
            .Returns <object[]>(_ => DataPortal.FetchChild <Category>(_[0] as MVCategory));

            var builder = new ContainerBuilder();

            builder.Register <IEntities>(_ => context.Object);
            builder.Register <IObjectFactory <ICategory> >(_ => categoryFactory.Object);

            using (new ObjectActivator(builder.Build(), new ActivatorCallContext())
                   .Bind(() => ApplicationContext.DataPortalActivator))
            {
                var categories = DataPortal.Fetch <CategoryCollection>();
                Assert.AreEqual(1, categories.Count, nameof(categories.Count));
            }

            context.VerifyAll();
            categoryFactory.VerifyAll();
        }
예제 #4
0
        internal static T Create <T>(Action <T> modifier)
            where T : new()
        {
            var entity = EntityCreator.Create <T>();

            modifier(entity);
            return(entity);
        }
예제 #5
0
        public void Fetch()
        {
            var entity = EntityCreator.Create <MVPoll>(_ => _.PollDeletedFlag = false);

            entity.MVPollOptions = new List <MVPollOption> {
                EntityCreator.Create <MVPollOption>()
            };

            var pollOptions = new Mock <IObjectFactory <BusinessList <IPollOption> > >(MockBehavior.Strict);

            pollOptions.Setup(_ => _.FetchChild()).Returns(new BusinessList <IPollOption>());

            var pollOption = new Mock <IObjectFactory <IPollOption> >(MockBehavior.Strict);

            pollOption.Setup(_ => _.FetchChild(It.IsAny <object[]>()))
            .Returns <object[]>(_ => DataPortal.FetchChild <PollOption>(_[0] as MVPollOption));

            var entities = new Mock <IEntities>(MockBehavior.Strict);

            entities.Setup(_ => _.MVPolls).Returns(new InMemoryDbSet <MVPoll> {
                entity
            });
            entities.Setup(_ => _.Dispose());

            var builder = new ContainerBuilder();

            builder.Register <IEntities>(_ => entities.Object);
            builder.Register <IObjectFactory <BusinessList <IPollOption> > >(_ => pollOptions.Object);
            builder.Register <IObjectFactory <IPollOption> >(_ => pollOption.Object);

            using (new ObjectActivator(builder.Build(), new ActivatorCallContext())
                   .Bind(() => ApplicationContext.DataPortalActivator))
            {
                var poll = new DataPortal <Poll>().Fetch(entity.PollID);

                Assert.AreEqual(entity.PollAdminRemovedFlag, poll.PollAdminRemovedFlag, nameof(poll.PollAdminRemovedFlag));
                Assert.AreEqual(entity.PollCategoryID, poll.PollCategoryID, nameof(poll.PollCategoryID));
                Assert.AreEqual(entity.PollDateRemoved, poll.PollDateRemoved, nameof(poll.PollDateRemoved));
                Assert.AreEqual(entity.PollDeletedDate, poll.PollDeletedDate, nameof(poll.PollDeletedDate));
                Assert.AreEqual(entity.PollDeletedFlag, poll.PollDeletedFlag, nameof(poll.PollDeletedFlag));
                Assert.AreEqual(entity.PollDescription, poll.PollDescription, nameof(poll.PollDescription));
                Assert.AreEqual(entity.PollEndDate, poll.PollEndDate, nameof(poll.PollEndDate));
                Assert.AreEqual(entity.PollID, poll.PollID, nameof(poll.PollID));
                Assert.AreEqual(entity.PollImageLink, poll.PollImageLink, nameof(poll.PollImageLink));
                Assert.AreEqual(entity.PollMaxAnswers, poll.PollMaxAnswers, nameof(poll.PollMaxAnswers));
                Assert.AreEqual(entity.PollMinAnswers, poll.PollMinAnswers, nameof(poll.PollMinAnswers));
                Assert.AreEqual(entity.PollQuestion, poll.PollQuestion, nameof(poll.PollQuestion));
                Assert.AreEqual(entity.PollStartDate, poll.PollStartDate, nameof(poll.PollStartDate));
                Assert.AreEqual(entity.UserID, poll.UserID, nameof(poll.UserID));
                Assert.AreEqual(1, poll.PollOptions.Count, nameof(poll.PollOptions));
            }

            entities.VerifyAll();
            pollOptions.VerifyAll();
            pollOption.VerifyAll();
        }
예제 #6
0
        public void FetchNotOwnedByUser()
        {
            var generator = new RandomObjectGenerator();
            var pollId    = generator.Generate <int>();
            var userId    = generator.Generate <int>();

            var pollDataResults        = Mock.Of <IPollDataResults>();
            var pollDataResultsFactory = new Mock <IObjectFactory <IPollDataResults> >(MockBehavior.Strict);

            pollDataResultsFactory.Setup(_ => _.FetchChild(pollId)).Returns(pollDataResults);

            var pollComments        = Mock.Of <IPollComments>();
            var pollCommentsFactory = new Mock <IObjectFactory <IPollComments> >(MockBehavior.Strict);

            pollCommentsFactory.Setup(_ => _.FetchChild(pollId)).Returns(pollComments);

            var poll = EntityCreator.Create <MVPoll>(_ =>
            {
                _.PollID          = pollId;
                _.UserID          = userId + 1;
                _.PollDeletedFlag = null;
                _.PollStartDate   = DateTime.UtcNow.AddDays(-1);
                _.PollEndDate     = DateTime.UtcNow.AddDays(1);
            });

            var entities = new Mock <IEntities>(MockBehavior.Strict);

            entities.Setup(_ => _.MVPolls).Returns(new InMemoryDbSet <MVPoll>
            {
                poll
            });
            entities.Setup(_ => _.Dispose());

            var builder = new ContainerBuilder();

            builder.Register <IObjectFactory <IPollDataResults> >(_ => pollDataResultsFactory.Object);
            builder.Register <IObjectFactory <IPollComments> >(_ => pollCommentsFactory.Object);
            builder.Register <IEntities>(_ => entities.Object);

            using (new ObjectActivator(builder.Build(), new ActivatorCallContext())
                   .Bind(() => ApplicationContext.DataPortalActivator))
            {
                var pollResults = DataPortal.Fetch <PollResults>(new PollResultsCriteria(userId, pollId));
                Assert.AreEqual(pollId, pollResults.PollID, nameof(pollResults.PollID));
                Assert.AreEqual(poll.PollImageLink, pollResults.PollImageLink, nameof(pollResults.PollImageLink));
                Assert.AreSame(pollDataResults, pollResults.PollDataResults, nameof(pollResults.PollDataResults));
                Assert.AreSame(pollComments, pollResults.PollComments, nameof(pollResults.PollComments));
                Assert.IsFalse(pollResults.IsPollOwnedByUser, nameof(pollResults.IsPollOwnedByUser));
                Assert.IsTrue(pollResults.IsActive, nameof(pollResults.IsActive));
            }

            pollDataResultsFactory.VerifyAll();
            pollCommentsFactory.VerifyAll();
            entities.VerifyAll();
        }
예제 #7
0
        public void Fetch()
        {
            var entity = EntityCreator.Create <MVCategory>();

            var container = new ContainerBuilder();

            container.RegisterInstance(Mock.Of <IEntities>()).As <IEntities>();

            using (new ObjectActivator(container.Build(), new ActivatorCallContext())
                   .Bind(() => ApplicationContext.DataPortalActivator))
            {
                var category = DataPortal.FetchChild <Category>(entity);

                Assert.AreEqual(entity.CategoryID, category.ID, nameof(category.ID));
                Assert.AreEqual(entity.CategoryName, category.Name, nameof(category.Name));
            }
        }
예제 #8
0
        public void Fetch()
        {
            var data = EntityCreator.Create <PollData>();

            var container = new ContainerBuilder();

            container.RegisterInstance(Mock.Of <IEntities>()).As <IEntities>();

            using (new ObjectActivator(container.Build(), new ActivatorCallContext())
                   .Bind(() => ApplicationContext.DataPortalActivator))
            {
                var result = DataPortal.FetchChild <PollDataResult>(data);

                Assert.AreEqual(data.PollOptionID, result.PollOptionID, nameof(result.PollOptionID));
                Assert.AreEqual(data.ResponseCount, result.ResponseCount, nameof(result.ResponseCount));
            }
        }
예제 #9
0
        public void Fetch()
        {
            var container = new ContainerBuilder();

            container.RegisterInstance(Mock.Of <IEntities>()).As <IEntities>();

            var data = EntityCreator.Create <PollSearchResultsData>();

            using (new ObjectActivator(container.Build(), new ActivatorCallContext())
                   .Bind(() => ApplicationContext.DataPortalActivator))
            {
                var result = DataPortal.FetchChild <PollSearchResult>(data);

                Assert.AreEqual(data.Id, result.Id, nameof(result.Id));
                Assert.AreEqual(data.ImageLink, result.ImageLink, nameof(result.ImageLink));
                Assert.AreEqual(data.Question, result.Question, nameof(result.Question));
            }
        }
예제 #10
0
        public void CreateWhenUserHasSubmittedAnswersBefore()
        {
            var generator = new RandomObjectGenerator();
            var userId    = generator.Generate <int>();
            var pollId    = generator.Generate <int>();

            var entity = EntityCreator.Create <MVPollSubmission>(_ =>
            {
                _.UserID = userId;
                _.PollID = pollId;
            });

            var entities = new Mock <IEntities>();

            entities.Setup(_ => _.MVPollSubmissions)
            .Returns(new InMemoryDbSet <MVPollSubmission> {
                entity
            });
            entities.Setup(_ => _.Dispose());

            var pollFactory = new Mock <IObjectFactory <IPoll> >();

            pollFactory.Setup(_ => _.Fetch(pollId)).Returns <int>(_ => DataPortal.Fetch <Poll>(_));

            var pollSubmissionResponsesFactory = new Mock <IObjectFactory <IPollSubmissionResponseCollection> >();

            pollSubmissionResponsesFactory.Setup(_ => _.CreateChild(It.IsAny <object[]>()))
            .Returns <object[]>(_ => DataPortal.CreateChild <PollSubmissionResponseCollection>(_[0] as BusinessList <IPollOption>));

            var builder = new ContainerBuilder();

            builder.Register <IEntities>(_ => entities.Object);
            builder.Register <IObjectFactory <IPoll> >(_ => pollFactory.Object);
            builder.Register <IObjectFactory <IPollSubmissionResponseCollection> >(_ => pollSubmissionResponsesFactory.Object);

            using (new ObjectActivator(builder.Build(), Mock.Of <ICallContext>())
                   .Bind(() => ApplicationContext.DataPortalActivator))
            {
                var criteria = new PollSubmissionCriteria(pollId, userId);
                new DataPortal <PollSubmission>().Create(criteria);
            }
        }
예제 #11
0
        public void Fetch()
        {
            var generator = new RandomObjectGenerator();
            var profileId = generator.Generate <string>();
            var userId    = generator.Generate <int>();
            var userName  = generator.Generate <string>();

            var entity = EntityCreator.Create <MVUser>(_ =>
            {
                _.ProfileID  = profileId;
                _.UserID     = userId;
                _.UserName   = userName;
                _.MVUserRole = EntityCreator.Create <MVUserRole>();
            });

            var entities = new Mock <IEntities>(MockBehavior.Strict);

            entities.Setup(_ => _.MVUsers)
            .Returns(new InMemoryDbSet <MVUser> {
                entity
            });
            entities.Setup(_ => _.Dispose());

            var builder = new ContainerBuilder();

            builder.Register <IEntities>(_ => entities.Object);

            using (new ObjectActivator(builder.Build(), new ActivatorCallContext())
                   .Bind(() => ApplicationContext.DataPortalActivator))
            {
                var identity = DataPortal.Fetch <UserIdentity>(profileId);

                Assert.AreEqual(profileId, identity.ProfileID, nameof(identity.ProfileID));
                Assert.AreEqual(userId, identity.UserID, nameof(identity.UserID));
                Assert.AreEqual(userName, identity.UserName, nameof(identity.UserName));
                Assert.IsTrue(identity.IsAuthenticated, nameof(identity.IsAuthenticated));
            }

            entities.VerifyAll();
        }
예제 #12
0
        public void Update()
        {
            var generator         = new RandomObjectGenerator();
            var newOptionPosition = generator.Generate <short>();
            var newOptionText     = generator.Generate <string>();

            var entity = EntityCreator.Create <MVPollOption>();

            var poll = Mock.Of <IPoll>();

            var entities = new Mock <IEntities>(MockBehavior.Strict);

            entities.Setup(_ => _.MVPollOptions)
            .Returns(new InMemoryDbSet <MVPollOption> {
                entity
            });
            entities.Setup(_ => _.SetState(It.IsAny <MVPollOption>(), EntityState.Modified));
            entities.Setup(_ => _.SaveChanges()).Returns(1);
            entities.Setup(_ => _.Dispose());

            var builder = new ContainerBuilder();

            builder.Register <IEntities>(_ => entities.Object);

            using (new ObjectActivator(builder.Build(), new ActivatorCallContext())
                   .Bind(() => ApplicationContext.DataPortalActivator))
            {
                var pollOption = DataPortal.FetchChild <PollOption>(entity);
                pollOption.OptionPosition = newOptionPosition;
                pollOption.OptionText     = newOptionText;

                DataPortal.UpdateChild(pollOption, poll);

                Assert.AreEqual(newOptionPosition, pollOption.OptionPosition, nameof(pollOption.OptionPosition));
                Assert.AreEqual(newOptionText, pollOption.OptionText, nameof(pollOption.OptionText));
            }

            entities.VerifyAll();
        }
예제 #13
0
        public void ExecuteWhenUserHasSubmittedAnswersForThePoll()
        {
            var submission = EntityCreator.Create <MVPollSubmission>();

            var entities = new Mock <IEntities>(MockBehavior.Strict);

            entities.Setup(_ => _.MVPollSubmissions).Returns(
                new InMemoryDbSet <MVPollSubmission> {
                submission
            });
            entities.Setup(_ => _.Dispose());

            var factory = Mock.Of <IObjectFactory <IPollSubmission> >();

            var builder = new ContainerBuilder();

            builder.Register <IEntities>(_ => entities.Object);
            builder.Register <IObjectFactory <IPollSubmission> >(_ => factory);

            using (new ObjectActivator(builder.Build(), new ActivatorCallContext())
                   .Bind(() => ApplicationContext.DataPortalActivator))
            {
                var command = DataPortal.Execute <PollSubmissionCommand>(
                    new PollSubmissionCommand
                {
                    PollID = submission.PollID,
                    UserID = submission.UserID
                });

                Assert.AreEqual(submission.PollID, command.PollID, nameof(command.PollID));
                Assert.AreEqual(submission.UserID, command.UserID, nameof(command.UserID));
                Assert.IsNull(command.Submission, nameof(command.Submission));
            }

            entities.VerifyAll();
        }
예제 #14
0
        public void Fetch()
        {
            var generator = new RandomObjectGenerator();
            var userName  = generator.Generate <string>();

            var pollComment = new PollCommentData
            {
                Comment  = EntityCreator.Create <MVPollComment>(),
                UserName = userName
            };

            var childPollComment = new PollCommentData
            {
                Comment = EntityCreator.Create <MVPollComment>(_ =>
                {
                    _.ParentCommentID = pollComment.Comment.PollCommentID;
                    _.PollID          = pollComment.Comment.PollID;
                    _.UserID          = pollComment.Comment.UserID;
                }),
                UserName = userName
            };

            var comments = new List <PollCommentData> {
                pollComment, childPollComment
            };

            var newPollComment = Mock.Of <IPollComment>();

            var pollCommentFactoryCount = 0;
            var pollCommentFactory      = new Mock <IObjectFactory <IPollComment> >(MockBehavior.Strict);

            pollCommentFactory.Setup(_ => _.FetchChild(childPollComment, comments))
            .Callback <object[]>(_ => pollCommentFactoryCount++)
            .Returns(newPollComment);

            var pollComments = new Mock <IPollCommentCollection>(MockBehavior.Strict);

            pollComments.Setup(_ => _.Add(newPollComment));
            pollComments.Setup(_ => _.SetParent(It.IsAny <PollComment>()));
            pollComments.SetupGet(_ => _.EditLevel).Returns(0);

            var pollCommentsFactoryCount = 0;
            var pollCommentsFactory      = new Mock <IObjectFactory <IPollCommentCollection> >(MockBehavior.Strict);

            pollCommentsFactory.Setup(_ => _.FetchChild())
            .Callback(() => pollCommentsFactoryCount++)
            .Returns(pollComments.Object);

            var builder = new ContainerBuilder();

            builder.Register <IObjectFactory <IPollComment> >(_ => pollCommentFactory.Object);
            builder.Register <IObjectFactory <IPollCommentCollection> >(_ => pollCommentsFactory.Object);
            builder.Register <IEntities>(_ => Mock.Of <IEntities>());

            using (new ObjectActivator(builder.Build(), new ActivatorCallContext())
                   .Bind(() => ApplicationContext.DataPortalActivator))
            {
                var result = DataPortal.FetchChild <PollComment>(pollComment, comments);
                Assert.AreEqual(pollComment.Comment.CommentDate, result.CommentDate);
                Assert.AreEqual(pollComment.Comment.CommentText, result.CommentText);
                Assert.AreEqual(pollComment.Comment.PollCommentID, result.PollCommentID);
                Assert.AreEqual(pollComment.Comment.UserID, result.UserID);
                Assert.AreEqual(pollComment.UserName, result.UserName);
                Assert.AreSame(pollComments.Object, result.Comments);
            }

            pollCommentsFactory.VerifyAll();
            pollComments.VerifyAll();
            pollCommentFactory.VerifyAll();
        }
예제 #15
0
        public void Update()
        {
            var now = DateTime.UtcNow;

            var entity = EntityCreator.Create <MVPoll>(_ =>
            {
                _.PollDeletedFlag = false;
                _.PollMinAnswers  = 1;
                _.PollMaxAnswers  = 2;
                _.PollStartDate   = now;
                _.PollEndDate     = now.AddDays(2);
            });

            entity.MVPollOptions = new List <MVPollOption>
            {
                EntityCreator.Create <MVPollOption>(),
                EntityCreator.Create <MVPollOption>(),
                EntityCreator.Create <MVPollOption>()
            };

            var   generator = new RandomObjectGenerator();
            var   newPollAdminRemoveFlag = generator.Generate <bool>();
            var   newPollCategoryId      = generator.Generate <int>();
            var   newPollDateRemoved     = generator.Generate <DateTime>();
            var   newPollDeletedDate     = generator.Generate <DateTime>();
            var   newPollDeletedFlag     = generator.Generate <bool>();
            var   newPollDescription     = generator.Generate <string>();
            var   newPollEndDate         = entity.PollEndDate.AddDays(1);
            var   newPollImageLink       = generator.Generate <string>();
            short newPollMaxAnswers      = 3;
            short newPollMinAnswers      = 2;
            var   newPollQuestion        = generator.Generate <string>();
            var   newPollStartDate       = entity.PollStartDate.AddDays(1);

            var entities = new Mock <IEntities>(MockBehavior.Strict);

            entities.Setup(_ => _.MVPolls).Returns(new InMemoryDbSet <MVPoll> {
                entity
            });
            entities.Setup(_ => _.SetState(It.IsAny <MVPoll>(), EntityState.Modified));
            entities.Setup(_ => _.SaveChanges()).Returns(1);
            entities.Setup(_ => _.Dispose());

            var pollOptions = new Mock <IObjectFactory <BusinessList <IPollOption> > >();

            pollOptions.Setup(_ => _.FetchChild()).Returns(new BusinessList <IPollOption>());

            var pollOption = new Mock <IObjectFactory <IPollOption> >();

            pollOption.Setup(_ => _.FetchChild(It.IsAny <object[]>()))
            .Returns <object[]>(_ => DataPortal.FetchChild <PollOption>(_[0] as MVPollOption));

            var builder = new ContainerBuilder();

            builder.Register <IEntities>(_ => entities.Object);
            builder.Register <IObjectFactory <BusinessList <IPollOption> > >(_ => pollOptions.Object);
            builder.Register <IObjectFactory <IPollOption> >(_ => pollOption.Object);

            using (new ObjectActivator(builder.Build(), new ActivatorCallContext())
                   .Bind(() => ApplicationContext.DataPortalActivator))
            {
                var poll = new DataPortal <Poll>().Fetch(entity.PollID);
                poll.PollAdminRemovedFlag = newPollAdminRemoveFlag;
                poll.PollCategoryID       = newPollCategoryId;
                poll.PollDateRemoved      = newPollDateRemoved;
                poll.PollDeletedDate      = newPollDeletedDate;
                poll.PollDeletedFlag      = newPollDeletedFlag;
                poll.PollDescription      = newPollDescription;
                poll.PollEndDate          = newPollEndDate;
                poll.PollImageLink        = newPollImageLink;
                poll.PollMaxAnswers       = newPollMaxAnswers;
                poll.PollMinAnswers       = newPollMinAnswers;
                poll.PollQuestion         = newPollQuestion;
                poll.PollStartDate        = newPollStartDate;

                poll = poll.Save();

                Assert.AreEqual(newPollAdminRemoveFlag, poll.PollAdminRemovedFlag, nameof(poll.PollAdminRemovedFlag));
                Assert.AreEqual(newPollCategoryId, poll.PollCategoryID, nameof(poll.PollCategoryID));
                Assert.AreEqual(newPollDateRemoved, poll.PollDateRemoved, nameof(poll.PollDateRemoved));
                Assert.AreEqual(newPollDeletedDate, poll.PollDeletedDate, nameof(poll.PollDeletedDate));
                Assert.AreEqual(newPollDeletedFlag, poll.PollDeletedFlag, nameof(poll.PollDeletedFlag));
                Assert.AreEqual(newPollDescription, poll.PollDescription, nameof(poll.PollDescription));
                Assert.AreEqual(newPollEndDate.ToUniversalTime(), poll.PollEndDate, nameof(poll.PollEndDate));
                Assert.AreEqual(newPollImageLink, poll.PollImageLink, nameof(poll.PollImageLink));
                Assert.AreEqual(newPollMaxAnswers, poll.PollMaxAnswers, nameof(poll.PollMaxAnswers));
                Assert.AreEqual(newPollMinAnswers, poll.PollMinAnswers, nameof(poll.PollMinAnswers));
                Assert.AreEqual(newPollQuestion, poll.PollQuestion, nameof(poll.PollQuestion));
                Assert.AreEqual(newPollStartDate.ToUniversalTime(), poll.PollStartDate, nameof(poll.PollStartDate));
            }

            entities.VerifyAll();
        }
예제 #16
0
        public void Insert()
        {
            var now       = DateTime.UtcNow;
            var generator = new RandomObjectGenerator();
            var userId    = generator.Generate <int>();

            var poll = EntityCreator.Create <MVPoll>(_ =>
            {
                _.PollDeletedFlag = false;
                _.PollStartDate   = now.AddDays(-2);
                _.PollEndDate     = now.AddDays(2);
                _.PollMinAnswers  = 2;
                _.PollMaxAnswers  = 3;
            });

            poll.MVPollOptions = new List <MVPollOption>
            {
                EntityCreator.Create <MVPollOption>(),
                EntityCreator.Create <MVPollOption>(),
                EntityCreator.Create <MVPollOption>(),
                EntityCreator.Create <MVPollOption>()
            };

            var category = EntityCreator.Create <MVCategory>(_ => _.CategoryID = poll.PollCategoryID);

            var polls = new InMemoryDbSet <MVPoll> {
                poll
            };
            var submissions = new InMemoryDbSet <MVPollSubmission>();
            var responses   = new InMemoryDbSet <MVPollResponse>();

            var saveChangesCount = 0;
            var submissionId     = generator.Generate <int>();

            var entities = new Mock <IEntities>(MockBehavior.Strict);

            entities.Setup(_ => _.MVPolls).Returns(polls);
            entities.Setup(_ => _.MVPollSubmissions).Returns(submissions);
            entities.Setup(_ => _.MVPollResponses).Returns(responses);
            entities.Setup(_ => _.MVCategories)
            .Returns(new InMemoryDbSet <MVCategory> {
                category
            });
            entities.Setup(_ => _.SaveChanges()).Callback(() =>
            {
                if (saveChangesCount == 0)
                {
                    submissions.Local[0].PollSubmissionID = submissionId;
                }

                saveChangesCount++;
            }).Returns(1);
            entities.Setup(_ => _.Dispose());

            var pollOptions = new Mock <IObjectFactory <BusinessList <IPollOption> > >();

            pollOptions.Setup(_ => _.FetchChild()).Returns(new BusinessList <IPollOption>());

            var pollOption = new Mock <IObjectFactory <IPollOption> >();

            pollOption.Setup(_ => _.FetchChild(It.IsAny <object[]>()))
            .Returns <object[]>(_ => DataPortal.FetchChild <PollOption>(_[0] as MVPollOption));

            var pollFactory = new Mock <IObjectFactory <IPoll> >();

            pollFactory.Setup(_ => _.Fetch(poll.PollID)).Returns <int>(_ => DataPortal.Fetch <Poll>(_));

            var pollSubmissionResponsesFactory = new Mock <IObjectFactory <IPollSubmissionResponseCollection> >();

            pollSubmissionResponsesFactory.Setup(_ => _.CreateChild(It.IsAny <object[]>()))
            .Returns <object[]>(_ => DataPortal.CreateChild <PollSubmissionResponseCollection>(_[0] as BusinessList <IPollOption>));

            var pollSubmissionResponseFactory = new Mock <IObjectFactory <IPollSubmissionResponse> >();

            pollSubmissionResponseFactory.Setup(_ => _.CreateChild(It.IsAny <object[]>()))
            .Returns <object[]>(_ => DataPortal.CreateChild <PollSubmissionResponse>(_[0] as IPollOption));

            var builder = new ContainerBuilder();

            builder.Register <IEntities>(_ => entities.Object);
            builder.Register <IObjectFactory <BusinessList <IPollOption> > >(_ => pollOptions.Object);
            builder.Register <IObjectFactory <IPollOption> >(_ => pollOption.Object);
            builder.Register <IObjectFactory <IPoll> >(_ => pollFactory.Object);
            builder.Register <IObjectFactory <IPollSubmissionResponseCollection> >(_ => pollSubmissionResponsesFactory.Object);
            builder.Register <IObjectFactory <IPollSubmissionResponse> >(_ => pollSubmissionResponseFactory.Object);

            using (new ObjectActivator(builder.Build(), new ActivatorCallContext())
                   .Bind(() => ApplicationContext.DataPortalActivator))
            {
                var criteria   = new PollSubmissionCriteria(poll.PollID, userId);
                var submission = new DataPortal <PollSubmission>().Create(criteria);

                submission.Responses[1].IsOptionSelected = true;
                submission.Responses[3].IsOptionSelected = true;

                submission = submission.Save();

                Assert.AreEqual(1, submissions.Local.Count, nameof(submissions.Local.Count));
                Assert.AreEqual(submissionId, submission.PollSubmissionID, nameof(submission.PollSubmissionID));
                Assert.AreEqual(4, responses.Local.Count, nameof(responses.Local.Count));
                Assert.IsFalse(responses.Local[0].OptionSelected, nameof(MVPollResponse.OptionSelected));
                Assert.IsTrue(responses.Local[1].OptionSelected, nameof(MVPollResponse.OptionSelected));
                Assert.IsFalse(responses.Local[2].OptionSelected, nameof(MVPollResponse.OptionSelected));
                Assert.IsTrue(responses.Local[3].OptionSelected, nameof(MVPollResponse.OptionSelected));
            }

            entities.VerifyAll();
        }
예제 #17
0
        public void CreateWhenPollIsDeleted()
        {
            var now       = DateTime.UtcNow;
            var generator = new RandomObjectGenerator();
            var userId    = generator.Generate <int>();

            var poll = EntityCreator.Create <MVPoll>(_ =>
            {
                _.PollDeletedFlag = true;
                _.PollStartDate   = now.AddDays(-2);
                _.PollEndDate     = now.AddDays(2);
                _.PollMinAnswers  = 2;
                _.PollMaxAnswers  = 3;
            });

            poll.MVPollOptions = new List <MVPollOption>
            {
                EntityCreator.Create <MVPollOption>(),
                EntityCreator.Create <MVPollOption>(),
                EntityCreator.Create <MVPollOption>(),
                EntityCreator.Create <MVPollOption>()
            };

            var category = EntityCreator.Create <MVCategory>(_ => _.CategoryID = poll.PollCategoryID);

            var pollFactory = new Mock <IObjectFactory <IPoll> >();

            pollFactory.Setup(_ => _.Fetch(poll.PollID)).Returns <int>(_ => DataPortal.Fetch <Poll>(_));

            var entities = new Mock <IEntities>(MockBehavior.Strict);

            entities.Setup(_ => _.MVPolls)
            .Returns(new InMemoryDbSet <MVPoll> {
                poll
            });
            entities.Setup(_ => _.MVPollSubmissions)
            .Returns(new InMemoryDbSet <MVPollSubmission>());
            entities.Setup(_ => _.MVCategories)
            .Returns(new InMemoryDbSet <MVCategory> {
                category
            });
            entities.Setup(_ => _.Dispose());

            var pollOptions = new Mock <IObjectFactory <BusinessList <IPollOption> > >();

            pollOptions.Setup(_ => _.FetchChild()).Returns(new BusinessList <IPollOption>());

            var pollOption = new Mock <IObjectFactory <IPollOption> >();

            pollOption.Setup(_ => _.FetchChild(It.IsAny <object[]>()))
            .Returns <object[]>(_ => DataPortal.FetchChild <PollOption>(_[0] as MVPollOption));

            var pollSubmissionResponsesFactory = new Mock <IObjectFactory <IPollSubmissionResponseCollection> >();

            pollSubmissionResponsesFactory.Setup(_ => _.CreateChild(It.IsAny <object[]>()))
            .Returns <object[]>(_ => DataPortal.CreateChild <PollSubmissionResponseCollection>(_[0] as BusinessList <IPollOption>));

            var pollSubmissionResponseFactory = new Mock <IObjectFactory <IPollSubmissionResponse> >();

            pollSubmissionResponseFactory.Setup(_ => _.CreateChild(It.IsAny <object[]>()))
            .Returns <object[]>(_ => DataPortal.CreateChild <PollSubmissionResponse>(_[0] as IPollOption));

            var builder = new ContainerBuilder();

            builder.Register <IEntities>(_ => entities.Object);
            builder.Register <IObjectFactory <BusinessList <IPollOption> > >(_ => pollOptions.Object);
            builder.Register <IObjectFactory <IPollOption> >(_ => pollOption.Object);
            builder.Register <IObjectFactory <IPoll> >(_ => pollFactory.Object);
            builder.Register <IObjectFactory <IPollSubmissionResponseCollection> >(_ => pollSubmissionResponsesFactory.Object);
            builder.Register <IObjectFactory <IPollSubmissionResponse> >(_ => pollSubmissionResponseFactory.Object);

            using (new ObjectActivator(builder.Build(), new ActivatorCallContext())
                   .Bind(() => ApplicationContext.DataPortalActivator))
            {
                var submission = new DataPortal <PollSubmission>().Create(
                    new PollSubmissionCriteria(poll.PollID, userId));
                submission.BrokenRulesCollection.AssertRuleCount(PollSubmission.PollDeletedFlagProperty, 1);
                submission.BrokenRulesCollection.AssertBusinessRuleExists <PollSubmissionPollDeletedFlagRule>(
                    PollSubmission.PollDeletedFlagProperty, true);
            }

            entities.VerifyAll();
        }
예제 #18
0
        public void Create()
        {
            var now       = DateTime.UtcNow;
            var generator = new RandomObjectGenerator();
            var userId    = generator.Generate <int>();

            var pollEntity = EntityCreator.Create <MVPoll>(_ =>
            {
                _.PollDeletedFlag = false;
                _.PollStartDate   = now.AddDays(-2);
                _.PollEndDate     = now.AddDays(2);
                _.PollMinAnswers  = 2;
                _.PollMaxAnswers  = 3;
            });

            pollEntity.MVPollOptions = new List <MVPollOption>
            {
                EntityCreator.Create <MVPollOption>(),
                EntityCreator.Create <MVPollOption>(),
                EntityCreator.Create <MVPollOption>(),
                EntityCreator.Create <MVPollOption>()
            };

            var category = EntityCreator.Create <MVCategory>(_ => _.CategoryID = pollEntity.PollCategoryID);

            Poll poll = null;

            var pollFactory = new Mock <IObjectFactory <IPoll> >(MockBehavior.Strict);

            pollFactory.Setup(_ => _.Fetch(pollEntity.PollID))
            .Returns <int>(_ =>
            {
                poll = DataPortal.Fetch <Poll>(_);
                return(poll);
            });

            var pollSubmissionResponsesFactory = new Mock <IObjectFactory <IPollSubmissionResponseCollection> >(MockBehavior.Strict);

            pollSubmissionResponsesFactory.Setup(_ => _.CreateChild(It.IsAny <object[]>()))
            .Callback <object[]>(_ => Assert.AreSame(poll.PollOptions, _[0]))
            .Returns <object[]>(_ => DataPortal.CreateChild <PollSubmissionResponseCollection>(_[0] as BusinessList <IPollOption>));

            var entities = new Mock <IEntities>(MockBehavior.Strict);

            entities.Setup(_ => _.MVPolls)
            .Returns(new InMemoryDbSet <MVPoll> {
                pollEntity
            });
            entities.Setup(_ => _.MVPollSubmissions)
            .Returns(new InMemoryDbSet <MVPollSubmission>());
            entities.Setup(_ => _.MVCategories)
            .Returns(new InMemoryDbSet <MVCategory> {
                category
            });
            entities.Setup(_ => _.Dispose());

            var pollOptions = new Mock <IObjectFactory <BusinessList <IPollOption> > >();

            pollOptions.Setup(_ => _.FetchChild()).Returns(new BusinessList <IPollOption>());

            var pollOption = new Mock <IObjectFactory <IPollOption> >();

            pollOption.Setup(_ => _.FetchChild(It.IsAny <object[]>()))
            .Returns <object[]>(_ => DataPortal.FetchChild <PollOption>(_[0] as MVPollOption));

            var pollSubmissionResponseFactory = new Mock <IObjectFactory <IPollSubmissionResponse> >();

            pollSubmissionResponseFactory.Setup(_ => _.CreateChild(It.IsAny <object[]>()))
            .Returns <object[]>(_ => DataPortal.CreateChild <PollSubmissionResponse>(_[0] as IPollOption));

            var builder = new ContainerBuilder();

            builder.Register <IEntities>(_ => entities.Object);
            builder.Register <IObjectFactory <IPoll> >(_ => pollFactory.Object);
            builder.Register <IObjectFactory <BusinessList <IPollOption> > >(_ => pollOptions.Object);
            builder.Register <IObjectFactory <IPollOption> >(_ => pollOption.Object);
            builder.Register <IObjectFactory <IPollSubmissionResponseCollection> >(_ => pollSubmissionResponsesFactory.Object);
            builder.Register <IObjectFactory <IPollSubmissionResponse> >(_ => pollSubmissionResponseFactory.Object);

            using (new ObjectActivator(builder.Build(), new ActivatorCallContext())
                   .Bind(() => ApplicationContext.DataPortalActivator))
            {
                var criteria   = new PollSubmissionCriteria(pollEntity.PollID, userId);
                var submission = DataPortal.Create <PollSubmission>(criteria);

                Assert.AreEqual(pollEntity.PollID, submission.PollID, nameof(submission.PollID));
                Assert.AreEqual(pollEntity.PollImageLink, submission.PollImageLink, nameof(submission.PollImageLink));
                Assert.AreEqual(userId, submission.UserID, nameof(submission.UserID));
                Assert.AreEqual(pollEntity.PollQuestion, submission.PollQuestion, nameof(submission.PollQuestion));
                Assert.AreEqual(category.CategoryName, submission.CategoryName, nameof(submission.CategoryName));
                Assert.AreEqual(pollEntity.PollDescription, submission.PollDescription, nameof(submission.PollDescription));
                Assert.AreEqual(pollEntity.PollMaxAnswers.Value, submission.PollMaxAnswers, nameof(submission.PollMaxAnswers));
                Assert.AreEqual(pollEntity.PollMinAnswers.Value, submission.PollMinAnswers, nameof(submission.PollMinAnswers));
                Assert.AreEqual(4, submission.Responses.Count, nameof(submission.Responses));

                submission.BrokenRulesCollection.AssertRuleCount(1);
                submission.BrokenRulesCollection.AssertRuleCount(PollSubmission.ResponsesProperty, 1);
                submission.BrokenRulesCollection.AssertBusinessRuleExists <MinimumAndMaximumPollSubmissionResponsesRule>(
                    PollSubmission.ResponsesProperty, true);
            }

            entities.VerifyAll();
            pollFactory.VerifyAll();
            pollSubmissionResponsesFactory.VerifyAll();
        }
예제 #19
0
        public void Fetch()
        {
            var generator = new RandomObjectGenerator();
            var pollId    = generator.Generate <int>();

            var userEntity        = EntityCreator.Create <MVUser>();
            var pollCommentEntity = EntityCreator.Create <MVPollComment>(_ =>
            {
                _.ParentCommentID = null;
                _.PollID          = pollId;
                _.UserID          = userEntity.UserID;
            });
            var childPollCommentEntity = EntityCreator.Create <MVPollComment>(_ =>
            {
                _.ParentCommentID = generator.Generate <int>();
                _.PollID          = pollId;
                _.UserID          = userEntity.UserID;
            });

            var pollCommentFactoryCount = 0;
            var pollComment             = Mock.Of <IPollComment>();
            var pollCommentFactory      = new Mock <IObjectFactory <IPollComment> >(MockBehavior.Strict);

            pollCommentFactory.Setup(_ => _.FetchChild(
                                         It.IsAny <PollCommentData>(), It.IsAny <List <PollCommentData> >()))
            .Callback(() => pollCommentFactoryCount++)
            .Returns(pollComment);

            var addCount = 0;
            var pollCommentCollection = new Mock <IPollCommentCollection>(MockBehavior.Strict);

            pollCommentCollection.Setup(_ => _.Add(pollComment)).Callback <IPollComment>(_ => addCount++);
            pollCommentCollection.Setup(_ => _.SetParent(It.IsAny <PollComments>()));
            pollCommentCollection.SetupGet(_ => _.EditLevel).Returns(0);

            var pollCommentsFactory = new Mock <IObjectFactory <IPollCommentCollection> >(MockBehavior.Strict);

            pollCommentsFactory.Setup(_ => _.FetchChild()).Returns(pollCommentCollection.Object);

            var entities = new Mock <IEntities>(MockBehavior.Strict);

            entities.Setup(_ => _.MVPollComments).Returns(
                new InMemoryDbSet <MVPollComment> {
                pollCommentEntity, childPollCommentEntity
            });
            entities.Setup(_ => _.MVUsers).Returns(
                new InMemoryDbSet <MVUser> {
                userEntity
            });
            entities.Setup(_ => _.Dispose());

            var builder = new ContainerBuilder();

            builder.Register <IObjectFactory <IPollComment> >(_ => pollCommentFactory.Object);
            builder.Register <IObjectFactory <IPollCommentCollection> >(_ => pollCommentsFactory.Object);
            builder.Register <IEntities>(_ => entities.Object);

            using (new ObjectActivator(builder.Build(), new ActivatorCallContext())
                   .Bind(() => ApplicationContext.DataPortalActivator))
            {
                var results = DataPortal.FetchChild <PollComments>(pollId);
                Assert.AreSame(pollCommentCollection.Object, results.Comments);
                Assert.AreEqual(1, pollCommentFactoryCount);
                Assert.AreEqual(1, addCount);
            }

            entities.VerifyAll();
            pollCommentsFactory.VerifyAll();
            pollCommentCollection.VerifyAll();
            pollCommentFactory.VerifyAll();
        }
예제 #20
0
        public void Fetch()
        {
            var generator = new RandomObjectGenerator();
            var pollID    = generator.Generate <int>();

            var response1 = EntityCreator.Create <MVPollResponse>(_ =>
            {
                _.PollID         = pollID;
                _.PollOptionID   = 1;
                _.OptionSelected = true;
            });
            var response2 = EntityCreator.Create <MVPollResponse>(_ =>
            {
                _.PollID         = pollID;
                _.PollOptionID   = 2;
                _.OptionSelected = true;
            });
            var response3 = EntityCreator.Create <MVPollResponse>(_ =>
            {
                _.PollID         = pollID;
                _.PollOptionID   = 3;
                _.OptionSelected = false;
            });
            var response4 = EntityCreator.Create <MVPollResponse>(_ =>
            {
                _.PollID         = pollID;
                _.PollOptionID   = 1;
                _.OptionSelected = false;
            });
            var response5 = EntityCreator.Create <MVPollResponse>(_ =>
            {
                _.PollID         = pollID;
                _.PollOptionID   = 2;
                _.OptionSelected = true;
            });
            var response6 = EntityCreator.Create <MVPollResponse>(_ =>
            {
                _.PollID         = pollID;
                _.PollOptionID   = 1;
                _.OptionSelected = false;
            });

            var option1 = EntityCreator.Create <MVPollOption>(_ =>
            {
                _.PollOptionID = 1;
                _.PollID       = pollID;
            });
            var option2 = EntityCreator.Create <MVPollOption>(_ =>
            {
                _.PollOptionID = 2;
                _.PollID       = pollID;
            });
            var option3 = EntityCreator.Create <MVPollOption>(_ =>
            {
                _.PollOptionID = 3;
                _.PollID       = pollID;
            });

            var poll = EntityCreator.Create <MVPoll>(_ =>
            {
                _.PollDeletedFlag = false;
                _.PollID          = pollID;
            });

            var entities = new Mock <IEntities>(MockBehavior.Strict);

            entities.Setup(_ => _.MVPollResponses).Returns(new InMemoryDbSet <MVPollResponse>
            {
                response1, response2, response3, response4, response5, response6
            });
            entities.Setup(_ => _.MVPollOptions).Returns(new InMemoryDbSet <MVPollOption>
            {
                option1, option2, option3
            });
            entities.Setup(_ => _.MVPolls).Returns(new InMemoryDbSet <MVPoll> {
                poll
            });
            entities.Setup(_ => _.Dispose());

            var pollDataResultsFactory = new Mock <IObjectFactory <ReadOnlySwitchList <IPollDataResult> > >(MockBehavior.Strict);

            pollDataResultsFactory.Setup(_ => _.FetchChild()).Returns(DataPortal.FetchChild <ReadOnlySwitchList <IPollDataResult> >());

            var pollDataResultFactory = new Mock <IObjectFactory <IPollDataResult> >(MockBehavior.Strict);

            pollDataResultFactory.Setup(_ => _.FetchChild(It.IsAny <object[]>()))
            .Returns <object[]>(_ => DataPortal.FetchChild <PollDataResult>(_[0] as PollData));

            var builder = new ContainerBuilder();

            builder.Register <IEntities>(_ => entities.Object);
            builder.Register <IObjectFactory <ReadOnlySwitchList <IPollDataResult> > >(_ => pollDataResultsFactory.Object);
            builder.Register <IObjectFactory <IPollDataResult> >(_ => pollDataResultFactory.Object);

            using (new ObjectActivator(builder.Build(), new ActivatorCallContext())
                   .Bind(() => ApplicationContext.DataPortalActivator))
            {
                var results = DataPortal.FetchChild <PollDataResults>(pollID);

                Assert.AreEqual(pollID, results.PollID, nameof(results.PollID));
                Assert.AreEqual(poll.PollQuestion, results.Question, nameof(results.Question));
                Assert.AreEqual(3, results.Results.Count, nameof(results.Results));
                Assert.AreEqual(1, results.Results.First(_ => _.PollOptionID == 1).ResponseCount);
                Assert.AreEqual(2, results.Results.First(_ => _.PollOptionID == 2).ResponseCount);
                Assert.AreEqual(0, results.Results.First(_ => _.PollOptionID == 3).ResponseCount);
            }

            entities.VerifyAll();
            pollDataResultsFactory.VerifyAll();
            pollDataResultFactory.VerifyAll();
        }
예제 #21
0
        public void FetchByUserForPollsThatAreNotActive()
        {
            var now = DateTime.UtcNow;

            var category1 = new MVCategory {
                CategoryID = 1, CategoryName = "1"
            };
            var category2 = new MVCategory {
                CategoryID = 2, CategoryName = "2"
            };

            var poll1 = EntityCreator.Create <MVPoll>(_ =>
            {
                _.PollDeletedFlag = false;
                _.PollStartDate   = now.AddDays(-4);
                _.PollEndDate     = DateTime.UtcNow.AddDays(-2);
                _.PollCategoryID  = 1;
                _.UserID          = 1;
            });
            var poll2 = EntityCreator.Create <MVPoll>(_ =>
            {
                _.PollDeletedFlag = false;
                _.PollStartDate   = now.AddDays(-2);
                _.PollEndDate     = DateTime.UtcNow.AddDays(2);
                _.UserID          = 1;
            });
            var poll3 = EntityCreator.Create <MVPoll>(_ =>
            {
                _.PollDeletedFlag = false;
                _.PollStartDate   = now.AddDays(-4);
                _.PollEndDate     = DateTime.UtcNow.AddDays(-2);
                _.PollCategoryID  = 2;
                _.UserID          = 1;
            });
            var poll4 = EntityCreator.Create <MVPoll>(_ =>
            {
                _.PollDeletedFlag = true;
                _.PollStartDate   = now.AddDays(-4);
                _.PollEndDate     = DateTime.UtcNow.AddDays(-2);
                _.PollCategoryID  = 2;
                _.UserID          = 1;
            });

            var entities = new Mock <IEntities>(MockBehavior.Strict);

            entities.Setup(_ => _.MVCategories).Returns(new InMemoryDbSet <MVCategory> {
                category1, category2
            });
            entities.Setup(_ => _.MVPolls).Returns(new InMemoryDbSet <MVPoll> {
                poll1, poll2, poll3, poll4
            });
            entities.Setup(_ => _.MVPollSubmissions).Returns(new InMemoryDbSet <MVPollSubmission>());
            entities.Setup(_ => _.Dispose());

            var pollSearchResultsByCategoryFactory = new Mock <IObjectFactory <ReadOnlySwitchList <IPollSearchResultsByCategory> > >();

            pollSearchResultsByCategoryFactory.Setup(_ => _.FetchChild()).Returns(DataPortal.FetchChild <ReadOnlySwitchList <IPollSearchResultsByCategory> >());

            var pollSearchResultByCategoryFactory = new Mock <IObjectFactory <IPollSearchResultsByCategory> >();

            pollSearchResultByCategoryFactory.Setup(_ => _.FetchChild(It.IsAny <object[]>()))
            .Returns <object[]>(_ => DataPortal.FetchChild <PollSearchResultsByCategory>(_[0] as List <PollSearchResultsData>));

            var pollSearchResultsFactory = new Mock <IObjectFactory <ReadOnlySwitchList <IPollSearchResult> > >();

            pollSearchResultsFactory.Setup(_ => _.FetchChild()).Returns(() => DataPortal.FetchChild <ReadOnlySwitchList <IPollSearchResult> >());

            var pollSearchResultFactory = new Mock <IObjectFactory <IPollSearchResult> >();

            pollSearchResultFactory.Setup(_ => _.FetchChild(It.IsAny <object[]>()))
            .Returns <object[]>(_ => DataPortal.FetchChild <PollSearchResult>(_[0] as PollSearchResultsData));

            var builder = new ContainerBuilder();

            builder.Register <IEntities>(_ => entities.Object);
            builder.Register <ISearchWhereClause>(_ => Mock.Of <ISearchWhereClause>());
            builder.Register <IObjectFactory <ReadOnlySwitchList <IPollSearchResultsByCategory> > >(_ => pollSearchResultsByCategoryFactory.Object);
            builder.Register <IObjectFactory <IPollSearchResultsByCategory> >(_ => pollSearchResultByCategoryFactory.Object);
            builder.Register <IObjectFactory <ReadOnlySwitchList <IPollSearchResult> > >(_ => pollSearchResultsFactory.Object);
            builder.Register <IObjectFactory <IPollSearchResult> >(_ => pollSearchResultFactory.Object);

            using (new ObjectActivator(builder.Build(), new ActivatorCallContext())
                   .Bind(() => ApplicationContext.DataPortalActivator))
            {
                var result = DataPortal.Fetch <PollSearchResults>(
                    new PollSearchResultsByUserCriteria(1, false));
                Assert.AreEqual(2, result.SearchResultsByCategory.Count,
                                nameof(result.SearchResultsByCategory));
            }

            entities.VerifyAll();
        }
예제 #22
0
        public void FetchByPollQuestion()
        {
            var now       = DateTime.UtcNow;
            var category1 = new MVCategory {
                CategoryID = 1, CategoryName = "1"
            };

            var poll1 = EntityCreator.Create <MVPoll>(_ =>
            {
                _.PollDeletedFlag = false;
                _.PollCategoryID  = category1.CategoryID;
                _.PollQuestion    = "12345";
                _.PollEndDate     = now.AddDays(2);
                _.PollStartDate   = now.AddDays(-2);
            });
            var poll2 = EntityCreator.Create <MVPoll>(_ =>
            {
                _.PollDeletedFlag = false;
                _.PollCategoryID  = category1.CategoryID;
                _.PollQuestion    = "AbCdE";
                _.PollEndDate     = now.AddDays(2);
                _.PollStartDate   = now.AddDays(-2);
            });
            var poll3 = EntityCreator.Create <MVPoll>(_ =>
            {
                _.PollDeletedFlag = true;
                _.PollCategoryID  = category1.CategoryID;
                _.PollQuestion    = "DeFgH";
                _.PollEndDate     = now.AddDays(2);
                _.PollStartDate   = now.AddDays(-2);
            });

            var submission1 = EntityCreator.Create <MVPollSubmission>(_ =>
            {
                _.PollID = poll2.PollID;
            });
            var submission2 = EntityCreator.Create <MVPollSubmission>(_ =>
            {
                _.PollID = poll2.PollID;
            });
            var submission3 = EntityCreator.Create <MVPollSubmission>(_ =>
            {
                _.PollID = poll1.PollID;
            });
            var submission4 = EntityCreator.Create <MVPollSubmission>(_ =>
            {
                _.PollID = poll2.PollID;
            });

            var entities = new Mock <IEntities>(MockBehavior.Strict);

            entities.Setup(_ => _.MVCategories).Returns(new InMemoryDbSet <MVCategory> {
                category1
            });
            entities.Setup(_ => _.MVPolls).Returns(new InMemoryDbSet <MVPoll> {
                poll1, poll2, poll3
            });
            entities.Setup(_ => _.MVPollSubmissions).Returns(new InMemoryDbSet <MVPollSubmission> {
                submission1, submission2, submission3, submission4
            });
            entities.Setup(_ => _.Dispose());

            var searchWhereClause = new Mock <ISearchWhereClause>(MockBehavior.Strict);

            searchWhereClause.Setup(_ => _.WhereClause(It.IsAny <DateTime>(), "%bcd%")).Returns(_ => _.PollQuestion == "AbCdE");

            var pollSearchResultsByCategoryFactory = new Mock <IObjectFactory <ReadOnlySwitchList <IPollSearchResultsByCategory> > >();

            pollSearchResultsByCategoryFactory.Setup(_ => _.FetchChild()).Returns(DataPortal.FetchChild <ReadOnlySwitchList <IPollSearchResultsByCategory> >());

            var pollSearchResultByCategoryFactory = new Mock <IObjectFactory <IPollSearchResultsByCategory> >();

            pollSearchResultByCategoryFactory.Setup(_ => _.FetchChild(It.IsAny <object[]>()))
            .Returns <object[]>(_ => DataPortal.FetchChild <PollSearchResultsByCategory>(_[0] as List <PollSearchResultsData>));

            var pollSearchResultsFactory = new Mock <IObjectFactory <ReadOnlySwitchList <IPollSearchResult> > >();

            pollSearchResultsFactory.Setup(_ => _.FetchChild()).Returns(() => DataPortal.FetchChild <ReadOnlySwitchList <IPollSearchResult> >());

            var pollSearchResultFactory = new Mock <IObjectFactory <IPollSearchResult> >();

            pollSearchResultFactory.Setup(_ => _.FetchChild(It.IsAny <object[]>()))
            .Returns <object[]>(_ => DataPortal.FetchChild <PollSearchResult>(_[0] as PollSearchResultsData));

            var builder = new ContainerBuilder();

            builder.Register <IEntities>(_ => entities.Object);
            builder.Register <ISearchWhereClause>(_ => searchWhereClause.Object);
            builder.Register <IObjectFactory <ReadOnlySwitchList <IPollSearchResultsByCategory> > >(_ => pollSearchResultsByCategoryFactory.Object);
            builder.Register <IObjectFactory <IPollSearchResultsByCategory> >(_ => pollSearchResultByCategoryFactory.Object);
            builder.Register <IObjectFactory <ReadOnlySwitchList <IPollSearchResult> > >(_ => pollSearchResultsFactory.Object);
            builder.Register <IObjectFactory <IPollSearchResult> >(_ => pollSearchResultFactory.Object);

            using (new ObjectActivator(builder.Build(), new ActivatorCallContext())
                   .Bind(() => ApplicationContext.DataPortalActivator))
            {
                var result = DataPortal.Fetch <PollSearchResults>("bCd");
                Assert.AreEqual(1, result.SearchResultsByCategory.Count,
                                nameof(result.SearchResultsByCategory));
                Assert.AreEqual(1, result.SearchResultsByCategory[0].SearchResults.Count,
                                nameof(ICollection.Count));
                Assert.AreEqual(poll2.PollQuestion, result.SearchResultsByCategory[0].SearchResults[0].Question,
                                nameof(IPollSearchResult.Question));
            }

            searchWhereClause.VerifyAll();
            entities.VerifyAll();
        }
예제 #23
0
        public void FetchByNewest()
        {
            var now       = DateTime.UtcNow;
            var category1 = new MVCategory {
                CategoryID = 1, CategoryName = "b"
            };
            var category2 = new MVCategory {
                CategoryID = 2, CategoryName = "a"
            };

            var poll1 = EntityCreator.Create <MVPoll>(_ =>
            {
                _.PollDeletedFlag = false;
                _.PollEndDate     = now.AddDays(2);
                _.PollStartDate   = now.AddDays(-2);
                _.PollCategoryID  = 1;
            });
            var poll2 = EntityCreator.Create <MVPoll>(_ =>
            {
                _.PollDeletedFlag = false;
                _.PollEndDate     = now.AddDays(2);
                _.PollStartDate   = now.AddDays(-2);
                _.PollCategoryID  = 2;
            });
            var poll3 = EntityCreator.Create <MVPoll>(_ =>
            {
                _.PollDeletedFlag = false;
                _.PollEndDate     = now.AddDays(2);
                _.PollStartDate   = now.AddDays(-4);
                _.PollCategoryID  = 1;
            });
            var poll4 = EntityCreator.Create <MVPoll>(_ =>
            {
                _.PollDeletedFlag = false;
                _.PollEndDate     = now.AddDays(2);
                _.PollStartDate   = now.AddDays(-4);
                _.PollCategoryID  = 2;
            });
            var poll5 = EntityCreator.Create <MVPoll>(_ =>
            {
                _.PollDeletedFlag = false;
                _.PollEndDate     = now.AddDays(2);
                _.PollStartDate   = now.AddDays(-1);
                _.PollCategoryID  = 1;
            });
            var poll6 = EntityCreator.Create <MVPoll>(_ =>
            {
                _.PollDeletedFlag = false;
                _.PollEndDate     = now.AddDays(2);
                _.PollStartDate   = now.AddDays(-1);
                _.PollCategoryID  = 2;
            });
            var poll7 = EntityCreator.Create <MVPoll>(_ =>
            {
                _.PollDeletedFlag = true;
                _.PollEndDate     = now.AddDays(2);
                _.PollStartDate   = now.AddDays(-1);
                _.PollCategoryID  = 2;
            });

            var entities = new Mock <IEntities>(MockBehavior.Strict);

            entities.Setup(_ => _.MVCategories).Returns(new InMemoryDbSet <MVCategory> {
                category1, category2
            });
            entities.Setup(_ => _.MVPolls).Returns(new InMemoryDbSet <MVPoll> {
                poll1, poll2, poll3, poll4, poll5, poll6, poll7
            });
            entities.Setup(_ => _.MVPollSubmissions).Returns(new InMemoryDbSet <MVPollSubmission>());
            entities.Setup(_ => _.Dispose());

            var pollSearchResultsByCategoryFactory = new Mock <IObjectFactory <ReadOnlySwitchList <IPollSearchResultsByCategory> > >();

            pollSearchResultsByCategoryFactory.Setup(_ => _.FetchChild()).Returns(DataPortal.FetchChild <ReadOnlySwitchList <IPollSearchResultsByCategory> >());

            var pollSearchResultByCategoryFactory = new Mock <IObjectFactory <IPollSearchResultsByCategory> >();

            pollSearchResultByCategoryFactory.Setup(_ => _.FetchChild(It.IsAny <object[]>()))
            .Returns <object[]>(_ => DataPortal.FetchChild <PollSearchResultsByCategory>(_[0] as List <PollSearchResultsData>));

            var pollSearchResultsFactory = new Mock <IObjectFactory <ReadOnlySwitchList <IPollSearchResult> > >();

            pollSearchResultsFactory.Setup(_ => _.FetchChild()).Returns(() => DataPortal.FetchChild <ReadOnlySwitchList <IPollSearchResult> >());

            var pollSearchResultFactory = new Mock <IObjectFactory <IPollSearchResult> >();

            pollSearchResultFactory.Setup(_ => _.FetchChild(It.IsAny <object[]>()))
            .Returns <object[]>(_ => DataPortal.FetchChild <PollSearchResult>(_[0] as PollSearchResultsData));

            var builder = new ContainerBuilder();

            builder.Register <IEntities>(_ => entities.Object);
            builder.Register <ISearchWhereClause>(_ => Mock.Of <ISearchWhereClause>());
            builder.Register <IObjectFactory <ReadOnlySwitchList <IPollSearchResultsByCategory> > >(_ => pollSearchResultsByCategoryFactory.Object);
            builder.Register <IObjectFactory <IPollSearchResultsByCategory> >(_ => pollSearchResultByCategoryFactory.Object);
            builder.Register <IObjectFactory <ReadOnlySwitchList <IPollSearchResult> > >(_ => pollSearchResultsFactory.Object);
            builder.Register <IObjectFactory <IPollSearchResult> >(_ => pollSearchResultFactory.Object);

            using (new ObjectActivator(builder.Build(), new ActivatorCallContext())
                   .Bind(() => ApplicationContext.DataPortalActivator))
            {
                var result = DataPortal.Fetch <PollSearchResults>(PollSearchResultsQueryType.Newest);
                Assert.AreEqual(2, result.SearchResultsByCategory.Count,
                                nameof(result.SearchResultsByCategory));

                var firstCategory = result.SearchResultsByCategory[0];
                Assert.AreEqual("a", firstCategory.Category,
                                $"{nameof(firstCategory.Category)} a");
                Assert.AreEqual(3, firstCategory.SearchResults.Count,
                                $"{nameof(firstCategory.SearchResults)} a");
                Assert.AreEqual(poll6.PollQuestion, firstCategory.SearchResults[0].Question,
                                $"{nameof(IPollSearchResult.Question)} a 0");
                Assert.AreEqual(poll2.PollQuestion, firstCategory.SearchResults[1].Question,
                                $"{nameof(IPollSearchResult.Question)} a 1");
                Assert.AreEqual(poll4.PollQuestion, firstCategory.SearchResults[2].Question,
                                $"{nameof(IPollSearchResult.Question)} a 2");

                var secondCategory = result.SearchResultsByCategory[1];
                Assert.AreEqual("b", secondCategory.Category,
                                $"{nameof(secondCategory.Category)} b");
                Assert.AreEqual(3, secondCategory.SearchResults.Count,
                                $"{nameof(secondCategory.SearchResults)} b");
                Assert.AreEqual(poll5.PollQuestion, secondCategory.SearchResults[0].Question,
                                $"{nameof(IPollSearchResult.Question)} b 0");
                Assert.AreEqual(poll1.PollQuestion, secondCategory.SearchResults[1].Question,
                                $"{nameof(IPollSearchResult.Question)} b 1");
                Assert.AreEqual(poll3.PollQuestion, secondCategory.SearchResults[2].Question,
                                nameof(IPollSearchResult.Question));
            }

            entities.VerifyAll();
        }
예제 #24
0
        public void Delete()
        {
            var generator = new RandomObjectGenerator();
            var userId    = generator.Generate <int>();
            var now       = DateTime.UtcNow;

            var entity = EntityCreator.Create <MVPoll>(_ =>
            {
                _.PollDeletedFlag = false;
                _.PollMinAnswers  = 1;
                _.PollMaxAnswers  = 2;
                _.PollStartDate   = now;
                _.PollEndDate     = now.AddDays(2);
                _.UserID          = userId;
            });

            entity.MVPollOptions = new List <MVPollOption>
            {
                EntityCreator.Create <MVPollOption>(),
                EntityCreator.Create <MVPollOption>(),
                EntityCreator.Create <MVPollOption>()
            };

            var polls = new InMemoryDbSet <MVPoll> {
                entity
            };

            var entities = new Mock <IEntities>(MockBehavior.Strict);

            entities.Setup(_ => _.MVPolls).Returns(polls);
            entities.Setup(_ => _.SetState(It.IsAny <MVPoll>(), EntityState.Modified));
            entities.Setup(_ => _.SaveChanges()).Returns(1);
            entities.Setup(_ => _.Dispose());

            var pollOptions = new Mock <IObjectFactory <BusinessList <IPollOption> > >();

            pollOptions.Setup(_ => _.FetchChild()).Returns(new BusinessList <IPollOption>());

            var pollOption = new Mock <IObjectFactory <IPollOption> >();

            pollOption.Setup(_ => _.FetchChild(It.IsAny <object[]>()))
            .Returns <object[]>(_ => DataPortal.FetchChild <PollOption>(_[0] as MVPollOption));

            var builder = new ContainerBuilder();

            builder.Register <IEntities>(_ => entities.Object);
            builder.Register <IObjectFactory <BusinessList <IPollOption> > >(_ => pollOptions.Object);
            builder.Register <IObjectFactory <IPollOption> >(_ => pollOption.Object);

            var identity = new Mock <IUserIdentity>(MockBehavior.Strict);

            identity.Setup(_ => _.UserID).Returns(userId);
            identity.Setup(_ => _.IsInRole(UserRoles.Admin)).Returns(false);

            var principal = new Mock <IPrincipal>(MockBehavior.Strict);

            principal.Setup(_ => _.Identity).Returns(identity.Object);

            using (principal.Object.Bind(() => ApplicationContext.User))
            {
                using (new ObjectActivator(builder.Build(), new ActivatorCallContext())
                       .Bind(() => ApplicationContext.DataPortalActivator))
                {
                    var poll = new DataPortal <Poll>().Fetch(entity.PollID);
                    poll.Delete();
                    poll = poll.Save();

                    Assert.AreEqual(2, polls.Local.Count);
                    var deletedPoll = polls.Local[1];
                    Assert.IsNotNull(deletedPoll.PollDeletedDate, nameof(deletedPoll.PollDeletedDate));
                    Assert.IsTrue(deletedPoll.PollDeletedFlag.Value, nameof(deletedPoll.PollDeletedFlag));
                }
            }

            principal.VerifyAll();
            identity.VerifyAll();
            entities.VerifyAll();
        }