public void ConstructingControllerStartsTimelines()
{
var checkTimelines = new Mock<ITimer>();
var updateTimelines = new Mock<ITimer>();
var queue = new Queue<ITimer>();
queue.Enqueue(checkTimelines.Object);
queue.Enqueue(updateTimelines.Object);
SysTimer.Override = queue.Dequeue;
var timelines = new Mock<ITimelines>();
var controller = new TimelineController(timelines.Object);
controller.StartTimelines();
checkTimelines.Raise(c => c.Elapsed += null, EventArgs.Empty);
updateTimelines.Raise(u => u.Elapsed += null, EventArgs.Empty);
checkTimelines.VerifySet(c => c.Interval = 100);
checkTimelines.VerifySet(c => c.Interval = 60000);
checkTimelines.Verify(c => c.Start());
timelines.Verify(t => t.HomeTimeline());
timelines.Verify(t => t.MentionsTimeline());
updateTimelines.VerifySet(u => u.Interval = 30000);
updateTimelines.Verify(u => u.Start());
timelines.Verify(t => t.UpdateTimeStamps());
Assert.That(controller, Is.Not.Null);
}
public void should_create_parameters_for_any_parameters_found_in_the_command_text_with_matching_properties_in_the_object()
{
// Arrange
var task = TaskFactory<BuildParametersUsing<MockObject>>.Create();
var mockDbCommand = new Mock<IDbCommand> { DefaultValue = DefaultValue.Mock };
var mockDbDataParameter = new Mock<IDbDataParameter>();
mockDbCommand.Setup(dbCommand => dbCommand.CreateParameter()).Returns(mockDbDataParameter.Object);
mockDbCommand.Setup(dbCommand => dbCommand.CommandText).Returns("select blah");
task.CommandWithParameters = mockDbCommand.Object;
var mockObject = new MockObject { Name = "John Doe", Age = 21 };
task.ObjectWithValues = mockObject;
var mockFindParameters = new Mock<FindParametersInCommandText>();
mockFindParameters.Setup(findParams => findParams.ParameterNames).Returns(new string[] { "@Age" });
task.FindParametersInCommandText = mockFindParameters.Object;
// Act
task.Execute();
// Assert
mockDbDataParameter.VerifySet(param => param.ParameterName = "@Age");
mockDbDataParameter.VerifySet(param => param.Value = 21);
mockDbCommand.Verify(dbCommand => dbCommand.Parameters.Add(mockDbDataParameter.Object), Times.Once());
}
public void it_should_pass_data_to_file_writer()
{
// arrange
var order = new Order {OrderId = 1001, OrderTotal = 10.53M};
var mockFileWriter = new Mock<IFileWriter>();
var orderWriter = new OrderWriter(mockFileWriter.Object);
// act
orderWriter.WriteOrder(order);
// assert
mockFileWriter.Verify(fw => fw.WriteLine("1001,10.53"), Times.Exactly(1));
// method is not executed, expression tree is veryfied
mockFileWriter.Verify(fw => fw.WriteLine(It.IsAny<string>()), Times.Once());
// use regex
mockFileWriter.Verify(fw => fw.WriteLine(It.IsRegex("^1001")), Times.Once());
// use predicate
mockFileWriter.Verify(fw => fw.WriteLine(It.Is<string>(s => s.Length > 3)), Times.Once());
mockFileWriter.Verify(fw => fw.WriteLine(It.Is<string>(s => s.StartsWith("1001,10.53"))), Times.Once());
// can use local variable
string expectedValue = "1001,10.53";
mockFileWriter.Verify(fw => fw.WriteLine(It.Is<string>(s => s.StartsWith(expectedValue))), Times.Once());
// verify property
mockFileWriter.VerifySet(fw => fw.FileName = It.IsAny<string>());
mockFileWriter.VerifySet(fw => fw.FileName = "1001.txt");
mockFileWriter.VerifySet(fw => fw.FileName = It.Is<string>(s => s.StartsWith("1001")));
}
private void Example()
{
var mock = new Mock<IFoo>();
mock.Verify(foo => foo.Execute("ping"));
// Verify with custom error message for failure
mock.Verify(foo => foo.Execute("ping"), "When doing operation X, the service should be pinged always");
// Method should never be called
mock.Verify(foo => foo.Execute("ping"), Times.Never());
// Called at least once
mock.Verify(foo => foo.Execute("ping"), Times.AtLeastOnce());
mock.VerifyGet(foo => foo.Name);
// Verify setter invocation, regardless of value.
mock.VerifySet(foo => foo.Name);
// Verify setter called with specific value
mock.VerifySet(foo => foo.Name = "foo");
// Verify setter with an argument matcher
mock.VerifySet(foo => foo.Value = It.IsInRange(1, 5, Range.Inclusive));
}
public void GenerateBoard()
{
Mock<Grid> grid = new Mock<Grid>();
grid.SetupAllProperties();
MainGame game = new MainGame(grid.Object, 200);
grid.VerifySet(x => x.Width = It.IsAny<double>());
grid.VerifySet(x => x.Height = It.IsAny<double>());
}
public void ForProduction_Should_dissallow_upsert_of_schemas_and_synchronization()
{
var settingsFake = new Mock<IDbSettings>();
var dbFake = new Mock<ISisoDatabase>();
dbFake.SetupGet(f => f.Settings).Returns(settingsFake.Object);
dbFake.Object.Configure().ForProduction();
settingsFake.VerifySet(f => f.AllowUpsertsOfSchemas = false);
settingsFake.VerifySet(f => f.SynchronizeSchemaChanges = false);
}
public void AuthorizationState_must_define_post_method_and_content_type()
{
var mock = new Mock<HttpHelper>("https://www.mystore.com/manager")
.SetupProperty(m => m.HttpWebRequest.Method);
mock.Setup(m => m.HttpWebRequest.GetRequestStream()).Returns(new MemoryStream());
mock.Setup(m => m.HttpWebRequest.GetResponse().GetResponseStream()).Returns(new MemoryStream());
var target = new APIAuthorizer("client", "key", new Uri("https://www.mystore.com/manager"));
target.AuthorizationState("code", mock.Object);
mock.VerifySet(h => h.HttpWebRequest.Method = "POST");
mock.VerifySet(h => h.HttpWebRequest.ContentType = "application/x-www-form-urlencoded");
}
public void Apply_SetsSqlServerConnectionStringWithIntegratedSecurityParameterValuesOnInterface()
{
// arrage
var information = new Mock<IConnectToDatabaseConnectionInformation>();
var cn = "Server=myServerAddress;Database=myDataBase;Integrated Security=SSPI;";
// act
ConnectionStringHelper.Apply(information.Object, cn);
// assert
information.VerifySet(x => x.Server = "myServerAddress");
information.VerifySet(x => x.Database = "myDataBase");
information.VerifySet(x => x.UseIntegratedSecurity = true);
}
public void RedirectWithoutBypassingSecurityWarningIssuesPermanentRedirect()
{
// Arrange.
const string RedirectUrl = "https://www.somewebsite.com/admin/protected-content/";
var mockResponse = new Mock<HttpResponseBase>();
var redirector = new LocationRedirector();
// Act.
redirector.Redirect(mockResponse.Object, RedirectUrl, false);
// Assert.
mockResponse.VerifySet(resp => resp.StatusCode = 301);
mockResponse.VerifySet(resp => resp.RedirectLocation = RedirectUrl);
mockResponse.Verify(resp => resp.End());
}
public void Apply_SetsSqlServerConnectionStringWithUsernameAndPasswordParameterValuesOnInterface()
{
// arrage
var information = new Mock<IConnectToDatabaseConnectionInformation>();
var cn = "Data Source=myServerAddress;Initial Catalog=myDataBase;User Id=myUsername;Password=myPassword;";
// act
ConnectionStringHelper.Apply(information.Object, cn);
// assert
information.VerifySet(x => x.Server = "myServerAddress");
information.VerifySet(x => x.Database = "myDataBase");
information.VerifySet(x => x.Username = "myUsername");
information.VerifySet(x => x.Password = "myPassword");
}
public async Task Given_No_Topic_When_Getting_Then_Topic_List_Returned()
{
var mockSubscriptionTrackingService = new Mock<ISubscriptionTrackingService>();
var topics = new TopicName[] {"topic-1", "topic-2", "topic-3"};
var controller = new TopicController(mockSubscriptionTrackingService.Object, topics);
var mockRequest = new Mock<IHttpResourceRequest>();
var requestUri = new UriBuilder
{
Scheme = "http",
Host = "localhost",
Path = "/platibus/topic/"
}.Uri;
mockRequest.Setup(r => r.HttpMethod).Returns("GET");
mockRequest.Setup(r => r.Url).Returns(requestUri);
var mockResponse = new Mock<IHttpResourceResponse>();
var responseOutputStream = new MemoryStream();
var responseEncoding = Encoding.UTF8;
mockResponse.Setup(r => r.ContentEncoding).Returns(responseEncoding);
mockResponse.Setup(r => r.OutputStream).Returns(responseOutputStream);
await controller.Process(mockRequest.Object, mockResponse.Object, Enumerable.Empty<string>());
mockResponse.VerifySet(r => r.StatusCode = 200);
var responseContent = responseEncoding.GetString(responseOutputStream.GetBuffer());
var topicsFromResponse = new NewtonsoftJsonSerializer().Deserialize<string[]>(responseContent);
Assert.That(topicsFromResponse.Length, Is.EqualTo(3));
Assert.That(topicsFromResponse, Contains.Item("topic-1"));
Assert.That(topicsFromResponse, Contains.Item("topic-2"));
Assert.That(topicsFromResponse, Contains.Item("topic-3"));
}
public void DefinitionSetsLexerToIgnoreWhitespace()
{
var mockedLexer = new Mock<ILexer>();
_htmlDefinitions.SetupLexer(mockedLexer.Object);
mockedLexer.VerifySet(x => x.IgnoreWhitespace = true);
}
public void ItDoesNotSetTheSearchStringIfThereIsNotADefaultValue()
{
var promptItems = A.ObservableCollection(Mock.Of<ISearchablePromptItem>(), Mock.Of<ISearchablePromptItem>());
var promptInfo = A.PromptInfo()
.WithDefaultValues(new ObservableCollection<ValidValue>())
.Build();
_promptItemCollectionProvider
.Setup(
b => b.Get(
promptInfo.Name,
promptInfo.PromptLevelInfo.ParameterName,
promptInfo.DefaultValues))
.Returns(promptItems);
var promptToReturn = new Mock<IMultiSelectPrompt>();
_casscadingSearchProvider
.Setup(p => p.Get(
promptInfo.Label, promptInfo.Name,
promptInfo.PromptLevelInfo.ParameterName,
promptItems,
promptItems))
.Returns(promptToReturn.Object);
_builder.BuildFrom(promptInfo);
promptToReturn.VerifySet(p => p.SearchString = It.IsAny<string>(), Times.Exactly(0));
}
public void Initialize()
{
var context = new Mock<IContextAware>();
var view = new Mock<INotificationView>();
{
view.SetupSet(v => v.Model = It.IsAny<NotificationModel>())
.Verifiable();
}
var parameter = new NotificationParameter(context.Object);
var container = new Mock<IDependencyInjectionProxy>();
{
container.Setup(c => c.Resolve<IContextAware>())
.Returns(context.Object);
container.Setup(c => c.Resolve<ICollectNotifications>())
.Returns(new Mock<ICollectNotifications>().Object);
}
var presenter = new NotificationPresenter(container.Object);
((IPresenter)presenter).Initialize(view.Object, parameter);
Assert.AreSame(view.Object, presenter.View);
Assert.AreSame(parameter, presenter.Parameter);
view.VerifySet(v => v.Model = It.IsAny<NotificationModel>(), Times.Once());
}
public void Initialize()
{
var context = new Mock<IContextAware>();
var view = new Mock<IProjectDescriptionView>();
{
view.SetupSet(v => v.Model = It.IsAny<ProjectDescriptionModel>())
.Verifiable();
}
var parameter = new ProjectDescriptionParameter(context.Object);
var project = new Mock<IProject>();
var facade = new ProjectFacade(project.Object);
var projectLink = new Mock<ILinkToProjects>();
{
projectLink.Setup(p => p.ActiveProject())
.Returns(facade);
}
var container = new Mock<IDependencyInjectionProxy>();
{
container.Setup(c => c.Resolve<IContextAware>())
.Returns(context.Object);
container.Setup(c => c.Resolve<ILinkToProjects>())
.Returns(projectLink.Object);
}
var presenter = new ProjectDescriptionPresenter(container.Object);
((IPresenter)presenter).Initialize(view.Object, parameter);
Assert.AreSame(view.Object, presenter.View);
Assert.AreSame(parameter, presenter.Parameter);
view.VerifySet(v => v.Model = It.IsAny<ProjectDescriptionModel>(), Times.Once());
}
public void CanGetJavaScriptFiles()
{
var handler = new JsHandler(_fileLocationsPaths);
var mockContext = new Mock<HttpContextBase>();
var mockRequest = new Mock<HttpRequestBase>();
var mockResponse = new Mock<HttpResponseBase>();
var mockCache = new Mock<HttpCachePolicyBase>();
mockRequest.Setup(x => x["files"]).Returns("test_js_file.js,test_js_file2.js");
mockResponse.Setup(x => x.Headers).Returns(new System.Collections.Specialized.NameValueCollection());
mockResponse.Setup(x => x.Cache).Returns(mockCache.Object);
//there is a problem with this terrible property VaryByParams
//mockCache.Setup(x => x.VaryByParams).Returns(new HttpCacheVaryByParams());
mockContext.Setup(x => x.Request).Returns(mockRequest.Object);
mockContext.Setup(x => x.Response).Returns(mockResponse.Object);
mockResponse.Setup(x => x.Write(It.IsAny<string>()))
.Callback<string>(x =>
{
Assert.IsNotNullOrEmpty(x, "Merged file content is empty");
});
handler.ProcessRequest(mockContext.Object);
mockResponse.VerifySet(x => x.ContentType, "Content type should be set at least once");
mockResponse.Verify(x => x.Write(It.IsAny<string>()), "Write method should be called at least once");
}
public async Task WriteAsync_DoesNotWriteNullStrings()
{
// Arrange
Encoding encoding = Encoding.UTF8;
var memoryStream = new MemoryStream();
var response = new Mock<HttpResponse>();
response.SetupProperty<long?>(o => o.ContentLength);
response.SetupGet(r => r.Body).Returns(memoryStream);
var httpContext = new Mock<HttpContext>();
httpContext.Setup(o => o.Response).Returns(response.Object);
var formatter = new StringOutputFormatter();
var context = new OutputFormatterWriteContext(
httpContext.Object,
new TestHttpResponseStreamWriterFactory().CreateWriter,
typeof(string),
@object: null);
// Act
await formatter.WriteResponseBodyAsync(context);
// Assert
Assert.Equal(0, memoryStream.Length);
response.VerifySet(r => r.ContentLength = It.IsAny<long?>(), Times.Never());
}
public void HtmlTokenDefinitionsPassedToLexer()
{
var mockedLexer = new Mock<ILexer>();
_htmlDefinitions.SetupLexer(mockedLexer.Object);
mockedLexer.VerifySet(x => x.TokenDefinitions = It.IsAny<TokenDefinition[]>());
}
public void should_have_a_http_post_method()
{
var mock = new Mock<ICloudFilesRequest>();
mock.SetupGet(x => x.Headers).Returns(new WebHeaderCollection());
setPublicContainerDetails.Apply(mock.Object);
mock.VerifySet(x => x.Method = "POST");
}
public async Task WriteAsync_DoesNotWriteNullStrings()
{
// Arrange
Encoding encoding = Encoding.UTF8;
var memoryStream = new MemoryStream();
var response = new Mock<HttpResponse>();
response.SetupProperty<long?>(o => o.ContentLength);
response.SetupGet(r => r.Body).Returns(memoryStream);
var mockHttpContext = new Mock<HttpContext>();
mockHttpContext.Setup(o => o.Response).Returns(response.Object);
var formatter = new StringOutputFormatter();
var formatterContext = new OutputFormatterContext()
{
Object = null,
DeclaredType = typeof(string),
HttpContext = mockHttpContext.Object,
SelectedEncoding = encoding
};
// Act
await formatter.WriteResponseBodyAsync(formatterContext);
// Assert
Assert.Equal(0, memoryStream.Length);
response.VerifySet(r => r.ContentLength = It.IsAny<long?>(), Times.Never());
}
public void Call_with_HttpMethod_Post_must_write_content_on_request_body()
{
var content = "{" +
"\"id\": \"1\"," +
"\"name\": \"Department\"" +
"}";
string writedString = string.Empty;
var mockMS = new Mock<MemoryStream>();
mockMS.Setup(m => m.CanWrite).Returns(true);
mockMS.Setup(m => m.Write(It.IsAny<byte[]>(), It.IsAny<int>(), It.IsAny<int>())).Callback(
(byte[] b, int i1, int i2) =>
{
writedString = new System.Text.ASCIIEncoding().GetString(b, i1, i2);
});
var mock = new Mock<HttpHelper>("https://www.mystore.com/api/v1");
mock.SetupProperty(m => m.HttpWebRequest.Method);
mock.SetupProperty(m => m.HttpWebRequest.ContentType);
mock.SetupProperty(m => m.HttpWebRequest.Headers, new WebHeaderCollection());
mock.Setup(m => m.HttpWebRequest.GetRequestStream()).Returns(mockMS.Object);
mock.Setup(m => m.HttpWebRequest.GetResponse().GetResponseStream()).Returns(new MemoryStream());
APIClient target = new APIClient(new AuthState
{
AccessToken = "token",
ApiUrl = "https://www.mystore.com/api/v1"
});
target.Call(HttpMethods.POST, "departments", content, mock.Object);
mock.VerifySet(h => h.HttpWebRequest.Method = "POST");
Assert.AreEqual(content, writedString);
}
public void TestConstructor()
{
//Test on defaults of port 25 and
var mock = new Mock<SMTP.ISmtpClient>();
mock.SetupProperty(foo => foo.EnableSsl);
var client = mock.Object;
var credentials = new NetworkCredential("username", "password");
SMTP.GetInstance(client, credentials);
mock.Verify(foo => foo.EnableSsl, Times.Never());
mock = new Mock<SMTP.ISmtpClient>();
mock.SetupProperty(foo => foo.EnableSsl);
client = mock.Object;
credentials = new NetworkCredential("username", "password");
SMTP.GetInstance(client, credentials, port:SMTP.SslPort);
mock.VerifySet(foo => foo.EnableSsl = true);
mock = new Mock<SMTP.ISmtpClient>();
mock.SetupProperty(foo => foo.EnableSsl);
client = mock.Object;
credentials = new NetworkCredential("username", "password");
try
{
SMTP.GetInstance(client, credentials, port: SMTP.TlsPort);
Assert.Fail("should have thrown an unsupported port exception");
}
catch (NotSupportedException ex)
{
Assert.AreEqual("TLS not supported", ex.Message);
}
}
public async Task Given_No_Topic_When_Posting_Then_400_Returned()
{
var mockSubscriptionTrackingService = new Mock<ISubscriptionTrackingService>();
var topics = new TopicName[] {"topic-1", "topic-2", "topic-3"};
var controller = new TopicController(mockSubscriptionTrackingService.Object, topics);
var mockRequest = new Mock<IHttpResourceRequest>();
var requestUri = new UriBuilder
{
Scheme = "http",
Host = "localhost",
Path = "/platibus/topic/"
}.Uri;
mockRequest.Setup(r => r.HttpMethod).Returns("POST");
mockRequest.Setup(r => r.Url).Returns(requestUri);
var mockResponse = new Mock<IHttpResourceResponse>();
var responseOutputStream = new MemoryStream();
var responseEncoding = Encoding.UTF8;
mockResponse.Setup(r => r.ContentEncoding).Returns(responseEncoding);
mockResponse.Setup(r => r.OutputStream).Returns(responseOutputStream);
await controller.Process(mockRequest.Object, mockResponse.Object, Enumerable.Empty<string>());
mockResponse.VerifySet(r => r.StatusCode = 400);
}
public void ConnectRequestCallsReceiveOnConnectionThenSend()
{
var context = new Mock<HttpContextBase>();
var request = new Mock<HttpRequestBase>();
var response = new Mock<HttpResponseBase>();
request.Setup(m => m.Path).Returns("/foo/connect");
request.Setup(m => m["clientId"]).Returns("1");
context.Setup(m => m.Response).Returns(response.Object);
context.Setup(m => m.Request).Returns(request.Object);
var json = new Mock<IJsonStringifier>();
var heartBeat = new Mock<ITransportHeartBeat>();
var transport = new Mock<LongPollingTransport>(context.Object, json.Object, heartBeat.Object) { CallBase = true };
var connection = new Mock<IConnection>();
PersistentResponse persistentResponse = null;
connection.Setup(m => m.ReceiveAsync()).Returns(TaskAsyncHelper.FromResult<PersistentResponse>(persistentResponse));
transport.Object.ProcessRequest(connection.Object)().Wait();
heartBeat.Verify(m => m.AddConnection(transport.Object), Times.Once());
connection.Verify(m => m.ReceiveAsync(), Times.Once());
transport.Verify(m => m.Send(persistentResponse), Times.Once());
response.VerifySet(m => m.ContentType = "application/json");
response.Verify(m => m.Write(It.IsAny<string>()), Times.Once());
json.Verify(m => m.Stringify(persistentResponse), Times.Once());
}
public void Initialize()
{
var context = new Mock<IContextAware>();
var view = new Mock<IFeedbackView>();
{
view.SetupSet(v => v.Model = It.IsAny<FeedbackModel>())
.Verifiable();
}
var parameter = new FeedbackParameter(context.Object);
var container = new Mock<IDependencyInjectionProxy>();
{
container.Setup(c => c.Resolve<IContextAware>())
.Returns(context.Object);
container.Setup(c => c.Resolve<SendFeedbackReportCommand>())
.Returns(new SendFeedbackReportCommand(new Mock<ISendFeedbackReports>().Object));
container.Setup(c => c.Resolve<IBuildReports>())
.Returns(new Mock<IBuildReports>().Object);
}
var presenter = new FeedbackPresenter(container.Object);
((IPresenter)presenter).Initialize(view.Object, parameter);
Assert.AreSame(view.Object, presenter.View);
Assert.AreSame(parameter, presenter.Parameter);
view.VerifySet(v => v.Model = It.IsAny<FeedbackModel>(), Times.Once());
}
public void Initialize()
{
var context = new Mock<IContextAware>();
var view = new Mock<IProjectView>();
{
view.SetupSet(v => v.Model = It.IsAny<ProjectModel>())
.Verifiable();
}
var parameter = new ProjectParameter(context.Object);
var projectLink = new Mock<ILinkToProjects>();
Func<string, IDisposable> func = s => new MockDisposable();
var command = new CloseProjectCommand(projectLink.Object, func);
var container = new Mock<IDependencyInjectionProxy>();
{
container.Setup(c => c.Resolve<IContextAware>())
.Returns(context.Object);
container.Setup(c => c.Resolve<CloseProjectCommand>())
.Returns(command);
}
var presenter = new ProjectPresenter(container.Object);
((IPresenter)presenter).Initialize(view.Object, parameter);
Assert.AreSame(view.Object, presenter.View);
Assert.AreSame(parameter, presenter.Parameter);
view.VerifySet(v => v.Model = It.IsAny<ProjectModel>(), Times.Once());
}
public void Example()
{
var mock = new Mock<IFoo>();
mock.Setup(foo => foo.Name).Returns("bar");
// auto-mocking hierarchies (a.k.a. recursive mocks)
mock.Setup(foo => foo.Bar.Baz.Name).Returns("baz");
// expects an invocation to set the value to "foo"
mock.SetupSet(foo => foo.Name = "foo");
// or verify the setter directly
mock.VerifySet(foo => foo.Name = "foo");
//Setup a property so that it will automatically start tracking its value (also known as Stub):
// start "tracking" sets/gets to this property
mock.SetupProperty(f => f.Name);
// alternatively, provide a default value for the stubbed property
mock.SetupProperty(f => f.Name, "foo");
// Now you can do:
IFoo ifoo = mock.Object;
// Initial value was stored
Assert.AreEqual("foo", ifoo.Name);
// New value set which changes the initial value
ifoo.Name = "bar";
Assert.AreEqual("bar", ifoo.Name);
}
public void MissingHttpStatusText()
{
bool isInvoked = false;
string badHeader = "HTTP/1.1 200\r\nContent-Length: 35\r\nConnection: close\r\nContent-Type: image/gif\r\n\r\n";
byte[] badHeaderData = Encoding.UTF8.GetBytes( badHeader );
Mock<IHttpStreamParserContext> mockContext = new Mock<IHttpStreamParserContext>();
mockContext.Setup(m => m.OnReadResponseHeaderComplete("1.1", It.IsAny<IHttpHeaders>(), 200, ""))
.Callback<string, IHttpHeaders, int, string>(
(s, h, si, st) =>
{
isInvoked = true;
Assert.That(h.Count, Is.EqualTo(3));
Assert.That(h["connection"], Is.EqualTo("close"));
});
ReadHeaderState headerState = new ReadHeaderState( mockContext.Object );
headerState.AcceptData( badHeaderData );
mockContext.VerifySet(m => m.State = It.IsAny<ReadNormalBodyState>());
Assert.IsTrue(isInvoked);
}
public void ValidRequestText()
{
bool isInvoked = false;
string header = "GET / HTTP/1.1\r\nHost: www.yahoo.com\r\n\r\n";
byte[] headerData = Encoding.UTF8.GetBytes(header);
Mock<IHttpStreamParserContext> mockContext = new Mock<IHttpStreamParserContext>();
mockContext.Setup(m => m.OnReadRequestHeaderComplete("1.1", It.IsAny<IHttpHeaders>(), "GET", "/"))
.Callback<string, IHttpHeaders, string, string>(
(s, h, si, st) =>
{
isInvoked = true;
Assert.That(h.Count, Is.EqualTo(1));
Assert.That(h["host"], Is.EqualTo("www.yahoo.com"));
});
ReadHeaderState headerState = new ReadHeaderState(mockContext.Object);
headerState.AcceptData(headerData);
mockContext.VerifySet(m => m.State = It.IsAny<ReadHeaderState>());
Assert.IsTrue(isInvoked);
}
public void should_have_a_http_post_method()
{
var mock = new Mock<ICloudFilesRequest>();
var headers = new WebHeaderCollection();
mock.SetupGet(x => x.Headers).Returns(headers);
setStorageItemInformation.Apply(mock.Object);
mock.VerifySet(x=>x.Method="POST");
}
