public void ShouldCreateEqualityQueryOnCollectionContainsMethod() { Expression<Func<TestClass, bool>> expression = x => x.CollectionData.Contains("5"); var expressionVisitor = new ExpressionVisitor(); var repositoryQuery = new RepositoryQuery(); var queryContainer = new QueryContainer(repositoryQuery); expressionVisitor.Visit(null, expression, queryContainer); var query = queryContainer.Query; Assert.That(query, Is.Not.Null); Assert.That(query.Operand, Is.EqualTo(MongoOperand.Equals)); Assert.That(query.PropertyName, Is.EqualTo("CollectionData")); Assert.That(query.Value, Is.EqualTo(BsonValue.Create("5"))); Assert.That(query.Inverted, Is.False); Assert.That(query.MongoQuery.ToString(), Is.EqualTo(Query.EQ("CollectionData", "5").ToString())); }
private string FindDeepParameter(Expression expression) { if (expression.NodeType == ExpressionType.MemberAccess) { var memberExpression = expression as MemberExpression; if (memberExpression != null) { var name = memberExpression.Member.Name; var subName = FindDeepParameter(memberExpression.Expression); if (!string.IsNullOrEmpty(subName)) { return subName + "." + name; } return name; } } if (expression.NodeType == ExpressionType.Call) { var methodCallExpression = expression as MethodCallExpression; if (methodCallExpression != null && methodCallExpression.Method.Name == "get_Item" && methodCallExpression.Object != null && methodCallExpression.Object.Type.GetGenericTypeDefinition() == typeof(Dictionary<,>)) { var container = new QueryContainer(new RepositoryQuery()); Visit(null, methodCallExpression.Object, container); var dictionaryKey = GetValueFromExpression(methodCallExpression.Arguments[0]) as string; var name = container.Query.PropertyName + "." + dictionaryKey; return name; } } return string.Empty; }
public void ShouldSupportToStringOnMemberAccessExpression() { const int someConstant = 5; Expression<Func<TestClass, bool>> expression = x => x.SomeData == someConstant.ToString(); var expressionVisitor = new ExpressionVisitor(); var repositoryQuery = new RepositoryQuery(); var queryContainer = new QueryContainer(repositoryQuery); expressionVisitor.Visit(null, expression, queryContainer); var query = queryContainer.Query; Assert.That(query, Is.Not.Null); Assert.That(query.Inverted, Is.False); Assert.That(query.Operand, Is.EqualTo(MongoOperand.Equals)); Assert.That(query.Value, Is.EqualTo(BsonValue.Create("5"))); Assert.That(query.MongoQuery.ToString(), Is.EqualTo(Query.EQ("SomeData", "5").ToString())); }
public void ShouldThrowNotSupportedExceptionOnToStringMethodOnCollectionValue() { Expression<Func<TestClass, bool>> expression = x => x.IntData.ToString() == "5"; var expressionVisitor = new ExpressionVisitor(); var repositoryQuery = new RepositoryQuery(); var queryContainer = new QueryContainer(repositoryQuery); expressionVisitor.Visit(null, expression, queryContainer); }
public void ShouldSupportQueriesWithMultipleAnds() { var expressionVisitor = new ExpressionVisitor(); Expression<Func<TestClass, bool>> expression = x => x.Id == "1" && x.IntData == 2 && x.SomeData == "3"; var repositoryQuery = new RepositoryQuery(); var queryContainer = new QueryContainer(repositoryQuery); expressionVisitor.Visit(null, expression, queryContainer); var query = queryContainer.Query; var andQuery = Query.And(Query.EQ("_id", "1"), Query.EQ("IntData", 2), Query.EQ("SomeData", "3")); Assert.That(query.MongoQuery.ToString(), Is.EqualTo(andQuery.ToString())); }
public void ShouldSupportQueriesWithOrOperatorAndConstants() { var expressionVisitor = new ExpressionVisitor(); Expression<Func<TestClass, bool>> expression = x => x.Id == "5" || x.SomeData == "6"; var repositoryQuery = new RepositoryQuery(); var queryContainer = new QueryContainer(repositoryQuery); expressionVisitor.Visit(null, expression, queryContainer); var query = queryContainer.Query; var andQuery = Query.Or(Query.EQ("_id", "5"), Query.EQ("SomeData", "6")); Assert.That(query.MongoQuery.ToString(), Is.EqualTo(andQuery.ToString())); }
private void VisitUnary(ParameterExpression[] parameters, UnaryExpression unaryExpression, QueryContainer container) { Visit(parameters, unaryExpression.Operand, container); }
public void ShouldSupportQueriesWithAndOperatorAndConstantVariableExpression() { var expressionVisitor = new ExpressionVisitor(); const string idValue = "5"; const string someDataValue = "6"; Expression<Func<TestClass, bool>> expression = x => x.Id == idValue && x.SomeData == someDataValue; var repositoryQuery = new RepositoryQuery(); var queryContainer = new QueryContainer(repositoryQuery); expressionVisitor.Visit(null, expression, queryContainer); var query = queryContainer.Query; var andQuery = Query.And(Query.EQ("_id", idValue), Query.EQ("SomeData", someDataValue)); Assert.That(query.MongoQuery.ToString(), Is.EqualTo(andQuery.ToString())); }
private void VisitMethodCall(ParameterExpression[] parameters, MethodCallExpression expression, QueryContainer container) { var declaringType = expression.Method.DeclaringType; var enumerableType = (declaringType.GetInterfaces() .Where(x => x.IsGenericType) .Where(x => x.GetGenericTypeDefinition() == typeof(IEnumerable<>)) .Select(x => x.GetGenericArguments()[0]) .FirstOrDefault() != null); if (enumerableType && expression.Method.Name == "Contains") { var memberExpression = expression.Object as MemberExpression; if (memberExpression != null) { var constantExpression = memberExpression.Expression as ConstantExpression; var prop = memberExpression.Member; var fieldName = prop.Name; if (constantExpression != null) { var value = constantExpression.Value; var fieldType = value.GetType(); var fieldInfo = fieldType.GetField(fieldName); var field = fieldInfo.GetValue(value); var bsonValue = BsonArray.Create(field); var inverted = container.Query.Inverted; container.Query = new InRepositoryQuery { Value = bsonValue, Inverted = inverted }; } } Visit(parameters, expression.Arguments[0], container); } else if ((declaringType == typeof(IEnumerable) || declaringType == typeof(Enumerable) && declaringType != typeof(string) && declaringType.IsPrimitive == false) && expression.Method.Name == "Contains") { var inverted = container.Query.Inverted; var memberExpression = expression.Arguments[0] as MemberExpression; if (memberExpression != null && memberExpression.Expression is ParameterExpression) { container.Query.Operand = MongoOperand.Equals; } else { container.Query = new InRepositoryQuery { Inverted = inverted }; } Visit(parameters, expression.Arguments[0], container); Visit(parameters, expression.Arguments[1], container); } else if (expression.Method.Name == "get_Item" && expression.Object != null && expression.Object.Type.GetGenericTypeDefinition() == typeof(Dictionary<,>)) { Visit(parameters, expression.Object, container); var dictionaryKey = GetValueFromExpression(expression.Arguments[0]) as string; container.Query.PropertyName += "." + dictionaryKey; //Append the dictionary key } else if(expression.Method.Name == "IsNullOrEmpty") { var orRepositoryQuery = new OrRepositoryQuery { LeftContainer = new QueryContainer(new RepositoryQuery()) { Query = { Value = "", Operand = MongoOperand.Equals, Inverted = container.Query.Inverted } } }; Visit(null, expression.Arguments[0], orRepositoryQuery.LeftContainer); orRepositoryQuery.RightContainer = new QueryContainer(new RepositoryQuery()) { Query = { Value = null, Operand = MongoOperand.Equals, Inverted = container.Query.Inverted } }; Visit(null, expression.Arguments[0], orRepositoryQuery.RightContainer); container.Query = orRepositoryQuery; } else if(expression.Method.Name == "IsNotNullOrEmpty") { var orRepositoryQuery = new OrRepositoryQuery { LeftContainer = new QueryContainer(new RepositoryQuery()) { Query = { Value = "", Operand = MongoOperand.NotEquals } } }; Visit(null, expression.Arguments[0], orRepositoryQuery.LeftContainer); orRepositoryQuery.RightContainer = new QueryContainer(new RepositoryQuery()) { Query = { Value = null, Operand = MongoOperand.NotEquals } }; Visit(null, expression.Arguments[0], orRepositoryQuery.RightContainer); container.Query = orRepositoryQuery; } else if (expression.Method.Name == "Parse") { var memberExpression = expression.Arguments[0] as MemberExpression; if (expression.Arguments[0] is ConstantExpression || (memberExpression != null && memberExpression.Expression is ConstantExpression)) { var value = GetValueFromExpression(expression); container.Query.Value = BsonValue.Create(value); } else { throw new NotSupportedException("Parse on non-Constant Expressions is not supported"); } } else if (expression.Method.Name == "ToString") { var memberExpression = expression.Object as MemberExpression; if (expression.Object is ConstantExpression || (memberExpression != null && memberExpression.Expression is ConstantExpression)) { var value = GetValueFromExpression(expression); container.Query.Value = BsonValue.Create(value); } else { throw new NotSupportedException("ToString on non-Constant Expressions is not supported"); } } else { throw new NotSupportedException(string.Format("Method {0} is not supported", expression.Method.Name)); } }
public void Visit(ParameterExpression[] parameters, Expression expression, QueryContainer container) { if (expression == null) { return; } switch (expression.NodeType) { case ExpressionType.Not: container.Query.Inverted = true; VisitUnary(parameters, (UnaryExpression)expression, container); break; case ExpressionType.Negate: case ExpressionType.NegateChecked: case ExpressionType.Convert: case ExpressionType.ConvertChecked: case ExpressionType.ArrayLength: case ExpressionType.Quote: case ExpressionType.TypeAs: VisitUnary(parameters, (UnaryExpression)expression, container); break; case ExpressionType.And: case ExpressionType.AndAlso: VisitBinary(parameters, expression as BinaryExpression, container); break; case ExpressionType.Add: case ExpressionType.AddChecked: case ExpressionType.Subtract: case ExpressionType.SubtractChecked: case ExpressionType.Multiply: case ExpressionType.MultiplyChecked: case ExpressionType.Divide: case ExpressionType.Modulo: case ExpressionType.Or: case ExpressionType.OrElse: case ExpressionType.LessThan: case ExpressionType.LessThanOrEqual: case ExpressionType.GreaterThan: case ExpressionType.GreaterThanOrEqual: case ExpressionType.Equal: case ExpressionType.NotEqual: case ExpressionType.Coalesce: case ExpressionType.ArrayIndex: case ExpressionType.RightShift: case ExpressionType.LeftShift: case ExpressionType.ExclusiveOr: VisitBinary(parameters, (BinaryExpression)expression, container); break; case ExpressionType.TypeIs: case ExpressionType.Conditional: case ExpressionType.Constant: VisitConstant(expression as ConstantExpression, container); break; case ExpressionType.MemberAccess: VisitMember(parameters, expression, container); break; case ExpressionType.Lambda: VisitLambda((LambdaExpression)expression, container); break; case ExpressionType.Call: VisitMethodCall(parameters, expression as MethodCallExpression, container); break; default: throw new NotSupportedException(string.Format("Unhandled expression type: '{0}'", expression.NodeType)); } }
private void VisitMember(ParameterExpression[] parameters, Expression expression, QueryContainer container) { var memberExpression = (MemberExpression)expression; var expressionName = expression.ToString(); var subStrings = expressionName.Split('.'); var isDeepParameter = false; if (subStrings.Length > 0 && parameters != null && parameters.Length > 0) { isDeepParameter = parameters[0].ToString() == subStrings[0]; } if (memberExpression.Expression is ParameterExpression || isDeepParameter) { string name; if (isDeepParameter) { name = FindDeepParameter(memberExpression); } else { name = memberExpression.Member.Name; } if (name.ToLower() == "id") { name = "_id"; } container.Query.PropertyName = name; if (memberExpression.Type == typeof(bool) && container.Query.Operand == MongoOperand.NotSet) { container.Query.Operand = MongoOperand.Equals; container.Query.Value = true; } } else { var value = GetValueFromExpression(memberExpression); container.Query.Value = BsonValue.Create(value); } }
private void VisitLambda(LambdaExpression lambdaExpression, QueryContainer container) { var newLambdaParam = lambdaExpression.Parameters.ToArray(); Visit(newLambdaParam, lambdaExpression.Body, container); }
private void VisitBinary(ParameterExpression[] parameters, BinaryExpression binaryExpression, QueryContainer container) { QueryContainer queryLeft; QueryContainer queryRight; switch (binaryExpression.NodeType) { case ExpressionType.AndAlso: case ExpressionType.And: var andQuery = new AndRepositoryQuery(); queryLeft = new QueryContainer(new RepositoryQuery()); queryRight = new QueryContainer(new RepositoryQuery()); andQuery.LeftContainer = queryLeft; andQuery.RightContainer = queryRight; container.Query = andQuery; break; case ExpressionType.Or: case ExpressionType.OrElse: var orQuery = new OrRepositoryQuery(); queryLeft = new QueryContainer(new RepositoryQuery()); queryRight = new QueryContainer(new RepositoryQuery()); orQuery.LeftContainer = queryLeft; orQuery.RightContainer = queryRight; container.Query = orQuery; break; default: container.Query.Operand = FindMongoOperand(binaryExpression.NodeType); queryLeft = queryRight = container; break; } Visit(parameters, binaryExpression.Left, queryLeft); Visit(parameters, binaryExpression.Right, queryRight); }
public void ShouldSupportImplicitCastWithEnums() { var expressionVisitor = new ExpressionVisitor(); Expression<Func<TestClass, bool>> expression = x => x.EnumValue == TestEnum.EnumValue1; var repositoryQuery = new RepositoryQuery(); var queryContainer = new QueryContainer(repositoryQuery); expressionVisitor.Visit(null, expression, queryContainer); var query = queryContainer.Query; Assert.That(query, Is.Not.Null); Assert.That(query.Operand, Is.EqualTo(MongoOperand.Equals)); Assert.That(query.Inverted, Is.False); Assert.That(query.PropertyName, Is.EqualTo("EnumValue")); Assert.That(query.Value, Is.EqualTo(BsonValue.Create(TestEnum.EnumValue1))); Assert.That(query.MongoQuery.ToString(), Is.EqualTo(Query.EQ("EnumValue", TestEnum.EnumValue1).ToString())); }
public void ShouldCreateEqualsQueryOnInvertedSimpleDictionaryData() { Expression<Func<DictionaryTestClass, bool>> expression = x => !(x.SimpleDictionaryData["myKey"] != "myValue");//I know resharper wants you to refactor this, please don't var expressionVisitor = new ExpressionVisitor(); var repositoryQuery = new RepositoryQuery(); var queryContainer = new QueryContainer(repositoryQuery); expressionVisitor.Visit(null, expression, queryContainer); var query = queryContainer.Query; Assert.That(query, Is.Not.Null); Assert.That(query.Operand, Is.EqualTo(MongoOperand.NotEquals)); Assert.That(query.Inverted, Is.True); Assert.That(query.PropertyName, Is.EqualTo("SimpleDictionaryData.myKey")); Assert.That(query.Value, Is.EqualTo(BsonValue.Create("myValue"))); Assert.That(query.MongoQuery.ToString(), Is.EqualTo(Query.EQ("SimpleDictionaryData.myKey", "myValue").ToString())); }
public void ShouldSupportParseMethodOnConstantExpression() { Expression<Func<TestClass, bool>> expression = x => x.IntData == int.Parse("5"); var expressionVisitor = new ExpressionVisitor(); var repositoryQuery = new RepositoryQuery(); var queryContainer = new QueryContainer(repositoryQuery); expressionVisitor.Visit(null, expression, queryContainer); var query = queryContainer.Query; Assert.That(query, Is.Not.Null); Assert.That(query.Inverted, Is.False); Assert.That(query.Operand, Is.EqualTo(MongoOperand.Equals)); Assert.That(query.Value, Is.EqualTo(BsonValue.Create(5))); Assert.That(query.MongoQuery.ToString(), Is.EqualTo(Query.EQ("IntData", 5).ToString())); }
public void ShouldCreateEqualsQueryOnReallyComplexDictionaryData() { Expression<Func<DictionaryTestClass, bool>> expression = x => x.ComplexDictionaryData["myKey"].DeeplyEmbeddedData.EvenMoreData == "myValue"; var expressionVisitor = new ExpressionVisitor(); var repositoryQuery = new RepositoryQuery(); var queryContainer = new QueryContainer(repositoryQuery); expressionVisitor.Visit(null, expression, queryContainer); var query = queryContainer.Query; Assert.That(query, Is.Not.Null); Assert.That(query.Operand, Is.EqualTo(MongoOperand.Equals)); Assert.That(query.Inverted, Is.False); Assert.That(query.PropertyName, Is.EqualTo("ComplexDictionaryData.myKey.DeeplyEmbeddedData.EvenMoreData")); Assert.That(query.Value, Is.EqualTo(BsonValue.Create("myValue"))); Assert.That(query.MongoQuery.ToString(), Is.EqualTo(Query.EQ("ComplexDictionaryData.myKey.DeeplyEmbeddedData.EvenMoreData", "myValue").ToString())); }
public void ShouldSupportQueriesWithAndOperatorAndMemberExpression() { var expressionVisitor = new ExpressionVisitor(); // ReSharper disable ConvertToConstant.Local var idValue = "5"; //these should not be changed to const! That's a different code path var someDataValue = "6"; //these should not be changed to const! That's a different code path // ReSharper restore ConvertToConstant.Local Expression<Func<TestClass, bool>> expression = x => x.Id == idValue && x.SomeData == someDataValue; var repositoryQuery = new RepositoryQuery(); var queryContainer = new QueryContainer(repositoryQuery); expressionVisitor.Visit(null, expression, queryContainer); var query = queryContainer.Query; var andQuery = Query.And(Query.EQ("_id", idValue), Query.EQ("SomeData", someDataValue)); Assert.That(query.MongoQuery.ToString(), Is.EqualTo(andQuery.ToString())); }
public void ShouldCreateInvertedNotEqualsQuery() { var expressionVisitor = new ExpressionVisitor(); Expression<Func<TestClass, bool>> expression = x => !(x.Id != "5");//I know resharper wants you to refactor this, please don't var repositoryQuery = new RepositoryQuery(); var queryContainer = new QueryContainer(repositoryQuery); expressionVisitor.Visit(null, expression, queryContainer); var query = queryContainer.Query; Assert.That(query.Value, Is.EqualTo(BsonValue.Create("5"))); Assert.That(query.Operand, Is.EqualTo(MongoOperand.NotEquals)); Assert.That(query.PropertyName, Is.EqualTo("_id")); Assert.That(query.Inverted, Is.True); Assert.That(query.MongoQuery.ToString(),Is.EqualTo(Query.EQ("_id", "5").ToString())); }
public void ShouldSupportQueriesWithMultipleOrs() { var expressionVisitor = new ExpressionVisitor(); Expression<Func<TestClass, bool>> expression = x => x.Id == "1" || x.Id == "2" || x.Id == "3"; var repositoryQuery = new RepositoryQuery(); var queryContainer = new QueryContainer(repositoryQuery); expressionVisitor.Visit(null, expression, queryContainer); var query = queryContainer.Query; var orQuery = Query.Or(Query.EQ("_id", "1"), Query.EQ("_id", "2"), Query.EQ("_id", "3")); Assert.That(query.MongoQuery.ToString(), Is.EqualTo(orQuery.ToString())); }
public void ShouldCreateLessThanQuery() { var expressionVisitor = new ExpressionVisitor(); Expression<Func<TestClass, bool>> expression = x => x.IntData < 5; var repositoryQuery = new RepositoryQuery(); var queryContainer = new QueryContainer(repositoryQuery); expressionVisitor.Visit(null, expression, queryContainer); var query = queryContainer.Query; Assert.That(query.Value, Is.EqualTo(BsonValue.Create(5))); Assert.That(query.Operand, Is.EqualTo(MongoOperand.LessThan)); Assert.That(query.PropertyName, Is.EqualTo("IntData")); Assert.That(query.Inverted, Is.False); Assert.That(query.MongoQuery.ToString(), Is.EqualTo(Query.LT("IntData", 5).ToString())); }
public void ShouldSupportStringIsNullOrEmpty() { Expression<Func<TestClass, bool>> expression = x => string.IsNullOrEmpty(x.SomeData); var expressionVisitor = new ExpressionVisitor(); var repositoryQuery = new RepositoryQuery(); var queryContainer = new QueryContainer(repositoryQuery); expressionVisitor.Visit(null, expression, queryContainer); var query = queryContainer.Query; Assert.That(query, Is.Not.Null); Assert.That(query.Inverted, Is.False); Assert.That(query is OrRepositoryQuery); var queryComplete = Query.Or(Query.EQ("SomeData", ""), Query.EQ("SomeData", BsonNull.Value)); Assert.That(query.MongoQuery.ToString(), Is.EqualTo(queryComplete.ToString())); }
public void ShouldCreateNotEqualsQueryOnInvertedBooleanValue() { Expression<Func<TestClass, bool>> expression = x => !x.Enabled; var expressionVisitor = new ExpressionVisitor(); var repositoryQuery = new RepositoryQuery(); var queryContainer = new QueryContainer(repositoryQuery); expressionVisitor.Visit(null, expression, queryContainer); var query = queryContainer.Query; Assert.That(query, Is.Not.Null); Assert.That(query.Operand, Is.EqualTo(MongoOperand.Equals)); Assert.That(query.Inverted, Is.True); Assert.That(query.PropertyName, Is.EqualTo("Enabled")); Assert.That(query.Value, Is.EqualTo(BsonValue.Create(true))); Assert.That(query.MongoQuery.ToString(), Is.EqualTo(Query.NE("Enabled", true).ToString())); }
public void ShouldThrowNotSupportedExceptionOnParseMethodOnCollectionValue() { Expression<Func<TestClass, bool>> expression = x => long.Parse(x.Id) == 5; var expressionVisitor = new ExpressionVisitor(); var repositoryQuery = new RepositoryQuery(); var queryContainer = new QueryContainer(repositoryQuery); expressionVisitor.Visit(null, expression, queryContainer); }
public void ShouldCreateNotEqualsQueryOnSimpleDictionaryData() { Expression<Func<DictionaryTestClass, bool>> expression = x => x.SimpleDictionaryData["myKey"] != "myValue"; var expressionVisitor = new ExpressionVisitor(); var repositoryQuery = new RepositoryQuery(); var queryContainer = new QueryContainer(repositoryQuery); expressionVisitor.Visit(null, expression, queryContainer); var query = queryContainer.Query; Assert.That(query, Is.Not.Null); Assert.That(query.Operand, Is.EqualTo(MongoOperand.NotEquals)); Assert.That(query.Inverted, Is.False); Assert.That(query.PropertyName, Is.EqualTo("SimpleDictionaryData.myKey")); Assert.That(query.Value, Is.EqualTo(BsonValue.Create("myValue"))); Assert.That(query.MongoQuery.ToString(), Is.EqualTo(Query.NE("SimpleDictionaryData.myKey", "myValue").ToString())); }
public void ShouldThrowNotSupportedOnUnknownOperand() { Expression<Func<TestClass, bool>> expression = x => x.SomeData + x.Id == "something"; var expressionVisitor = new ExpressionVisitor(); var repositoryQuery = new RepositoryQuery(); var queryContainer = new QueryContainer(repositoryQuery); expressionVisitor.Visit(null, expression, queryContainer); }
public void ShouldCreateNotInQueryOnInvertedParameterContainsMethodUsingList() { var dataStrings = new[] {"1", "2"}.ToList(); Expression<Func<TestClass, bool>> expression = x => !dataStrings.Contains(x.Id); var expressionVisitor = new ExpressionVisitor(); var repositoryQuery = new RepositoryQuery(); var queryContainer = new QueryContainer(repositoryQuery); expressionVisitor.Visit(null, expression, queryContainer); var query = queryContainer.Query; Assert.That(query, Is.Not.Null); var inQuery = Query.NotIn("_id", BsonArray.Create(dataStrings)); Assert.That(query.MongoQuery.ToString(), Is.EqualTo(inQuery.ToString())); }
public void ShouldCreateEqualsQuery() { var expressionVisitor = new ExpressionVisitor(); Expression<Func<TestClass, bool>> expression = x => x.Id == "5"; var repositoryQuery = new RepositoryQuery(); var queryContainer = new QueryContainer(repositoryQuery); expressionVisitor.Visit(null, expression, queryContainer); var query = queryContainer.Query; Assert.That(query.Value, Is.EqualTo(BsonValue.Create("5"))); Assert.That(query.Operand, Is.EqualTo(MongoOperand.Equals)); Assert.That(query.PropertyName, Is.EqualTo("_id")); Assert.That(query.Inverted, Is.False); Assert.That(query.MongoQuery.ToString(), Is.EqualTo(Query.EQ("_id", "5").ToString())); }
private static void VisitConstant(ConstantExpression expression, QueryContainer container) { var value = GetValueFromExpression(expression); container.Query.Value = BsonValue.Create(value); }