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