private void Check(string expr, int count)
{
var parts = GenericExpressionHelper.Split(expr);
Assert.AreEqual(expr ?? string.Empty, string.Concat(parts));
Assert.AreEqual(count, parts.Length);
}
public void ConvertTypesInExpressions()
{
string ToCSharp(string expr) => GenericExpressionHelper.ConvertApexTypesToCSharp(expr);
string ToApex(string expr) => GenericExpressionHelper.ConvertCSharpTypesToApex(expr);
Assert.AreEqual("Map<string, string>", ToCSharp("Map<String, String>"));
Assert.AreEqual("Map<String, String>", ToApex("Map<string, string>"));
}
public override void VisitExpression(ExpressionSyntax node)
{
// replace Apex-style constructor initializers:
// new Class(Prop1=Value1, Prop2=Value2) => new Class { Prop1=Value1, Prop2=Value2 }
var expr = GenericExpressionHelper.ConvertApexConstructorInitializerToCSharp(node.ExpressionString);
// split into portions and process one by one
base.VisitExpression(new ExpressionSyntax(expr));
}
private ApexTypeSyntax ConvertType(TypeSyntax type)
{
if (type != null)
{
var apexType = GenericExpressionHelper.ConvertCSharpTypesToApex(type.ToString());
return(new ApexTypeSyntax(apexType));
}
return(null);
}
protected override void AppendExpressionPart(string part)
{
// replace string.class => typeof(string), string.valueOf(x) => x.ToString(), etc
part = GenericExpressionHelper.ConvertTypeofExpressionsToCSharp(part);
part = GenericExpressionHelper.ConvertStringValueofToString(part);
part = GenericExpressionHelper.ConvertApexInstanceOfTypeExpressionToCSharp(part);
part = GenericExpressionHelper.ConvertApexTypesToCSharp(part);
base.AppendExpressionPart(part);
}
public void ApexPritimiveTypesStaticMethodsAreNotConvertedToCSharp()
{
string ToCSharp(string expr) => GenericExpressionHelper.ConvertApexTypesToCSharp(expr);
string ToApex(string expr) => GenericExpressionHelper.ConvertCSharpTypesToApex(expr);
Assert.AreEqual("a = (int)b", ToCSharp("a = (Integer)b"));
Assert.AreEqual("a = Integer.valueOf(b)", ToCSharp("a = Integer.valueOf(b)"));
Assert.AreEqual("a = (Integer)b", ToApex("a = (int)b"));
Assert.AreEqual("a = Integer.valueOf(b)", ToApex("a = Integer.valueOf(b)"));
}
public void SomeDotClassIsConvertedToTypeofClass()
{
var text = "string.class";
var csharp = GenericExpressionHelper.ConvertTypeofExpressionsToCSharp(text);
Assert.AreEqual("typeof(string)", csharp);
text = "mock(MyLittleClass.class)";
csharp = GenericExpressionHelper.ConvertTypeofExpressionsToCSharp(text);
Assert.AreEqual("mock(typeof(MyLittleClass))", csharp);
}
public void ConvertSoqlExpressionReturnsConvertedApexSoqlExpression()
{
var text = "List<Contact> contacts = Soql.Query<Contact>(\"SELECT Id, Email, Phone FROM Contact\");";
var expr = GenericExpressionHelper.ConvertSoqlQueriesToApex(text);
Assert.AreEqual("List<Contact> contacts = [SELECT Id, Email, Phone FROM Contact];", expr);
text = @"List<Contact> contacts = Soql.Query<Contact>(""SELECT Id, Email, Phone FROM Contact WHERE Email = :email"", email);";
expr = GenericExpressionHelper.ConvertSoqlQueriesToApex(text);
Assert.AreEqual("List<Contact> contacts = [SELECT Id, Email, Phone FROM Contact WHERE Email = :email];", expr);
}
/// <summary>
/// Get the unvalidated string of a model property posted in Request.
/// </summary>
/// <typeparam name="M">The type of the model</typeparam>
/// <param name="propertySelector">An expression to select the property from the model.</param>
/// <returns>Returns the string in the request for the property.</returns>
protected string GetUnvalidatedPropertyFromRequest <M>(Expression <Func <M, object> > propertySelector)
{
if (propertySelector == null)
{
throw new ArgumentNullException(nameof(propertySelector));
}
string requestKey = GenericExpressionHelper.GetExpressionText(propertySelector);
return(this.Request.Unvalidated[requestKey]);
}
public void ApexMembersSpelledTheSameWayAsPrimitiveTypesAreNotConvertedToCSharp()
{
string ToCSharp(string expr) => GenericExpressionHelper.ConvertApexTypesToCSharp(expr);
string ToApex(string expr) => GenericExpressionHelper.ConvertCSharpTypesToApex(expr);
Assert.AreEqual("a = (Date)x", ToCSharp("a = (date)x"));
Assert.AreEqual("a = new Date(x)", ToCSharp("a = new date(x)"));
Assert.AreEqual("a = new Date(x).date()", ToCSharp("a = new Date(x).date()"));
Assert.AreEqual("a = new Date(x)", ToApex("a = new Date(x)"));
Assert.AreEqual("a = new Date(x).date()", ToApex("a = new Date(x).date()"));
}
/// <summary>
/// Attempt to update the specified model instance using values from the controller's current value provider.
/// </summary>
/// <typeparam name="M">The type of the model.</typeparam>
/// <typeparam name="VM">The type of object which contains the model.</typeparam>
/// <param name="modelSelector">The expression which extracts the model from which container.</param>
/// <param name="model">The model to update.</param>
/// <returns>Returns true when the included model properties were valid.</returns>
protected bool TryUpdateModel <M, VM>(M model, Expression <Func <VM, M> > modelSelector)
where M : class
{
if (modelSelector == null)
{
throw new ArgumentNullException(nameof(modelSelector));
}
string modelPrefix = GenericExpressionHelper.GetExpressionText(modelSelector);
return(TryUpdateModel(model, modelPrefix));
}
private static string[] GetPropertyNames <M>(Expression <Func <M, object> >[] propertySelectors)
where M : class
{
string[] propertyNames = new string[propertySelectors.Length];
for (int i = 0; i < propertySelectors.Length; i++)
{
propertyNames[i] = GenericExpressionHelper.GetExpressionText(propertySelectors[i]);
}
return(propertyNames);
}
public void ComplexClassExpressionsAreConvertedToTypeof()
{
var text = "Map<string, string>.class";
var csharp = GenericExpressionHelper.ConvertTypeofExpressionsToCSharp(text);
Assert.AreEqual("typeof(Map<string, string>)", csharp);
text = "string12.class";
csharp = GenericExpressionHelper.ConvertTypeofExpressionsToCSharp(text);
Assert.AreEqual("typeof(string12)", csharp);
text = "Some.New.Stuff.class";
csharp = GenericExpressionHelper.ConvertTypeofExpressionsToCSharp(text);
Assert.AreEqual("typeof(Some.New.Stuff)", csharp);
text = "List<string>.class";
csharp = GenericExpressionHelper.ConvertTypeofExpressionsToCSharp(text);
Assert.AreEqual("typeof(List<string>)", csharp);
text = "List<System.string1>.class";
csharp = GenericExpressionHelper.ConvertTypeofExpressionsToCSharp(text);
Assert.AreEqual("typeof(List<System.string1>)", csharp);
text = "System.List<string>.class";
csharp = GenericExpressionHelper.ConvertTypeofExpressionsToCSharp(text);
Assert.AreEqual("typeof(System.List<string>)", csharp);
text = "System.Map<string, string, string>.class";
csharp = GenericExpressionHelper.ConvertTypeofExpressionsToCSharp(text);
Assert.AreEqual("typeof(System.Map<string, string, string>)", csharp);
text = "Map<List<string>, string>.class";
csharp = GenericExpressionHelper.ConvertTypeofExpressionsToCSharp(text);
Assert.AreEqual("typeof(Map<List<string>, string>)", csharp);
text = "Map<string, System.List<string>>.class";
csharp = GenericExpressionHelper.ConvertTypeofExpressionsToCSharp(text);
Assert.AreEqual("typeof(Map<string, System.List<string>>)", csharp);
text = "Map<List<string>, System.List<string>>.class";
csharp = GenericExpressionHelper.ConvertTypeofExpressionsToCSharp(text);
Assert.AreEqual("typeof(Map<List<string>, System.List<string>>)", csharp);
text = "Map<System.Map<int , string> , System.List<string, int>>.class";
csharp = GenericExpressionHelper.ConvertTypeofExpressionsToCSharp(text);
Assert.AreEqual("typeof(Map<System.Map<int , string> , System.List<string, int>>)", csharp);
// more than two levels deep — cannot be supported by regular expressions
text = "Map<List<Set<string>>, System.List<string>>.class";
csharp = GenericExpressionHelper.ConvertTypeofExpressionsToCSharp(text);
Assert.AreEqual("Map<List<Set<string>>, System.List<string>>.class", csharp);
}
public void GetSoqlExpressionReturnsApexSoqlExpressionBody()
{
var text = "List<Contact> contacts = Soql.Query<Contact>(\"SELECT Id, Email, Phone FROM Contact\");";
var expr = GenericExpressionHelper.ExtractSoqlQueries(text);
Assert.AreEqual(1, expr.Length);
Assert.AreEqual("SELECT Id, Email, Phone FROM Contact", expr[0]);
text = "Soql.Query<Contact>(\"SELECT Id, Email, Phone FROM Contact WHERE Email = :email\", email);";
expr = GenericExpressionHelper.ExtractSoqlQueries(text);
Assert.AreEqual(1, expr.Length);
Assert.AreEqual("SELECT Id, Email, Phone FROM Contact WHERE Email = :email", expr[0]);
}
protected override void AppendSoqlQuery(string soqlQuery)
{
var queryText = soqlQuery.Substring(1, soqlQuery.Length - 2);
var tableName = GenericExpressionHelper.GetSoqlTableName(queryText);
var parameters = GenericExpressionHelper.GetSoqlParameters(queryText);
var paramList = string.Empty;
if (parameters.Any())
{
paramList = ", " + string.Join(", ", parameters);
}
Append("Soql.query<{0}>(@\"{1}\"{2})", tableName, queryText, paramList);
}
private void Check(string expr, params string[] expectedParts)
{
var parts = GenericExpressionHelper.Split(expr);
Assert.AreEqual(expr, string.Concat(parts));
if (!expectedParts.IsNullOrEmpty())
{
Assert.AreEqual(expectedParts.Length, parts.Length);
foreach (var part in parts.Zip(expectedParts, (p, e) => new { p, e }))
{
Assert.AreEqual(part.e, part.p);
}
}
}
public void ConvertSoqlInserUpdateDeleteOperationsReturnsApexStatements()
{
var text = "Soql.Insert(contact);";
var apex = GenericExpressionHelper.ConvertSoqlStatementsToApex(text);
Assert.AreEqual("insert contact;", apex);
text = "Soql.Update(contact);";
apex = GenericExpressionHelper.ConvertSoqlStatementsToApex(text);
Assert.AreEqual("update contact;", apex);
text = "Soql.Delete(contact);";
apex = GenericExpressionHelper.ConvertSoqlStatementsToApex(text);
Assert.AreEqual("delete contact;", apex);
}
/// <summary>
/// Updates the specified model instance using values from the controller's current value provider
/// and included properties.
/// </summary>
/// <typeparam name="M">The type of the model.</typeparam>
/// <typeparam name="VM">The type of object which contains the model.</typeparam>
/// <param name="modelSelector">The expression to extract the model the view model of type <typeparamref name="VM"/>.</param>
/// <param name="model">The model to update.</param>
/// <param name="excludedPropertiesSelectors">Array of expressions of excluded properties.</param>
/// <exception cref="InvalidOperationException">Thrown when the included properties are not valid.</exception>
protected void UpdateModelExcluding <M, VM>(
Expression <Func <VM, M> > modelSelector,
M model,
params Expression <Func <M, object> >[] excludedPropertiesSelectors)
where M : class
{
if (modelSelector == null)
{
throw new ArgumentNullException(nameof(modelSelector));
}
string prefix = GenericExpressionHelper.GetExpressionText(modelSelector);
UpdateModelExcluding(prefix, model, excludedPropertiesSelectors);
}
/// <summary>
/// Using the controller's value provider, Bind a <see cref="IStatefulObjectExecutionModel"/> for executing a path on a stateful object.
/// Any validation errors are capured in ModelState.
/// </summary>
/// <typeparam name="ST">The type of state transitions of the stateful object.</typeparam>
/// <typeparam name="SO">The type of the stateful object.</typeparam>
/// <typeparam name="WM">The type of the workflow manager for the stateful object.</typeparam>
/// <typeparam name="VM">The type of the view model containing the <see cref="IStatefulObjectExecutionModel"/>.</typeparam>
/// <param name="workflowManager">he workflow manager for the stateful object.</param>
/// <param name="modelSelector">The expression to extract <see cref="IStatefulObjectExecutionModel"/> from the view model of type <typeparamref name="VM"/>.</param>
/// <returns>Returns the model requested. Check ModelState for any validation errors.</returns>
protected async Task <StatefulObjectExecutionModel <U, ST, SO> > BindStatefulObjectExecutionModelAsync <ST, SO, WM, VM>(
WM workflowManager,
Expression <Func <VM, IStatefulObjectExecutionModel> > modelSelector)
where ST : StateTransition <U>
where SO : IStateful <U, ST>
where WM : IWorkflowManager <U, ST, SO>
{
if (modelSelector == null)
{
throw new ArgumentNullException(nameof(modelSelector));
}
string prefix = GenericExpressionHelper.GetExpressionText(modelSelector);
return(await BindStatefulObjectExecutionModelAsync <ST, SO, WM>(workflowManager, prefix));
}
public override void VisitAnnotation(AnnotationSyntax node)
{
var attribute = ConvertUnitTestAnnotation(node, CurrentMember);
if (string.IsNullOrWhiteSpace(attribute.Parameters))
{
AppendIndentedLine("[{0}]", attribute.Identifier);
}
else
{
// make sure parameters are comma-separated
var parameters = GenericExpressionHelper.ConvertApexAnnotationParametersToCSharp(attribute.Parameters);
parameters = parameters.Replace("\'", "\"");
AppendIndentedLine("[{0}({1})]", attribute.Identifier, parameters);
}
}
public void TypeofSomeIsConvertedToSomeDotClass()
{
var text = "typeof(string)";
var apex = GenericExpressionHelper.ConvertTypeofExpressionsToApex(text);
Assert.AreEqual("string.class", apex);
text = "mock(typeof(MyLittleClass))";
apex = GenericExpressionHelper.ConvertTypeofExpressionsToApex(text);
Assert.AreEqual("mock(MyLittleClass.class)", apex);
// backward conversion is supported
text = "typeof(Map<string, string>)";
apex = GenericExpressionHelper.ConvertTypeofExpressionsToApex(text);
Assert.AreEqual("Map<string, string>.class", apex);
}
public void SomeDotClassIsConvertedToTypeofClass()
{
var text = "string.class";
var csharp = GenericExpressionHelper.ConvertTypeofExpressionsToCSharp(text);
Assert.AreEqual("typeof(string)", csharp);
text = "mock(MyLittleClass.class)";
csharp = GenericExpressionHelper.ConvertTypeofExpressionsToCSharp(text);
Assert.AreEqual("mock(typeof(MyLittleClass))", csharp);
// not supported by regex-based expression helper
text = "Map<string, string>.class)";
csharp = GenericExpressionHelper.ConvertTypeofExpressionsToCSharp(text);
Assert.AreEqual("Map<string, string>.class)", csharp);
}
/// <summary>
/// Attempt to get the value of a model property from a value provider,
/// else return null if the value was not specified.
/// </summary>
/// <typeparam name="M">The type of the model being bound to the value provider.</typeparam>
/// <param name="valueProvider">The Value provoder.</param>
/// <param name="modelPropertyExpression">Expression for selecting the property from the bound model.</param>
/// <returns>Returns the result found if the value exists, else null.</returns>
public static ValueProviderResult GetValue <M>(
this IValueProvider valueProvider,
Expression <Func <M, object> > modelPropertyExpression)
{
if (valueProvider == null)
{
throw new ArgumentNullException(nameof(valueProvider));
}
if (modelPropertyExpression == null)
{
throw new ArgumentNullException(nameof(modelPropertyExpression));
}
string propertyKey = GenericExpressionHelper.GetExpressionText(modelPropertyExpression);
return(valueProvider.GetValue(propertyKey));
}
private ApexExpressionSyntax ConvertExpression(ExpressionSyntax expression)
{
if (expression == null)
{
return(null);
}
var apexExpr = expression.ToString();
apexExpr = GenericExpressionHelper.ConvertSoqlQueriesToApex(apexExpr);
apexExpr = GenericExpressionHelper.ConvertSoqlStatementsToApex(apexExpr);
apexExpr = GenericExpressionHelper.ConvertTypeofExpressionsToApex(apexExpr);
apexExpr = GenericExpressionHelper.ConvertCSharpIsTypeExpressionToApex(apexExpr);
apexExpr = GenericExpressionHelper.ConvertCSharpTypesToApex(apexExpr);
apexExpr = apexExpr.Replace("\"", "'");
return(new ApexExpressionSyntax(apexExpr));
}
public void DoubleLiteralsAreConvertedToDecimalLiterals()
{
string ToCSharp(string expr) => GenericExpressionHelper.ConvertApexDoubleLiteralsToDecimals(expr);
string ToApex(string expr) => GenericExpressionHelper.ConvertCSharpDecimalLiteralsToDoubles(expr);
Assert.AreEqual("a = 123.45m", ToCSharp("a = 123.45"));
Assert.AreEqual("a = .45m", ToCSharp("a = .45"));
Assert.AreEqual("a = 1.0m", ToCSharp("a = 1.0"));
Assert.AreEqual("a123.45", ToCSharp("a123.45"));
Assert.AreEqual("a.", ToCSharp("a."));
Assert.AreEqual("a = 123.45", ToApex("a = 123.45m"));
Assert.AreEqual("a = .45", ToApex("a = .45M"));
Assert.AreEqual("a = 1.0", ToApex("a = 1.0m"));
Assert.AreEqual("a123.45m", ToApex("a123.45m"));
Assert.AreEqual("a.m", ToCSharp("a.m"));
}
public void ConvertTypeNames()
{
string ToCSharp(string type) => GenericExpressionHelper.ConvertApexTypeToCSharp(type);
string ToApex(string type) => GenericExpressionHelper.ConvertCSharpTypeToApex(type);
Assert.AreEqual("bool", ToCSharp(ApexKeywords.Boolean));
Assert.AreEqual("bool", ToCSharp("boolean"));
Assert.AreEqual("bool", ToCSharp("BOOLEAN"));
Assert.AreEqual("string", ToCSharp(ApexKeywords.String));
Assert.AreEqual("string", ToCSharp("string"));
Assert.AreEqual("int", ToCSharp(ApexKeywords.Integer));
Assert.AreEqual(ApexKeywords.Integer, ToApex("int"));
Assert.AreEqual(ApexKeywords.String, ToApex("string"));
Assert.AreEqual(ApexKeywords.Datetime, ToApex("DateTime"));
Assert.AreEqual(ApexKeywords.Time, ToApex("Time"));
}
public void DateTimeNowAndDateTodayAreConverted()
{
var text = "Datetime.now()";
var csharp = GenericExpressionHelper.ConvertApexDateTimeNowToCSharp(text);
Assert.AreEqual("DateTime.Now", csharp);
text = "Date.today()";
csharp = GenericExpressionHelper.ConvertApexDateTodayToCSharp(text);
Assert.AreEqual("DateTime.Today", csharp);
text = "DateTime.Now";
var apex = GenericExpressionHelper.ConvertCSharpDateTimeNowToApex(text);
Assert.AreEqual("Datetime.now()", apex);
text = "DateTime.Today";
apex = GenericExpressionHelper.ConvertCSharpDateTimeTodayToApex(text);
Assert.AreEqual("Date.today()", apex);
}
public void StringValueofSomethingIsConvertedToSomethingToString()
{
var text = "string.valueOf(1)";
var csharp = GenericExpressionHelper.ConvertStringValueofToString(text);
Assert.AreEqual("1.ToString()", csharp);
text = "string.valueOf(something)";
csharp = GenericExpressionHelper.ConvertStringValueofToString(text);
Assert.AreEqual("something.ToString()", csharp);
text = "string.valueOf(something+1)";
csharp = GenericExpressionHelper.ConvertStringValueofToString(text);
Assert.AreEqual("(something+1).ToString()", csharp);
// not supported by regex-based expression helper
text = "string.valueOf(method())";
csharp = GenericExpressionHelper.ConvertStringValueofToString(text);
Assert.AreEqual("string.valueOf(method())", csharp);
}
private void SplitAndAppendParts(string expression)
{
var parts = GenericExpressionHelper.Split(expression);
foreach (var part in parts)
{
if (part.StartsWith("'"))
{
AppendStringLiteral(part);
}
else if (part.StartsWith("["))
{
AppendSoqlQuery(part);
}
else
{
AppendExpressionPart(part);
}
}
}
public void ApexInstanceOfConvertedToCSharpAndBackAgain()
{
string ToCSharp(string x) => GenericExpressionHelper.ConvertApexInstanceOfTypeExpressionToCSharp(x);
string ToApex(string x) => GenericExpressionHelper.ConvertCSharpIsTypeExpressionToApex(x);
var text = "Property instanceof int";
var csharp = ToCSharp(text);
Assert.AreEqual("Property is int", csharp);
var apex = ToApex(csharp);
Assert.AreEqual(text, apex);
text = @"int a = Value instanceof Map<string, string> ? 10 : 20";
csharp = ToCSharp(text);
Assert.AreEqual(@"int a = Value is Map<string, string> ? 10 : 20", csharp);
apex = ToApex(csharp);
Assert.AreEqual(text, apex);
}
