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]);
}
