public static HttpContextAccessor CreateHttpContextAccessor(RequestTelemetry requestTelemetry = null, ActionContext actionContext = null)
{
var services = new ServiceCollection();
var request = new DefaultHttpContext().Request;
request.Method = "GET";
request.Path = new PathString("/Test");
var contextAccessor = new HttpContextAccessor() { HttpContext = request.HttpContext };
services.AddInstance<IHttpContextAccessor>(contextAccessor);
if (actionContext != null)
{
var si = new ScopedInstance<ActionContext>();
si.Value = actionContext;
services.AddInstance<IScopedInstance<ActionContext>>(si);
}
if (requestTelemetry != null)
{
services.AddInstance<RequestTelemetry>(requestTelemetry);
}
IServiceProvider serviceProvider = services.BuildServiceProvider();
contextAccessor.HttpContext.RequestServices = serviceProvider;
return contextAccessor;
}
public void GetCookieToken_CookieDoesNotExist_ReturnsNull()
{
// Arrange
var requestCookies = new Mock<IReadableStringCollection>();
requestCookies
.Setup(o => o.Get(It.IsAny<string>()))
.Returns(string.Empty);
var mockHttpContext = new Mock<HttpContext>();
mockHttpContext
.Setup(o => o.Request.Cookies)
.Returns(requestCookies.Object);
var contextAccessor = new ScopedInstance<AntiForgeryContext>();
mockHttpContext.SetupGet(o => o.RequestServices)
.Returns(GetServiceProvider(contextAccessor));
var config = new AntiForgeryOptions()
{
CookieName = _cookieName
};
var tokenStore = new AntiForgeryTokenStore(
config: config,
serializer: null);
// Act
var token = tokenStore.GetCookieToken(mockHttpContext.Object);
// Assert
Assert.Null(token);
}
/// <summary>
/// Converts a LINQ expression to a select clause expression.
/// </summary>
/// <param name="expression">The expression.</param>
/// <returns></returns>
public static SelectClause LinqToSelectClause(System.Linq.Expressions.Expression expression)
{
if (expression == null)
{
return(null);
}
switch (expression.NodeType)
{
case ExpressionType.Lambda:
do
{
var lambda = (System.Linq.Expressions.LambdaExpression)expression;
using (ScopedInstance <System.Linq.Expressions.LambdaExpression> .Set(lambda))
{
return(LinqToSelectClause(lambda.Body));
}
} while (false);
case ExpressionType.New:
return(NewToSelectClause(
(System.Linq.Expressions.NewExpression)expression));
}
throw new ArgumentException(
String.Format("Expression of type {0} is not supported", expression.NodeType), "expression");
}
public void GetCookieToken_CookieIsMissingInRequest_LooksUpCookieInAntiForgeryContext()
{
// Arrange
var requestCookies = new Mock<IReadableStringCollection>();
requestCookies
.Setup(o => o.Get(It.IsAny<string>()))
.Returns(string.Empty);
var mockHttpContext = new Mock<HttpContext>();
mockHttpContext
.Setup(o => o.Request.Cookies)
.Returns(requestCookies.Object);
var contextAccessor = new ScopedInstance<AntiForgeryContext>();
mockHttpContext.SetupGet(o => o.RequestServices)
.Returns(GetServiceProvider(contextAccessor));
// add a cookie explicitly.
var cookie = new AntiForgeryToken();
contextAccessor.Value = new AntiForgeryContext() { CookieToken = cookie };
var config = new AntiForgeryOptions()
{
CookieName = _cookieName
};
var tokenStore = new AntiForgeryTokenStore(
config: config,
serializer: null);
// Act
var token = tokenStore.GetCookieToken(mockHttpContext.Object);
// Assert
Assert.Equal(cookie, token);
}
/// <summary>
/// Boilerplate for creating views on filter streams. Make your own if you'd like.
/// </summary>
/// <typeparam name="TIn">The type of the in.</typeparam>
/// <typeparam name="TOut">The type of the out.</typeparam>
/// <param name="esperQuery">The esper query.</param>
/// <param name="viewFactory">The viewFactory.</param>
/// <returns></returns>
/// <exception cref="System.ArgumentException">no stream available to use for window
/// or
/// no stream available to use for window</exception>
public static EsperQuery <TOut> FilterView <TIn, TOut>(this EsperQuery <TIn> esperQuery, Func <View> viewFactory)
{
var parentObjectModel = esperQuery.ObjectModel;
var deriveObjectModel = parentObjectModel.ShallowCopy();
var deriveFromClause = deriveObjectModel.FromClause;
using (ScopedInstance <EPStatementObjectModel> .Set(deriveObjectModel))
{
var streams = deriveFromClause.Streams;
if (streams == null)
{
throw new ArgumentException("no stream available to use for window");
}
var filter = streams.OfType <FilterStream>().Last();
if (filter == null)
{
throw new ArgumentException("no stream available to use for window");
}
filter.AddView(viewFactory.Invoke());
}
return(new EsperQuery <TOut>(esperQuery.ServiceProvider, deriveObjectModel));
}
public void GetCookieToken_CookieDoesNotExist_ReturnsNull()
{
// Arrange
var requestCookies = new Mock <IReadableStringCollection>();
requestCookies
.Setup(o => o.Get(It.IsAny <string>()))
.Returns(string.Empty);
var mockHttpContext = new Mock <HttpContext>();
mockHttpContext
.Setup(o => o.Request.Cookies)
.Returns(requestCookies.Object);
var contextAccessor = new ScopedInstance <AntiForgeryContext>();
mockHttpContext.SetupGet(o => o.RequestServices)
.Returns(GetServiceProvider(contextAccessor));
var config = new AntiForgeryOptions()
{
CookieName = _cookieName
};
var tokenStore = new AntiForgeryTokenStore(
config: config,
serializer: null);
// Act
var token = tokenStore.GetCookieToken(mockHttpContext.Object);
// Assert
Assert.Null(token);
}
/// <summary>
/// Handles the tasks in queue.
/// </summary>
private void HandleTasksInQueue()
{
bool isDebugEnabled = Log.IsDebugEnabled;
Log.Debug(
"HandleTasksInQueue: Instance {0} thread {1} starting with {2}",
_id,
Thread.CurrentThread.Name,
_taskQueue.GetType().Name);
using (ScopedInstance <IBlockingQueue <Runnable> > .Set(_taskQueue)) // introduces the queue into scope
{
while (_liveMode != LiveMode.STOPPED)
{
Runnable task;
Interlocked.Increment(ref _tasksRunning);
try {
if (_taskQueue.Pop(500, out task))
{
try {
task.Invoke();
}
catch (Exception e) {
Log.Warn("HandleTasksInQueue: Instance {0} finished with abnormal termination", _id, e);
TaskError?.Invoke(this, new ThreadExceptionEventArgs(e));
}
finally {
Interlocked.Increment(ref _numExecuted);
}
}
else if (_liveMode == LiveMode.STOPPING)
{
if (isDebugEnabled)
{
Log.Debug(
"HandleTasksInQueue: Instance {0} no items detected in queue, terminating",
_id);
}
break;
}
else if (isDebugEnabled)
{
Log.Debug(
"HandleTasksInQueue: Instance {0} no items detected in queue, start loop again",
_id);
}
}
finally {
Interlocked.Decrement(ref _tasksRunning);
}
}
}
Log.Debug("HandleTasksInQueue: Instance {0} thread ending", _id);
}
/// <summary>
/// Converts a lambda expression to a soda expression.
/// </summary>
/// <param name="expression">The expression.</param>
/// <returns></returns>
private static Expression LambdaToSoda(System.Linq.Expressions.Expression expression)
{
var lambda = (System.Linq.Expressions.LambdaExpression)expression;
using (ScopedInstance <System.Linq.Expressions.LambdaExpression> .Set(lambda))
{
return(LinqToSodaExpression(lambda.Body));
}
}
/// <summary>
/// Imports a collection of schemas.
/// </summary>
/// <param name="schemaSet">The schema set.</param>
public void ImportSchemas(XmlSchemaSet schemaSet)
{
using (ScopedInstance <XmlSchemaSet> .Set(schemaSet))
{
foreach (XmlSchema schema in schemaSet.Schemas())
{
ImportSchema(schema);
}
}
}
/// <summary>
/// Add a property / column to the query.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="esperQuery">The esper query.</param>
/// <param name="property">The property.</param>
/// <returns></returns>
public static EsperQuery <T> AddProperty <T>(this EsperQuery <T> esperQuery, String property)
{
var parentObjectModel = esperQuery.ObjectModel;
var deriveObjectModel = parentObjectModel.ShallowCopy();
using (ScopedInstance <EPStatementObjectModel> .Set(deriveObjectModel)) {
deriveObjectModel.SelectClause.Add(property);
return(new EsperQuery <T>(esperQuery.ServiceProvider, deriveObjectModel));
}
}
public void ScopedInstanceDoesNotThrowOnNonIDisposable()
{
// Arrange
var scopedInstance = new ScopedInstance<object>()
{
Value = new object(),
};
// Act
scopedInstance.Dispose();
}
/// <summary>
/// Groups the results of the expression.
/// </summary>
/// <typeparam name="TSource">The type of the source.</typeparam>
/// <typeparam name="TKey">The type of the key.</typeparam>
/// <param name="esperQuery">The esper query.</param>
/// <param name="keySelectionExpression">The key selection expression.</param>
/// <returns></returns>
public static EsperQuery <TSource> GroupBy <TSource, TKey>(this EsperQuery <TSource> esperQuery,
Expression <Func <TSource, TKey> > keySelectionExpression)
{
var parentObjectModel = esperQuery.ObjectModel;
var deriveObjectModel = parentObjectModel.ShallowCopy();
// Adapt or set the where clause according to the expression contents
using (ScopedInstance <EPStatementObjectModel> .Set(deriveObjectModel)) {
var sodaExpression = LinqToSoda.LinqToSodaExpression(keySelectionExpression);
deriveObjectModel.GroupByClause = GroupByClause.Create(sodaExpression);
return(new EsperQuery <TSource>(esperQuery.ServiceProvider, deriveObjectModel));
}
}
/// <summary>
/// Adds the property.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="esperQuery">The esper query.</param>
/// <param name="propertyName">Name of the property.</param>
/// <param name="expression">The expression.</param>
/// <returns></returns>
public static EsperQuery <T> AddProperty <T>(this EsperQuery <T> esperQuery, String propertyName, System.Linq.Expressions.Expression <Func <object> > expression)
{
var parentObjectModel = esperQuery.ObjectModel;
var deriveObjectModel = parentObjectModel.ShallowCopy();
using (ScopedInstance <EPStatementObjectModel> .Set(deriveObjectModel))
{
deriveObjectModel.SelectClause.Add(
LinqToSoda.LinqToSodaExpression(expression),
propertyName);
return(new EsperQuery <T>(esperQuery.ServiceProvider, deriveObjectModel));
}
}
public void ScopedInstanceDoesNotThrowOnNull()
{
// Arrange
var scopedInstance = new ScopedInstance<Disposable>()
{
Value = null, // just making it explicit that there is not value set yet.
};
// Act
scopedInstance.Dispose();
// Assert
Assert.Null(scopedInstance.Value);
}
/// <summary>
/// Gets the native element representation of the named element.
/// </summary>
/// <param name="schemaSet">The schema set.</param>
/// <param name="elementName">Name of the element.</param>
/// <returns></returns>
public Element GetNativeElement(XmlSchemaSet schemaSet, XmlQualifiedName elementName)
{
using (ScopedInstance <XmlSchemaSet> .Set(schemaSet))
{
if ((elementName == null) ||
(elementName == XmlQualifiedName.Empty))
{
throw new ArgumentException("invalid root element", "elementName");
}
var rootElementNamespace = elementName.Namespace;
var rootElementSchema = schemaSet.Schemas(rootElementNamespace).OfType <XmlSchema>().FirstOrDefault();
return(GetNativeElement(rootElementSchema, elementName));
}
}
public void ScopedInstanceDisposesIDisposables()
{
var disposable = new Disposable();
// Arrange
var scopedInstance = new ScopedInstance<Disposable>
{
Value = disposable,
};
// Act
scopedInstance.Dispose();
// Assert
Assert.True(disposable.IsDisposed);
}
public void SaveCookieToken(bool requireSsl, bool?expectedCookieSecureFlag)
{
// Arrange
var token = new AntiForgeryToken();
var mockCookies = new Mock <IResponseCookies>();
bool defaultCookieSecureValue = expectedCookieSecureFlag ?? false; // pulled from config; set by ctor
var cookies = new MockResponseCookieCollection();
cookies.Count = 0;
var mockHttpContext = new Mock <HttpContext>();
mockHttpContext.Setup(o => o.Response.Cookies)
.Returns(cookies);
var contextAccessor = new ScopedInstance <AntiForgeryContext>();
mockHttpContext.SetupGet(o => o.RequestServices)
.Returns(GetServiceProvider(contextAccessor));
var mockSerializer = new Mock <IAntiForgeryTokenSerializer>();
mockSerializer.Setup(o => o.Serialize(token))
.Returns("serialized-value");
var config = new AntiForgeryOptions()
{
CookieName = _cookieName,
RequireSSL = requireSsl
};
var tokenStore = new AntiForgeryTokenStore(
config: config,
serializer: mockSerializer.Object);
// Act
tokenStore.SaveCookieToken(mockHttpContext.Object, token);
// Assert
Assert.Equal(1, cookies.Count);
Assert.NotNull(contextAccessor.Value.CookieToken);
Assert.NotNull(cookies);
Assert.Equal(_cookieName, cookies.Key);
Assert.Equal("serialized-value", cookies.Value);
Assert.True(cookies.Options.HttpOnly);
Assert.Equal(defaultCookieSecureValue, cookies.Options.Secure);
}
public void Run()
{
using (ScopedInstance <BoundBlockingQueueOverride> .Set(BoundBlockingQueueOverride.Default))
{
try
{
_epRuntime.ProcessStatementFilterSingle(_handleCallback.AgentInstanceHandle, _handleCallback, _event,
_filterVersion);
_epRuntime.Dispatch();
_epRuntime.ProcessThreadWorkQueue();
}
catch (Exception e)
{
Log.Error("Unexpected error processing route execution: " + e.Message, e);
}
}
}
/// <summary>
/// Constrains the specified esper query.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="esperQuery">The esper query.</param>
/// <param name="expression">The expression.</param>
/// <returns></returns>
public static EsperQuery <T> Having <T>(this EsperQuery <T> esperQuery, System.Linq.Expressions.Expression <Func <T, bool> > expression)
{
var parentObjectModel = esperQuery.ObjectModel;
var deriveObjectModel = parentObjectModel.ShallowCopy();
// Adapt or set the where clause according to the expression contents
using (ScopedInstance <EPStatementObjectModel> .Set(deriveObjectModel))
{
var sodaExpression = LinqToSoda.LinqToSodaExpression(expression);
deriveObjectModel.HavingClause = deriveObjectModel.HavingClause == null
? sodaExpression
: Expressions.And(deriveObjectModel.WhereClause, sodaExpression);
deriveObjectModel.FromClause.Streams[0].StreamName =
expression.Parameters[0].Name;
return(new EsperQuery <T>(esperQuery.ServiceProvider, deriveObjectModel));
}
}
/// <summary>
/// Joins the specified outer.
/// </summary>
/// <typeparam name="TOuter">The type of the outer.</typeparam>
/// <typeparam name="TInner">The type of the inner.</typeparam>
/// <typeparam name="TKey">The type of the key.</typeparam>
/// <typeparam name="TResult">The type of the result.</typeparam>
/// <param name="outer">The outer.</param>
/// <param name="inner">The inner.</param>
/// <param name="outerKeySelector">The outer key selector.</param>
/// <param name="innerKeySelector">The inner key selector.</param>
/// <param name="resultSelector">The result selector.</param>
/// <returns></returns>
public static EsperQuery <TResult> Join <TOuter, TInner, TKey, TResult>(
this EsperQuery <TOuter> outer,
EsperQuery <TInner> inner,
Expression <Func <TOuter, TKey> > outerKeySelector,
Expression <Func <TInner, TKey> > innerKeySelector,
Expression <Func <TOuter, TInner, TResult> > resultSelector)
{
var parentObjectModel = outer.ObjectModel;
var deriveObjectModel = new EPStatementObjectModel();
using (ScopedInstance <EPStatementObjectModel> .Set(deriveObjectModel)) {
deriveObjectModel.Annotations = parentObjectModel.Annotations;
var innerKey = LinqToSoda.LinqToSodaExpression(innerKeySelector);
var outerKey = LinqToSoda.LinqToSodaExpression(outerKeySelector);
deriveObjectModel.FromClause = new FromClause(
outer.ObjectModel.FromClause.Streams.Concat(
inner.ObjectModel.FromClause.Streams)
.ToArray());
var parametersArray = resultSelector.Parameters.ToArray();
for (var ii = 0; ii < parametersArray.Length; ii++)
{
deriveObjectModel.FromClause.Streams[ii].StreamName =
parametersArray[ii].Name;
}
deriveObjectModel.FromClause.OuterJoinQualifiers = new List <OuterJoinQualifier>();
deriveObjectModel.FromClause.OuterJoinQualifiers.Add(
new OuterJoinQualifier(
OuterJoinType.LEFT,
outerKey,
innerKey,
new PropertyValueExpressionPair[0]));
deriveObjectModel.SelectClause = LinqToSoda.LinqToSelectClause(resultSelector);
var toEPL = deriveObjectModel.ToEPL();
return(new EsperQuery <TResult>(outer.ServiceProvider, deriveObjectModel));
}
}
public void GetCookieToken_CookieIsMissingInRequest_LooksUpCookieInAntiForgeryContext()
{
// Arrange
var requestCookies = new Mock <IReadableStringCollection>();
requestCookies
.Setup(o => o.Get(It.IsAny <string>()))
.Returns(string.Empty);
var mockHttpContext = new Mock <HttpContext>();
mockHttpContext
.Setup(o => o.Request.Cookies)
.Returns(requestCookies.Object);
var contextAccessor = new ScopedInstance <AntiForgeryContext>();
mockHttpContext.SetupGet(o => o.RequestServices)
.Returns(GetServiceProvider(contextAccessor));
// add a cookie explicitly.
var cookie = new AntiForgeryToken();
contextAccessor.Value = new AntiForgeryContext()
{
CookieToken = cookie
};
var config = new AntiForgeryOptions()
{
CookieName = _cookieName
};
var tokenStore = new AntiForgeryTokenStore(
config: config,
serializer: null);
// Act
var token = tokenStore.GetCookieToken(mockHttpContext.Object);
// Assert
Assert.Equal(cookie, token);
}
/// <summary>
/// Creates a window.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="serviceProvider">The service provider.</param>
/// <param name="windowName">Name of the window.</param>
/// <param name="view">The view.</param>
/// <param name="esperQuery">The esper query.</param>
/// <param name="insertWhereExpression">The insert where expression.</param>
/// <returns></returns>
public static EPStatementObjectModel CreateWindowAsObjectModel <T>(
this EPServiceProvider serviceProvider,
string windowName,
View view,
EsperQuery <T> esperQuery,
System.Linq.Expressions.Expression <Func <T, bool> > insertWhereExpression)
{
var deriveObjectModel = DeriveObjectModel(esperQuery);
using (ScopedInstance <EPStatementObjectModel> .Set(deriveObjectModel)) {
deriveObjectModel.CreateWindow = CreateWindowClause.Create(windowName, view);
deriveObjectModel.CreateWindow.IsInsert = false;
if (insertWhereExpression != null)
{
deriveObjectModel.CreateWindow.InsertWhereClause =
LinqToSoda.LinqToSodaExpression(insertWhereExpression);
deriveObjectModel.CreateWindow.IsInsert = true;
}
return(deriveObjectModel);
}
}
/// <summary>
/// Creates the delete trigger.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="serviceProvider">The service provider.</param>
/// <param name="windowName">Name of the window.</param>
/// <param name="asName">As name.</param>
/// <param name="fromClause">From clause.</param>
/// <param name="deferredWhereClause">The deferred where clause.</param>
/// <returns></returns>
public static EPStatement CreateDeleteTrigger <T>(EPServiceProvider serviceProvider,
string windowName,
string asName,
EsperQuery <T> fromClause,
Func <Expression> deferredWhereClause)
{
var deriveObjectModel = DeriveObjectModel(fromClause);
using (ScopedInstance <EPStatementObjectModel> .Set(deriveObjectModel)) {
deriveObjectModel.OnExpr = OnClause.CreateOnDelete(windowName, asName);
if (deferredWhereClause != null)
{
var whereClause = deferredWhereClause.Invoke();
if (whereClause != null)
{
deriveObjectModel.WhereClause = whereClause;
}
}
return(serviceProvider.EPAdministrator.Create(deriveObjectModel));
}
}
private HttpContext GetMockHttpContext(string cookieName, string cookieValue)
{
var requestCookies = new MockCookieCollection(new Dictionary <string, string>()
{
{ cookieName, cookieValue }
});
var request = new Mock <HttpRequest>();
request.Setup(o => o.Cookies)
.Returns(requestCookies);
var mockHttpContext = new Mock <HttpContext>();
mockHttpContext.Setup(o => o.Request)
.Returns(request.Object);
var contextAccessor = new ScopedInstance <AntiForgeryContext>();
mockHttpContext.SetupGet(o => o.RequestServices)
.Returns(GetServiceProvider(contextAccessor));
return(mockHttpContext.Object);
}
private HttpContext GetMockHttpContext(string cookieName, string cookieValue)
{
var requestCookies = new MockCookieCollection(new Dictionary<string, string>() { { cookieName, cookieValue } });
var request = new Mock<HttpRequest>();
request.Setup(o => o.Cookies)
.Returns(requestCookies);
var mockHttpContext = new Mock<HttpContext>();
mockHttpContext.Setup(o => o.Request)
.Returns(request.Object);
var contextAccessor = new ScopedInstance<AntiForgeryContext>();
mockHttpContext.SetupGet(o => o.RequestServices)
.Returns(GetServiceProvider(contextAccessor));
return mockHttpContext.Object;
}
public void SaveCookieToken(bool requireSsl, bool? expectedCookieSecureFlag)
{
// Arrange
var token = new AntiForgeryToken();
var mockCookies = new Mock<IResponseCookies>();
bool defaultCookieSecureValue = expectedCookieSecureFlag ?? false; // pulled from config; set by ctor
var cookies = new MockResponseCookieCollection();
cookies.Count = 0;
var mockHttpContext = new Mock<HttpContext>();
mockHttpContext.Setup(o => o.Response.Cookies)
.Returns(cookies);
var contextAccessor = new ScopedInstance<AntiForgeryContext>();
mockHttpContext.SetupGet(o => o.RequestServices)
.Returns(GetServiceProvider(contextAccessor));
var mockSerializer = new Mock<IAntiForgeryTokenSerializer>();
mockSerializer.Setup(o => o.Serialize(token))
.Returns("serialized-value");
var config = new AntiForgeryOptions()
{
CookieName = _cookieName,
RequireSSL = requireSsl
};
var tokenStore = new AntiForgeryTokenStore(
config: config,
serializer: mockSerializer.Object);
// Act
tokenStore.SaveCookieToken(mockHttpContext.Object, token);
// Assert
Assert.Equal(1, cookies.Count);
Assert.NotNull(contextAccessor.Value.CookieToken);
Assert.NotNull(cookies);
Assert.Equal(_cookieName, cookies.Key);
Assert.Equal("serialized-value", cookies.Value);
Assert.True(cookies.Options.HttpOnly);
Assert.Equal(defaultCookieSecureValue, cookies.Options.Secure);
}
public AnotherStringHandler(ScopedInstance scopedInstance, ConcurrentQueue <Guid> guidQueue)
{
_scopedInstance = scopedInstance;
_guidQueue = guidQueue;
}
