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