public void FunctionsByDefaultAgainstAmbientHttpContext()
{
var accessor = _container.Resolve <IWorkContextAccessor>();
var explicitHttpContext = new StubHttpContext();
var ambientHttpContext = new StubHttpContext();
_httpContextCurrent = ambientHttpContext;
Assert.That(accessor.GetContext(), Is.Null);
Assert.That(accessor.GetContext(ambientHttpContext), Is.Null);
Assert.That(accessor.GetContext(explicitHttpContext), Is.Null);
var scope = accessor.CreateWorkContextScope();
Assert.That(accessor.GetContext(), Is.Not.Null);
Assert.That(accessor.GetContext(ambientHttpContext), Is.Not.Null);
Assert.That(accessor.GetContext(explicitHttpContext), Is.Null);
Assert.That(accessor.GetContext(), Is.SameAs(accessor.GetContext(ambientHttpContext)));
_httpContextCurrent = explicitHttpContext;
Assert.That(accessor.GetContext(), Is.Null);
_httpContextCurrent = ambientHttpContext;
Assert.That(accessor.GetContext(), Is.Not.Null);
scope.Dispose();
Assert.That(accessor.GetContext(), Is.Null);
}
public void Init()
{
var builder = new ContainerBuilder();
builder.RegisterType <DefaultProcessingEngine>().As <IProcessingEngine>();
builder.RegisterModule(new WorkContextModule());
builder.RegisterType <WorkContextAccessor>().As <IWorkContextAccessor>();
builder.RegisterAutoMocking(MockBehavior.Loose);
_container = builder.Build();
_shellContext = new ShellContext {
Descriptor = new ShellDescriptor(),
Settings = new ShellSettings(),
LifetimeScope = _container.BeginLifetimeScope(),
};
var httpContext = new StubHttpContext();
_container.Mock <IShellContextFactory>()
.Setup(x => x.CreateDescribedContext(_shellContext.Settings, _shellContext.Descriptor))
.Returns(_shellContext);
_container.Mock <IHttpContextAccessor>()
.Setup(x => x.Current())
.Returns(httpContext);
}
public void DifferentChildScopesWillNotCollideInTheSameHttpContext()
{
var shell1 = _container.BeginLifetimeScope();
var accessor1 = shell1.Resolve <IWorkContextAccessor>();
var shell2 = _container.BeginLifetimeScope();
var accessor2 = shell2.Resolve <IWorkContextAccessor>();
var httpContext = new StubHttpContext();
Assert.That(accessor1.GetContext(httpContext), Is.Null);
Assert.That(accessor2.GetContext(httpContext), Is.Null);
var scope1 = accessor1.CreateWorkContextScope(httpContext);
Assert.That(accessor1.GetContext(httpContext), Is.Not.Null);
Assert.That(accessor2.GetContext(httpContext), Is.Null);
var scope2 = accessor2.CreateWorkContextScope(httpContext);
Assert.That(accessor1.GetContext(httpContext), Is.Not.Null);
Assert.That(accessor2.GetContext(httpContext), Is.Not.Null);
scope1.Dispose();
Assert.That(accessor1.GetContext(httpContext), Is.Null);
Assert.That(accessor2.GetContext(httpContext), Is.Not.Null);
scope2.Dispose();
Assert.That(accessor1.GetContext(httpContext), Is.Null);
Assert.That(accessor2.GetContext(httpContext), Is.Null);
}
private static ViewContext CompileView(string viewContents)
{
var settings = new SparkSettings();
var container = SparkRubyEngineStarter.CreateContainer(settings);
var viewFolder = new InMemoryViewFolder {
{ string.Format("stub{0}index.spark", Path.DirectorySeparatorChar), viewContents }
};
container.SetServiceBuilder <IViewFolder>(c => viewFolder);
var viewEngine = container.GetService <IViewEngine>();
var httpContext = new StubHttpContext();
var routeData = new RouteData();
routeData.Values.Add("controller", "stub");
routeData.Values.Add("action", "index");
var controller = new StubController();
var controllerContext = new ControllerContext(httpContext, routeData, controller);
var result = viewEngine.FindPartialView(controllerContext, "index", false);
return(new ViewContext(controllerContext, result.View, new ViewDataDictionary(), new TempDataDictionary(), new StringWriter()));
}
public void parameters_still_work()
{
var context = StubHttpContext.Empty();
route.SetValues(context, new string[] { "folder", "folder2", "somebody" });
context.GetRouteData("name").ShouldBe("somebody");
}
public void TheSelectionShouldBe(string Url, out string Selected, [Default("NONE")] out ArgumentExpectation Arguments)
{
var env = StubHttpContext.Empty();
var leaf = _tree.Select(Url);
Selected = leaf.Pattern;
Arguments = new ArgumentExpectation(env);
}
public void Init(ViewRequest viewReq)
{
_viewBag = new Dictionary <string, object>();
_httpCtx = new StubHttpContext();
_ctx = new ViewContext(_httpCtx, _viewBag, new object(), viewReq);
_serviceRegistry = CreateStubServiceRegistry();
_modelProvider = CreateMetadataProvider();
_serviceRegistry._modelMetadataProvider = _modelProvider;
_helperContext = new HelperContext(_ctx, _serviceRegistry);
}
public void get_empty_spread_values_from_nested()
{
var parameter = new Spread(4);
var env = StubHttpContext.Empty();
parameter.SetValues(env, "a/b/c/d".Split('/'));
env.GetSpreadData().Count().ShouldBe(0);
}
public void get_empty_spread_values_from_root()
{
var parameter = new Spread(0);
var env = StubHttpContext.Empty();
parameter.SetValues(env, new string[0]);
env.GetSpreadData().Count().ShouldBe(0);
}
public void set_spread_values_from_0()
{
var parameter = new Spread(0);
var env = StubHttpContext.Empty();
parameter.SetValues(env, "a/b/c/d/e".Split('/'));
env.GetSpreadData().ShouldBe(new[] { "a", "b", "c", "d", "e" });
}
private static ActionExecutedContext BuildContext()
{
var httpContext = new StubHttpContext();
var routeData = new RouteData();
var controllerContext = new ControllerContext(httpContext, routeData, new Mock <ControllerBase>().Object);
var actionDescriptor = new Mock <ActionDescriptor>().Object;
return(new ActionExecutedContext(controllerContext, actionDescriptor, false /*cancelled*/, null /*exception*/));
}
public void DoesNotRegisterAnyOtherRoute(
string controller,
string action,
RouteCollection routes)
{
var url = string.Format("{0}/{1}", controller, action);
var httpContext = new StubHttpContext(new StubHttpRequest(url));
RouteConfig.RegisterRoutes(routes);
var routeData = routes.GetRouteData(httpContext);
Assert.Null(routeData);
}
public void ScopeIsCreatedAndCanBeRetrievedFromHttpContextBase()
{
var accessor = _container.Resolve <IWorkContextAccessor>();
var httpContext = new StubHttpContext();
var workContextScope = accessor.CreateWorkContextScope(httpContext);
Assert.That(workContextScope.WorkContext, Is.Not.Null);
var workContext = accessor.GetContext(httpContext);
Assert.That(workContext, Is.SameAs(workContextScope.WorkContext));
}
public void RegistersHomeIndexRoute(
string url,
RouteCollection routes)
{
var httpContext = new StubHttpContext(new StubHttpRequest(url));
RouteConfig.RegisterRoutes(routes);
var routeData = routes.GetRouteData(httpContext);
var stringComparer = StringComparer.Create(CultureInfo.CurrentCulture, true);
Assert.Equal("Home", (string)routeData.Values["controller"], stringComparer);
Assert.Equal("Index", (string)routeData.Values["action"], stringComparer);
}
public void ContextIsNullAfterDisposingScope()
{
var accessor = _container.Resolve <IWorkContextAccessor>();
var httpContext = new StubHttpContext();
Assert.That(accessor.GetContext(httpContext), Is.Null);
var scope = accessor.CreateWorkContextScope(httpContext);
Assert.That(accessor.GetContext(httpContext), Is.Not.Null);
scope.Dispose();
Assert.That(accessor.GetContext(httpContext), Is.Null);
}
public void NormalExecutionReturnsExpectedObjects()
{
var settings = new ShellSettings {
Name = ShellSettings.DefaultName
};
var descriptor = new ShellDescriptor {
SerialNumber = 6655321
};
var blueprint = new ShellBlueprint();
var shellLifetimeScope = _container.BeginLifetimeScope("shell");
var httpContext = new StubHttpContext();
_container.Mock <IShellDescriptorCache>()
.Setup(x => x.Fetch(ShellSettings.DefaultName))
.Returns(descriptor);
_container.Mock <ICompositionStrategy>()
.Setup(x => x.Compose(settings, descriptor))
.Returns(blueprint);
_container.Mock <IShellContainerFactory>()
.Setup(x => x.CreateContainer(settings, blueprint))
.Returns(shellLifetimeScope);
_container.Mock <IShellDescriptorManager>()
.Setup(x => x.GetShellDescriptor())
.Returns(descriptor);
_container.Mock <IWorkContextEvents>()
.Setup(x => x.Started());
_container.Mock <IHttpContextAccessor>()
.Setup(x => x.Current())
.Returns(httpContext);
_container.Mock <IHttpContextAccessor>()
.Setup(x => x.CreateContext(It.IsAny <ILifetimeScope>()))
.Returns(httpContext);
var factory = _container.Resolve <IShellContextFactory>();
var context = factory.CreateShellContext(settings);
Assert.That(context.Settings, Is.SameAs(settings));
Assert.That(context.Descriptor, Is.SameAs(descriptor));
Assert.That(context.Blueprint, Is.SameAs(blueprint));
Assert.That(context.LifetimeScope, Is.SameAs(shellLifetimeScope));
Assert.That(context.Shell, Is.SameAs(shellLifetimeScope.Resolve <IOrchardShell>()));
}
public void TheResultShouldBe([SelectionValues("GET", "POST", "DELETE", "PUT", "HEAD")] string HttpMethod, string Url, out int Status, out string Body, [Default("NONE")] out ArgumentExpectation Arguments)
{
var context = StubHttpContext.Empty();
context.RelativeUrl(Url);
context.HttpMethod(HttpMethod);
_router.Invoke(context).Wait();
Status = context.Response.StatusCode;
context.Response.Body.Position = 0;
Body = context.Response.Body.ReadAllText();
Arguments = new ArgumentExpectation(context);
}
public void round_trip_writing_and_parsing()
{
var form1 = new Dictionary <string, string>
{
["a"] = "what?",
["b"] = "now?",
["c"] = "really?"
};
var context = new StubHttpContext(null, null);
context.WriteFormData(form1);
context.Request.Body.ReadAllText()
.ShouldBe("a=what?&b=now?&c=really?");
}
private static RequestContext GetRequestContext(IWorkContextAccessor workContextAccessor)
{
var handler = new MvcRouteHandler();
var route = new Route("yadda", handler)
{
DataTokens =
new RouteValueDictionary {
{ "IWorkContextAccessor", workContextAccessor }
}
};
var httpContext = new StubHttpContext();
var routeData = route.GetRouteData(httpContext);
return(new RequestContext(httpContext, routeData));
}
public void DifferentHttpContextWillHoldDifferentWorkContext()
{
var accessor = _container.Resolve <IWorkContextAccessor>();
var httpContext1 = new StubHttpContext();
var workContextScope1 = accessor.CreateWorkContextScope(httpContext1);
var workContext1 = accessor.GetContext(httpContext1);
var httpContext2 = new StubHttpContext();
var workContextScope2 = accessor.CreateWorkContextScope(httpContext2);
var workContext2 = accessor.GetContext(httpContext2);
Assert.That(workContext1, Is.Not.Null);
Assert.That(workContext1, Is.SameAs(workContextScope1.WorkContext));
Assert.That(workContext2, Is.Not.Null);
Assert.That(workContext2, Is.SameAs(workContextScope2.WorkContext));
Assert.That(workContext1, Is.Not.SameAs(workContext2));
}
public void MatchingRouteToActiveShellTableWillLimitTheAbilityToMatchRoutes()
{
var routeFoo = new Route("foo", new MvcRouteHandler());
_settingsA.RequestUrlHost = "a.example.com";
_containerA.Resolve <IRoutePublisher>().Publish(
new[] { new RouteDescriptor {
Priority = 0, Route = routeFoo
} });
_rootContainer.Resolve <IRunningShellTable>().Add(_settingsA);
_settingsB.RequestUrlHost = "b.example.com";
_containerB.Resolve <IRoutePublisher>().Publish(
new[] { new RouteDescriptor {
Priority = 0, Route = routeFoo
} });
_rootContainer.Resolve <IRunningShellTable>().Add(_settingsB);
var httpContext = new StubHttpContext("~/foo");
var routeData = _routes.GetRouteData(httpContext);
Assert.That(routeData, Is.Null);
var httpContextA = new StubHttpContext("~/foo", "a.example.com");
var routeDataA = _routes.GetRouteData(httpContextA);
Assert.That(routeDataA, Is.Not.Null);
Assert.That(routeDataA.DataTokens.ContainsKey("IWorkContextAccessor"), Is.True);
var workContextAccessorA = (IWorkContextAccessor)routeDataA.DataTokens["IWorkContextAccessor"];
var workContextScopeA = workContextAccessorA.CreateWorkContextScope(httpContextA);
Assert.That(workContextScopeA.Resolve <IRoutePublisher>(), Is.SameAs(_containerA.Resolve <IRoutePublisher>()));
Assert.That(workContextScopeA.Resolve <IRoutePublisher>(), Is.Not.SameAs(_containerB.Resolve <IRoutePublisher>()));
var httpContextB = new StubHttpContext("~/foo", "b.example.com");
var routeDataB = _routes.GetRouteData(httpContextB);
Assert.That(routeDataB, Is.Not.Null);
Assert.That(routeDataB.DataTokens.ContainsKey("IWorkContextAccessor"), Is.True);
var workContextAccessorB = (IWorkContextAccessor)routeDataB.DataTokens["IWorkContextAccessor"];
var workContextScopeB = workContextAccessorB.CreateWorkContextScope(httpContextB);
Assert.That(workContextScopeB.Resolve <IRoutePublisher>(), Is.SameAs(_containerB.Resolve <IRoutePublisher>()));
Assert.That(workContextScopeB.Resolve <IRoutePublisher>(), Is.Not.SameAs(_containerA.Resolve <IRoutePublisher>()));
}
public void RegistersCorrectBuildRoute(
string s1,
string s2,
string s3,
RouteCollection routes)
{
var url = string.Format("~/api/{0}/{1}/{2}", s1, s2, s3);
var httpContext = new StubHttpContext(new StubHttpRequest(url));
RouteConfig.RegisterRoutes(routes);
var routeData = routes.GetRouteData(httpContext);
Assert.Equal("TfsBuilder", routeData.Values["controller"]);
Assert.Equal("Build", routeData.Values["action"]);
Assert.Equal(s1, routeData.Values["account"]);
Assert.Equal(s2, routeData.Values["teamProject"]);
Assert.Equal(s3, routeData.Values["definitionName"]);
}
public void setup_before_each_test()
{
IHeaderDictionary headers = new HeaderDictionary(new Dictionary <string, StringValues> {
{ "User-Agent", new StringValues("my-user-agent") }
});
var httpRequest = new StubHttpRequest(headers)
{
Method = "GET", Path = "/ping", QueryString = new QueryString("?v=1")
};
var httpResponse = new StubHttpResponse {
StatusCode = 23
};
_httpContext = new StubHttpContext(httpRequest, httpResponse);
_logger = new StubLogger <JsonLoggingHttpServerEventCallback>();
_testSubject = new JsonLoggingHttpServerEventCallback(_logger);
}
public static ScenarioAssertionException Run(IScenarioAssertion assertion,
Action <HttpContext> configuration)
{
var ex = new ScenarioAssertionException();
var context = StubHttpContext.Empty();
configuration(context);
var stream = context.Response.Body;
stream.Position = 0;
assertion.Assert(null, context, ex);
return(ex);
}
public void can_parse_xml()
{
var context = StubHttpContext.Empty();
var serializer = new XmlSerializer(typeof(MyMessage));
serializer.Serialize(context.Response.Body, new MyMessage {
Age = 3, Name = "Declan"
});
context.Response.Body.Position = 0;
var body = new HttpResponseBody(null, context);
var message = body.ReadAsXml <MyMessage>();
message.Name.ShouldBe("Declan");
}
public void can_get_raw_xml_document()
{
var context = StubHttpContext.Empty();
var serializer = new XmlSerializer(typeof(MyMessage));
serializer.Serialize(context.Response.Body, new MyMessage {
Age = 3, Name = "Declan"
});
context.Response.Body.Position = 0;
var body = new HttpResponseBody(null, context);
var root = body.ReadAsXml();
root.DocumentElement["Name"].InnerText.ShouldBe("Declan");
}
public void can_write_xml_to_request()
{
var context = StubHttpContext.Empty();
new HttpRequestBody(null, context).XmlInputIs(new MyMessage {
Age = 3, Name = "Declan"
});
context.Request.Body.Position = 0;
var xml = context.Request.Body.ReadAllText();
var doc = new XmlDocument();
doc.LoadXml(xml);
doc.DocumentElement["Name"].InnerText.ShouldBe("Declan");
}
public void can_write_xml_to_request()
{
var context = StubHttpContext.Empty();
using (var system = SystemUnderTest.For(b => b.Configure(app => app.Run(c => c.Response.WriteAsync("Hello")))))
{
var scenario = new Scenario(system);
new HttpRequestBody(null, scenario).XmlInputIs(new MyMessage {
Age = 3, Name = "Declan"
});
scenario.SetupHttpContext(context);
context.Request.Body.Position = 0;
var xml = context.Request.Body.ReadAllText();
var doc = new XmlDocument();
doc.LoadXml(xml);
doc.DocumentElement["Name"].InnerText.ShouldBe("Declan");
}
}
private static ViewContext CompileView(string viewContents)
{
var settings = new SparkSettings();
var container = SparkRubyEngineStarter.CreateContainer(settings);
var viewFolder = new InMemoryViewFolder { { "stub\\index.spark", viewContents } };
container.SetServiceBuilder<IViewFolder>(c => viewFolder);
var viewEngine = container.GetService<IViewEngine>();
var httpContext = new StubHttpContext();
var routeData = new RouteData();
routeData.Values.Add("controller", "stub");
routeData.Values.Add("action", "index");
var controller = new StubController();
var controllerContext = new ControllerContext(httpContext, routeData, controller);
var result = viewEngine.FindPartialView(controllerContext, "index", false);
return new ViewContext(controllerContext, result.View, new ViewDataDictionary(), new TempDataDictionary(), new StringWriter());
}
public ArgumentExpectation(StubHttpContext context)
{
_spread = context.GetSpreadData();
_args = context.GetRouteData();
}
