public void Root_Grouping_with_tuple_element_gets_converted()
{
var results = CreateResult <IGrouping <Int32, Tuple <Int32, String> > >(
NestedResolveResult.Pack("hello", NestedResolveResult.Pack(2, 42)),
NestedResolveResult.Pack("and now for something", NestedResolveResult.Pack(2, 4321)),
NestedResolveResult.Pack("there", NestedResolveResult.Pack(2, 42)),
NestedResolveResult.Pack("completely different", NestedResolveResult.Pack(2, 4321))
);
Assert.Equal(2, results.Count());
var first = Assert.Single(results, r => r.Key == 42);
var second = Assert.Single(results, r => r.Key == 4321);
Assert.Equal(new[]
{
Tuple.Create(2, "hello"),
Tuple.Create(2, "there")
}, first);
Assert.Equal(new[]
{
Tuple.Create(2, "and now for something"),
Tuple.Create(2, "completely different")
}, second);
}
public void Unpacks_non_nested_parent()
{
var expected = "parent";
var actual = NestedResolveResult.Unpack <String>(expected);
Assert.Equal(expected, actual);
}
public void Packs_nested_parent()
{
var parent = NestedResolveResult.Pack("42", "parent");
var nested = NestedResolveResult.Pack("nested", parent);
Assert.Equal("nested", nested.Value);
Assert.Equal(new[] { "parent", "42" }, nested.Parents);
}
public virtual Object ConvertNested(NestedResolveResult nested)
{
var components = nested.ExtractComponents(ComponentTypesFlattened);
using (var enumerator = components.AsEnumerable().GetEnumerator())
{
return ConvertNestedComponents(enumerator);
}
}
public void Packs_non_nested_parent()
{
var packed = NestedResolveResult.Pack("42", "parent");
Assert.Equal("42", packed.Value);
var parent = Assert.Single(packed.Parents);
Assert.Equal("parent", parent);
}
public void Gets_converted_to_Tuple()
{
var result = CreateResult <Tuple <String, Int32> >(
NestedResolveResult.Pack(42, "test")
);
var actual = Assert.Single(result);
Assert.Equal(Tuple.Create("test", 42), actual);
}
public void Gets_unpacked()
{
var result = CreateResult <String>(
NestedResolveResult.Pack("42", "parent")
);
var actual = Assert.Single(result);
Assert.Equal("42", actual);
}
public void Unpacks_nested_parent()
{
var packed = NestedResolveResult.Pack(
"baby",
NestedResolveResult.Pack("mama", "granny")
);
var unpacked = NestedResolveResult.Unpack <String>(packed);
Assert.Equal("baby", unpacked);
}
private static NestedResolveResult <City> CreateVinaDelMar()
=> NestedResolveResult.Pack(
Universe.Create <City>("Viña del Mar"),
NestedResolveResult.Pack(
Universe.Create <Country>("Chile"),
NestedResolveResult.Pack(
Universe.Create <Continent>("South America"),
Universe.Create <Planet>("Earth")
)
)
);
public void Gets_converted_to_Tuple_of_Tuples()
{
var result = CreateResult <Tuple <String, Tuple <Boolean, Int32> > >(
NestedResolveResult.Pack(42,
NestedResolveResult.Pack(true, "test")
)
);
var actual = Assert.Single(result);
Assert.Equal(Tuple.Create("test", Tuple.Create(true, 42)), actual);
}
protected override String GetIdentifierFromNested(NestedResolveResult nested)
{
if (nested == null)
{
throw Logger.Fatal.ArgumentNull(nameof(nested));
}
var tuple = nested.ExtractComponents <List, View>();
return(HarshUrl.GetRelativeTo(
tuple.Item2.ServerRelativeUrl,
tuple.Item1.RootFolder.ServerRelativeUrl
));
}
public void Root_Grouping_with_tuple_keys_gets_converted()
{
var results = CreateResult <IGrouping <Tuple <Int32, Int32>, String> >(
NestedResolveResult.Pack("hello", NestedResolveResult.Pack(2, 42)),
NestedResolveResult.Pack("and now for something", NestedResolveResult.Pack(2, 4321)),
NestedResolveResult.Pack("there", NestedResolveResult.Pack(2, 42)),
NestedResolveResult.Pack("completely different", NestedResolveResult.Pack(2, 4321))
).ToArray();
Assert.Equal(2, results.Count());
var first = Assert.Single(results, r => r.Key.Equals(Tuple.Create(42, 2)));
var second = Assert.Single(results, r => r.Key.Equals(Tuple.Create(4321, 2)));
Assert.Equal(new[] { "hello", "there" }, first);
Assert.Equal(new[] { "and now for something", "completely different" }, second);
}
public void Nested_Grouping_gets_converted()
{
var results = CreateResult <IGrouping <Int32, IGrouping <Int32, String> > >(
NestedResolveResult.Pack("hello", NestedResolveResult.Pack(2, 42)),
NestedResolveResult.Pack("and now for something", NestedResolveResult.Pack(2, 4321)),
NestedResolveResult.Pack("there", NestedResolveResult.Pack(2, 42)),
NestedResolveResult.Pack("completely different", NestedResolveResult.Pack(2, 4321))
);
Assert.Equal(2, results.Count());
var first = Assert.Single(results, r => r.Key == 42);
var second = Assert.Single(results, r => r.Key == 4321);
var first2 = Assert.Single(first, g => g.Key == 2);
var second2 = Assert.Single(second, g => g.Key == 2);
Assert.Equal(new[] { "hello", "there" }, first2);
Assert.Equal(new[] { "and now for something", "completely different" }, second2);
}
