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());
        }
Beispiel #11
0
        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);
        }
Beispiel #12
0
        public void HtmlTokenDefinitionsPassedToLexer()
        {
            var mockedLexer = new Mock<ILexer>();
            _htmlDefinitions.SetupLexer(mockedLexer.Object);

            mockedLexer.VerifySet(x => x.TokenDefinitions = It.IsAny<TokenDefinition[]>());
        }
Beispiel #13
0
        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");
 }
Beispiel #31
0
        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);
        }
Beispiel #32
0
        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);
        }
Beispiel #35
0
        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);
        }
Beispiel #36
0
        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);
        }
Beispiel #37
0
        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);
        }
Beispiel #38
0
        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);
            }
        }
Beispiel #39
0
        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));
        }
Beispiel #40
0
        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);
        }
Beispiel #41
0
        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>()));
        }
Beispiel #43
0
        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());
        }
Beispiel #45
0
        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);
        }
Beispiel #46
0
        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();
        }
Beispiel #47
0
        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());
        }
Beispiel #48
0
        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;
        }
Beispiel #50
0
        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);
        }
Beispiel #51
0
        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);
            }
        }
Beispiel #52
0
        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
        }
Beispiel #53
0
        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())));
        }
Beispiel #54
0
        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");
        }
Beispiel #55
0
        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();
        }
Beispiel #56
0
        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);
            }
        }
Beispiel #59
0
        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)));
        }
Beispiel #60
0
        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));
            }
        }