public LiquidCollection CreateArray()
{
// Arrange
return(new LiquidCollection {
LiquidString.Create("1"),
LiquidNumeric.Create(2),
LiquidString.Create("Three"),
new LiquidBoolean(true)
});;
}
public void It_Should_Convert_A_Numeric_To_A_Date()
{
var date = new DateTime(2015, 10, 29, 10, 11, 12);
var result = ValueCaster.Cast <LiquidNumeric, LiquidDate>(LiquidNumeric.Create(date.Ticks));
Assert.That(result.IsSuccess, Is.True);
Assert.That(result.SuccessResult.HasValue, Is.True);
// ReSharper disable once PossibleInvalidOperationException
Assert.That(result.SuccessValue <LiquidDate>().DateTimeValue.Value, Is.EqualTo(date));
}
public void It_Should_Return_Error_When_Multiple_Constructors()
{
// Arrange
var filter = FilterFactory.InstantiateFilter("mockfilter", typeof(TwoConstructorFilter), new List <Option <ILiquidValue> > {
LiquidNumeric.Create(123)
});
// Assert
Assert.True(filter.IsFailure);
}
public void It_Should_Return_Error_When_Null_Type()
{
// Arrange
var filter = FilterFactory.InstantiateFilter("mockfilter", null, new List <Option <ILiquidValue> > {
LiquidNumeric.Create(123)
});
// Assert
Assert.True(filter.IsFailure);
}
public LiquidHash CreateDictionary()
{
return(new LiquidHash
{
{ "one", LiquidString.Create("1") },
{ "two", LiquidNumeric.Create(2) },
{ "three", LiquidString.Create("Three") },
{ "four", new LiquidBoolean(true) }
});
}
private LiquidCollection CreateArrayValues()
{
return(new LiquidCollection
{
LiquidNumeric.Create(1),
LiquidNumeric.Create(2),
LiquidNumeric.Create(3),
LiquidNumeric.Create(4)
});
}
public void It_Should_Cast_An_Int_To_A_String_Like_Ruby_Liquid(int input, String expected)
{
// Arrange
var castFilter = new CastFilter <LiquidNumeric, LiquidString>();
// Act
var result = castFilter.Apply(new TemplateContext(), LiquidNumeric.Create(input)).SuccessValue <LiquidString>();
// Assert
Assert.That(result.StringVal, Is.EqualTo(expected));
}
public void It_Should_Cast_A_Decimal_To_A_String_Like_Ruby_Liquid(decimal input, String expected)
{
// Arrange
var castFilter = new CastFilter <LiquidNumeric, LiquidString>();
// Act
var result = castFilter.Apply(new TemplateContext(), LiquidNumeric.Create(input)).SuccessValue <LiquidString>();
// Assert
Assert.Equal(expected, result.StringVal);
}
public void It_Should_Pluralize_An_Integerr(int input, String expected)
{
// Arrange
TemplateContext ctx = new TemplateContext();
ctx.DefineLocalVariable("input", LiquidNumeric.Create(input));
var result = RenderingHelper.RenderTemplate("Result : {{ input | pluralize: 'thing', 'things' }}", ctx);
// Assert
Assert.Equal("Result : " + expected, result);
}
public void It_Should_Generate_Some_Values(int start, int end, int[] expected)
{
// Arrange
var generatorValue = new LiquidRange(LiquidNumeric.Create(start), LiquidNumeric.Create(end));
// Act
var result = generatorValue.AsEnumerable();
// Assert
Assert.Equal(expected.ToList(), result.Select(x => Convert.ToInt32(x.Value)));
}
public void It_Should_Cast_Numeric_Args_To_A_String()
{
// Arrange
var filter = FilterFactory.InstantiateFilter("mockfilter", typeof(MockStringToStringFilter), new List <Option <ILiquidValue> > {
LiquidNumeric.Create(123)
});
// Act
Assert.Equal("123", ((MockStringToStringFilter)filter.Value).LiquidStringArg1.Value);
}
public void It_Should_Evaluate_To_Itself()
{
// Arrange
var number = LiquidNumeric.Create(123m);
// Act
var result = number.Eval(new TemplateContext(), new List <Option <ILiquidValue> >()).SuccessValue <LiquidNumeric>();
// Assert
Assert.Equal(123m, result.Value);
}
public void Test_Filter()
{
ITemplateContext ctx = new TemplateContext()
.WithAllFilters()
.DefineLocalVariable("resultcount", LiquidNumeric.Create(42))
.DefineLocalVariable("searchterm", LiquidString.Create("MiXeDcAsE"));
var parsingResult = LiquidTemplate.Create("{{ resultcount }} {{ resultcount | pluralize: 'item', 'items' }} were found for '{{searchterm | downcase}}'.");
Assert.That(parsingResult.LiquidTemplate.Render(ctx).Result, Is.EqualTo("42 items were found for 'mixedcase'."));
}
public void It_Should_Pluralize_A_Decimal_Number(decimal input, String expected)
{
// Arrange
TemplateContext ctx = new TemplateContext();
ctx.DefineLocalVariable("input", LiquidNumeric.Create(input));
var result = RenderingHelper.RenderTemplate("Result : {{ input | pluralize: 'thing', 'things' }}", ctx);
// Assert
Assert.That(result, Is.EqualTo("Result : " + expected));
}
public void A_Generator_Value_Should_Return_The_Size()
{
// Arrange
var strVal = new LiquidRange(LiquidNumeric.Create(3), LiquidNumeric.Create(10));
var filter = new SizeFilter();
// Act
var result = filter.Apply(new TemplateContext(), strVal).SuccessValue <LiquidNumeric>();
// Assert
Assert.Equal(8, result.Value);
}
public void It_Should_Dereference_A_LiquidHash()
{
// Arrange
var dictValue = new LiquidHash
{
{ "string1", LiquidString.Create("a string") },
{ "string2", LiquidNumeric.Create(123) },
{ "string3", LiquidNumeric.Create(456m) }
};
// Assert
Assert.Equal("a string", dictValue.ValueAt("string1").Value.ToString());
}
public void It_Should_Return_The_Same_Object_If_Dest_Is_An_ExpressionConstant()
{
// Arrange
var original = new LiquidCollection {
LiquidNumeric.Create(123.4m), LiquidNumeric.Create(5)
};
// Act
var result = ValueCaster.Cast <LiquidCollection, LiquidValue>(original).SuccessValue <LiquidCollection>();
// Assert
Assert.That(result, Is.EqualTo(original));
}
public static LiquidExpressionResult GetReturnValue(decimal result, LiquidNumeric val1, LiquidNumeric val2)
{
if (val1.IsInt && val2.IsInt)
{
//var int32 = Convert.ToInt32(val);
var int32 = (int)System.Math.Floor(result); // ruby liquid seems to round down.
return(LiquidExpressionResult.Success(LiquidNumeric.Create(int32)));
}
else
{
return(LiquidExpressionResult.Success(LiquidNumeric.Create(result)));
}
}
public void It_Should_Generate_Some_Values_Descending()
{
// Arrange
var generatorValue = new LiquidRange(LiquidNumeric.Create(5), LiquidNumeric.Create(2));
// Act
var result = generatorValue.AsEnumerable();
// Assert
Assert.Equal(new List <int> {
5, 4, 3, 2
}, result.Select(x => Convert.ToInt32(x.Value)));
}
public void It_Should_Parse_A_Regular_Variable()
{
String input = @"{{ v | plus: v }}";
var template = LiquidTemplate.Create(input);
// Act
String result = template.LiquidTemplate.Render(new TemplateContext()
.DefineLocalVariable("v", LiquidNumeric.Create(3))
.WithAllFilters()).Result;
// Assert
Assert.Equal("6", result.Trim());
}
public void It_Can_Cast_With_Generics()
{
// Arrange
var num = LiquidNumeric.Create(123.45m);
// Act
var stringliteral = ValueCaster.Cast <LiquidNumeric, LiquidString>(num)
.SuccessValue <LiquidString>()
.StringVal;
// Assert
Assert.Equal("123.45", stringliteral);
}
public void It_Should_Return_The_Same_Object_If_Src_And_Dest_Are_Arrays()
{
// Arrange
var original = new LiquidCollection {
LiquidNumeric.Create(123.4m), LiquidNumeric.Create(5)
};
// Act
var result = ValueCaster.Cast <LiquidCollection, LiquidCollection>(original).SuccessValue <LiquidCollection>();
// Assert
Assert.Equal(original, result);
}
public void It_Should_Cast_A_Number_To_A_String()
{
// Arrange
var num = LiquidNumeric.Create(123.45m);
// Act
var stringliteral = ValueCaster.Cast <LiquidNumeric, LiquidString>(num)
.SuccessValue <LiquidString>()
.StringVal;
// Assert
Assert.Equal("123.45", stringliteral);
}
public void It_Can_Cast_With_Generics_Via_Reflection()
{
// Arrange
var num = LiquidNumeric.Create(123.45m);
// Act
MethodInfo method = typeof(ValueCaster).GetMethod("Cast");
MethodInfo generic = method.MakeGenericMethod(typeof(LiquidNumeric), typeof(LiquidString));
var castResult = (LiquidExpressionResult)generic.Invoke(null, new object[] { num });
var stringLiteral = castResult.SuccessValue <LiquidString>();
// Assert
Assert.Equal("123.45", stringLiteral.Value);
}
public void It_Should_Create_A_For_Like_Loop()
{
// Act
var templateContext = new TemplateContext()
.WithAllFilters()
.DefineLocalVariable("array", new LiquidCollection {
LiquidNumeric.Create(10), LiquidNumeric.Create(11)
})
.WithCustomTagBlockRenderer <ForLikeBlockTag>("forcustom");
var result = RenderingHelper.RenderTemplate("Result : {% forcustom \"item\" array %}{{item}}{% endforcustom %}", templateContext);
// Assert
Assert.Equal("Result : START CUSTOM FOR LOOP1011END CUSTOM FOR LOOP", result);
}
private static TemplateContext CreateContextWithDictionary()
{
var ctx = new TemplateContext();
var payments = new LiquidCollection
{
LiquidNumeric.Create(12.34m),
LiquidNumeric.Create(33.45m),
};
ctx.DefineLocalVariable("user", new LiquidHash {
{ "payments", payments }
});
return(ctx);
}
public void It_Can_Use_Reserved_Words()
{
// Arrange
TemplateContext ctx = new TemplateContext();
ctx.DefineLocalVariable("limit", LiquidNumeric.Create(3));
ctx.DefineLocalVariable("offset", LiquidNumeric.Create(1));
var template = LiquidTemplate.Create("Result : {% for wef in \"Hello\" limit:limit offset:offset %}<li>{{ for }}</li>{% endfor %}");
// Act
String result = template.LiquidTemplate.Render(new TemplateContext()).Result;
// Assert
Assert.Equal("Result : <li>e</li><li>l</li><li>l</li>", result);
}
public void It_Should_Not_Slice_A_Number()
{
// Arrange
var ctx = new TemplateContext().WithAllFilters();
ctx.DefineLocalVariable("num", LiquidNumeric.Create(1));
// Act
//var result = RenderingHelper.RenderTemplate("Result : {{ num | slice : 1,2 }}", ctx);
var template = LiquidTemplate.Create("Result : {{ num | slice : 1,2 }}");
var result = template.LiquidTemplate.Render(ctx);
// Assert
Assert.That(result.Result, Is.StringContaining("Can't slice a object of type"));
}
public void It_Should_Dereference_An_Array_Element()
{
// Arrange
LiquidCollection liquidCollection = new LiquidCollection {
LiquidString.Create("a string"),
LiquidNumeric.Create(123),
LiquidNumeric.Create(456m),
new LiquidBoolean(false)
};
// Assert
var valueAt = liquidCollection.ValueAt(0);
Assert.That(valueAt.Value, Is.EqualTo("a string"));
}
public void Test_Simple_Collection()
{
ITemplateContext ctx = new TemplateContext();
ctx.DefineLocalVariable("items", new LiquidCollection
{
LiquidNumeric.Create(2),
LiquidNumeric.Create(4),
LiquidNumeric.Create(6)
});
var parsingResult = LiquidTemplate.Create("<ul>{% for item in items %}<li>{{item}}</li>{% endfor %}</ul>");
Assert.That(parsingResult.LiquidTemplate.Render(ctx).Result, Is.EqualTo("<ul><li>2</li><li>4</li><li>6</li></ul>"));
}
