public void post_CallsPopulateRequestParameters() { // Arrange var testBundle = new AddImageRequestTestBundle(); var mockWebRequest = new Mock<IWebRequest>(MockBehavior.Strict); var mockLog = new Mock<ILog>(); testBundle.MockLogProvider.Setup(x => x.GetLogger(It.IsAny<Type>())).Returns(mockLog.Object); testBundle.AddImageRequest.FileBytes = new byte[] {1, 2, 3}; testBundle.AddImageRequest.FileName = "Test.foo"; testBundle.AddImageRequest.RequestUrl = "http://google.com/"; mockWebRequest.SetupSet(x => x.Method = "POST"); mockWebRequest.SetupSet(x => x.ContentType = "application/x-www-form-urlencoded"); mockWebRequest.SetupSet(x => x.ContentLength = 30); mockWebRequest.SetupGet(x => x.Headers).Returns(new WebHeaderCollection()); mockWebRequest.Setup(x => x.GetRequestStream()).Returns(new MemoryStream()); mockWebRequest.Setup(x => x.GetResponse()).Returns(new Mock<IHttpWebResponse>().Object); testBundle.MockWebRequestFactory.Setup(x => x.Create(It.IsAny<string>())).Returns(mockWebRequest.Object); // WebRequestFactory.AddWebRequestMock(mockWebRequest.Object); // Act testBundle.AddImageRequest.Post(); // Assert Assert.AreEqual("http://google.com/image", testBundle.AddImageRequest.RequestUrl); }
public void op_ExecuteResult_ControllerContext() { var response = new Mock<HttpResponseBase>(MockBehavior.Strict); response .SetupSet(x => x.ContentEncoding = Encoding.UTF8) .Verifiable(); response .SetupSet(x => x.ContentType = "application/xml") .Verifiable(); response .Setup(x => x.Write(It.IsAny<string>())) .Verifiable(); var context = new Mock<HttpContextBase>(MockBehavior.Strict); context .SetupGet(x => x.Response) .Returns(response.Object) .Verifiable(); new XmlSerializationResult(123).ExecuteResult(new ControllerContext { HttpContext = context.Object }); response.VerifyAll(); }
public void Should_be_able_prepare_a_query() { const string sql = "select @Id"; var guid = Guid.NewGuid(); var mc = new MappedColumn<Guid>("Id", DbType.Guid); var query = new RawQuery(sql).AddParameterValue(mc, guid); var dataParameterCollection = new Mock<IDataParameterCollection>(); var dataParameterFactory = new Mock<IDbDataParameterFactory>(); dataParameterFactory.Setup(m => m.Create("@Id", DbType.Guid, guid)); var dataSource = new DataSource("data-source", dataParameterFactory.Object); var command = new Mock<IDbCommand>(); dataParameterCollection.Setup(m => m.Add(It.IsAny<IDbDataParameter>())).Verifiable(); command.SetupGet(m => m.Parameters).Returns(dataParameterCollection.Object); command.SetupSet(m => m.CommandText = sql).Verifiable(); command.SetupSet(m => m.CommandType = CommandType.Text).Verifiable(); query.Prepare(dataSource, command.Object); command.VerifyAll(); dataParameterFactory.VerifyAll(); }
public void ExecuteResult() { // Arrange string content = "Some content."; string contentType = "Some content type."; Encoding contentEncoding = Encoding.UTF8; // Arrange expectations Mock<ControllerContext> mockControllerContext = new Mock<ControllerContext>(MockBehavior.Strict); mockControllerContext.SetupSet(c => c.HttpContext.Response.ContentType = contentType).Verifiable(); mockControllerContext.SetupSet(c => c.HttpContext.Response.ContentEncoding = contentEncoding).Verifiable(); mockControllerContext.Setup(c => c.HttpContext.Response.Write(content)).Verifiable(); ContentResult result = new ContentResult { Content = content, ContentType = contentType, ContentEncoding = contentEncoding }; // Act result.ExecuteResult(mockControllerContext.Object); // Assert mockControllerContext.Verify(); }
public void op_ExecuteResult_ControllerContext() { var response = new Mock<HttpResponseBase>(MockBehavior.Strict); response .SetupSet(x => x.ContentEncoding = Encoding.UTF8) .Verifiable(); response .SetupSet(x => x.ContentType = "text/plain") .Verifiable(); response .Setup(x => x.Write(It.IsAny<string>())) .Verifiable(); var context = new Mock<HttpContextBase>(MockBehavior.Strict); context .Setup(x => x.Response) .Returns(response.Object) .Verifiable(); new TextResult("test").ExecuteResult(new ControllerContext { HttpContext = context.Object }); context.VerifyAll(); }
public void op_OnActionExecuting_FilterExecutedContext() { var context = new Mock<HttpContextBase>(MockBehavior.Strict); context .SetupSet(x => x.Response.BufferOutput = true) .Verifiable(); context .SetupSet(x => x.Response.Filter = It.IsAny<WrappedStream>()) .Verifiable(); using (var stream = new MemoryStream()) { context .SetupGet(x => x.Response.Filter) .Returns(stream) .Verifiable(); new ContentMD5Attribute().OnActionExecuting(new ActionExecutingContext { HttpContext = context.Object }); } context.VerifyAll(); }
public void ExecuteResultWithDescription() { // Arrange Mock<ControllerContext> mockControllerContext = new Mock<ControllerContext>(); mockControllerContext.SetupSet(c => c.HttpContext.Response.StatusCode = 666).Verifiable(); mockControllerContext.SetupSet(c => c.HttpContext.Response.StatusDescription = "Foo Bar").Verifiable(); HttpStatusCodeResult result = new HttpStatusCodeResult(666, "Foo Bar"); // Act result.ExecuteResult(mockControllerContext.Object); // Assert mockControllerContext.Verify(); }
protected Mock<IRestClient> GetMockClient(string content) { var response = new Mock<IRestResponse>(MockBehavior.Strict); response.SetupGet(x => x.Content).Returns(content); response.SetupGet(x => x.ResponseUri).Returns(new Uri("http://google.com")); response.SetupGet(x => x.StatusDescription).Returns(""); response.SetupGet(x => x.StatusCode).Returns(HttpStatusCode.OK); var client = new Mock<IRestClient>(MockBehavior.Strict); client.SetupSet(x => x.BaseUrl = It.IsAny<Uri>()); client.SetupSet(x => x.Authenticator = It.IsAny<IAuthenticator>()); client.Setup(x => x.Execute(It.IsAny<IRestRequest>())).Returns(response.Object); return client; }
public void ExecuteResult() { // Arrange Mock<ControllerContext> mockControllerContext = new Mock<ControllerContext>(); mockControllerContext.SetupSet(c => c.HttpContext.Response.StatusCode = 401).Verifiable(); mockControllerContext.SetupSet(c => c.HttpContext.Response.StatusDescription = "Some description").Verifiable(); HttpUnauthorizedResult result = new HttpUnauthorizedResult("Some description"); // Act result.ExecuteResult(mockControllerContext.Object); // Assert mockControllerContext.Verify(); }
public void AddingExceptionShouldStoreExceptionInLoggingEvent() { var loggingEventMock = new Mock<LoggingEvent>(); loggingEventMock.Object.Tags = new List<string>(); var loggingEventBuilder = new LoggingEventBuilder(loggingEventMock.Object); loggingEventMock.SetupSet(x => x.Text = It.Is<string>(v => v == "exceptionmessage")); loggingEventMock.Setup(x => x.Tags.Add(It.Is<string>(v => v == "error"))); loggingEventMock.SetupSet(x => x.Data["MS_Exception"] = It.IsAny<ExceptionInformation>()); loggingEventBuilder.AddException(new Exception("exceptionmessage")); loggingEventMock.VerifyAll(); }
public void RunReturnsFailureIfForceFails() { var urnName = "urn:ccnet:test:otherproject"; var task = new ForceBuild { ProjectName = urnName }; var thisProject = new Project("thisProject", task); var invokerMock = new Mock<IActionInvoker>(MockBehavior.Strict); invokerMock.SetupSet(ai => ai.Server = It.IsAny<Server>()); invokerMock.Setup(ai => ai.Invoke(urnName, It.IsAny<InvokeArguments>())) .Returns(new InvokeResult { ResultCode = RemoteResultCode.FatalError }) .Verifiable(); new Server("test", thisProject) { ActionInvoker = invokerMock.Object }; var contextMock = new Mock<TaskExecutionContext>(MockBehavior.Strict, new TaskExecutionParameters()); contextMock .Setup(c => c.AddEntryToBuildLog("Force build failed for '" + urnName + "' - result code " + RemoteResultCode.FatalError)) .Verifiable(); contextMock.SetupProperty(c => c.CurrentStatus); task.Run(contextMock.Object).Count(); invokerMock.Verify(); contextMock.Verify(); Assert.AreEqual(IntegrationStatus.Failure, contextMock.Object.CurrentStatus); }
public void GetRecommendations_PerformsCorrectRequest() { //Setup UserReqStub request = new UserReqStub("ExternalID", "DevKey", "api.careerbuilder.com", "", ""); //Mock crap RestResponse<List<RecommendJobResult>> response = new RestResponse<List<RecommendJobResult>>(); response.Data = new List<RecommendJobResult>(); var restReq = new Mock<IRestRequest>(); restReq.Setup(x => x.AddParameter("DeveloperKey", "DevKey")); restReq.Setup(x => x.AddParameter("ExternalID", "ExternalID")); restReq.SetupSet(x => x.RootElement = "RecommendJobResults"); var restClient = new Mock<IRestClient>(); restClient.SetupSet(x => x.BaseUrl = "https://api.careerbuilder.com/v1/recommendations/foruser"); restClient.Setup(x => x.Execute<List<RecommendJobResult>>(It.IsAny<IRestRequest>())).Returns(response); request.Request = restReq.Object; request.Client = restClient.Object; //Assert// List<RecommendJobResult> resp = request.GetRecommendations(); restReq.VerifyAll(); restClient.VerifyAll(); }
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 CallApiAsync_ShouldCallOnError_IfRestRequestDoesNotCompleteSuccessfully() { var mockFactory = new Mock<IRestClientFactory>(MockBehavior.Strict); var mockRestClient = new Mock<IRestClient>(MockBehavior.Strict); var mockProcessor = new Mock<IResponseProcessor>(MockBehavior.Strict); var response = new RestResponse<object>(); var exception = new GitHubException(new GitHubResponse(response), ErrorType.NoNetwork); mockFactory.Setup<IRestClient>(f => f.CreateRestClient(It.IsAny<string>())).Returns(mockRestClient.Object); mockRestClient .Setup(c => c.ExecuteAsync<object>(It.IsAny<IRestRequest>(), It.IsAny<Action<RestResponse<object>, RestRequestAsyncHandle>>())) .Returns(_testHandle) .Callback<IRestRequest, Action<RestResponse<object>, RestRequestAsyncHandle>>((r, c) => c(response, _testHandle)); mockRestClient.SetupSet(c => c.Authenticator = It.IsAny<IAuthenticator>()); mockProcessor.Setup(p => p.TryProcessResponseErrors(It.IsAny<IGitHubResponse>(), out exception)) .Returns(true); var client = CreateClient(mockFactory.Object, mockProcessor.Object); var onErrorInvoked = false; client.CallApiAsync<object>(new GitHubRequest("foo", API.v3, NGitHub.Web.Method.GET), o => { }, e => onErrorInvoked = true); Assert.IsTrue(onErrorInvoked); }
public void SafeResetKeyBindings2() { var mock = new Mock<Command>(MockBehavior.Strict); mock.SetupSet(x => x.Bindings = It.IsAny<object>()).Throws(new COMException()).Verifiable(); mock.Object.SafeResetBindings(); mock.Verify(); }
public void ListAll_PerformsCorrectRequest() { //Setup var request = new CategoriesStub("DevKey", "api.careerbuilder.com", "", ""); //Mock crap var response = new RestResponse<List<Category>> {Data = new List<Category>()}; var restReq = new Mock<IRestRequest>(); restReq.Setup(x => x.AddParameter("DeveloperKey", "DevKey")); restReq.Setup(x => x.AddParameter("CountryCode", "NL")); restReq.SetupSet(x => x.RootElement = "Categories"); var restClient = new Mock<IRestClient>(); restClient.SetupSet(x => x.BaseUrl = "https://api.careerbuilder.com/v1/categories"); restClient.Setup(x => x.Execute<List<Category>>(It.IsAny<IRestRequest>())).Returns(response); request.Request = restReq.Object; request.Client = restClient.Object; //Assert List<Category> cats = request.WhereCountryCode(CountryCode.NL).ListAll(); Assert.IsTrue(cats.Count == 0); restReq.VerifyAll(); restClient.VerifyAll(); }
public void RunForcesABuildUsingAProjecName() { var projectName = "otherproject"; var urnName = "urn:ccnet:test:" + projectName; var task = new ForceBuild { ProjectName = projectName }; var thisProject = new Project("thisProject", task); var invokerMock = new Mock<IActionInvoker>(MockBehavior.Strict); invokerMock.SetupSet(ai => ai.Server = It.IsAny<Server>()); invokerMock.Setup(ai => ai.Invoke(urnName, It.IsAny<InvokeArguments>())) .Returns(new InvokeResult { Data = "<Blank xmlns=\"urn:cruisecontrol:common\" />", ResultCode = RemoteResultCode.Success }) .Verifiable(); new Server("test", thisProject) { ActionInvoker = invokerMock.Object }; var contextMock = new Mock<TaskExecutionContext>(MockBehavior.Strict, new TaskExecutionParameters()); contextMock.Setup(c => c.AddEntryToBuildLog("Force build successfully sent to '" + projectName + "'")).Verifiable(); task.Run(contextMock.Object).Count(); invokerMock.Verify(); contextMock.Verify(); }
public TestContext(string path, Dictionary<string, string> query, Dictionary<string, string> form) { ResponseContentType = null; ResponseBuffer = new List<string>(); MockRequest = GetRequestForUrl(path, query, form); MockResponseHeaders = new Mock<IHeaderDictionary>(); MockResponseHeaders.Setup(m => m.Append("X-Content-Type-Options", "nosniff")); var mockResponseBody = new Mock<Stream>(); mockResponseBody.Setup(m => m.Write(It.IsAny<byte[]>(), It.IsAny<int>(), It.IsAny<int>())) .Callback<byte[], int, int>((buffer, offset, count) => ResponseBuffer.Add(Encoding.UTF8.GetString(buffer, offset, count))); MockResponse = new Mock<HttpResponse>(); MockResponse.SetupGet(m => m.Headers).Returns(MockResponseHeaders.Object); MockResponse.SetupGet(m => m.Body).Returns(mockResponseBody.Object); MockResponse.SetupSet(m => m.ContentType = It.IsAny<string>()) .Callback<string>(type => ResponseContentType = type); MockHttpContext = new Mock<HttpContext>(); MockHttpContext.SetupGet(m => m.Response).Returns(MockResponse.Object); MockHttpContext.SetupGet(m => m.Request).Returns(MockRequest.Object); MockHttpContext.SetupGet(m => m.RequestAborted).Returns(CancellationToken.None); MockRequest.SetupGet(m => m.HttpContext).Returns(MockHttpContext.Object); MockResponse.SetupGet(m => m.HttpContext).Returns(MockHttpContext.Object); }
public void GenError() { var handler = new SetV1MessageHandler(); var mock = new Mock<ScalarObject>(new ObjectIdentifier("1.3.6.1.2.1.1.4.0")); mock.Setup(foo => foo.Data).Throws<Exception>(); mock.Setup(foo => foo.MatchGet(new ObjectIdentifier("1.3.6.1.2.1.1.4.0"))).Returns(mock.Object); mock.SetupSet(foo => foo.Data = new OctetString("test")).Throws<Exception>(); var store = new ObjectStore(); store.Add(mock.Object); var context = SnmpContextFactory.Create( new SetRequestMessage( 300, VersionCode.V1, new OctetString("lextm"), new List<Variable> { new Variable(new ObjectIdentifier("1.3.6.1.2.1.1.4.0"), new OctetString("test")) } ), new IPEndPoint(IPAddress.Loopback, 100), new UserRegistry(), null, null); handler.Handle(context, store); var genError = (ResponseMessage)context.Response; Assert.AreEqual(ErrorCode.GenError, genError.ErrorStatus); }
public void TestWritingResponse() { TokenResponse response = new TokenResponse { Body = "body", HttpStatusCode = 200 }; Mock<HttpResponseBase> mckResponse = new Mock<HttpResponseBase>(); mckResponse.SetupSet(x => x.ContentType = "application/json"); mckResponse.SetupSet(x => x.StatusCode = 200); mckResponse.Setup(x => x.Write("body")); TokenResponseWriter writer = new TokenResponseWriter(mckResponse.Object); writer.WriteResponse(response); mckResponse.VerifyAll(); }
public void Retrieve_AddsProperHeaders() { //Setup var site = new TargetSiteMock("10.0.0.1") { SetHost = "api.koolkid.com", SetSecure = true }; site.SetHeaders.Add("ILikeHeaders", "true"); var request = new BlankAppStub("JXXXXXXXXXXXXXXXXXX", "DevKey", "api.careerbuilder.com", "",site); //Mock crap var response = new RestResponse<BlankApplication> {Data = new BlankApplication()}; var restReq = new Mock<IRestRequest>(); restReq.Setup(x => x.AddHeader("Host", "api.koolkid.com")); restReq.Setup(x => x.AddHeader("ILikeHeaders", "true")); restReq.Setup(x => x.AddParameter("DeveloperKey", "DevKey")); restReq.Setup(x => x.AddParameter("JobDID", "JXXXXXXXXXXXXXXXXXX")); restReq.SetupSet(x => x.RootElement = "BlankApplication"); var restClient = new Mock<IRestClient>(); restClient.SetupSet(x => x.BaseUrl = "https://10.0.0.1/v1/application/blank"); restClient.Setup(x => x.Execute<BlankApplication>(It.IsAny<IRestRequest>())).Returns(response); request.Request = restReq.Object; request.Client = restClient.Object; //Assert BlankApplication resp = request.Retrieve(); restReq.VerifyAll(); restClient.VerifyAll(); }
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 ProcessRequest_WithSingleBlogPost_ProducesSitemapWithBlogPostNode() { //arrange var entries = new List<Entry>(); entries.Add(new Entry(PostType.BlogPost) {Id = 123, DateModified = DateTime.ParseExact("2008/01/23", "yyyy/MM/dd", CultureInfo.InvariantCulture)}); var repository = new Mock<ObjectProvider>(); repository.Setup(r => r.GetPostCountsByMonth()).Returns(new List<ArchiveCount>()); repository.Setup( r => r.GetEntries(It.IsAny<int>(), PostType.BlogPost, It.IsAny<PostConfig>(), It.IsAny<bool>())).Returns (entries); repository.Setup( r => r.GetEntries(It.IsAny<int>(), PostType.Story, It.IsAny<PostConfig>(), It.IsAny<bool>())).Returns( new List<Entry>()); repository.Setup(r => r.GetCategories(CategoryType.PostCollection, true)).Returns(new List<LinkCategory>()); var subtextContext = new Mock<ISubtextContext>(); subtextContext.SetupSet(c => c.HttpContext.Response.ContentType, It.IsAny<string>()); StringWriter writer = subtextContext.FakeSitemapHandlerRequest(repository); subtextContext.Setup(c => c.Blog).Returns(new Blog {Host = "localhost"}); var handler = new SiteMapHttpHandler(subtextContext.Object); //act handler.ProcessRequest(); //assert var doc = new XmlDocument(); doc.LoadXml(writer.ToString()); XmlNode entryUrlNode = doc.DocumentElement.ChildNodes[1]; Assert.AreEqual("http://localhost/some-blogpost-with-id-of-123", entryUrlNode.ChildNodes[0].InnerText); Assert.AreEqual("2008-01-23", entryUrlNode.ChildNodes[1].InnerText); }
public void Submit_PerformsCorrectRequest() { //setup var request = new SavedSearchRetrieveRequestStub("DevKey", "api.careerbuilder.com", "", "", 12345); var dummyApp = new SavedSearchRetrieveRequestModel(); //Mock var response = new RestResponse<SavedSearchRetrieveResponseModel> { Data = new SavedSearchRetrieveResponseModel(), ResponseStatus = ResponseStatus.Completed }; var restReq = new Mock<IRestRequest>(); restReq.Setup(x => x.AddParameter("DeveloperKey", dummyApp.DeveloperKey)); restReq.Setup(x => x.AddParameter("ExternalUserID", dummyApp.ExternalUserID)); restReq.Setup(x => x.AddParameter("ExternalID", dummyApp.ExternalID)); var restClient = new Mock<IRestClient>(); restClient.SetupSet(x => x.BaseUrl = "https://api.careerbuilder.com/v1/SavedSearch/retrieve"); restClient.Setup(x => x.Execute<SavedSearchRetrieveResponseModel>(It.IsAny<IRestRequest>())).Returns(response); request.Request = restReq.Object; request.Client = restClient.Object; //Assertions SavedSearchRetrieveResponseModel rest = request.Submit(dummyApp); restReq.VerifyAll(); restClient.VerifyAll(); }
public void Initialize() { var context = new Mock<IContextAware>(); var view = new Mock<IFeedbackView>(); { view.SetupSet(v => v.Model = It.IsAny<FeedbackModel>()) .Verifiable(); } var parameter = new FeedbackParameter(context.Object); var container = new Mock<IDependencyInjectionProxy>(); { container.Setup(c => c.Resolve<IContextAware>()) .Returns(context.Object); container.Setup(c => c.Resolve<SendFeedbackReportCommand>()) .Returns(new SendFeedbackReportCommand(new Mock<ISendFeedbackReports>().Object)); container.Setup(c => c.Resolve<IBuildReports>()) .Returns(new Mock<IBuildReports>().Object); } var presenter = new FeedbackPresenter(container.Object); ((IPresenter)presenter).Initialize(view.Object, parameter); Assert.AreSame(view.Object, presenter.View); Assert.AreSame(parameter, presenter.Parameter); view.VerifySet(v => v.Model = It.IsAny<FeedbackModel>(), Times.Once()); }
public void Initialize() { var context = new Mock<IContextAware>(); var view = new Mock<INotificationView>(); { view.SetupSet(v => v.Model = It.IsAny<NotificationModel>()) .Verifiable(); } var parameter = new NotificationParameter(context.Object); var container = new Mock<IDependencyInjectionProxy>(); { container.Setup(c => c.Resolve<IContextAware>()) .Returns(context.Object); container.Setup(c => c.Resolve<ICollectNotifications>()) .Returns(new Mock<ICollectNotifications>().Object); } var presenter = new NotificationPresenter(container.Object); ((IPresenter)presenter).Initialize(view.Object, parameter); Assert.AreSame(view.Object, presenter.View); Assert.AreSame(parameter, presenter.Parameter); view.VerifySet(v => v.Model = It.IsAny<NotificationModel>(), Times.Once()); }
public void TestLogin() { // Arrange var mock = new Mock<IReviewRepository>(); var pendingMock = new Mock<IPendingRepository>(); var messageMock = new Mock<IMessageRepository>(); mock.Setup (x => x.Reviews).Returns (new List<Review> ().AsQueryable()); pendingMock.Setup (x => x.Reviews).Returns (new List<PendingReview> ().AsQueryable ()); messageMock.Setup (x => x.Items).Returns (new List<Message> ().AsQueryable ()); var context = new Mock<ControllerContext> (); var session = new Mock<HttpSessionStateBase> (); context.Setup (x => x.HttpContext.Session).Returns (session.Object); context.SetupGet (x => x.HttpContext.Session ["logged"]).Returns (false); context.SetupSet (x => x.HttpContext.Session ["logged"] = It.IsAny<bool> ()).Callback ( (string name, object value) => { context.SetupGet (x => x.HttpContext.Session ["logged"]).Returns ((bool)value); }); var controller = new AdminController(mock.Object, pendingMock.Object, messageMock.Object); controller.ControllerContext = context.Object; // Act var resultPassed = controller.Login("111"); var resultFailed = controller.Login ("112"); // Assert Assert.That(resultFailed, Is.TypeOf(typeof(RedirectToRouteResult))); Assert.That(resultPassed, Is.TypeOf(typeof(RedirectToRouteResult))); var resultPassedRedirect = resultPassed as RedirectToRouteResult; var resultFailedRedirect = resultFailed as RedirectToRouteResult; Assert.AreEqual (resultFailedRedirect.RouteValues["action"], "ThrowError"); Assert.AreEqual (resultPassedRedirect.RouteValues["action"], "Index"); }
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 static IFileSystem GetMockFileSystem(string file, Func <string> content) { var fileSystem = new Mock <IFileSystem>(MockBehavior.Strict); var fileBase = new Mock <FileBase>(MockBehavior.Strict); var dirBase = new Mock <DirectoryBase>(MockBehavior.Strict); var dirInfoBase = new Mock <DirectoryInfoBase>(MockBehavior.Strict); var dirInfoFactory = new Mock <IDirectoryInfoFactory>(MockBehavior.Strict); // Setup fileSystem.Setup(f => f.File) .Returns(fileBase.Object); fileSystem.Setup(f => f.Directory) .Returns(dirBase.Object); fileSystem.Setup(f => f.DirectoryInfo) .Returns(dirInfoFactory.Object); fileBase.Setup(f => f.Exists(It.IsAny <string>())) .Returns((string path) => path == file && content() != null); fileBase.Setup(f => f.OpenRead(It.IsAny <string>())) .Returns((string path) => { if (path == file) { return(new MemoryStream(Encoding.UTF8.GetBytes(content()))); } throw new InvalidOperationException("Should not reach here!"); }); fileBase.Setup(f => f.WriteAllText(It.IsAny <string>(), It.IsAny <string>())); fileBase.Setup(f => f.ReadAllText(It.IsAny <string>())) .Returns((string path) => { using (var reader = new StreamReader(fileBase.Object.OpenRead(path))) { return(reader.ReadToEnd()); } }); fileBase.Setup(f => f.ReadAllLines(It.IsAny <string>())) .Returns((string path) => { return(fileBase.Object.ReadAllText(path).Split(new[] { System.Environment.NewLine }, StringSplitOptions.None)); }); dirInfoFactory.Setup(d => d.FromDirectoryName(It.IsAny <string>())) .Returns(dirInfoBase.Object); dirBase.Setup(d => d.Exists(It.IsAny <string>())) .Returns((string path) => path == Path.GetDirectoryName(file)); dirBase.Setup(d => d.GetFiles(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <SearchOption>())) .Returns((string path, string pattern, SearchOption searchOption) => new[] { file }); dirInfoBase.SetupGet(d => d.Exists) .Returns(true); dirInfoBase.SetupSet(d => d.Attributes = FileAttributes.Normal); dirInfoBase.Setup(d => d.GetFileSystemInfos()) .Returns(new FileSystemInfoBase[0]); dirInfoBase.Setup(d => d.Delete()); FileSystemHelpers.Instance = fileSystem.Object; return(fileSystem.Object); }
private void TestGVFSDatabase(Action <GVFSDatabase> testCode, bool throwException = false) { MockFileSystem fileSystem = new MockFileSystem(new MockDirectory("GVFSDatabaseTests", null, null)); Mock <IDbCommand> mockCommand = new Mock <IDbCommand>(MockBehavior.Strict); mockCommand.SetupSet(x => x.CommandText = "PRAGMA journal_mode=WAL;"); mockCommand.SetupSet(x => x.CommandText = "PRAGMA cache_size=-40000;"); mockCommand.SetupSet(x => x.CommandText = "PRAGMA synchronous=NORMAL;"); mockCommand.SetupSet(x => x.CommandText = "PRAGMA user_version;"); mockCommand.Setup(x => x.ExecuteNonQuery()).Returns(1); mockCommand.Setup(x => x.ExecuteScalar()).Returns(1); mockCommand.Setup(x => x.Dispose()); Mock <IDbCommand> mockCommand2 = new Mock <IDbCommand>(MockBehavior.Strict); mockCommand2.SetupSet(x => x.CommandText = "CREATE TABLE IF NOT EXISTS [Placeholder] (path TEXT PRIMARY KEY COLLATE NOCASE, pathType TINYINT NOT NULL, sha char(40) ) WITHOUT ROWID;"); if (throwException) { mockCommand2.Setup(x => x.ExecuteNonQuery()).Throws(new Exception("Error")); } else { mockCommand2.Setup(x => x.ExecuteNonQuery()).Returns(1); } mockCommand2.Setup(x => x.Dispose()); List <Mock <IDbConnection> > mockConnections = new List <Mock <IDbConnection> >(); Mock <IDbConnection> mockConnection = new Mock <IDbConnection>(MockBehavior.Strict); mockConnection.SetupSequence(x => x.CreateCommand()) .Returns(mockCommand.Object) .Returns(mockCommand2.Object); mockConnection.Setup(x => x.Dispose()); mockConnections.Add(mockConnection); Mock <IDbConnectionFactory> mockConnectionFactory = new Mock <IDbConnectionFactory>(MockBehavior.Strict); bool firstConnection = true; string databasePath = Path.Combine("mock:root", ".mockvfsforgit", "databases", "VFSForGit.sqlite"); mockConnectionFactory.Setup(x => x.OpenNewConnection(databasePath)).Returns(() => { if (firstConnection) { firstConnection = false; return(mockConnection.Object); } else { Mock <IDbConnection> newMockConnection = new Mock <IDbConnection>(MockBehavior.Strict); newMockConnection.Setup(x => x.Dispose()); mockConnections.Add(newMockConnection); return(newMockConnection.Object); } }); using (GVFSDatabase database = new GVFSDatabase(fileSystem, "mock:root", mockConnectionFactory.Object, initialPooledConnections: 1)) { testCode?.Invoke(database); } mockCommand.Verify(x => x.Dispose(), Times.Once); mockCommand2.Verify(x => x.Dispose(), Times.Once); mockConnections.ForEach(connection => connection.Verify(x => x.Dispose(), Times.Once)); mockCommand.VerifyAll(); mockCommand2.VerifyAll(); mockConnections.ForEach(connection => connection.VerifyAll()); mockConnectionFactory.VerifyAll(); }
public void TestProfiledDbCommandWithIDbCommand() { var mockCommand = new Mock <IDbCommand>(); var mockDbProfiler = new Mock <IDbProfiler>(); var tags = new TagCollection(new[] { "test" }); var target = new ProfiledDbCommand(mockCommand.Object, mockDbProfiler.Object, tags); // test Cancel() var cancelCalled = false; mockCommand.Setup(cmd => cmd.Cancel()).Callback(() => cancelCalled = true); target.Cancel(); Assert.IsTrue(cancelCalled); // test CommandText var sql = "test sql;"; var sql2 = "test sql 2"; var commandTextSet = false; mockCommand.Setup(cmd => cmd.CommandText).Returns(sql); mockCommand.SetupSet(cmd => cmd.CommandText = It.IsAny <string>()).Callback <string>(a => { Assert.AreEqual(sql2, a); commandTextSet = true; }); Assert.AreEqual(sql, target.CommandText); target.CommandText = sql2; Assert.IsTrue(commandTextSet); // test CommandTimeout var timeout1 = 1; var timeout2 = 2; var commandTimeoutSet = false; mockCommand.Setup(cmd => cmd.CommandTimeout).Returns(timeout1); mockCommand.SetupSet(cmd => cmd.CommandTimeout = It.IsAny <int>()).Callback <int>(a => { Assert.AreEqual(timeout2, a); commandTimeoutSet = true; }); Assert.AreEqual(timeout1, target.CommandTimeout); target.CommandTimeout = timeout2; Assert.IsTrue(commandTimeoutSet); // test CommandType var cmdType1 = CommandType.StoredProcedure; var cmdType2 = CommandType.Text; var commandTypeSet = false; mockCommand.Setup(cmd => cmd.CommandType).Returns(cmdType1); mockCommand.SetupSet(cmd => cmd.CommandType = It.IsAny <CommandType>()).Callback <CommandType>(a => { Assert.AreEqual(cmdType2, a); commandTypeSet = true; }); Assert.AreEqual(cmdType1, target.CommandType); target.CommandType = cmdType2; Assert.IsTrue(commandTypeSet); // test CreateDbParameter() var mockParameter = new Mock <DbParameter>(); var parameterName = "p1"; mockParameter.Setup(p => p.ParameterName).Returns(parameterName); mockCommand.Setup(cmd => cmd.CreateParameter()).Returns(mockParameter.Object); var parameter = target.CreateParameter(); Assert.AreNotEqual(mockParameter.Object, parameter); Assert.AreEqual(parameterName, parameter.ParameterName); // test DbConnection Assert.IsNull(target.Connection); var mockConnection = new Mock <IDbConnection>(); var connStr = "test conn str"; mockConnection.Setup(c => c.ConnectionString).Returns(connStr); mockCommand.Setup(cmd => cmd.Connection).Returns(mockConnection.Object); var connection = target.Connection; Assert.AreNotEqual(mockConnection.Object, connection); Assert.AreEqual(connection, target.Connection); Assert.IsTrue(connection is ProfiledDbConnection); Assert.AreEqual(connStr, connection.ConnectionString); var mockConnection2 = new Mock <DbConnection>(); target.Connection = mockConnection2.Object; Assert.AreEqual(mockConnection2.Object, target.Connection); // test DbParameterCollection Assert.IsNull(target.Parameters); // ReSharper disable HeuristicUnreachableCode var mockParameterCollection = new Mock <IDataParameterCollection>(); mockParameterCollection.Setup(c => c.Count).Returns(1); mockCommand.Setup(cmd => cmd.Parameters).Returns(mockParameterCollection.Object); var parameterCollection = target.Parameters; Assert.IsFalse(ReferenceEquals(mockParameterCollection.Object, parameterCollection)); Assert.AreEqual(parameterCollection, target.Parameters); Assert.AreEqual(mockParameterCollection.Object.Count, parameterCollection.Count); // test DbTransaction Assert.IsNull(target.Transaction); var mockTransaction = new Mock <IDbTransaction>(); var isoLevel = IsolationLevel.Chaos; mockTransaction.Setup(t => t.IsolationLevel).Returns(isoLevel); mockCommand.Setup(cmd => cmd.Transaction).Returns(mockTransaction.Object); var transaction = target.Transaction; Assert.AreNotEqual(mockTransaction.Object, transaction); Assert.AreEqual(transaction, target.Transaction); Assert.IsTrue(transaction is ProfiledDbTransaction); Assert.AreEqual(isoLevel, transaction.IsolationLevel); var mockTransaction2 = new Mock <DbTransaction>(); target.Transaction = mockTransaction2.Object; Assert.AreEqual(mockTransaction2.Object, target.Transaction); //test ExecuteDbDataReader() var mockReader = new Mock <IDataReader>(); mockReader.Setup(r => r.Depth).Returns(1); var executeDbCommandCalled = false; mockDbProfiler.Setup(p => p.ExecuteDbCommand(It.IsAny <DbExecuteType>(), It.IsAny <IDbCommand>(), It.IsAny <Func <IDataReader> >(), It.IsAny <TagCollection>())) .Callback <DbExecuteType, IDbCommand, Func <IDataReader>, IEnumerable <string> >((a, b, c, d) => { Assert.AreEqual(mockCommand.Object, b); Assert.AreEqual(tags.First(), d.First()); c(); executeDbCommandCalled = true; }); var cmdBehavior = CommandBehavior.CloseConnection; mockCommand.Setup(c => c.ExecuteReader(cmdBehavior)).Returns(mockReader.Object); var reader = target.ExecuteReader(cmdBehavior); Assert.IsTrue(executeDbCommandCalled); Assert.AreNotEqual(mockReader.Object, reader); Assert.AreEqual(1, reader.Depth); // test ExecuteNonQuery() executeDbCommandCalled = false; var executeNonQueryCalled = false; var executeNonQueryResult = 1; mockCommand.Setup(c => c.ExecuteNonQuery()).Callback(() => executeNonQueryCalled = true).Returns(executeNonQueryResult); Assert.AreEqual(executeNonQueryResult, target.ExecuteNonQuery()); Assert.IsTrue(executeDbCommandCalled); Assert.IsTrue(executeNonQueryCalled); // test ExecuteScalar() executeDbCommandCalled = false; var executeScalarCalled = false; var executeScalarResult = new object(); mockCommand.Setup(c => c.ExecuteScalar()).Callback(() => executeScalarCalled = true).Returns(executeScalarResult); Assert.AreEqual(executeScalarResult, target.ExecuteScalar()); Assert.IsTrue(executeDbCommandCalled); Assert.IsTrue(executeScalarCalled); // test Prepare() var prepareCalled = false; mockCommand.Setup(c => c.Prepare()).Callback(() => prepareCalled = true); target.Prepare(); Assert.IsTrue(prepareCalled); // test UpdatedRowSource var updateRowSource1 = UpdateRowSource.Both; var updateRowSource2 = UpdateRowSource.FirstReturnedRecord; var updateRowSourceCalled = false; mockCommand.Setup(cmd => cmd.UpdatedRowSource).Returns(updateRowSource1); mockCommand.SetupSet(cmd => cmd.UpdatedRowSource = It.IsAny <UpdateRowSource>()).Callback <UpdateRowSource>(a => { Assert.AreEqual(updateRowSource2, a); updateRowSourceCalled = true; }); Assert.AreEqual(updateRowSource1, target.UpdatedRowSource); target.UpdatedRowSource = updateRowSource2; Assert.IsTrue(updateRowSourceCalled); // ReSharper restore HeuristicUnreachableCode }
public void ApplyProgress_PerkIsLevelCap_PerkDosntLeveledUp() { // ARRANGE var perkScheme = new PerkScheme { Levels = new[] { new PerkLevelSubScheme { MaxValue = 0, Jobs = new[] { new JobSubScheme { Type = JobType.Defeats, Value = 1 } } } } }; var perkJobMock = new Mock <IJob>(); perkJobMock.SetupProperty(x => x.Progress, 1); perkJobMock.SetupGet(x => x.Scheme) .Returns(perkScheme.Levels[0].Jobs[0]); var isComplete = false; perkJobMock.SetupGet(x => x.IsComplete).Returns(() => isComplete); perkJobMock.SetupSet(x => x.IsComplete).Callback(x => isComplete = x); var perkJob = perkJobMock.Object; var progressMock = new Mock <IJobProgress>(); progressMock.Setup(x => x.ApplyToJobs(It.IsAny <IEnumerable <IJob> >())) .Returns(new[] { perkJob }); var progress = progressMock.Object; var perkMock = new Mock <IPerk>(); perkMock.SetupGet(x => x.Scheme) .Returns(perkScheme); perkMock.SetupGet(x => x.CurrentLevel) .Returns(new PerkLevel(0, 0)); var perk = perkMock.Object; var perks = new[] { perk }; var evolutionDataMock = new Mock <IEvolutionData>(); evolutionDataMock.SetupGet(x => x.Perks) .Returns(perks); var evolutionData = evolutionDataMock.Object; var perkResolver = new PerkResolver(); // ACT perkResolver.ApplyProgress(progress, evolutionData); // ASSERT evolutionDataMock.Verify(x => x.PerkLevelUp(It.IsAny <IPerk>()), Times.Never); }
private void SetupViewModel(bool useRealUndoService = false) { _currentScriptVideoFrameNumber = 0; _scriptVideoServiceMock = new Mock <IScriptVideoService>(); _scriptVideoServiceMock.SetupAdd(svs => svs.FrameChanged += It.IsAny <EventHandler <FrameChangedEventArgs> >()); _scriptVideoServiceMock.SetupRemove(svs => svs.FrameChanged -= It.IsAny <EventHandler <FrameChangedEventArgs> >()); _scriptVideoContextMock = new Mock <IScriptVideoContext>(); _scriptVideoContextMock.Setup(svc => svc.HasVideo).Returns(true); _scriptVideoContextMock.SetupGet(svc => svc.FrameNumber).Returns(() => _currentScriptVideoFrameNumber); _scriptVideoContextMock.SetupSet(svc => svc.FrameNumber = It.IsAny <int>()).Callback <int>(value => { int previousFrameNumber = _currentScriptVideoFrameNumber; _currentScriptVideoFrameNumber = value; _scriptVideoServiceMock.Raise(svs => svs.FrameChanged += null, new FrameChangedEventArgs(previousFrameNumber, _currentScriptVideoFrameNumber)); }); _scriptVideoContextMock.Setup(svc => svc.IsVideoPlaying).Returns(false); _scriptVideoContextMock.Setup(svc => svc.VideoFrameCount).Returns(400); _scriptVideoContextMock.Setup(svc => svc.SeekableVideoFrameCount).Returns(399); _scriptVideoContextMock.Setup(svc => svc.VideoFrameSize).Returns(new SizeI(640, 480)); _scriptVideoServiceMock.Setup(svs => svs.GetContextReference()).Returns(_scriptVideoContextMock.Object); _timelineCommands = new TimelineCommands(); _applicationCommands = new ApplicationCommands(); if (useRealUndoService) { _undoService = UndoService.Current; _undoService.Clear(); _undoChangeFactory = new ChangeFactory(); } else { Mock <IUndoService> undoServiceMock; Mock <IChangeFactory> undoChangeFactoryMock; undoServiceMock = new Mock <IUndoService>(); undoServiceMock.Setup(us => us[It.IsAny <object>()]).Returns((object root) => { if (_undoRoot?.Root != root) { _undoRoot = new UndoRoot(root); } return(_undoRoot); }); _undoService = undoServiceMock.Object; undoChangeFactoryMock = new Mock <IChangeFactory>(); _undoChangeFactory = undoChangeFactoryMock.Object; } _clipboardServiceMock = new Mock <IClipboardService>(); _dialogServiceMock = new Mock <IDialogService>(); _timelineSegmentProvidingViewModel = new MockTimelineSegmentProvidingViewModel(GenerateTestSegmentModels(), _scriptVideoServiceMock.Object, _undoService, _undoChangeFactory, _clipboardServiceMock.Object, _applicationCommands); if (useRealUndoService) { _undoRoot = _undoService[_timelineSegmentProvidingViewModel]; } _viewModel = new VideoTimelineViewModel(_scriptVideoServiceMock.Object, _undoService, _undoChangeFactory, _clipboardServiceMock.Object, _dialogServiceMock.Object, _timelineCommands) { TimelineSegmentProvidingViewModel = _timelineSegmentProvidingViewModel }; _scriptVideoContextMock.Object.FrameNumber = 0; }
private void Expect_MainForm_SizeSet() { form.SetupSet(f => f.Size = new Size(1000, 700)).Verifiable(); form.SetupSet(f => f.WindowState = FormWindowState.Normal).Verifiable(); }
public async Task CanProcessCommand() { var domain = "www.certes.com"; var orderLoc = new Uri("http://acme.com/o/1"); var resourceGroup = "resGroup"; var challengeLoc = new Uri("http://acme.com/o/1/c/2"); var authzLoc = new Uri("http://acme.com/o/1/a/1"); var authz = new Authorization { Identifier = new Identifier { Type = IdentifierType.Dns, Value = domain }, Challenges = new[] { new Challenge { Token = "dns-token", Type = ChallengeTypes.Dns01, }, new Challenge { Token = "http-token", Type = ChallengeTypes.Http01, }, } }; var expectedRecordSetId = Guid.NewGuid().ToString(); var expectedRecordSet = new { data = new RecordSetInner(id: expectedRecordSetId) }; var settingsMock = new Mock <IUserSettings>(MockBehavior.Strict); settingsMock.Setup(m => m.GetDefaultServer()).ReturnsAsync(LetsEncryptV2); settingsMock.Setup(m => m.GetAccountKey(LetsEncryptV2)).ReturnsAsync(GetKeyV2()); settingsMock.Setup(m => m.GetAzureSettings()).ReturnsAsync(new AzureSettings { ClientId = "clientId", ClientSecret = "secret", SubscriptionId = Guid.NewGuid().ToString("N"), TenantId = Guid.NewGuid().ToString("N"), }); var challengeMock = new Mock <IChallengeContext>(MockBehavior.Strict); challengeMock.SetupGet(m => m.Location).Returns(challengeLoc); challengeMock.SetupGet(m => m.Type).Returns(ChallengeTypes.Dns01); challengeMock.SetupGet(m => m.Token).Returns(authz.Challenges[0].Token); var authzMock = new Mock <IAuthorizationContext>(MockBehavior.Strict); authzMock.Setup(m => m.Resource()).ReturnsAsync(authz); authzMock.Setup(m => m.Challenges()) .ReturnsAsync(new[] { challengeMock.Object }); var orderMock = new Mock <IOrderContext>(MockBehavior.Strict); orderMock.Setup(m => m.Authorizations()).ReturnsAsync(new[] { authzMock.Object }); var ctxMock = new Mock <IAcmeContext>(MockBehavior.Strict); ctxMock.Setup(m => m.GetDirectory()).ReturnsAsync(MockDirectoryV2); ctxMock.Setup(m => m.Order(orderLoc)).Returns(orderMock.Object); ctxMock.SetupGet(m => m.AccountKey).Returns(GetKeyV2()); var fileMock = new Mock <IFileUtil>(MockBehavior.Strict); var dnsMock = new Mock <IDnsManagementClient>(MockBehavior.Strict); var zonesOpMock = new Mock <IZonesOperations>(MockBehavior.Strict); var recordSetsOpMock = new Mock <IRecordSetsOperations>(MockBehavior.Strict); dnsMock.Setup(m => m.Dispose()); dnsMock.SetupSet(m => m.SubscriptionId); dnsMock.SetupGet(m => m.Zones).Returns(zonesOpMock.Object); dnsMock.SetupGet(m => m.RecordSets).Returns(recordSetsOpMock.Object); zonesOpMock.Setup(m => m.ListWithHttpMessagesAsync(default, default, default))
public void OperatorPending1() { var mode = new Mock <INormalMode>(); mode.SetupGet(x => x.KeyRemapMode).Returns(KeyRemapMode.OperatorPending).Verifiable(); _buffer.SetupGet(x => x.NormalMode).Returns(mode.Object); _buffer.SetupGet(x => x.ModeKind).Returns(ModeKind.Normal); _caret.SetupSet(x => x.CaretDisplay = CaretDisplay.HalfBlock).Verifiable(); _controller.Update(); _caret.Verify(); }
public void TestProfiledDbCommandWithProfiledDbCommand() { var mockCommand = new Mock <DbCommand>(); var mockDbProfiler = new Mock <IDbProfiler>(); var target = new ProfiledDbCommand(mockCommand.Object, mockDbProfiler.Object); // test CreateDbParameter() var mockParameter = new Mock <DbParameter>(); mockCommand.Protected().Setup <DbParameter>("CreateDbParameter").Returns(mockParameter.Object); Assert.AreEqual(mockParameter.Object, target.CreateParameter()); // test DbConnection var mockConnection = new Mock <DbConnection>(); var profiledConnection = new ProfiledDbConnection(mockConnection.Object, mockDbProfiler.Object); mockCommand.Protected().Setup <DbConnection>("DbConnection").Returns(profiledConnection); var connection = target.Connection; Assert.AreEqual(profiledConnection, connection); // test DbParameterCollection var mockParameterCollection = new Mock <DbParameterCollection>(); mockCommand.Protected().Setup <DbParameterCollection>("DbParameterCollection").Returns(mockParameterCollection.Object); var parameterCollection = target.Parameters; Assert.AreEqual(mockParameterCollection.Object, parameterCollection); // test DbTransaction var mockTransaction = new Mock <DbTransaction>(); var profiledTransaction = new ProfiledDbTransaction(mockTransaction.Object, mockDbProfiler.Object); mockCommand.Protected().Setup <DbTransaction>("DbTransaction").Returns(profiledTransaction); var transaction = target.Transaction; Assert.AreEqual(profiledTransaction, transaction); // test DesignTimeVisible var designTimeVisible1 = true; var designTimeVisible2 = false; var designTimeVisibleSet = false; mockCommand.Setup(cmd => cmd.DesignTimeVisible).Returns(designTimeVisible1); mockCommand.SetupSet(cmd => cmd.DesignTimeVisible = It.IsAny <bool>()).Callback <bool>(a => { Assert.AreEqual(designTimeVisible2, a); designTimeVisibleSet = true; }); Assert.AreEqual(designTimeVisible1, target.DesignTimeVisible); target.DesignTimeVisible = designTimeVisible2; Assert.IsTrue(designTimeVisibleSet); // test ExecuteDbDataReader() var mockReader = new Mock <DbDataReader>(); var profiledReader = new ProfiledDbDataReader(mockReader.Object, mockDbProfiler.Object); var cmdBehavior = CommandBehavior.CloseConnection; mockCommand.Protected().Setup <DbDataReader>("ExecuteDbDataReader", cmdBehavior).Returns(profiledReader); var executeDbCommandCalled = false; mockDbProfiler.Setup(p => p.ExecuteDbCommand(It.IsAny <DbExecuteType>(), It.IsAny <IDbCommand>(), It.IsAny <Func <IDataReader> >(), It.IsAny <TagCollection>())) .Callback <DbExecuteType, IDbCommand, Func <IDataReader>, IEnumerable <string> >((a, b, c, d) => { Assert.AreEqual(mockCommand.Object, b); c(); executeDbCommandCalled = true; }); var reader = target.ExecuteReader(cmdBehavior); Assert.IsTrue(executeDbCommandCalled); Assert.AreEqual(profiledReader, reader); // test Dispose() var disposeCalled = false; mockCommand.Protected().Setup("Dispose", true).Callback <bool>(a => disposeCalled = true); target.Dispose(); Assert.IsTrue(disposeCalled); }
public async Task SongController_PostEdit_ShoudReturnRedirectWithViewModel() { //Arrenge int modelId = 0; string modelName = null; decimal modelPrice = 0; double modelDuration = 0; int modelArtistId = 0; Ganre modelGanre = 0; string successMessage = null; int resultModelId = 1; string resultModelName = "TestSong"; decimal resultModelPrice = 2; double resultModelDuration = 3; int resultModelArtistId = 4; Ganre resultModelGanre = Ganre.Disco; var adminSongService = this.GetAdminSongServiceBaseMock(); adminSongService.Setup(s => s.ExistAsync(It.IsAny <int>())) .ReturnsAsync(true); var adminArtistService = this.GetAdminArtistServiceMock(); adminArtistService.Setup(a => a.ExistAsync(It.IsAny <int>())) .ReturnsAsync(true); adminSongService.Setup(s => s.EditAsync( It.IsAny <int>(), It.IsAny <string>(), It.IsAny <decimal>(), It.IsAny <double>(), It.IsAny <int>(), It.IsAny <Ganre>() )) .Callback((int id, string name, decimal price, double duration, int artistId, Ganre ganre) => { modelId = id; modelName = name; modelPrice = price; modelDuration = duration; modelArtistId = artistId; modelGanre = ganre; }) .Returns(Task.CompletedTask); adminSongService .Setup(a => a.IsGanreExist(It.IsAny <int>())) .Returns(true); var tempDate = new Mock <ITempDataDictionary>(); tempDate.SetupSet(t => t[WebConstants.TempDataSuccessMessageKey] = It.IsAny <string>()) .Callback((string key, object message) => successMessage = message as string); var controller = new SongsController(adminArtistService.Object, adminSongService.Object); controller.TempData = tempDate.Object; //Act var result = await controller.Edit(resultModelId, new SongFormViewModel { Name = resultModelName, Price = resultModelPrice, Duration = resultModelDuration, ArtistId = resultModelArtistId, Ganre = resultModelGanre }); //Assert modelId.Should().Be(resultModelId); modelName.Should().Be(resultModelName); modelPrice.Should().Be(resultModelPrice); modelDuration.Should().Be(resultModelDuration); modelArtistId.Should().Be(resultModelArtistId); modelGanre.Should().Be(resultModelGanre); successMessage.Should().Be($" Song {resultModelName} has been edited successfully"); result.Should().BeOfType <RedirectToActionResult>(); result.As <RedirectToActionResult>().ActionName.Should().Be("ListAll"); }
public void PlusRegister2() { _clipboard.SetupSet(x => x.Text = "bar").Verifiable(); _map.GetRegister('+').RegisterValue = RegisterValue.OfString("bar", OperationKind.CharacterWise); _factory.Verify(); }
public async Task RejectsRequestsWithMissingHeaders() { const string twitchNotification = @"{""data"":[{""id"":""f1c2a387-161a-49f9-a165-0f21d7a4e1c4"",""status"":""webhook_callback_verification_pending"",""type"":""channel.follow"",""version"":""1"",""cost"":1,""condition"":{""broadcaster_user_id"":""12826""},""transport"":{""method"":""webhook"",""callback"":""https://example.com/webhooks/callback""},""created_at"":""2019-11-16T10:11:12.123Z""}],""total"":1,""total_cost"":1,""max_total_cost"":10000,""limit"":10000}"; using Stream requestBody = new MemoryStream(System.Text.Encoding.UTF8.GetBytes(twitchNotification)); var missingSignature = new Dictionary <string, StringValues> { { TwitchConstants.EventSubHeaderNames.MessageId, new StringValues("e76c6bd4-55c9-4987-8304-da1588d8988b") }, { TwitchConstants.EventSubHeaderNames.MessageRetry, new StringValues("0") }, { TwitchConstants.EventSubHeaderNames.MessageTimeStamp, new StringValues("2019-11-16T10:11:12.123Z") }, { TwitchConstants.EventSubHeaderNames.MessageType, new StringValues("webhook_callback_verification") }, { TwitchConstants.EventSubHeaderNames.SubscriptionType, new StringValues("channel.follow") }, { TwitchConstants.EventSubHeaderNames.SubscriptionVersion, new StringValues("1") }, }; var missingMessageType = new Dictionary <string, StringValues> { { TwitchConstants.EventSubHeaderNames.MessageId, new StringValues("e76c6bd4-55c9-4987-8304-da1588d8988b") }, { TwitchConstants.EventSubHeaderNames.MessageRetry, new StringValues("0") }, { TwitchConstants.EventSubHeaderNames.MessageSignature, new StringValues("sha256=f56bf6ce06a1adf46fa27831d7d15d") }, { TwitchConstants.EventSubHeaderNames.MessageTimeStamp, new StringValues("2019-11-16T10:11:12.123Z") }, { TwitchConstants.EventSubHeaderNames.SubscriptionType, new StringValues("channel.follow") }, { TwitchConstants.EventSubHeaderNames.SubscriptionVersion, new StringValues("1") }, }; Mock <HttpResponse> httpResponse = new Mock <HttpResponse>(); httpResponse.SetupSet(r => r.StatusCode = 403); Mock <HttpContext> httpContextMoqNoSignature = new Mock <HttpContext>(); httpContextMoqNoSignature.Setup(c => c.Request.Headers) .Returns(new HeaderDictionary(missingSignature)); httpContextMoqNoSignature.Setup(c => c.Request.Body) .Returns(requestBody); httpContextMoqNoSignature.Setup(c => c.Response) .Returns(httpResponse.Object); Mock <HttpContext> httpContextMoqNoMessageType = new Mock <HttpContext>(); httpContextMoqNoMessageType.Setup(c => c.Request.Headers) .Returns(new HeaderDictionary(missingMessageType)); httpContextMoqNoMessageType.Setup(c => c.Request.Body) .Returns(requestBody); httpContextMoqNoMessageType.Setup(c => c.Response) .Returns(httpResponse.Object); Func <EventSubContext, TwitchEventSubEvent, Task> assertingHandler = (context, twitchEvent) => { throw new Exception("Should not reach the handler callback"); }; var eventSubOptions = new EventSubOptions { WebHookSecret = "secret", }; var mockLogger = new Mock <ILogger <EventSubHandler> >(); var eventHandler = new HandlerRegistration <TwitchEventSubEvent>(assertingHandler); var eventSubHandler = new EventSubHandler( new List <IHandlerRegistration> { eventHandler }, new OptionsWrapper <EventSubOptions>(eventSubOptions), mockLogger.Object); await eventSubHandler.HandleRequestAsync(httpContextMoqNoSignature.Object); await eventSubHandler.HandleRequestAsync(httpContextMoqNoMessageType.Object); }
public async Task Invoke_DifferentWorkers_CallAddAsyncForEachOne() { // Arrange var contextWorker1Mock = new Mock <IMessageContext>(); var contextWorker2Mock = new Mock <IMessageContext>(); var consumerContextWorker1Mock = new Mock <IMessageContextConsumer>(); var consumerContextWorker2Mock = new Mock <IMessageContextConsumer>(); var worker1Batch = new Mock <IWorkerBatch>(); var worker2Batch = new Mock <IWorkerBatch>(); var nextMock = new Mock <MiddlewareDelegate>(); contextWorker1Mock .SetupGet(x => x.WorkerId) .Returns(1); contextWorker1Mock .SetupGet(x => x.Consumer) .Returns(consumerContextWorker1Mock.Object); consumerContextWorker1Mock.SetupSet(x => x.ShouldStoreOffset = false); contextWorker2Mock .SetupGet(x => x.WorkerId) .Returns(2); contextWorker2Mock .SetupGet(x => x.Consumer) .Returns(consumerContextWorker2Mock.Object); consumerContextWorker2Mock.SetupSet(x => x.ShouldStoreOffset = false); worker1Batch .Setup(x => x.AddAsync(contextWorker1Mock.Object, nextMock.Object)) .Returns(Task.CompletedTask); worker2Batch .Setup(x => x.AddAsync(contextWorker2Mock.Object, nextMock.Object)) .Returns(Task.CompletedTask); this.workerBatchFactoryMock .SetupSequence(x => x.Create(batchSize, this.batchTimeout, this.logHandlerMock.Object)) .Returns(worker1Batch.Object) .Returns(worker2Batch.Object); // Act await this.target.Invoke(contextWorker1Mock.Object, nextMock.Object); await this.target.Invoke(contextWorker2Mock.Object, nextMock.Object); // Assert this.workerBatchFactoryMock.VerifyAll(); worker1Batch.VerifyAll(); worker2Batch.VerifyAll(); contextWorker1Mock.VerifyAll(); contextWorker2Mock.VerifyAll(); consumerContextWorker1Mock.VerifyAll(); consumerContextWorker2Mock.VerifyAll(); }
public void RemoteDocumentChangedAndSetUuidFailsOnLocalModificationDate() { DateTime creationDate = DateTime.UtcNow; string fileName = "a"; string path = Path.Combine(Path.GetTempPath(), fileName); string id = "id"; string parentId = "papa"; string lastChangeToken = "token"; string newChangeToken = "newToken"; byte[] newContent = Encoding.UTF8.GetBytes("content"); byte[] oldContent = Encoding.UTF8.GetBytes("older content"); long oldContentSize = oldContent.Length; long newContentSize = newContent.Length; byte[] expectedHash = SHA1Managed.Create().ComputeHash(newContent); byte[] oldHash = SHA1Managed.Create().ComputeHash(oldContent); var mappedObject = new MappedObject( fileName, id, MappedObjectType.File, parentId, lastChangeToken, oldContentSize) { Guid = Guid.NewGuid(), LastLocalWriteTimeUtc = new DateTime(0), LastRemoteWriteTimeUtc = new DateTime(0), LastChecksum = oldHash }; using (var oldContentStream = new MemoryStream(oldContent)) using (var stream = new MemoryStream()) { var backupFile = this.fsFactory.AddFile(Path.Combine(Path.GetTempPath(), fileName + ".bak.sync"), false); this.storage.AddMappedFile(mappedObject, path); Mock <IDocument> remoteObject = MockOfIDocumentUtil.CreateRemoteDocumentMock(null, id, fileName, parentId, newContentSize, newContent, newChangeToken); remoteObject.Setup(r => r.LastModificationDate).Returns(creationDate); Mock <IFileInfo> localFile = new Mock <IFileInfo>(); localFile.SetupProperty(f => f.LastWriteTimeUtc, new DateTime(0)); localFile.Setup(f => f.FullName).Returns(path); var cacheFile = this.fsFactory.SetupDownloadCacheFile(localFile.Object); cacheFile.Setup(c => c.Open(FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.None)).Returns(stream); cacheFile.Setup( c => c.Replace(localFile.Object, backupFile.Object, It.IsAny <bool>())).Returns(localFile.Object).Callback( () => backupFile.Setup( b => b.Open(FileMode.Open, FileAccess.Read, FileShare.None)).Returns(oldContentStream)); localFile.SetupSet(l => l.Uuid = It.IsAny <Guid?>()).Throws <RestoreModificationDateException>(); this.underTest.Solve(localFile.Object, remoteObject.Object, remoteContent: ContentChangeType.CHANGED); this.storage.VerifySavedMappedObject(MappedObjectType.File, id, fileName, parentId, newChangeToken, true, creationDate, creationDate, expectedHash, newContent.Length); Assert.That(localFile.Object.LastWriteTimeUtc, Is.EqualTo(creationDate)); cacheFile.Verify(c => c.Replace(localFile.Object, backupFile.Object, true), Times.Once()); backupFile.Verify(b => b.Delete(), Times.Once()); } }
public void SyncAllProjectsOK() { List <Project> fakeProjects = ProjectUtility.GetFakeSimpleProjects(); int index = 0; List <Project> resultToReturn = fakeProjects.GetRange(index, 2); string content = JsonConvert.SerializeObject(resultToReturn, new JsonSerializerSettings { DateTimeZoneHandling = DateTimeZoneHandling.Utc }); string stamp = "stamp" + index + ";projectid=" + index; Mock <HttpWebRequest> mockWebRequest = FakeWebRequest.CreateRequestWithResponse(content, new Dictionary <string, string> { { "SyncTimestamp", stamp } }); mockWebRequest.SetupSet(r => r.Method = "GET").Verifiable(); string lastStamp = stamp; string baseUrl = AproplanApiUtility.BuildRestUrl(mockApi.Object.ApiRootUrl, "projectsync", mockApi.Object.ApiVersion, mockApi.Object.RequesterId); SyncResult <Project> result = syncService.SyncAllProjects(null, (SyncResult <Project> r, ref bool cancel) => { string expectedUrl = baseUrl; if (index > 0) { expectedUrl = baseUrl + "×tamp=" + Uri.EscapeDataString(lastStamp); } Assert.AreEqual(expectedUrl, FakeWebRequest.Instance.UriCalled[FakeWebRequest.Instance.UriCalled.Count - 1].ToString()); Assert.AreEqual(stamp, r.ContinuationToken); Assert.AreEqual(resultToReturn.Count, r.Data.Count); for (var i = 0; i < resultToReturn.Count; i++) { Assert.AreEqual(resultToReturn[i].Id, r.Data[i].Id); } lastStamp = stamp; index += 2; int cpt = fakeProjects.Count - index; resultToReturn = cpt > 0 ? fakeProjects.GetRange(index, cpt < 2 ? 1 : 2) : new List <Project>(); content = JsonConvert.SerializeObject(resultToReturn, new JsonSerializerSettings { DateTimeZoneHandling = DateTimeZoneHandling.Utc }); if (resultToReturn.Count > 0) { stamp = "stamp" + index + ";projectid=" + index; } else { stamp = null; } mockWebRequest = FakeWebRequest.CreateRequestWithResponse(content, new Dictionary <string, string> { { "SyncTimestamp", stamp } }); mockWebRequest.SetupSet(req => req.Method = "GET").Verifiable(); }).GetAwaiter().GetResult(); Assert.AreEqual(4, FakeWebRequest.Instance.UriCalled.Count); Assert.AreEqual(fakeProjects.Count, result.Data.Count); Assert.AreEqual(true, string.IsNullOrEmpty(result.ContinuationToken)); mockWebRequest.Verify(); }
Context MakeContext(string path = "/", string query = "?query=query") { var context = new Context(); var branchesDaoMock = new Mock <IBranchesDao>(); branchesDaoMock.Setup(m => m.GetAllAsync( It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>(), It.IsAny <SortOrder>())) .ReturnsAsync(( string filterName, string filterAddress, string sortKey, SortOrder sortOrder) => { return(context.Branches .Where(b => b.Name.Contains(filterName)) .Where(b => b.Address.Contains(filterAddress)) .Order(sortKey, sortOrder)); }); branchesDaoMock.Setup(m => m.GetByIdAsync(It.IsAny <long>())) .ReturnsAsync((long id) => context.Branches.First(b => b.Id == id)); branchesDaoMock.Setup(m => m.CreateAsync(It.IsAny <Branch>())) .Callback((Branch branch) => { context.Branches.Add(branch); }); branchesDaoMock.Setup(m => m.UpdateAsync(It.IsAny <Branch>(), It.IsAny <Branch>())) .Callback((Branch branch, Branch oldBranch) => { var contextBranch = context.Branches.First(b => b.Id == branch.Id); contextBranch.Name = branch.Name; contextBranch.Address = branch.Address; }); branchesDaoMock.Setup(m => m.DeleteAsync(It.IsAny <long>())) .Callback((long id) => { var branch = context.Branches.First(b => b.Id == id); context.Branches.Remove(branch); }); context.BranchesDao = branchesDaoMock.Object; var httpContextMock = new Mock <HttpContext>(); httpContextMock.Setup(m => m.Request.Path) .Returns(path); httpContextMock.Setup(m => m.Request.QueryString) .Returns(new QueryString(query)); var controllerContext = new ControllerContext { HttpContext = httpContextMock.Object }; context.ControllerContext = controllerContext; var tempDataDictionaryMock = new Mock <ITempDataDictionary>(); tempDataDictionaryMock.Setup(m => m[It.IsAny <string>()]) .Returns((string key) => context.TempData[key]); tempDataDictionaryMock.SetupSet(m => m[It.IsAny <string>()] = It.IsAny <object>()) .Callback((string key, object o) => context.TempData[key] = o); context.TempDataDictionary = tempDataDictionaryMock.Object; return(context); }
public async Task WriteSimpleObject() { SimpleObject obj = new SimpleObject { Boolean = true, Byte = 12, SByte = 13, Int16 = 14, UInt16 = 15, Int32 = 16, UInt32 = 17u, Int64 = 18, UInt64 = 19ul, Single = 20.25f, Double = 22.23, String = "string", DateTime = new DateTime(2014, 02, 21, 19, 0, 0, DateTimeKind.Utc), Enum = EnumTest.Value1 }; const string hexBuffer = "AE67426F6F6C65616EF56553427974650D64427974650C65496E7431360E6655496E7431360F65496E743332106655496E7433321165496E743634126655496E7436341366537472696E6766737472696E676653696E676C65FA41A2000066446F75626C65FB40363AE147AE147B684461746554696D6574323031342D30322D32315431393A30303A30305A64456E756D6656616C756531"; byte[] buffer = hexBuffer.HexToBytes(); MemoryStream body = new MemoryStream(); Mock <HttpResponse> httpResponse = new Mock <HttpResponse>(MockBehavior.Strict); httpResponse.SetupSet(r => r.ContentType = "application/cbor"); httpResponse.Setup(r => r.Body).Returns(body); #if (NETCOREAPP3_0 || NETCOREAPP3_1) Pipe pipe = new Pipe(); httpResponse.Setup(r => r.BodyWriter).Returns(pipe.Writer); #endif Mock <HttpContext> httpContext = new Mock <HttpContext>(MockBehavior.Strict); httpContext.Setup(c => c.Response).Returns(httpResponse.Object); Mock <ModelMetadata> modelMetadata = new Mock <ModelMetadata>( MockBehavior.Strict, ModelMetadataIdentity.ForType(typeof(SimpleObject))); OutputFormatterWriteContext context = new OutputFormatterWriteContext( httpContext.Object, (stream, encoding) => new StreamWriter(stream, encoding), typeof(SimpleObject), obj); IOutputFormatter outputFormatter = new CborOutputFormatter( new CborOptions { EnumFormat = ValueFormat.WriteToString }); Assert.True(outputFormatter.CanWriteResult(context)); await outputFormatter.WriteAsync(context); #if (NETCOREAPP3_0 || NETCOREAPP3_1) await pipe.Reader.CopyToAsync(body); #endif string actualHexBuffer = BitConverter.ToString(body.ToArray()).Replace("-", ""); Assert.Equal(hexBuffer, actualHexBuffer); }
Context MakeContext( string path = "/", string query = "?query=query", int myBranchIndex = 0) { var context = new Context(); var currentUserServiceMock = new Mock <ICurrentUserService>(); currentUserServiceMock.Setup(m => m.GetUserAsync()) .ReturnsAsync(context.LoggedInUser); currentUserServiceMock.Setup(m => m.GetBranchAsync()) .ReturnsAsync(context.Branches[myBranchIndex]); context.CurrentUserService = currentUserServiceMock.Object; var branchesDaoMock = new Mock <IBranchesDao>(); branchesDaoMock.Setup(m => m.GetAllAsync( It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>(), It.IsAny <SortOrder>())) .ReturnsAsync(context.Branches); context.BranchesDao = branchesDaoMock.Object; var mailDaoMock = new Mock <IMailDao>(); mailDaoMock.Setup(m => m.GetAllAsync( It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>(), It.IsAny <long?>(), It.IsAny <string>(), It.IsAny <long?>(), It.IsAny <long?>(), It.IsAny <long?>(), It.IsAny <PostState?>(), It.IsAny <string>(), It.IsAny <SortOrder>() )). ReturnsAsync(( string filterId, string filterPersonFrom, string filterPersonTo, string filterAddressTo, long?filterBranchId, string filterBranchStockAddress, long?filterCarId, long?filterSourceBranchId, long?filterDestinationBranchId, PostState? filterState, string sortKey, SortOrder sortOrder) => { return(context.Mail .Where(p => p.Id.ToString().Contains(filterId)) .Where(p => p.PersonFrom.Contains(filterPersonFrom)) .Where(p => p.PersonTo.Contains(filterPersonTo)) .Where(p => p.DestinationBranchId == filterDestinationBranchId.Value) .Where(p => p.State == filterState.Value) .Order(sortKey, sortOrder)); }); mailDaoMock.Setup(m => m.CreateAsync(It.IsAny <Post>(), It.IsAny <User>())) .Callback((Post post, User user) => { context.Mail.Add(post); }); mailDaoMock.Setup(m => m.DeliverAsync(It.IsAny <long>(), It.IsAny <User>())) .Callback((long postId, User user) => { var post = context.Mail.First(p => p.Id == postId); post.BranchId = null; post.BranchStockAddress = null; post.CarId = null; post.State = PostState.Delivered; }); context.MailDaoMock = mailDaoMock; var httpContextMock = new Mock <HttpContext>(); httpContextMock.Setup(m => m.Request.Path) .Returns(path); httpContextMock.Setup(m => m.Request.QueryString) .Returns(new QueryString(query)); var controllerContext = new ControllerContext { HttpContext = httpContextMock.Object }; context.ControllerContext = controllerContext; var tempDataDictionaryMock = new Mock <ITempDataDictionary>(); var tryGetValueCallback = new Context.TryGetTempDataValueCallback((string key, out object value) => { context.TempData.TryGetValue(key, out value); }); object dummy; tempDataDictionaryMock.Setup(m => m.TryGetValue(It.IsAny <string>(), out dummy)) .Callback(tryGetValueCallback) .Returns(true); tempDataDictionaryMock.SetupSet(m => m[It.IsAny <string>()] = It.IsAny <object>()) .Callback((string key, object o) => context.TempData[key] = o); context.TempDataDictionary = tempDataDictionaryMock.Object; return(context); }
public void WhenThereIsCapture_Move_ReturnsCapturedPiece_IncrementsMoveCounter_AndAddsMoveToMovmentHistory() { var movementHistory = new Mock <IMovementHistory>(MockBehavior.Strict); var promoterMock = new Mock <IPiecePromoter>(MockBehavior.Strict); var castlingMoverMock = new Mock <ICastlingMover>(MockBehavior.Strict); var enPassantMoverMock = new Mock <IEnPassantMover>(MockBehavior.Strict); var movedPieceMock = new Mock <IChessPiece>(MockBehavior.Strict); var otherPieceMock = new Mock <IChessPiece>(MockBehavior.Strict); var capturedPieceMock = new Mock <IChessPiece>(MockBehavior.Strict); var piecePosition = new Position(3, 1); var destination = new Position(3, 3); var chessMove = new ChessMove(piecePosition, destination); movedPieceMock .SetupGet(p => p.Position) .Returns(piecePosition); movedPieceMock .SetupSet(p => p.Position = destination); movedPieceMock .Setup(p => p.IncrementMoveCounter()); otherPieceMock .SetupGet(p => p.Position) .Returns(new Position(1, 1)); capturedPieceMock .SetupGet(p => p.Position) .Returns(destination); var pieces = new List <IChessPiece>() { movedPieceMock.Object, otherPieceMock.Object, capturedPieceMock.Object }; promoterMock .Setup(p => p.PromoteIfPromotionMove(chessMove, pieces)) .Returns(false); castlingMoverMock .Setup(c => c.PerformCastlingIfCastlingMove(chessMove, pieces)) .Returns(false); enPassantMoverMock .Setup(e => e.PerformEnPassantIfApplicable(chessMove, pieces)) .Returns <IChessPiece>(null); movementHistory .Setup(h => h.Add(chessMove.ReturnWithCaptureAsTrue())); var pieceMover = new PieceMover(movementHistory.Object, promoterMock.Object, castlingMoverMock.Object, enPassantMoverMock.Object); var result = pieceMover.Move(chessMove, pieces); Assert.AreEqual(capturedPieceMock.Object, result); movedPieceMock .VerifySet(p => p.Position = destination); movedPieceMock .Verify(p => p.IncrementMoveCounter()); movementHistory .Verify(h => h.Add(chessMove.ReturnWithCaptureAsTrue())); }
private static void TestPollPut(Action <Mock <IObjectFactory <IPoll> >, Poll, Mock <IPoll> > pollFactorySetup, Func <PollController, Poll, Poll> pollControllerInvocation) { var pollModel = EntityCreator.Create <Poll>(_ => _.PollOptions = null); var poll = new Mock <IPoll>(MockBehavior.Strict); poll.SetupSet(_ => _.PollCategoryID = pollModel.PollCategoryID); poll.SetupSet(_ => _.PollQuestion = pollModel.PollQuestion); poll.SetupSet(_ => _.PollImageLink = pollModel.PollImageLink); poll.SetupSet(_ => _.PollMaxAnswers = pollModel.PollMaxAnswers); poll.SetupSet(_ => _.PollMinAnswers = pollModel.PollMinAnswers); poll.SetupSet(_ => _.PollStartDate = pollModel.PollStartDate); poll.SetupSet(_ => _.PollEndDate = pollModel.PollEndDate); poll.SetupSet(_ => _.PollAdminRemovedFlag = pollModel.PollAdminRemovedFlag); poll.SetupSet(_ => _.PollDateRemoved = pollModel.PollDateRemoved); poll.SetupSet(_ => _.PollDeletedFlag = pollModel.PollDeletedFlag); poll.SetupSet(_ => _.PollDeletedDate = pollModel.PollDeletedDate); poll.SetupSet(_ => _.PollDescription = pollModel.PollDescription); poll.SetupGet(_ => _.PollID).Returns(pollModel.PollID); poll.SetupGet(_ => _.UserID).Returns(pollModel.UserID); poll.SetupGet(_ => _.PollCategoryID).Returns(pollModel.PollCategoryID); poll.SetupGet(_ => _.PollQuestion).Returns(pollModel.PollQuestion); poll.SetupGet(_ => _.PollImageLink).Returns(pollModel.PollImageLink); poll.SetupGet(_ => _.PollMaxAnswers).Returns(pollModel.PollMaxAnswers); poll.SetupGet(_ => _.PollMinAnswers).Returns(pollModel.PollMinAnswers); poll.SetupGet(_ => _.PollStartDate).Returns(pollModel.PollStartDate); poll.SetupGet(_ => _.PollEndDate).Returns(pollModel.PollEndDate); poll.SetupGet(_ => _.PollAdminRemovedFlag).Returns(pollModel.PollAdminRemovedFlag); poll.SetupGet(_ => _.PollDateRemoved).Returns(pollModel.PollDateRemoved); poll.SetupGet(_ => _.PollDeletedFlag).Returns(pollModel.PollDeletedFlag); poll.SetupGet(_ => _.PollDeletedDate).Returns(pollModel.PollDeletedDate); poll.SetupGet(_ => _.PollDescription).Returns(pollModel.PollDescription); poll.SetupGet(_ => _.PollOptions).Returns(new BusinessList <IPollOption>()); poll.Setup(_ => _.Save()).Returns(poll.Object); var pollFactory = new Mock <IObjectFactory <IPoll> >(MockBehavior.Strict); pollFactorySetup(pollFactory, pollModel, poll); var auth = new Mock <IMyVoteAuthentication>(MockBehavior.Strict); auth.Setup(_ => _.GetCurrentUserID()).Returns(pollModel.UserID); var controller = new PollController(); controller.PollFactory = new Lazy <IObjectFactory <IPoll> >(() => pollFactory.Object); controller.MyVoteAuthentication = auth.Object; var result = pollControllerInvocation(controller, pollModel); pollFactory.VerifyAll(); poll.Verify(); }
private IFileSystem GetMockFileSystem() { var files = new Dictionary <string, MemoryStream>(); var fs = new Mock <IFileSystem>(MockBehavior.Strict); var fileBase = new Mock <FileBase>(MockBehavior.Strict); var fileInfoFactoryBase = new Mock <IFileInfoFactory>(MockBehavior.Strict); var dirBase = new Mock <DirectoryBase>(MockBehavior.Strict); var dirInfoBase = new Mock <DirectoryInfoBase>(MockBehavior.Strict); // Setup fs.SetupGet(f => f.File) .Returns(() => fileBase.Object); fs.SetupGet(f => f.FileInfo) .Returns(() => fileInfoFactoryBase.Object); fs.SetupGet(f => f.Directory) .Returns(() => dirBase.Object); fileBase.Setup(f => f.Exists(It.IsAny <string>())) .Returns((string path) => files.ContainsKey(path)); fileBase.Setup(f => f.Open(It.IsAny <string>(), FileMode.Append, FileAccess.Write, FileShare.ReadWrite | FileShare.Delete)) .Returns((string path, FileMode fileMode, FileAccess fileAccess, FileShare fileShare) => { MemoryStream stream; if (!files.TryGetValue(path, out stream)) { stream = MockMemoryStream(); files[path] = stream; } return(stream); }); fileBase.Setup(f => f.OpenRead(It.IsAny <string>())) .Returns((string path) => { MemoryStream stream = files[path]; stream.Position = 0; return(stream); }); fileBase.Setup(f => f.Move(It.IsAny <string>(), It.IsAny <string>())) .Callback((string sourceFileName, string destFileName) => { files[destFileName] = files[sourceFileName]; files.Remove(sourceFileName); }); fileInfoFactoryBase.Setup(f => f.FromFileName(It.IsAny <string>())) .Returns((string file) => { var fileInfoBase = new Mock <FileInfoBase>(MockBehavior.Strict); fileInfoBase.SetupGet(f => f.Exists) .Returns(() => files.ContainsKey(file)); fileInfoBase.SetupSet(f => f.Attributes = It.IsAny <FileAttributes>()); fileInfoBase.Setup(f => f.Delete()) .Callback(() => files.Remove(file)); return(fileInfoBase.Object); }); dirBase.Setup(d => d.GetFiles(It.IsAny <string>(), It.IsAny <string>())) .Returns(() => files.Keys.ToArray()); dirBase.Setup(d => d.CreateDirectory(It.IsAny <string>())) .Returns(dirInfoBase.Object); return(fs.Object); }
public void GetSinglePoll() { var generator = new RandomObjectGenerator(); var pollId = generator.Generate <int>(); var userId = generator.Generate <int>(); var pollCategoryID = generator.Generate <int>(); var pollQuestion = generator.Generate <string>(); var pollImageLink = generator.Generate <string>(); var pollMaxAnswers = generator.Generate <short>(); var pollMinAnswers = generator.Generate <short>(); var pollStartDate = generator.Generate <DateTime>(); var pollEndDate = generator.Generate <DateTime>(); var pollAdminRemovedFlag = generator.Generate <bool>(); var pollDateRemoved = generator.Generate <DateTime>(); var pollDeletedFlag = generator.Generate <bool>(); var pollDeletedDate = generator.Generate <DateTime>(); var pollDescription = generator.Generate <string>(); var pollOptionId = generator.Generate <int>(); var optionPosition = generator.Generate <short>(); var optionText = generator.Generate <string>(); var pollOption = new Mock <IPollOption>(MockBehavior.Strict); pollOption.Setup(_ => _.SetParent(It.IsAny <BusinessList <IPollOption> >())); pollOption.SetupGet(_ => _.IsChild).Returns(true); pollOption.SetupGet(_ => _.PollID).Returns(pollId); pollOption.SetupGet(_ => _.PollOptionID).Returns(pollOptionId); pollOption.SetupGet(_ => _.OptionPosition).Returns(optionPosition); pollOption.SetupGet(_ => _.OptionText).Returns(optionText); pollOption.SetupGet(_ => _.EditLevel).Returns(0); pollOption.SetupSet(_ => _.EditLevelAdded = 0); var poll = new Mock <IPoll>(MockBehavior.Strict); poll.SetupGet(_ => _.PollID).Returns(pollId); poll.SetupGet(_ => _.UserID).Returns(userId); poll.SetupGet(_ => _.PollCategoryID).Returns(pollCategoryID); poll.SetupGet(_ => _.PollQuestion).Returns(pollQuestion); poll.SetupGet(_ => _.PollImageLink).Returns(pollImageLink); poll.SetupGet(_ => _.PollMaxAnswers).Returns(pollMaxAnswers); poll.SetupGet(_ => _.PollMinAnswers).Returns(pollMinAnswers); poll.SetupGet(_ => _.PollStartDate).Returns(pollStartDate); poll.SetupGet(_ => _.PollEndDate).Returns(pollEndDate); poll.SetupGet(_ => _.PollAdminRemovedFlag).Returns(pollAdminRemovedFlag); poll.SetupGet(_ => _.PollDateRemoved).Returns(pollDateRemoved); poll.SetupGet(_ => _.PollDeletedFlag).Returns(pollDeletedFlag); poll.SetupGet(_ => _.PollDeletedDate).Returns(pollDeletedDate); poll.SetupGet(_ => _.PollDescription).Returns(pollDescription); poll.SetupGet(_ => _.PollOptions).Returns(new BusinessList <IPollOption> { pollOption.Object }); var pollFactory = new Mock <IObjectFactory <IPoll> >(MockBehavior.Strict); pollFactory.Setup(_ => _.Fetch(pollId)).Returns(poll.Object); var controller = new PollController(); controller.PollFactory = new Lazy <IObjectFactory <IPoll> >(() => pollFactory.Object); var pollResult = controller.Get(pollId); Assert.AreEqual(pollId, pollResult.PollID); Assert.AreEqual(userId, pollResult.UserID); Assert.AreEqual(pollCategoryID, pollResult.PollCategoryID); Assert.AreEqual(pollQuestion, pollResult.PollQuestion); Assert.AreEqual(pollImageLink, pollResult.PollImageLink); Assert.AreEqual(pollMaxAnswers, pollResult.PollMaxAnswers); Assert.AreEqual(pollMinAnswers, pollResult.PollMinAnswers); Assert.AreEqual(pollStartDate, pollResult.PollStartDate); Assert.AreEqual(pollEndDate, pollResult.PollEndDate); Assert.AreEqual(pollAdminRemovedFlag, pollResult.PollAdminRemovedFlag); Assert.AreEqual(pollDateRemoved, pollResult.PollDateRemoved); Assert.AreEqual(pollDeletedFlag, pollResult.PollDeletedFlag); Assert.AreEqual(pollDeletedDate, pollResult.PollDeletedDate); Assert.AreEqual(pollDescription, pollResult.PollDescription); Assert.AreEqual(1, pollResult.PollOptions.Count); var pollOptionResult = pollResult.PollOptions[0]; Assert.AreEqual(pollOptionId, pollOptionResult.PollOptionID); Assert.AreEqual(pollId, pollOptionResult.PollID); Assert.AreEqual(optionPosition, pollOptionResult.OptionPosition); Assert.AreEqual(optionText, pollOptionResult.OptionText); pollFactory.VerifyAll(); pollOption.VerifyAll(); poll.VerifyAll(); }
public void GetPackageDoNotShowUnlistedPackagesForUpdates2() { // Arrange var sourceRepository = new MockPackageRepository() { PackageUtility.CreatePackage("C", "1.0.0", listed: true), PackageUtility.CreatePackage("C", "2.0.0", listed: false), PackageUtility.CreatePackage("C", "2.0.1", listed: true), PackageUtility.CreatePackage("C", "2.0.3.4-alpha", listed: false), PackageUtility.CreatePackage("C", "2.0.3.5-alpha", listed: true), PackageUtility.CreatePackage("C", "2.5.0", listed: false), }; var repositoryFactory = new Mock <IPackageRepositoryFactory>(MockBehavior.Strict); repositoryFactory.Setup(r => r.CreateRepository("NuGet Official Source")).Returns(sourceRepository); var solutionManager = TestUtils.GetSolutionManager(); var localPackages = new IPackage[] { PackageUtility.CreatePackage("C", "1.0.0") }; var localRepository = new Mock <ISharedPackageRepository>(MockBehavior.Strict); localRepository.SetupSet(p => p.PackageSaveMode = PackageSaveModes.Nupkg); localRepository.Setup(p => p.GetPackages()).Returns(localPackages.AsQueryable()).Verifiable(); var packageManager = new VsPackageManager( solutionManager, sourceRepository, new Mock <IFileSystemProvider>().Object, new Mock <IFileSystem>().Object, localRepository.Object, new Mock <IDeleteOnRestartManager>().Object, new VsPackageInstallerEvents()); var mockPackageManagerFactory = new Mock <IVsPackageManagerFactory>(MockBehavior.Strict); mockPackageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(packageManager).Verifiable(); var cmdlet = new GetPackageCommand( repositoryFactory.Object, GetSourceProvider("NuGet Official Source"), solutionManager, mockPackageManagerFactory.Object, new Mock <IHttpClient>().Object, new Mock <IProductUpdateService>().Object); cmdlet.Updates = true; cmdlet.IncludePrerelease = true; cmdlet.AllVersions = true; cmdlet.Source = "NuGet Official Source"; // Act var packages = cmdlet.GetResults <dynamic>(); // Assert localRepository.Verify(); Assert.Equal(2, packages.Count()); AssertPackageResultsEqual(packages.ElementAt(0), new { Id = "C", Version = new SemanticVersion("2.0.1") }); AssertPackageResultsEqual(packages.ElementAt(1), new { Id = "C", Version = new SemanticVersion("2.0.3.5-alpha") }); }
public void ExecuteResult() { // Arrange object data = _jsonData; string contentType = "Some content type."; Encoding contentEncoding = Encoding.UTF8; // Arrange expectations Mock<ControllerContext> mockControllerContext = new Mock<ControllerContext>(MockBehavior.Strict); mockControllerContext.SetupGet(c => c.HttpContext.Request.HttpMethod).Returns("POST").Verifiable(); mockControllerContext.SetupSet(c => c.HttpContext.Response.ContentType = contentType).Verifiable(); mockControllerContext.SetupSet(c => c.HttpContext.Response.ContentEncoding = contentEncoding).Verifiable(); mockControllerContext.Setup(c => c.HttpContext.Response.Write(_jsonSerializedData)).Verifiable(); JsonResult result = new JsonResult { Data = data, ContentType = contentType, ContentEncoding = contentEncoding }; // Act result.ExecuteResult(mockControllerContext.Object); // Assert mockControllerContext.Verify(); }
public void Search_PerformsCorrectRequest() { //Setup JobSearchStub request = new JobSearchStub("DevKey", "api.careerbuilder.com","",""); //Mock crap RestResponse<ResponseJobSearch> response = new RestResponse<ResponseJobSearch>(); response.Data = new ResponseJobSearch(); var restReq = new Mock<IRestRequest>(); restReq.Setup(x => x.AddParameter("DeveloperKey", "DevKey")); restReq.Setup(x => x.AddParameter("CountryCode", "NL")); restReq.SetupSet(x => x.RootElement = "ResponseJobSearch"); var restClient = new Mock<IRestClient>(); restClient.SetupSet(x => x.BaseUrl = "https://api.careerbuilder.com/v1/jobsearch"); restClient.Setup(x => x.Execute<ResponseJobSearch>(It.IsAny<IRestRequest>())).Returns(response); request.Request = restReq.Object; request.Client = restClient.Object; //Assert ResponseJobSearch resp = request.WhereCountryCode(CountryCode.NL).Search(); restReq.Verify(); restClient.VerifyAll(); }