public ImageHandlerFixture() { _httpContext = MvcTestHelper.GetHttpContext(); _httpContext.HttpResponse.Expect(r => r.OutputStream).Returns(new Mock <Stream>().Object); var story = new Mock <IStory>(); story.ExpectGet(s => s.VoteCount).Returns(10); story.ExpectGet(s => s.CreatedAt).Returns(SystemTime.Now().AddDays(-8)); var repository = new Mock <IStoryRepository>(); repository.Expect(r => r.FindByUrl(It.IsAny <string>())).Returns(story.Object); _handler = new ImageHandler { Colors = new DefaultColors { BorderColor = "808080", TextBackColor = "404040", TextForeColor = "ffffff", CountBackColor = "eb4c07", CountForeColor = "ffffff" }, Width = 100, Height = 22, BorderWidth = 1, FontName = "Tahoma", FontSize = 12, NewStoryCacheDurationInMinutes = 5, ExpiredStoryCacheDurationInMinutes = 4320, StoryRepository = repository.Object, Settings = settings.Object }; }
private Mock <IStory> Setup(string ownerIp, params string[] promoterIps) { var ownerId = Guid.NewGuid(); var story = new Mock <IStory>(); var owner = new Mock <IUser>(); owner.ExpectGet(u => u.Id).Returns(ownerId); story.ExpectGet(s => s.PostedBy).Returns(owner.Object); story.ExpectGet(s => s.FromIPAddress).Returns(ownerIp); var votes = new List <IVote>(); foreach (string ip in promoterIps) { var promoter = new Mock <IUser>(); promoter.ExpectGet(u => u.Id).Returns(Guid.NewGuid()); var vote = new Mock <IVote>(); vote.ExpectGet(c => c.FromIPAddress).Returns(ip); vote.ExpectGet(c => c.ByUser).Returns(promoter.Object); votes.Add(vote.Object); } _repository.Expect(r => r.FindAfter(It.IsAny <Guid>(), It.IsAny <DateTime>())).Returns(votes).Verifiable(); return(story); }
public void NotifyCommentAsOffended_Should_Send_Offended_Comment_Details() { const string mailTemplate = "The following comment has been marked as offended by <%=offendedByUserName%>:\r\n\r\n" + "Site Url: <%=siteUrl%>" + "User: <%=postedByUserName%>" + "Comment: <%=comment%>"; var offendedBy = new Mock <IUser>(); offendedBy.ExpectGet(u => u.UserName).Returns("Offended By"); var postedBy = new Mock <IUser>(); postedBy.ExpectGet(u => u.UserName).Returns("Posted By"); var comment = new Mock <IComment>(); comment.ExpectGet(c => c.HtmlBody).Returns("<p>A dummy story"); comment.ExpectGet(c => c.ByUser).Returns(postedBy.Object); _file.Expect(f => f.ReadAllText(It.IsAny <string>())).Returns(mailTemplate).Verifiable(); _emailSender.NotifyCommentAsOffended("http://dotnetshoutout.com/The-Dummy_Story", comment.Object, offendedBy.Object); Sleep(); }
public void NotifyConfirmSpamStory_Should_Send_Confirmed_Story_Details() { const string mailTemplate = "The following story has been confirmed as spam by <%=confirmedByUserName%>:\r\n\r\n" + "Title: <%=title%>" + "Site Url: <%=siteUrl%>" + "Original Url: <%=originalUrl%>" + "User: <%=postedByUserName%>"; var confirmedBy = new Mock <IUser>(); confirmedBy.ExpectGet(u => u.UserName).Returns("Marked By"); var postedBy = new Mock <IUser>(); postedBy.ExpectGet(u => u.UserName).Returns("Posted By"); var story = new Mock <IStory>(); story.ExpectGet(s => s.Title).Returns("A dummy story"); story.ExpectGet(s => s.Url).Returns("http://www.dummystory.com"); story.ExpectGet(s => s.PostedBy).Returns(postedBy.Object); _file.Expect(f => f.ReadAllText(It.IsAny <string>())).Returns(mailTemplate).Verifiable(); _emailSender.NotifyConfirmSpamStory("http://dotnetshoutout.com/The-Dummy_Story", story.Object, confirmedBy.Object); Sleep(); }
public void Notify_Published_Stories_Should_Send_PublishStories() { const string mailTemplate = "Story Published: <%=timestamp%>\r\n"; var category = new Mock <ICategory>(); category.ExpectGet(c => c.Name).Returns("Dummy"); var story = new Mock <IStory>(); story.ExpectGet(s => s.Title).Returns("A dummy story"); story.ExpectGet(s => s.BelongsTo).Returns(category.Object); story.ExpectGet(s => s.Url).Returns("http://dummystory.com"); var publishedStory = new PublishedStory(story.Object) { Rank = 1 }; publishedStory.Weights.Add("View", 10); publishedStory.Weights.Add("Vote", 300); publishedStory.Weights.Add("Comment", 130); publishedStory.Weights.Add("User-Score", 450); publishedStory.Weights.Add("Known-Source", 5); publishedStory.Weights.Add("Freshness", 50); _file.Expect(f => f.ReadAllText(It.IsAny <string>())).Returns(mailTemplate).Verifiable(); _emailSender.NotifyPublishedStories(SystemTime.Now(), new[] { publishedStory }); Sleep(); }
public void NotifyStoryDelete_Should_Send_Deleted_Story_Details() { const string mailTemplate = "The following story has been deleted by <%=deletedByUserName%>:" + "Title: <%=title%>" + "Url: <%=url%>" + "User: <%=postedByUserName%>"; var postedBy = new Mock <IUser>(); postedBy.ExpectGet(u => u.UserName).Returns("Posted By"); var story = new Mock <IStory>(); story.ExpectGet(s => s.Title).Returns("A dummy story"); story.ExpectGet(s => s.Url).Returns("http://www.dummystory.com"); story.ExpectGet(s => s.PostedBy).Returns(postedBy.Object); _file.Expect(f => f.ReadAllText(It.IsAny <string>())).Returns(mailTemplate).Verifiable(); var deletedBy = new Mock <IUser>(); deletedBy.ExpectGet(u => u.UserName).Returns("Deleted By"); _emailSender.NotifyStoryDelete(story.Object, deletedBy.Object); Sleep(); }
private Mock <IStory> Setup(string ownerIp, params string[] ipAddresses) { var comments = new List <IComment>(); var ownerId = Guid.NewGuid(); var story = new Mock <IStory>(); var owner = new Mock <IUser>(); owner.ExpectGet(u => u.Id).Returns(ownerId); story.ExpectGet(s => s.PostedBy).Returns(owner.Object); story.ExpectGet(s => s.FromIPAddress).Returns(ownerIp); var ownerComment = new Mock <IComment>(); ownerComment.ExpectGet(c => c.ByUser).Returns(owner.Object); ownerComment.ExpectGet(c => c.FromIPAddress).Returns(ownerIp); comments.Add(ownerComment.Object); foreach (string ip in ipAddresses) { var user = new Mock <IUser>(); user.ExpectGet(u => u.Id).Returns(Guid.NewGuid()); var comment = new Mock <IComment>(); comment.ExpectGet(c => c.FromIPAddress).Returns(ip); comment.ExpectGet(c => c.ByUser).Returns(user.Object); comments.Add(comment.Object); } _repository.Expect(r => r.FindAfter(It.IsAny <Guid>(), It.IsAny <DateTime>())).Returns(comments).Verifiable(); return(story); }
public void SendComment_Should_Send_Comment_To_Subscribed_Users() { const string mailTemplate = "The following comments has been submitted by <%=userName%> in <%=detailUrl%> :\r\n\r\n" + "<%=comment%>"; var user = new Mock <IUser>(); user.ExpectGet(u => u.UserName).Returns("Dummy user"); user.ExpectGet(u => u.Email).Returns("*****@*****.**"); var story = new Mock <IStory>(); story.ExpectGet(s => s.Title).Returns("A dummy story"); var comment = new Mock <IComment>(); comment.ExpectGet(c => c.ByUser).Returns(user.Object); comment.ExpectGet(c => c.TextBody).Returns("The is a dummy comment"); comment.ExpectGet(c => c.ForStory).Returns(story.Object); var subscriber = new Mock <IUser>(); subscriber.ExpectGet(u => u.Email).Returns("*****@*****.**"); _file.Expect(f => f.ReadAllText(It.IsAny <string>())).Returns(mailTemplate).Verifiable(); _emailSender.SendComment("http://dotnetshoutout.com/The-Dummy_Story", comment.Object, new[] { user.Object, subscriber.Object }); Sleep(); }
public void Transform() { SPSKeyValueList list = new SPSKeyValueList(); list.Add("key0", "value0"); list.Add("key1", "value1"); list.Add("key2", "value2"); Mock <Page> mockPage = MockManager.MockObject <Page>(Constructor.Mocked); Mock <Control> mockControl = MockManager.MockObject <Control>(Constructor.Mocked); mockControl.MockedInstance.ID = "TestID"; Mock <SPSXsltControl> xsltMockControl = MockManager.MockObject <SPSXsltControl>(Constructor.Mocked); xsltMockControl.ExpectGet("Page", mockPage.MockedInstance); xsltMockControl.ExpectGet("Parent", mockControl.MockedInstance); SPSXsltControl xsltControl = xsltMockControl.MockedInstance; Assert.IsNotNull(xsltControl); xsltControl.XmlData = TestData.GetResource("TestData.xml"); xsltControl.Xsl = TestData.GetResource("Test.xslt"); StringWriter transform = xsltControl.Transform(); string output = transform.ToString(); Debug.WriteLine(output); Assert.IsTrue(output.Contains("TEST")); Assert.IsTrue(output.Contains("1")); Assert.IsTrue(output.Contains("2")); MockManager.Verify(); }
protected static ITag CreateStubTag() { var tag = new Mock <ITag>(); tag.ExpectGet(t => t.Id).Returns(Guid.NewGuid()); tag.ExpectGet(t => t.Name).Returns("Stub"); return(tag.Object); }
protected static IComment CreateStubComment() { var comment = new Mock <IComment>(); comment.ExpectGet(c => c.Id).Returns(Guid.NewGuid()); comment.ExpectGet(c => c.ForStory).Returns(CreateStubStory()); return(comment.Object); }
protected static IKnownSource CreateStubKnownSource() { var knownSource = new Mock <IKnownSource>(); knownSource.ExpectGet(ks => ks.Url).Returns("http://knownsoure.com"); knownSource.ExpectGet(ks => ks.Grade).Returns(KnownSourceGrade.A); return(knownSource.Object); }
protected static ICategory CreateStubCategory() { var category = new Mock <ICategory>(); category.ExpectGet(c => c.Id).Returns(Guid.NewGuid()); category.ExpectGet(c => c.Name).Returns("Stub"); return(category.Object); }
protected static IUser CreateStubUser() { var user = new Mock <IUser>(); user.ExpectGet(u => u.Id).Returns(Guid.NewGuid()); user.ExpectGet(u => u.UserName).Returns("Stub"); user.ExpectGet(u => u.Email).Returns("*****@*****.**"); return(user.Object); }
protected static IStory CreateStubStory() { var story = new Mock <IStory>(); story.ExpectGet(s => s.Id).Returns(Guid.NewGuid()); story.ExpectGet(s => s.Title).Returns("Stub"); story.ExpectGet(s => s.BelongsTo).Returns(CreateStubCategory()); return(story.Object); }
public void Should_Show_Next_Unless_Offset_Plus_Limit_Gte_Count() { var result = new Mock<IViewResult>(); result.ExpectGet(x => x.OffSet).Returns(5); var options = new ViewOptions(); options.Limit = 5; result.ExpectGet(x => x.TotalRows).Returns(10); var model = new PageableModel(); model.UpdatePaging(options, result.Object); Assert.IsFalse(model.ShowNext); }
private void Process_For_Comment() { var comment = new Mock <IComment>(); comment.ExpectGet(c => c.ForStory).Returns(new Mock <IStory>().Object); comment.ExpectGet(c => c.ByUser).Returns(new Mock <IUser>().Object); log.Expect(l => l.Warning(It.IsAny <string>())).Verifiable(); _emailSender.Expect(es => es.NotifySpamComment(It.IsAny <string>(), It.IsAny <IComment>(), It.IsAny <string>())).Verifiable(); _spamPostprocessor.Process("foo", true, "http://test.com", comment.Object); }
private FeedResult CommentedBy(string format, string userId) { var user = new Mock <IUser>(); user.ExpectGet(u => u.Id).Returns(Guid.NewGuid()); user.ExpectGet(u => u.UserName).Returns(userId); _userRepository.Expect(r => r.FindById(It.IsAny <Guid>())).Returns(user.Object).Verifiable(); _storyRepository.Expect(r => r.FindCommentedByUser(It.IsAny <Guid>(), It.IsAny <int>(), It.IsAny <int>())).Returns(new PagedResult <IStory>()).Verifiable(); return((FeedResult)_controller.CommentedBy(format, userId, 0, 10)); }
public AutoRefreshAttributeFixture() { _httpContext = MvcTestHelper.GetHttpContext("/Kigg", null, null); var settings = new Mock <IConfigurationSettings>(); settings.ExpectGet(s => s.FeedStoryPerPage).Returns(25); settings.ExpectGet(s => s.CarouselStoryCount).Returns(30); RouteTable.Routes.Clear(); new RegisterRoutes(settings.Object).Execute(); }
public void Calculate_Should_Return_Correct_Weight() { var user1 = new Mock <IUser>(); var user2 = new Mock <IUser>(); var user3 = new Mock <IUser>(); var moderator = new Mock <IUser>(); var admin = new Mock <IUser>(); user1.ExpectGet(u => u.Id).Returns(Guid.NewGuid()); user2.ExpectGet(u => u.Id).Returns(Guid.NewGuid()); user3.ExpectGet(u => u.Id).Returns(Guid.NewGuid()); user1.ExpectGet(u => u.CurrentScore).Returns(100); user2.ExpectGet(u => u.CurrentScore).Returns(200); user3.ExpectGet(u => u.CurrentScore).Returns(300); moderator.ExpectGet(u => u.Id).Returns(Guid.NewGuid()); admin.ExpectGet(u => u.Id).Returns(Guid.NewGuid()); moderator.ExpectGet(u => u.Role).Returns(Roles.Moderator); admin.ExpectGet(u => u.Role).Returns(Roles.Administrator); var user1Vote = new Mock <IVote>(); var user2Vote = new Mock <IVote>(); var user3Vote = new Mock <IVote>(); var moderatorVote = new Mock <IVote>(); var adminVote = new Mock <IVote>(); user1Vote.Expect(v => v.ByUser).Returns(user1.Object); user2Vote.Expect(v => v.ByUser).Returns(user2.Object); user3Vote.Expect(v => v.ByUser).Returns(user3.Object); moderatorVote.Expect(v => v.ByUser).Returns(moderator.Object); adminVote.Expect(v => v.ByUser).Returns(admin.Object); var story = new Mock <IStory>(); _repository.Expect(r => r.FindAfter(It.IsAny <Guid>(), It.IsAny <DateTime>())).Returns(new[] { user1Vote.Object, user2Vote.Object, user3Vote.Object, moderatorVote.Object, adminVote.Object }).Verifiable(); Assert.Equal( ( (Convert.ToDouble(user1.Object.CurrentScore) * ScorePercent) + (Convert.ToDouble(user2.Object.CurrentScore) * ScorePercent) + (Convert.ToDouble(user3.Object.CurrentScore) * ScorePercent) + ((Convert.ToDouble(user3.Object.CurrentScore) * ScorePercent) * ModaratorMultiply) + ((Convert.ToDouble(user3.Object.CurrentScore) * ScorePercent) * AdminMultiply) ), _strategy.Calculate(SystemTime.Now(), story.Object) ); _repository.Verify(); }
private FeedResult Category(string format, string categoryName) { var category = new Mock <ICategory>(); category.ExpectGet(c => c.Id).Returns(Guid.NewGuid()); category.ExpectGet(c => c.Name).Returns(categoryName); category.ExpectGet(c => c.UniqueName).Returns(categoryName); _categoryRepository.Expect(r => r.FindByUniqueName(It.IsAny <string>())).Returns(category.Object).Verifiable(); _storyRepository.Expect(r => r.FindPublishedByCategory(It.IsAny <Guid>(), It.IsAny <int>(), It.IsAny <int>())).Returns(new PagedResult <IStory>()).Verifiable(); return((FeedResult)_controller.Category(format, categoryName, 0, 10)); }
private void SetCurrentUser(Mock <IUser> user, Roles role) { var userId = Guid.NewGuid(); user.ExpectGet(u => u.Id).Returns(userId); user.ExpectGet(u => u.UserName).Returns(UserName); user.ExpectGet(u => u.Role).Returns(role); _httpContext.User.Identity.ExpectGet(i => i.Name).Returns(UserName); _httpContext.User.Identity.ExpectGet(i => i.IsAuthenticated).Returns(true); _userRepository.Expect(r => r.FindByUserName(UserName)).Returns(user.Object); }
protected static IVote CreateStubVote() { var story = new Mock <IStory>(); story.ExpectGet(s => s.Title).Returns("Stub Title"); story.ExpectGet(s => s.Url).Returns("Stub Url"); var vote = new Mock <IVote>(); vote.ExpectGet(v => v.ForStory).Returns(story.Object); return(vote.Object); }
private static void PrepareStoryToRemove(Mock <IStory> story) { const int counter = 5; DateTime fakeDate = SystemTime.Now().AddDays(-1); List <IMarkAsSpam> markAsSpams = new List <IMarkAsSpam>(); for (var i = 1; i <= counter; i++) { var markAsSpam = new Mock <IMarkAsSpam>(); markAsSpam.ExpectGet(m => m.ByUser).Returns(new Mock <IUser>().Object); markAsSpam.ExpectGet(m => m.MarkedAt).Returns(fakeDate.AddHours(1)); markAsSpams.Add(markAsSpam.Object); } story.ExpectGet(s => s.MarkAsSpams).Returns(markAsSpams); List <IComment> comments = new List <IComment>(); for (var i = 1; i <= counter; i++) { var comment = new Mock <IComment>(); comment.ExpectGet(c => c.ByUser).Returns(new Mock <IUser>().Object); comment.ExpectGet(c => c.CreatedAt).Returns(fakeDate.AddHours(1)); comments.Add(comment.Object); } story.ExpectGet(s => s.Comments).Returns(comments); List <IVote> votes = new List <IVote>(); for (var i = 1; i <= counter; i++) { var vote = new Mock <IVote>(); vote.ExpectGet(v => v.ByUser).Returns(new Mock <IUser>().Object); vote.ExpectGet(v => v.PromotedAt).Returns(fakeDate.AddHours(1)); votes.Add(vote.Object); } story.ExpectGet(s => s.Votes).Returns(votes); story.ExpectGet(s => s.CreatedAt).Returns(fakeDate); }
public void CurrentUserIPAddress_Returns_IPAaddress_When_HttpContext_Is_Not_Null() { var serverVariables = new NameValueCollection { { "HTTP_X_FORWARDED_FOR", "192.168.1.0" } }; var request = new Mock <HttpRequestBase>(); request.ExpectGet(r => r.UserHostAddress).Returns("202.192.168.1"); request.ExpectGet(r => r.ServerVariables).Returns(serverVariables); _context.ExpectGet(c => c.Request).Returns(request.Object); Assert.Equal("202.192.168.1->192.168.1.0", CreateEntry(_context.Object).CurrentUserIPAddress); }
public void Should_Show_Next_Unless_Offset_Plus_Limit_Gte_Count() { var result = new Mock <IViewResult>(); result.ExpectGet(x => x.OffSet).Returns(5); var options = new ViewOptions(); options.Limit = 5; result.ExpectGet(x => x.TotalRows).Returns(10); var model = new PageableModel(); model.UpdatePaging(options, result.Object); Assert.IsFalse(model.ShowNext); }
private FeedResult Tags(string format, string tagName) { var tag = new Mock <ITag>(); tag.ExpectGet(t => t.Id).Returns(Guid.NewGuid()); tag.ExpectGet(t => t.Name).Returns(tagName); tag.ExpectGet(t => t.UniqueName).Returns(tagName); _tagRepository.Expect(r => r.FindByUniqueName(It.IsAny <string>())).Returns((ITag)null).Verifiable(); _tagRepository.Expect(r => r.FindByName(It.IsAny <string>())).Returns(tag.Object).Verifiable(); _storyRepository.Expect(r => r.FindByTag(It.IsAny <Guid>(), It.IsAny <int>(), It.IsAny <int>())).Returns(new PagedResult <IStory>()).Verifiable(); return((FeedResult)_controller.Tags(format, tagName, 0, 10)); }
private ActionResult SuggestTags(string browser) { const string TagName = "ASPNETMVC"; var tag = new Mock <ITag>(); tag.ExpectGet(t => t.Id).Returns(Guid.NewGuid()); tag.ExpectGet(t => t.Name).Returns(TagName); _tagRepository.Expect(r => r.FindMatching(It.IsAny <string>(), It.IsAny <int>())).Returns(new List <ITag> { tag.Object }).Verifiable(); return(_controller.SuggestTags("ASPNET", null, browser)); }
public void ShouldAddClaimSet() { var principal = new GenericPrincipal(new GenericIdentity("foo"), null); var httpContext = new HttpContext( new HttpRequest("foo", "http://foo", ""), new HttpResponse(Console.Out)); HttpContext.Current = httpContext; httpContext.User = principal; object state = null; HttpContextIdentityPolicy policy = new HttpContextIdentityPolicy(); var evaluationContextMock = new Mock<EvaluationContext>(); var properties = new Dictionary<string, object>(); evaluationContextMock .ExpectGet(ec => ec.Properties) .Returns(properties); evaluationContextMock.Expect(ec => ec.AddClaimSet(policy, It.IsAny<ClaimSet>())).Verifiable(); policy.Evaluate(evaluationContextMock.Object, ref state); evaluationContextMock.Verify(); }
public static void SetupProperty <T, TProperty>(this Mock <T> mock, Expression <Func <T, TProperty> > property, TProperty defaultValue) where T : class { TProperty propertyValue = defaultValue; mock.ExpectGet(property).Returns(() => propertyValue); mock.ExpectSet(property).Callback(value => { propertyValue = value; }); }
public void AuthHeaderWithMalformedHeader() { // given given_pipeline_contributor<AuthenticationContributor>(); var mockScheme = new Mock<IAuthenticationScheme>(); mockScheme.ExpectGet(s => s.Name).Returns("BASIC"); mockScheme .Expect(s => s.Authenticate(It.IsAny<IRequest>())) .Returns(new AuthenticationResult.MalformedCredentials()); given_dependency(mockScheme.Object); Context.Request.Headers.Add("Authorization", "BASIC anythinghere"); // when var result = when_sending_notification<KnownStages.IHandlerSelection>(); // then Context.Response.Headers["Warning"].ShouldBe("Malformed credentials"); Context.OperationResult.ShouldBeOfType<OperationResult.BadRequest>(); result.ShouldBe(PipelineContinuation.RenderNow); }
public void AuthHeaderWithMalformedHeader() { // given given_pipeline_contributor <AuthenticationContributor>(); var mockScheme = new Mock <IAuthenticationScheme>(); mockScheme.ExpectGet(s => s.Name).Returns("BASIC"); mockScheme .Expect(s => s.Authenticate(It.IsAny <IRequest>())) .Returns(new AuthenticationResult.MalformedCredentials()); given_dependency(mockScheme.Object); Context.Request.Headers.Add("Authorization", "BASIC anythinghere"); // when var result = when_sending_notification <KnownStages.IHandlerSelection>(); // then Context.Response.Headers["Warning"].ShouldBe("Malformed credentials"); Context.OperationResult.ShouldBeOfType <OperationResult.BadRequest>(); result.ShouldBe(PipelineContinuation.RenderNow); }
public void ExecuteResult() { // Arrange object data = _jsonData; string contentType = "Some content type."; Encoding contentEncoding = Encoding.UTF8; // Arrange expectations Mock<ControllerContext> mockControllerContext = new Mock<ControllerContext>(MockBehavior.Strict); mockControllerContext.ExpectGet(c => c.HttpContext.Request.HttpMethod).Returns("POST").Verifiable(); mockControllerContext.ExpectSet(c => c.HttpContext.Response.ContentType, contentType).Verifiable(); mockControllerContext.ExpectSet(c => c.HttpContext.Response.ContentEncoding, contentEncoding).Verifiable(); mockControllerContext.Expect(c => c.HttpContext.Response.Write(_jsonSerializedData)).Verifiable(); JsonResult result = new JsonResult { Data = data, ContentType = contentType, ContentEncoding = contentEncoding }; // Act result.ExecuteResult(mockControllerContext.Object); // Assert mockControllerContext.Verify(); }
public void AuthHeaderWithValidCredentials() { // given given_pipeline_contributor <AuthenticationContributor>(); var mockScheme = new Mock <IAuthenticationScheme>(); mockScheme.ExpectGet(s => s.Name).Returns("BASIC"); var username = "******"; var roles = new[] { "role1", "role2" }; mockScheme .Expect(s => s.Authenticate(It.IsAny <IRequest>())) .Returns(new AuthenticationResult.Success(username, roles)); given_dependency(mockScheme.Object); Context.Request.Headers.Add("Authorization", "BASIC anythinghere"); // when var result = when_sending_notification <KnownStages.IHandlerSelection>(); // then result.ShouldBe(PipelineContinuation.Continue); Context.User.Identity.Name.ShouldBe(username); Context.User.IsInRole(roles[0]); Context.User.IsInRole(roles[1]); }
public void Should_Show_Previous_If_OffSet_Not_Equal_Zero() { var result = new Mock<IViewResult>(); result.ExpectGet(x => x.OffSet).Returns(1); var options = new ViewOptions(); var model = new PageableModel(); model.UpdatePaging(options, result.Object); Assert.IsTrue(model.ShowPrev); }
public void Should_Skip_1_On_Next_Url_When_Offset_is_Not_Zero() { var result = new Mock<IViewResult>(); result.ExpectGet(x => x.OffSet).Returns(1); var options = new ViewOptions(); var model = new PageableModel(); model.UpdatePaging(options, result.Object); Assert.IsTrue(model.PrevUrlParameters.Contains("skip=1")); Assert.IsTrue(model.PrevUrlParameters.Contains("descending=true")); }
public void SetUp() { _imageStoreMock = new Mock<StubImageStore>(); _now = DateTime.Now; _imageHandlerMock = new Mock<StubImageHandler>(_imageStoreMock.Object, _now); _imageHandler = _imageHandlerMock.Object; var requestMock = new Mock<HttpRequestBase>(); requestMock.ExpectGet(r => r.QueryString).Returns(new NameValueCollection()); _cachePolicyMock = new Mock<HttpCachePolicyBase>(); _responseMock = new Mock<HttpResponseBase>(); _responseMock.ExpectGet(r => r.Cache).Returns(_cachePolicyMock.Object); _responseMock.ExpectGet(r => r.OutputStream).Returns(new MemoryStream()); _contextMock = new Mock<HttpContextBase>(); _contextMock.ExpectGet(c => c.Request).Returns(requestMock.Object); _contextMock.ExpectGet(c => c.Response).Returns(_responseMock.Object); }
public void SetUp() { var requestMock = new Mock<HttpRequestBase>(); requestMock.ExpectGet(r => r.Path).Returns("basePath"); var contextMock = new Mock<HttpContextBase>(); contextMock.ExpectGet(c => c.Request).Returns(requestMock.Object); gi = new TestGeneratedImage(contextMock.Object) { ImageHandlerUrl = "Handler.ashx" }; }
public void CreateInterfaceMockTest() { var mock = new Mock<IMocked>(); mock.ExpectCall(m => m.Method(2)).Returns("2").Once(); mock.ExpectGet(m => m.Property).Gets(2).Never(); mock.ExpectSet(m => m.Property).Sets(2).Never(); var value = mock.Object.Method(2); mock.Verify(); Assert.That(value, Is.EqualTo("2")); }
public void BindModelReturnsEmptyResultIfEmptyFileInputElementInPost() { // Arrange Mock<HttpPostedFileBase> mockFile = new Mock<HttpPostedFileBase>(); mockFile.Expect(f => f.ContentLength).Returns(0); mockFile.Expect(f => f.FileName).Returns(String.Empty); Mock<ControllerContext> mockControllerContext = new Mock<ControllerContext>(); mockControllerContext.ExpectGet(c => c.HttpContext.Request.Files["fileName"]).Returns(mockFile.Object); HttpPostedFileBaseModelBinder binder = new HttpPostedFileBaseModelBinder(); ModelBindingContext bindingContext = new ModelBindingContext() { ModelName = "fileName" }; // Act object result = binder.BindModel(mockControllerContext.Object, bindingContext); // Assert Assert.IsNull(result); }
public void BindModelReturnsResultIfFileFound() { // Arrange Mock<HttpPostedFileBase> mockFile = new Mock<HttpPostedFileBase>(); mockFile.Expect(f => f.ContentLength).Returns(1234); mockFile.Expect(f => f.FileName).Returns("somefile"); Mock<ControllerContext> mockControllerContext = new Mock<ControllerContext>(); mockControllerContext.ExpectGet(c => c.HttpContext.Request.Files["fileName"]).Returns(mockFile.Object); HttpPostedFileBaseModelBinder binder = new HttpPostedFileBaseModelBinder(); ModelBindingContext bindingContext = new ModelBindingContext() { ModelName = "fileName" }; // Act object result = binder.BindModel(mockControllerContext.Object, bindingContext); // Assert Assert.IsNotNull(result); Assert.AreSame(mockFile.Object, result, "Returned file did not match mock file."); }
public void CanQueryBySpecification() { const string DATA = "One"; var moqSpecs = new Mock<SpecificationBase<FakeEntity>>(); moqSpecs.ExpectGet(x => x.Predicate) .Returns(x => x.Data == DATA); SpecificationBase<FakeEntity> specs = moqSpecs.Object; IQueryable<FakeEntity> entities = FakeEntity.CreateFakeEntities(); IQueryable<FakeEntity> entitiesWithDataOne = specs.Query(entities); Assert.GreaterThan(entitiesWithDataOne.Count(), 0); foreach (FakeEntity entity in entitiesWithDataOne) { Assert.AreEqual(DATA, entity.Data); } }
public void ShouldSetIdentityProperty() { var evaluationContextMock = new Mock<EvaluationContext>(); var properties = new Dictionary<string, object>(); evaluationContextMock .ExpectGet(ec => ec.Properties) .Returns(properties); var principal = new GenericPrincipal(new GenericIdentity("foo"), null); var httpContext = new HttpContext( new HttpRequest("foo", "http://foo", ""), new HttpResponse(Console.Out)); HttpContext.Current = httpContext; httpContext.User = principal; object state = null; HttpContextIdentityPolicy policy = new HttpContextIdentityPolicy(); policy.Evaluate(evaluationContextMock.Object, ref state); Assert.IsTrue(properties.ContainsKey("Identities")); Assert.IsTrue(properties["Identities"] is List<IIdentity>); Assert.AreSame(principal.Identity, ((List<IIdentity>)properties["Identities"])[0]); }
public static void PrepareRequestTo(string controller, string action) { var routeHandler = new AsyncMvcRouteHandler(); var httpContextBase = new Mock<HttpContextBase>(); var sessionState = new Mock<HttpSessionStateBase>(); var writer = new StringWriter(); var controllerFactory = new Mock<IControllerFactory>(); var request = new Mock<HttpRequestBase>(); var routeData = new RouteData(); routeData.Values["controller"] = controller; routeData.Values["action"] = action; httpContextBase.ExpectGet(x => x.Session).Returns(sessionState); httpContextBase.ExpectGet(x => x.Request).Returns(request); controllerFactory.Expect(x => x.CreateController(Arg.IsAny<RequestContext>(), controller)).Returns(new TestController()); ControllerBuilder.Current.SetControllerFactory(controllerFactory.Object); httpContext = new HttpContext(new HttpRequest("foo", "http://foo", "foo"), new HttpResponse(writer)); CallContext.HostContext = httpContext; var requestContext = new RequestContext(httpContextBase, routeData); httpHandler = (IHttpAsyncHandler)routeHandler.GetHttpHandler(requestContext); }
public void ShouldSetClaimForCurrentUserWithoutCachingIt() { var evaluationContextMock = new Mock<EvaluationContext>(); var principal = new GenericPrincipal(new GenericIdentity("foo"), null); var httpContext = new HttpContext( new HttpRequest("foo", "http://foo", ""), new HttpResponse(Console.Out)); HttpContext.Current = httpContext; httpContext.User = principal; var properties = new Dictionary<string, object>(); evaluationContextMock .ExpectGet(ec => ec.Properties) .Returns(properties); object state = null; HttpContextIdentityPolicy policy = new HttpContextIdentityPolicy(); policy.Evaluate(evaluationContextMock.Object, ref state); Assert.IsTrue(properties.ContainsKey("Principal")); Assert.IsTrue(properties["Principal"] is IPrincipal); Assert.AreSame(principal, (IPrincipal)properties["Principal"]); // Change the current principal principal = new GenericPrincipal(new GenericIdentity("bar"), null); httpContext.User = principal; policy.Evaluate(evaluationContextMock.Object, ref state); Assert.IsTrue(properties.ContainsKey("Principal")); Assert.IsTrue(properties["Principal"] is IPrincipal); Assert.AreSame(principal, (IPrincipal)properties["Principal"]); }
public void NullContentIsNotOutput() { // Arrange string contentType = "Some content type."; Encoding contentEncoding = Encoding.UTF8; // Arrange expectations Mock<ControllerContext> mockControllerContext = new Mock<ControllerContext>(MockBehavior.Strict); mockControllerContext.ExpectGet(c => c.HttpContext.Request.HttpMethod).Returns("POST").Verifiable(); mockControllerContext.ExpectSet(c => c.HttpContext.Response.ContentType, contentType).Verifiable(); mockControllerContext.ExpectSet(c => c.HttpContext.Response.ContentEncoding, contentEncoding).Verifiable(); JsonResult result = new JsonResult { ContentType = contentType, ContentEncoding = contentEncoding }; // Act result.ExecuteResult(mockControllerContext.Object); // Assert mockControllerContext.Verify(); }
public void GetRequestBlocked() { // Arrange expectations Mock<ControllerContext> mockControllerContext = new Mock<ControllerContext>(MockBehavior.Strict); mockControllerContext.ExpectGet(c => c.HttpContext.Request.HttpMethod).Returns("GET").Verifiable(); JsonResult result = new JsonResult(); // Act & Assert ExceptionHelper.ExpectInvalidOperationException( () => result.ExecuteResult(mockControllerContext.Object), "This request has been blocked because sensitive information could be disclosed to third party web sites when this is used in a GET request. To allow GET requests, set JsonRequestBehavior to AllowGet."); mockControllerContext.Verify(); }
public void MyTestInitialize() { _accountRepository = new Mock<IAccountRepository>(); _contactRepository = new Mock<IContactRepository>(); _contractRepository = new Mock<IContractRepository>(); _planRepository = new Mock<IPlanRepository>(); _generator = new Mock<INumberGeneratorService>(); _companyRepository = new Mock<ICompanyRepository>(); _agentRepository = new Mock<IAgentRepository>(); _customFeeRepository = new Mock<ICustomFeeRepository>(); _activityService = new Mock<IActivityLoggingService>(); _importManager = new Mock<Import.ICallDataImportManager>(); _dateTime = new Mock<IDateTimeFacade>(); _today = DateTime.Parse("2008-10-11"); _dateTime.ExpectGet(p => p.Today).Returns(_today); _service = new ContractService(_contractRepository.Object, _accountRepository.Object, _planRepository.Object, _contactRepository.Object, _companyRepository.Object, _agentRepository.Object, _activityService.Object, _generator.Object, _importManager.Object, _customFeeRepository.Object, _dateTime.Object); updateRequest = new UpdateContractRequest { ContractId = 1, PlanId = 1, ActivationDate = DateTime.Parse("12/11/2008"), EndDate = DateTime.Parse("12/11/2009"), UsedBy = "Michael", Pin = "6666", Puk = "6666", PhoneNumber1 = "012344394", PhoneNumber2 = "430493304", PhoneNumber3 = "324433344", PhoneNumber4 = "443343433", HomeAddress = GetAddress(), DeliveryAddress = GetAddress(), AccountName = "Test Account", AccountPassword = "" }; }
public void AuthHeaderWithValidCredentials() { // given given_pipeline_contributor<AuthenticationContributor>(); var mockScheme = new Mock<IAuthenticationScheme>(); mockScheme.ExpectGet(s => s.Name).Returns("BASIC"); var username = "******"; var roles = new[] { "role1", "role2" }; mockScheme .Expect(s => s.Authenticate(It.IsAny<IRequest>())) .Returns(new AuthenticationResult.Success(username, roles)); given_dependency(mockScheme.Object); Context.Request.Headers.Add("Authorization", "BASIC anythinghere"); // when var result = when_sending_notification<KnownStages.IHandlerSelection>(); // then result.ShouldBe(PipelineContinuation.Continue); Context.User.Identity.Name.ShouldBe(username); Context.User.IsInRole(roles[0]); Context.User.IsInRole(roles[1]); }