public void DeserializeToLinqResult_Fails()
{
var sequence = Enumerable.Range(1, 3);
var value = ValueSerializer.Serialize(SerializationContext.Default, sequence);
Assert.Throws <NotSupportedException>(() => ValueDeserializer.Deserialize(SerializationTestData.Context, value, sequence.GetType()));
}
public void DeserializeCustomPropertyConversion_ConverterRegistry()
{
Guid guid1 = Guid.NewGuid();
Guid guid2 = Guid.NewGuid();
var value = new Value
{
MapValue = new MapValue
{
Fields =
{
{ "Name", new Value {
StringValue = "test"
} },
{ "Guid", new Value {
StringValue = guid1.ToString("N")
} },
{ "GuidOrNull", new Value {
StringValue = guid2.ToString("N")
} },
}
}
};
var registry = new ConverterRegistry()
{
new SerializationTestData.GuidConverter()
};
var db = FirestoreDb.Create("proj", "db", new FakeFirestoreClient(), converterRegistry: registry);
var snapshot = GetSampleSnapshot(db, "doc1");
var context = new DeserializationContext(snapshot);
var pair = (SerializationTestData.GuidPair2)ValueDeserializer.Deserialize(context, value, typeof(SerializationTestData.GuidPair2));
Assert.Equal("test", pair.Name);
Assert.Equal(guid1, pair.Guid);
Assert.Equal(guid2, pair.GuidOrNull);
}
public T GetArgument <T>(string argumentName)
{
if (string.IsNullOrEmpty(argumentName))
{
throw new ArgumentNullException(nameof(argumentName));
}
Dictionary <string, ArgumentNode> arguments = GetArguments();
if (arguments.TryGetValue(argumentName, out ArgumentNode argValue) &&
Type.Arguments.TryGetField(argumentName, out InputField arg))
{
if (typeof(T).IsAssignableFrom(arg.Type.ClrType))
{
return((T)arg.Type.ParseLiteral(argValue.Value));
}
else
{
return(ValueDeserializer
.ParseLiteral <T>(arg.Type, argValue.Value));
}
}
throw new ArgumentException(
"The argument name is invalid.",
nameof(argumentName));
}
internal void SetValue(FirestoreDb db, Value value, object target)
{
object converted =
_converter == null?ValueDeserializer.Deserialize(db, value, _propertyInfo.PropertyType)
: value.ValueTypeCase == Value.ValueTypeOneofCase.NullValue ? null
: _converter.DeserializeValue(db, value);
_propertyInfo.SetValue(target, converted);
}
protected override object DeserializeArray(FirestoreDb db, RepeatedField <Value> values)
{
Array array = Array.CreateInstance(_elementType, values.Count);
for (int i = 0; i < values.Count; i++)
{
var converted = ValueDeserializer.Deserialize(db, values[i], _elementType);
array.SetValue(converted, i);
}
return(array);
}
public override object DeserializeMap(FirestoreDb db, IDictionary <string, Value> values)
{
// TODO: Compile an expression tree on construction, or at least accept an optional delegate for construction
// (allowing for special-casing of Dictionary<string, object>).
var ret = (IDictionary <string, TValue>)Activator.CreateInstance(_concreteType);
foreach (var pair in values)
{
ret.Add(pair.Key, (TValue)ValueDeserializer.Deserialize(db, pair.Value, typeof(TValue)));
}
return(ret);
}
protected override object DeserializeArray(DeserializationContext context, RepeatedField <Value> values)
{
// TODO: See if using a compiled expression tree is faster.
var list = (IList)Activator.CreateInstance(TargetType);
foreach (var value in values)
{
var deserialized = ValueDeserializer.Deserialize(context, value, _elementType);
list.Add(deserialized);
}
return(list);
}
public void ParseScalarNullValue()
{
// arrange
var sourceType = new IntType();
var targetType = typeof(int);
NullValueNode literal = NullValueNode.Default;
// act
object result = ValueDeserializer
.ParseLiteral(sourceType, targetType, literal);
// assert
Assert.Null(result);
}
public override object DeserializeMap(DeserializationContext context, IDictionary <string, Value> values)
{
// TODO: What if the keys in the map don't match our names, or there are spare/missing ones?
var accessor = CreateAccessor(Activator.CreateInstance(TargetType));
for (int i = 0; i < _names.Count; i++)
{
if (values.TryGetValue(_names[i], out var value))
{
accessor[i] = ValueDeserializer.Deserialize(context, value, _elementTypes[i]);
}
}
return(accessor.Value);
}
private void SetProperty(InputField argument, object obj, PropertyInfo property)
{
Dictionary <string, ArgumentNode> arguments = GetArguments();
if (arguments.TryGetValue(argument.Name,
out ArgumentNode argumentValue))
{
object parsedValue = ValueDeserializer.ParseLiteral(
argument.Type, property.PropertyType, argumentValue.Value);
ValueDeserializer.SetProperty(
property, argument.Type.IsListType(),
obj, parsedValue);
}
}
public void ParseScalarListToArray()
{
// arrange
var sourceType = new ListType(new IntType());
var targetType = typeof(int[]);
var literal = new ListValueNode(new IntValueNode("1"));
// act
object result = ValueDeserializer
.ParseLiteral(sourceType, targetType, literal);
// assert
Assert.IsType <int[]>(result);
Assert.Collection((int[])result, t => Assert.Equal(1, t));
}
public void ParseNonNullScalar()
{
// arrange
var sourceType = new NonNullType(new IntType());
var targetType = typeof(int);
IntValueNode literal = new IntValueNode("1");
// act
object result = ValueDeserializer
.ParseLiteral(sourceType, targetType, literal);
// assert
Assert.IsType <int>(result);
Assert.Equal(1, result);
}
public void ParseScalarAndConvert()
{
// arrange
var sourceType = new IntType();
var targetType = typeof(string);
var literal = new IntValueNode("1");
// act
object result = ValueDeserializer
.ParseLiteral(sourceType, targetType, literal);
// assert
Assert.IsType <string>(result);
Assert.Equal("1", result);
}
public void ParseAndMapObject()
{
// arrange
ISchema schema = CreateSchema();
var sourceType = schema.GetType <INamedInputType>("FooInput");
var targetType = typeof(FooOnlyBar1);
var literal = CreateFoo();
// act
FooOnlyBar1 result = ValueDeserializer
.ParseLiteral(sourceType, targetType, literal) as FooOnlyBar1;
// assert
Assert.NotNull(result);
Assert.Equal("123", result.Bar1);
}
public void DeserializeToExpando()
{
var value = new Value {
MapValue = new MapValue {
Fields = { { "name", new Value {
StringValue = "Jon"
} },{ "score", new Value {
IntegerValue = 10L
} } }
}
};
dynamic result = ValueDeserializer.Deserialize(SerializationTestData.Context, value, typeof(ExpandoObject));
Assert.Equal("Jon", result.name);
Assert.Equal(10L, result.score);
}
public void ParseObjectGraph()
{
// arrange
ISchema schema = CreateSchema();
var sourceType = schema.GetType <INamedInputType>("BarInput");
var targetType = typeof(Bar);
var literal = CreateBar();
// act
Bar result = ValueDeserializer
.ParseLiteral(sourceType, targetType, literal)
as Bar;
// assert
Assert.NotNull(result);
Assert.NotNull(result.Foo);
Assert.Equal("123", result.Foo.Bar1);
Assert.Equal("456", result.Foo.Bar2);
}
public void DeserializeToSpecificDictionary()
{
var value = new Value {
MapValue = new MapValue {
Fields = { { "x", new Value {
IntegerValue = 10L
} },{ "y", new Value {
IntegerValue = 20L
} } }
}
};
var result = ValueDeserializer.Deserialize(SerializationTestData.Context, value, typeof(Dictionary <string, int>));
Assert.IsType <Dictionary <string, int> >(result);
var expected = new Dictionary <string, int>
{
["x"] = 10,
["y"] = 20
};
Assert.Equal(expected, result);
}
public void DeserializeToObjectDictionary()
{
var value = new Value {
MapValue = new MapValue {
Fields = { { "name", new Value {
StringValue = "Jon"
} },{ "score", new Value {
IntegerValue = 10L
} } }
}
};
var result = ValueDeserializer.Deserialize(SerializationTestData.Context, value, typeof(object));
Assert.IsType <Dictionary <string, object> >(result);
var expected = new Dictionary <string, object>
{
["name"] = "Jon",
["score"] = 10L
};
Assert.Equal(expected, result);
}
public void ParseAndMapObjectGraphWithList()
{
// arrange
ISchema schema = CreateSchema();
var sourceType = schema.GetType <INamedInputType>(
"BarWithArrayInput");
var targetType = typeof(BarWithListOnlyGet);
var literal = CreateBarWithArray();
// act
BarWithListOnlyGet result = ValueDeserializer
.ParseLiteral(sourceType, targetType, literal)
as BarWithListOnlyGet;
// assert
Assert.NotNull(result);
Assert.NotNull(result.Foos);
Assert.Collection(result.Foos,
t =>
{
Assert.Equal("123", t.Bar1);
Assert.Equal("456", t.Bar2);
});
}
public object DeserializeMap_Attributed() => ValueDeserializer.DeserializeMap(FakeDb, SampleData.SerializedMap, typeof(HighScore));
public object DeserializeMap_Expando() => ValueDeserializer.DeserializeMap(FakeDb, SampleData.SerializedMap, typeof(ExpandoObject));
public object DeserializeMap_Dictionary() => ValueDeserializer.DeserializeMap(FakeDb, SampleData.SerializedMap, typeof(Dictionary <string, object>));
public object Deserialize_Expando() => ValueDeserializer.Deserialize(Context, SampleData.Serialized, typeof(ExpandoObject));
public object Deserialize_Dictionary() => ValueDeserializer.Deserialize(Context, SampleData.Serialized, typeof(Dictionary <string, object>));
public object Deserialize_Attributed() => ValueDeserializer.Deserialize(Context, SampleData.Serialized, typeof(HighScore));
public TooltipsRegistry(HttpClient client, ValueDeserializer deserializer)
{
_client = client;
_deserializer = deserializer;
}
