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 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 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 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 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 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 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 = "******");
information.VerifySet(x => x.Password = "******");
}
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 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 HtmlTokenDefinitionsPassedToLexer()
{
var mockedLexer = new Mock<ILexer>();
_htmlDefinitions.SetupLexer(mockedLexer.Object);
mockedLexer.VerifySet(x => x.TokenDefinitions = It.IsAny<TokenDefinition[]>());
}
public void DefinitionSetsLexerToIgnoreWhitespace()
{
var mockedLexer = new Mock<ILexer>();
_htmlDefinitions.SetupLexer(mockedLexer.Object);
mockedLexer.VerifySet(x => x.IgnoreWhitespace = true);
}
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 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 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 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 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 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 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<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 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 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 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 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 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 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 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 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 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");
}
public void Can_read_write_property_nullable_with_value()
{
var value = DateTime.Now;
Mock.SetupGet(x => x.Nullable).Returns(value);
Mock.SetupSet(x => x.Nullable = value);
NetTestHelper.RunQml(qmlApplicationEngine,
@"
import QtQuick 2.0
import tests 1.0
DateTimeTestsQml {
id: test
Component.onCompleted: function() {
var v = test.nullable
test.nullable = v
}
}
");
Mock.VerifyGet(x => x.Nullable, Times.Once);
Mock.VerifySet(x => x.Nullable = value);
}
public async Task BackUploadOnUpdate()
{
// Arrange
var account = new Account("test", 80);
await context.AddAsync(account);
await context.SaveChangesAsync();
// Act
account.UpdateAccount("foo");
await new UpdateAccountCommand.Handler(contextAdapterMock.Object,
backupServiceMock.Object,
settingsFacadeMock.Object)
.Handle(new UpdateAccountCommand {
Account = account
}, default);
Account loadedAccount = await context.Accounts.FindAsync(account.Id);
// Assert
backupServiceMock.Verify(x => x.UploadBackupAsync(BackupMode.Automatic), Times.Once);
settingsFacadeMock.VerifySet(x => x.LastDatabaseUpdate = It.IsAny <DateTime>(), Times.Once);
}
public void LocalAndRemoteFilesAreSavedAsEqualIfTheContentIsEqual()
{
var fileInfo = new Mock <IFileInfo>();
var parentDir = Mock.Of <IDirectoryInfo>(d => d.FullName == Path.GetTempPath());
fileInfo.SetupAllProperties();
fileInfo.Setup(f => f.FullName).Returns(this.path);
fileInfo.Setup(f => f.Name).Returns(this.objectName);
fileInfo.Setup(f => f.Directory).Returns(parentDir);
fileInfo.Setup(f => f.Exists).Returns(true);
byte[] content = Encoding.UTF8.GetBytes("content");
fileInfo.SetupStream(content);
byte[] expectedHash = SHA1Managed.Create().ComputeHash(content);
Mock <IDocument> remoteObject = MockOfIDocumentUtil.CreateRemoteDocumentMock(null, this.id, this.objectName, this.parentId, content.Length, content, this.lastChangeToken);
remoteObject.SetupContentStreamHash(expectedHash);
remoteObject.Setup(f => f.LastModificationDate).Returns((DateTime?)this.creationDate);
this.underTest.Solve(fileInfo.Object, remoteObject.Object);
fileInfo.VerifySet(f => f.Uuid = It.Is <Guid?>(uuid => uuid != null && !uuid.Equals(Guid.Empty)), Times.Once());
this.storage.VerifySavedMappedObject(MappedObjectType.File, this.id, this.objectName, this.parentId, this.lastChangeToken, true, this.creationDate, this.creationDate, expectedHash, content.Length);
}
public void AuditController_Resuming_Workflow_Does_Not_Require_Authentication_Given_allowLogIn_Is_False()
{
var request = new Mock <HttpRequestBase>();
var response = new Mock <HttpResponseBase>();
request.SetupGet(x => x.Headers).Returns(
new WebHeaderCollection
{
{ "X-Requested-With", "XMLHttpRequest" },
});
var context = new Mock <HttpContextBase>();
context.SetupGet(x => x.Request).Returns(request.Object);
context.SetupGet(x => x.Response).Returns(response.Object);
var controller = new AuditController();
controller.ControllerContext = new ControllerContext(context.Object, new RouteData(), controller);
controller.TempData.Add("allowLogin", false);
controller.PerformResume(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>());
response.VerifySet(res => res.StatusCode = 401, Times.AtLeastOnce);
Assert.AreEqual(1, controller.TempData.Count);
}
public void TestProcessCommand_IsVerbosePropagation()
{
// Preconditions
Debug.Assert(managerMock != null);
Debug.Assert(outputMock != null);
/* GIVEN */
outputMock.SetupSet(output => output.IsVerbose = true);
var command = new ProcessCommand(managerMock.Object, outputMock.Object);
var options = new ProcessOptions
{
IsVerbose = true,
ConfigPath = "C:/",
InputFile = "C:/"
};
/* WHEN */
command.Execute(options);
/* THEN */
outputMock.VerifySet(output => output.IsVerbose = true);
}
public void AmountProperty()
{
var navigationService = new Mock <INavigationService>();
var editExpense = new Mock <IEditExpense>();
var actual = new AddExpensePageViewModel(navigationService.Object, editExpense.Object);
Assert.NotNull(actual.Amount);
Assert.Equal(0, actual.Amount.Value);
// ViewMode -> Model
actual.Amount.Value = 1;
editExpense.VerifySet(x => x.Amount = 1, Times.Once);
// Model -> ViewModel
editExpense.NotifyPropertyChanged(m => m.Amount, 2);
Assert.Equal(2, actual.Amount.Value);
// Destroy
actual.Destroy();
editExpense.NotifyPropertyChanged(m => m.Amount, 3);
Assert.NotEqual(3, actual.Amount.Value);
}
public void LocationProperty()
{
var navigationService = new Mock <INavigationService>();
var editExpense = new Mock <IEditExpense>();
var actual = new AddExpensePageViewModel(navigationService.Object, editExpense.Object);
Assert.NotNull(actual.Location);
Assert.Null(actual.Location.Value);
// ViewMode -> Model
actual.Location.Value = "SetValue";
editExpense.VerifySet(x => x.Location = "SetValue", Times.Once);
// Model -> ViewModel
editExpense.NotifyPropertyChanged(m => m.Location, "UpdateValue");
Assert.Equal("UpdateValue", actual.Location.Value);
// Destroy
actual.Destroy();
editExpense.NotifyPropertyChanged(m => m.Location, "Destroy");
Assert.NotEqual("Destroy", actual.Location.Value);
}
public void RemoteFileAddedAndExceptionOnModificationDateIsThrown()
{
var fileInfo = new Mock <IFileInfo>();
var cacheFileInfo = this.fsFactory.SetupDownloadCacheFile();
var parentDir = Mock.Of <IDirectoryInfo>(d => d.FullName == Path.GetTempPath());
fileInfo.SetupAllProperties();
fileInfo.Setup(f => f.FullName).Returns(this.path);
fileInfo.Setup(f => f.Name).Returns(this.objectName);
fileInfo.Setup(f => f.Directory).Returns(parentDir);
fileInfo.SetupSet(f => f.LastWriteTimeUtc = It.IsAny <DateTime>()).Throws <IOException>();
DateTime modification = DateTime.UtcNow;
fileInfo.SetupGet(f => f.LastWriteTimeUtc).Returns(modification);
byte[] content = Encoding.UTF8.GetBytes("content");
byte[] expectedHash = SHA1Managed.Create().ComputeHash(content);
cacheFileInfo.SetupAllProperties();
cacheFileInfo.Setup(f => f.FullName).Returns(this.path + ".sync");
cacheFileInfo.Setup(f => f.Name).Returns(this.objectName + ".sync");
cacheFileInfo.Setup(f => f.Directory).Returns(parentDir);
cacheFileInfo.Setup(f => f.IsExtendedAttributeAvailable()).Returns(true);
using (var stream = new MemoryStream()) {
cacheFileInfo.Setup(f => f.Open(FileMode.Create, FileAccess.Write, FileShare.Read)).Returns(stream);
this.fsFactory.AddIFileInfo(cacheFileInfo.Object);
Mock <IDocument> remoteObject = MockOfIDocumentUtil.CreateRemoteDocumentMock(null, this.id, this.objectName, this.parentId, content.Length, content, this.lastChangeToken);
remoteObject.Setup(f => f.LastModificationDate).Returns((DateTime?)this.creationDate);
this.underTest.Solve(fileInfo.Object, remoteObject.Object);
cacheFileInfo.Verify(f => f.Open(FileMode.Create, FileAccess.Write, FileShare.Read), Times.Once());
cacheFileInfo.VerifySet(f => f.Uuid = It.Is <Guid?>(uuid => uuid != null && !uuid.Equals(Guid.Empty)), Times.Once());
cacheFileInfo.Verify(f => f.MoveTo(this.path), Times.Once());
fileInfo.VerifySet(d => d.LastWriteTimeUtc = It.Is <DateTime>(date => date.Equals(this.creationDate)), Times.Once());
this.storage.VerifySavedMappedObject(MappedObjectType.File, this.id, this.objectName, this.parentId, this.lastChangeToken, true, modification, this.creationDate, expectedHash, content.Length);
}
}
public void MuteVolumeLevelsMultipleControllers()
{
Semaphore volumeSetLock = new Semaphore(0, 2);
Dictionary <String, String> expectedVals = new Dictionary <string, string>
{
{ "Command", "volume" },
{ "direction", "mute" },
{ "levelNum", "0" },
{ "source", "" },
};
Mock <IVolumeController> controller1 = new Mock <IVolumeController>(MockBehavior.Strict);
controller1.Setup(v => v.IsValid).Returns(true);
controller1.Setup(v => v.Name).Returns("Test Volume Controller");
controller1.SetupGet(v => v.Volume).Returns(0.5);
controller1.SetupSet(v => v.Volume = 0.0).Callback(() => volumeSetLock.Release());
AddComponentToConfigurationManager(controller1.Object);
Mock <IVolumeController> controller2 = new Mock <IVolumeController>(MockBehavior.Strict);
controller2.Setup(v => v.IsValid).Returns(true);
controller2.Setup(v => v.Name).Returns("Test Volume Controller Two");
controller2.SetupGet(v => v.Volume).Returns(0.5);
controller2.SetupSet(v => v.Volume = 0.0).Callback(() => volumeSetLock.Release());
AddComponentToConfigurationManager(controller2.Object);
CurrentConversation = new VolumeConversation(GetConfigurationManager(), new List <IOInterfaceReference>
{
new IOInterfaceReference("", "Test Volume Controller", GetConfigurationManager()),
new IOInterfaceReference("", "Test Volume Controller Two", GetConfigurationManager()),
});
Assert.AreEqual("OK", RunSingleConversation <VolumeConversation>(expectedVals));
Assert.IsTrue(volumeSetLock.WaitOne());
Assert.IsTrue(volumeSetLock.WaitOne());
controller1.VerifySet(v => v.Volume = 0.0, Times.Exactly(1));
controller2.VerifySet(v => v.Volume = 0.0, Times.Exactly(1));
}
public void Recall_PerformCommand_PlayerCharacter()
{
Mock <IBaseObjectId> roomId = new Mock <IBaseObjectId>();
Mock <IRoom> room = new Mock <IRoom>();
Mock <IBaseObjectId> recallPoint = new Mock <IBaseObjectId>();
Mock <IRoom> altRoom = new Mock <IRoom>();
Mock <IZone> zone = new Mock <IZone>();
Mock <IWorld> world = new Mock <IWorld>();
Mock <IPlayerCharacter> pc = new Mock <IPlayerCharacter>();
Dictionary <int, IZone> zoneDictioanry = new Dictionary <int, IZone>();
Dictionary <int, IRoom> roomDictioanry = new Dictionary <int, IRoom>();
List <IPlayerCharacter> pcInRoom = new List <IPlayerCharacter>();
List <IPlayerCharacter> pcTargetRoom = new List <IPlayerCharacter>();
pc.Setup(e => e.RecallPoint).Returns(roomId.Object);
pc.Setup(e => e.Room).Returns(room.Object);
pc.Setup(e => e.RecallPoint).Returns(recallPoint.Object);
room.Setup(e => e.Attributes).Returns(new List <RoomAttribute>());
room.Setup(e => e.PlayerCharacters).Returns(pcInRoom);
world.Setup(e => e.Zones).Returns(zoneDictioanry);
zone.Setup(e => e.Rooms).Returns(roomDictioanry);
altRoom.Setup(e => e.PlayerCharacters).Returns(pcTargetRoom);
roomDictioanry.Add(0, altRoom.Object);
zoneDictioanry.Add(0, zone.Object);
pcInRoom.Add(pc.Object);
GlobalReference.GlobalValues.World = world.Object;
IResult result = command.PerformCommand(pc.Object, mockCommand.Object);
Assert.IsTrue(result.ResultSuccess);
Assert.AreEqual("message", result.ResultMessage);
room.Verify(e => e.RemoveMobileObjectFromRoom(pc.Object));
altRoom.Verify(e => e.AddMobileObjectToRoom(pc.Object));
pc.VerifySet(e => e.Room = altRoom.Object);
pc.Verify(e => e.EnqueueCommand("Look"), Times.Once);
}
public async Task ObjectResult_WithMultipleContentTypes_Ignores406Formatter()
{
// Arrange
var objectResult = new ObjectResult(new Person()
{
Name = "John"
});
objectResult.ContentTypes.Add(new MediaTypeHeaderValue("application/foo"));
objectResult.ContentTypes.Add(new MediaTypeHeaderValue("application/json"));
var outputFormatters = new IOutputFormatter[]
{
new HttpNotAcceptableOutputFormatter(),
new JsonOutputFormatter()
};
var response = new Mock <HttpResponse>();
var responseStream = new MemoryStream();
response.SetupGet(r => r.Body).Returns(responseStream);
var expectedData = "{\"Name\":\"John\"}";
var actionContext = CreateMockActionContext(
outputFormatters,
response.Object,
requestAcceptHeader: "application/non-existing",
requestContentType: "application/non-existing");
// Act
await objectResult.ExecuteResultAsync(actionContext);
// Assert
response.VerifySet(r => r.ContentType = "application/json; charset=utf-8");
responseStream.Position = 0;
var actual = new StreamReader(responseStream).ReadToEnd();
Assert.Equal(expectedData, actual);
}
public async Task ValidDeleteRequestToTopicSubscriberResourceRemovesSubscription()
{
var mockSubscriptionTrackingService = new Mock <ISubscriptionTrackingService>();
mockSubscriptionTrackingService.Setup(sts =>
sts.RemoveSubscription(It.IsAny <TopicName>(), It.IsAny <Uri>(),
It.IsAny <CancellationToken>()))
.Returns(Task.FromResult(true));
var topics = new TopicName[] { "topic-1", "topic-2", "topic-3" };
var controller = new TopicController(mockSubscriptionTrackingService.Object, topics);
var mockRequest = new Mock <IHttpResourceRequest>();
var encodedSubscriberUri = new UrlEncoder().Encode("http://example.com/platibus");
var requestUri = new UriBuilder
{
Scheme = "http",
Host = "localhost",
Path = "/platibus/topic/topic-1/subscriber",
Query = string.Format("uri={0}", encodedSubscriberUri)
}.Uri;
mockRequest.Setup(r => r.HttpMethod).Returns("DELETE");
mockRequest.Setup(r => r.Url).Returns(requestUri);
mockRequest.Setup(r => r.QueryString).Returns(new NameValueCollection
{
{ "uri", "http://example.com/platibus" }
});
var mockResponse = new Mock <IHttpResourceResponse>();
await controller.Process(mockRequest.Object, mockResponse.Object, new[] { "topic-1", "subscriber", encodedSubscriberUri });
mockResponse.VerifySet(r => r.StatusCode = 200);
mockSubscriptionTrackingService.Verify(ts => ts.RemoveSubscription(
"topic-1", new Uri("http://example.com/platibus"), It.IsAny <CancellationToken>()));
}
public void DataConvertion_Methods_StringConvertedToITaskObject()
{
// Prepare:
var obj = new XMLDataConverter();
var data = "<task Name=\"TaskName\" Description=\"TaskDescription\" StartDate=\"01.01.2021 00:00:00\" EndDate=\"02.01.2021 00:00:05\" Complete=\"True\" Category=\"TaskCategory\" />";
var taskMock = new Mock <ITask>();
taskMock.SetupAllProperties();
// Execute:
obj.ToObject(taskMock.Object, data);
// Verify:
taskMock.VerifySet(x => x.Name = "TaskName");
taskMock.VerifySet(x => x.Description = "TaskDescription");
taskMock.VerifySet(x => x.StartDate = DateTime.Parse("01.01.2021 00:00:00"));
taskMock.VerifySet(x => x.EndDate = DateTime.Parse("02.01.2021 00:00:05"));
taskMock.VerifySet(x => x.Complete = true);
taskMock.VerifySet(x => x.Category = "TaskCategory");
}
public void Initialize()
{
var context = new Mock <IContextAware>();
var project = new Mock <ILinkToProjects>();
var progress = new Mock <ITrackSteppingProgress>();
var aggregator = new Mock <IEventAggregator>();
var view = new Mock <IDatasetDetailView>();
{
view.SetupSet(v => v.Model = It.IsAny <DatasetDetailModel>())
.Verifiable();
}
var proxy = new Mock <IProxyDataset>();
var dataset = new DatasetFacade(proxy.Object);
var parameter = new DatasetDetailParameter(context.Object, dataset);
var container = new Mock <IDependencyInjectionProxy>();
{
container.Setup(c => c.Resolve <IContextAware>())
.Returns(context.Object);
container.Setup(c => c.Resolve <ILinkToProjects>())
.Returns(project.Object);
container.Setup(c => c.Resolve <ITrackSteppingProgress>())
.Returns(progress.Object);
container.Setup(c => c.Resolve <CloseViewCommand>(It.IsAny <Autofac.Core.Parameter[]>()))
.Returns(new CloseViewCommand(aggregator.Object, "a", parameter));
}
var presenter = new DatasetDetailPresenter(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 <DatasetDetailModel>(), Times.Once());
}
public void UseWithSetsValuesWhenValuesPresent()
{
var windowMock = new Mock <IWindow>();
var settignsStub = new Mock <ISettings>();
settignsStub.Setup(settings => settings.GetDouble(HeightKey)).Returns(Height);
settignsStub.Setup(settings => settings.GetDouble(WidthKey)).Returns(Width);
settignsStub.Setup(settings => settings.GetDouble(TopKey)).Returns(Top);
settignsStub.Setup(settings => settings.GetDouble(LeftKey)).Returns(Left);
settignsStub.Setup(settings => settings.GetBoolean(MaximizedKey)).Returns(true);
WindowPositionSettings.UseWith(windowMock.Object, settignsStub.Object);
windowMock.VerifySet(window => window.WindowStartupLocation = WindowStartupLocation.Manual);
windowMock.VerifySet(window => window.Height = Height);
windowMock.VerifySet(window => window.Width = Width);
windowMock.VerifySet(window => window.Top = Top);
windowMock.VerifySet(window => window.Left = Left);
windowMock.VerifySet(window => window.WindowState = WindowState.Maximized);
}
public async Task CopyFileAsync_ReportProgress()
{
_fileSystem
.Setup(mock => mock.Search("src/a.txt", It.IsAny <ISearchListener>()))
.Callback <string, ISearchListener>((dest, listener) =>
{
listener.OnFile("src/a.txt");
});
_fileSystem
.Setup(mock => mock.Search("src/b.txt", It.IsAny <ISearchListener>()))
.Callback <string, ISearchListener>((dest, listener) =>
{
listener.OnFile("src/b.txt");
});
await _explorer.CopyFilesAsync("dest", new[] { "src/a.txt", "src/b.txt" });
_fileSystem.Verify(mock => mock.Search("src/a.txt", It.IsAny <ISearchListener>()), Times.Once);
_fileSystem.Verify(mock => mock.Search("src/b.txt", It.IsAny <ISearchListener>()), Times.Once);
_fileSystem.Verify(mock => mock.CopyFile(
CheckPath("src/a.txt"),
CheckPath("dest/a.txt")), Times.Once);
_fileSystem.Verify(mock => mock.CopyFile(
CheckPath("src/b.txt"),
CheckPath("dest/b.txt")), Times.Once);
_fileSystem.VerifyNoOtherCalls();
_dialogView.VerifyNoOtherCalls();
_progressController.VerifySet(mock => mock.TotalTaskCount = 2, Times.Once);
_progressController.Verify(mock => mock.Report(It.Is <ILoadingProgress>(progress =>
progress.Message == "src/a.txt")), Times.Once);
_progressController.Verify(mock => mock.Report(It.Is <ILoadingProgress>(progress =>
progress.Message == "src/b.txt")), Times.Once);
_progressController.Verify(mock => mock.Close(), Times.Once);
_progressController.VerifyNoOtherCalls();
}
public void RemoteFolderChanged([Values(true, false)] bool childrenAreIgnored)
{
DateTime creationDate = DateTime.UtcNow;
string folderName = "a";
string path = Path.Combine(Path.GetTempPath(), folderName);
string id = "id";
string parentId = "papa";
string lastChangeToken = "token";
string newChangeToken = "newToken";
var dirInfo = new Mock <IDirectoryInfo>();
dirInfo.Setup(d => d.FullName).Returns(path);
dirInfo.Setup(d => d.Name).Returns(folderName);
dirInfo.Setup(d => d.Parent).Returns(Mock.Of <IDirectoryInfo>());
var mappedObject = new MappedObject(
folderName,
id,
MappedObjectType.Folder,
parentId,
lastChangeToken)
{
Guid = Guid.NewGuid()
};
this.storage.AddMappedFolder(mappedObject);
Mock <IFolder> remoteObject = MockOfIFolderUtil.CreateRemoteFolderMock(id, folderName, path, parentId, newChangeToken, childrenAreIgnored);
remoteObject.Setup(f => f.LastModificationDate).Returns((DateTime?)creationDate);
this.underTest.Solve(dirInfo.Object, remoteObject.Object);
this.storage.VerifySavedMappedObject(MappedObjectType.Folder, id, folderName, parentId, newChangeToken, ignored: childrenAreIgnored);
dirInfo.VerifySet(d => d.LastWriteTimeUtc = It.Is <DateTime>(date => date.Equals(creationDate)), Times.Once());
}
public void BuyWithLevel2Ship()
{
// Arrange
SystemWeaponUpgrade upgrade = this.CreateSystemWeaponUpgrade();
Mock <Ship> shipMock = new Mock <Ship>();
shipMock.Expect(s => s.BaseShip.Level)
.Returns(2).Verifiable();
Weapon currentUpgrade = new Weapon();
currentUpgrade.WeaponId = 2;
// Trade value will be 80
currentUpgrade.BasePrice = 100;
currentUpgrade.CargoCost = 1;
shipMock.Expect(s => s.Weapon)
.Returns(currentUpgrade).Verifiable();
// Cargo space free is 10
shipMock.Expect(s => s.CargoSpaceFree)
.Returns(10).Verifiable();
// Cash on hand is 5000
shipMock.Expect(s => s.Credits)
.Returns(5000).Verifiable();
// Act
upgrade.Buy(shipMock.Object);
// Assert
shipMock.Verify();
// Cost of the upgrade should be (750*2 - 80*2) credits
shipMock.VerifySet(s => s.Credits, 5000 - (750 * 2 - (80 * 2)));
Assert.That(upgrade.Quantity, Is.EqualTo(0), "Should be no upgrades left in the system of this model");
}
public void WillGetAndSetResponseFilterIfHtmlContent()
{
var module = new RequestReduceModule();
var context = new Mock <HttpContextBase>();
var config = new Mock <IRRConfiguration>();
config.Setup(x => x.SpriteVirtualPath).Returns("/Virtual");
context.Setup(x => x.Items.Contains(RequestReduceModule.CONTEXT_KEY)).Returns(false);
context.Setup(x => x.Request.RawUrl).Returns("/content/blah");
context.Setup(x => x.Response.ContentType).Returns("text/html");
context.Setup(x => x.Request.QueryString).Returns(new NameValueCollection());
context.Setup(x => x.Server).Returns(new Mock <HttpServerUtilityBase>().Object);
RRContainer.Current = new Container(x =>
{
x.For <IRRConfiguration>().Use(config.Object);
x.For <AbstractFilter>().Use(new Mock <AbstractFilter>().Object);
});
module.InstallFilter(context.Object);
context.VerifyGet(x => x.Response.Filter, Times.Once());
context.VerifySet(x => x.Response.Filter = It.IsAny <Stream>(), Times.Once());
RRContainer.Current = null;
}
public void IncrementICombatStatisticsContainerParameter_CurrentCombatStatisticsDamageDonePropertyWithCorrectAmount()
{
// Arrange
var damageCommandResolutionHandler = new MockDamageCommandResolutionHandler();
var command = new Mock <ICommand>();
var combatStatisticsContainer = new Mock <ICombatStatisticsContainer>();
var matchingEventName = "Damage";
var expectedIncrementAmount = 42;
command.SetupGet(c => c.EventName).Returns(matchingEventName);
command.SetupGet(c => c.EffectEffectiveAmount).Returns(expectedIncrementAmount);
var currentCombatStatistics = new Mock <ICombatStatistics>();
combatStatisticsContainer.SetupGet(c => c.CurrentCombatStatistics).Returns(currentCombatStatistics.Object);
// Act
damageCommandResolutionHandler.HandleCommand(command.Object, combatStatisticsContainer.Object);
// Assert
currentCombatStatistics.VerifySet(s => s.DamageDone += expectedIncrementAmount, Times.Once);
}
public void TestWebRequestJobPassesFireInstanceIdInTheQueryString()
{
const string testFireInstanceId = "123";
using (WebApp.Start <Startup>(BaseHostingAddress)) // base hosting address
{
// Arrange
var pluginRunner = new WebRequest.WebRequestJob();
_mockJobExecutionContext.SetupGet(p => p.FireInstanceId).Returns(testFireInstanceId);
IJobDetail jobDetail = new JobDetailImpl("jobsettings", typeof(IJob));
jobDetail.JobDataMap.Add("actionType", "http");
jobDetail.JobDataMap.Add("method", "GET");
jobDetail.JobDataMap.Add("contentType", "text/plain");
jobDetail.JobDataMap.Add("uri", BaseHostingAddress + "/testapi/test?JobName=TestJob&FireInstanceId={$FireInstanceId}");
_mockJobExecutionContext.SetupGet(p => p.MergedJobDataMap).Returns(jobDetail.JobDataMap);
// Act
pluginRunner.Execute(_mockJobExecutionContext.Object);
// Assert
_mockJobExecutionContext.VerifySet(p => p.Result = "\"" + testFireInstanceId + "\"", Times.Once);
}
}
public void MyProperties()
{
var mock = new Mock <IFoo>();
mock.Setup(foo => foo.Name).Returns("bar");
mock.Object.Name = "will not be assigned"; //This will not be assigned. The setter doesn't exist
Assert.That(mock.Object.Name, Is.EqualTo("bar"));
mock.Setup(foo => foo.SomeBaz.Name).Returns("hello");
Assert.That(mock.Object.SomeBaz.Name, Is.EqualTo("hello"));
bool setterCalled = false;
mock.SetupSet(foo =>
{
foo.Name = It.IsAny <string>();
}).Callback <string>((value) => setterCalled = true);
mock.Object.Name = "def"; // now the setter exists
mock.VerifySet(foo =>
{
foo.Name = "def";
}, Times.AtLeastOnce); //assert if it is called once
}
public void TestSelectActionParentServerSource()
{
//arrange
var childMock = new Mock <IExplorerItemViewModel>();
var axParentMock = new Mock <IEnvironmentViewModel>();
childMock.SetupGet(it => it.IsResourceChecked).Returns(true);
childMock.SetupGet(it => it.ResourceType).Returns("DbService");
axParentMock.SetupGet(it => it.ResourceType).Returns("ServerSource");
childMock.SetupGet(it => it.Parent).Returns(axParentMock.Object);
axParentMock.Setup(it => it.UnfilteredChildren)
.Returns(new ObservableCollection <IExplorerItemViewModel>()
{
childMock.Object
});
//act
_target.Environments.First().SelectAction(childMock.Object);
//assert
axParentMock.VerifySet(it => it.IsFolderChecked = true);
_deployStatsViewerViewModel.Verify(
it => it.TryCalculate(It.Is <IList <IExplorerTreeItem> >(match => !match.Any())));
}
public void TestProperty()
{
mock.Setup(foo => foo.Name).Returns("bar");
//var name = mock.Object.Name;
// auto-mocking hierarchies (a.k.a. recursive mocks)
mock.Setup(foo => foo.Bar.Baz.Name).Returns("baz");
//var barName = mock.Object.Bar.Baz.Name;
// expects an invocation to set the value to "foo"
mock.SetupSet(foo => foo.Name = "dog");
mock.Object.Name = "dog";
mock.SetupGet(foo => foo.Name);
//name = mock.Object.Name;
mock.VerifyGet(foo => foo.Name);
// or verify the setter directly
mock.VerifySet(foo => foo.Name = "dog");
}
public async Task VerifyThatCreateMultiRelationshipWorks()
{
var viewmodel = new RelationshipBrowserViewModel(this.iteration, this.session.Object, this.thingDialogNavigationService.Object, this.panelNavigationService.Object, null, null);
viewmodel.RelationshipCreator.SelectedRelationshipCreator = viewmodel.RelationshipCreator.MultiRelationshipCreator;
var creator = viewmodel.RelationshipCreator.MultiRelationshipCreator;
var dropinfo = new Mock <IDropInfo>();
dropinfo.Setup(x => x.Payload).Returns(this.elementDefinition1);
dropinfo.SetupProperty(x => x.Effects);
creator.DragOver(dropinfo.Object);
dropinfo.VerifySet(x => x.Effects = DragDropEffects.Copy);
await creator.Drop(dropinfo.Object);
Assert.IsTrue(creator.RelatedThings.Any(x => x.Thing == this.elementDefinition1));
var dropinfo2 = new Mock <IDropInfo>();
dropinfo2.Setup(x => x.Payload).Returns(this.elementDefinition2);
await creator.Drop(dropinfo2.Object);
Assert.AreEqual(2, creator.RelatedThings.Count);
creator.RelatedThings.First().RemoveRelatedThingCommand.Execute(null);
Assert.AreEqual(1, creator.RelatedThings.Count);
Assert.IsTrue(viewmodel.RelationshipCreator.CreateRelationshipCommand.CanExecute(null));
viewmodel.RelationshipCreator.CreateRelationshipCommand.Execute(null);
creator.ReInitializeControl();
Assert.AreEqual(0, creator.RelatedThings.Count);
creator.Dispose();
}
public void Local1ByteFileAddedWithoutExtAttr()
{
this.SetUpMocks(false);
Mock <IFileInfo> fileInfo = new Mock <IFileInfo>();
fileInfo.Setup(f => f.Length).Returns(1);
var fileContent = new byte[1];
var localFileStream = new MemoryStream(fileContent);
byte[] hash = SHA1Managed.Create().ComputeHash(fileContent);
fileInfo.Setup(f => f.Open(FileMode.Open, FileAccess.Read)).Returns(localFileStream);
Mock <IDocument> document;
this.RunSolveFile(this.localObjectName, this.remoteObjectId, this.parentId, lastChangeToken, this.withExtendedAttributes, fileInfo, out document);
this.storage.VerifySavedMappedObject(MappedObjectType.File, this.remoteObjectId, this.localObjectName, this.parentId, lastChangeToken, Times.Exactly(2), this.withExtendedAttributes, null, null, hash, 1);
this.VerifyCreateDocument();
fileInfo.VerifySet(f => f.Uuid = It.IsAny <Guid?>(), Times.Never());
fileInfo.VerifyThatLocalFileObjectLastWriteTimeUtcIsNeverModified();
document.Verify(d => d.SetContentStream(It.IsAny <IContentStream>(), true, true), Times.Once());
document.VerifyUpdateLastModificationDate(fileInfo.Object.LastWriteTimeUtc, true);
}
public void WillNotSetResponseFilterIfFaviconIco()
{
RRContainer.Current = null;
var module = new RequestReduceModule();
var context = new Mock <HttpContextBase>();
var config = new Mock <IRRConfiguration>();
config.Setup(x => x.ResourceVirtualPath).Returns("/Virtual");
context.Setup(x => x.Items.Contains(ResponseFilter.ContextKey)).Returns(false);
context.Setup(x => x.Response.ContentType).Returns("text/html");
context.Setup(x => x.Request.QueryString).Returns(new NameValueCollection());
context.Setup(x => x.Server).Returns(new Mock <HttpServerUtilityBase>().Object);
context.Setup(x => x.Request.Url).Returns(new Uri("http://host/favicon.ico"));
RRContainer.Current = new Container(x =>
{
x.For <IRRConfiguration>().Use(config.Object);
x.For <AbstractFilter>().Use(new Mock <AbstractFilter>().Object);
});
module.InstallFilter(context.Object);
context.VerifySet(x => x.Response.Filter = It.IsAny <Stream>(), Times.Never());
RRContainer.Current = null;
}
public void TestCall()
{
unchecked
{
var sut = new InstructionsetFactory().CreateInstructionset();
var instruction = new Instruction(Opcodes.CALL, new byte[] { 0, 0xcd, 0xab });
var bus = new Mock <IBus>();
var registers = new Mock <IRegisters>();
registers.Setup(r => r.PC).Returns(0xeeee);
registers.Setup(r => r.SP).Returns(0xff00);
var operation = sut[Opcodes.CALL];
operation(instruction, registers.Object, bus.Object);
//store pc to [sp]
bus.Verify(b => b.Write(0xff00, (short)0xeeee));
//inc sp by 2
registers.Verify(r => r.IncrementSP());
//set pc to 0xabcd
registers.VerifySet(r => r.PC = 0xabcd);
}
}
public void StartStreamingTest()
{
var cameraMock = new Mock <IExtendedCamera>();
var proxyFactoryMock = new Mock <IProxyFactory>();
var mediaClientMock = new Mock <Media>();
mediaClientMock.Setup(x => x.GetStreamUriAsync(It.IsAny <StreamSetup>(), It.IsAny <string>()))
.ReturnsAsync(new MediaUri()
{
Uri = "rtsp://test.com"
});
proxyFactoryMock.Setup(x => x.Create <Media, MediaClient>(It.IsAny <Uri>()))
.Returns(() => mediaClientMock.Object);
cameraMock.Setup(x => x.ConnectionUser).Returns(new CameraUser("test", "test"));
var connectedState = new CameraConnectedState(cameraMock.Object, proxyFactoryMock.Object);
connectedState.StartStreaming(new Profile()
{
token = "192.168.0.1"
}, 10);
cameraMock.VerifySet(x => x.StateObject = It.Is <ICameraState>(y => y.GetType() == typeof(CameraStreamingState)));
}
public void Impl_ClientSize_Should_Be_Set_After_Layout_Pass()
{
using (PerspexLocator.EnterScope())
{
RegisterServices();
PerspexLocator.CurrentMutable.Bind <ILayoutManager>().ToConstant(new LayoutManager());
var impl = new Mock <ITopLevelImpl>();
var target = new TestTopLevel(impl.Object)
{
Template = CreateTemplate(),
Content = new TextBlock
{
Width = 321,
Height = 432,
}
};
target.LayoutManager.ExecuteLayoutPass();
impl.VerifySet(x => x.ClientSize = new Size(321, 432));
}
}
