public void CreateValues_ObjectAsDictionary_Object()
{
// arrange
Schema schema = CreateSchema();
OperationDefinitionNode operation = CreateQuery(
"query test($test: BarInput!) { a }");
var fooInput = new Dictionary <string, object>();
fooInput["b"] = "B";
var barInput = new Dictionary <string, object>();
barInput["f"] = fooInput;
var variableValues = new Dictionary <string, object>();
variableValues.Add("test", barInput);
var resolver = new VariableValueBuilder(schema, operation);
// act
VariableValueCollection coercedVariableValues =
resolver.CreateValues(variableValues);
// assert
Bar bar = coercedVariableValues.GetVariable <Bar>("test");
Assert.NotNull(bar.F);
Assert.Equal(BarEnum.B, bar.F.B);
}
public void CreateValues_ListOfObject_ListOfString()
{
// arrange
Schema schema = CreateSchema();
OperationDefinitionNode operation = CreateQuery(
"query test($test: [String]) { a }");
var variableValues = new Dictionary <string, object>
{
{ "test", new List <object> {
"a", "b"
} }
};
var resolver = new VariableValueBuilder(schema, operation);
// act
VariableValueCollection coercedVariableValues =
resolver.CreateValues(variableValues);
// assert
var list = coercedVariableValues.GetVariable <string[]>("test");
Assert.Collection(list,
t => Assert.Equal("a", t),
t => Assert.Equal("b", t));
}
public void CoerceInputObjectWithEnumAsEnumValueNode()
{
// arrange
Schema schema = CreateSchema();
OperationDefinitionNode operation = CreateQuery(
"query test($test: BarInput!) { a }");
var fooInput = new ObjectValueNode(
new ObjectFieldNode("b",
new EnumValueNode("B")));
var barInput = new ObjectValueNode(
new ObjectFieldNode("f", fooInput));
var variableValues = new Dictionary <string, object>
{
{ "test", barInput }
};
var resolver = new VariableValueBuilder(schema, operation);
// act
VariableValueCollection coercedVariableValues =
resolver.CreateValues(variableValues);
// assert
Bar bar = coercedVariableValues.GetVariable <Bar>("test");
Assert.NotNull(bar.F);
Assert.Equal(BarEnum.B, bar.F.B);
}
public void Backing_Type_Can_Be_Used_As_Variable()
{
// arrange
Schema schema = CreateSchema();
OperationDefinitionNode operation = CreateQuery(
"query test($test: BarInput!) { a }");
var variableValues = new Dictionary <string, object>
{
{ "test", new Bar {
F = new Foo {
B = BarEnum.A
}
} }
};
var resolver = new VariableValueBuilder(schema, operation);
// act
VariableValueCollection coercedVariableValues =
resolver.CreateValues(variableValues);
// assert
Bar bar = coercedVariableValues.GetVariable <Bar>("test");
Assert.NotNull(bar.F);
Assert.Equal(BarEnum.A, bar.F.B);
}
public void Variable_InputObjectAsClrType_NonNullListItemNull()
{
// arrange
Schema schema = CreateSchema();
OperationDefinitionNode operation = CreateQuery(
"query test($test: BazInput) { a }");
var variableValues = new Dictionary <string, object>
{
{ "test", new Baz
{
Foo = "foo",
Quox = new string[] { null }
} }
};
// act
var resolver = new VariableValueBuilder(schema, operation);
VariableValueCollection variables = resolver.CreateValues(variableValues);
// assert
Baz baz = variables.GetVariable <Baz>("test");
Assert.Equal("foo", baz.Foo);
Assert.Collection(baz.Quox, t => Assert.Null(t));
}
public void GetVariable_Name_Is_Invalid(string name)
{
// arrange
var values = new Dictionary <string, VariableValue>();
var variables = new VariableValueCollection(TypeConversion.Default, values);
// act
Action action = () => variables.GetVariable <string>(name);
// assert
Assert.Throws <ArgumentException>(action);
}
public void GetVariable_Converted()
{
// arrange
var values = new Dictionary <string, VariableValue>
{
{ "abc", new VariableValue("abc", new StringType(), "123") }
};
var variables = new VariableValueCollection(TypeConversion.Default, values);
// act
int value = variables.GetVariable <int>("abc");
// assert
Assert.Equal(123, value);
}
public void GetVariable_StringValue_As_IValueNodeOfString()
{
// arrange
var values = new Dictionary <string, VariableValue>
{
{ "abc", new VariableValue("abc", new StringType(), new StringValueNode("def")) }
};
var variables = new VariableValueCollection(TypeConversion.Default, values);
// act
var value = variables.GetVariable <IValueNode <string> >("abc");
// assert
Assert.Equal("def", value.Value);
}
public void QueryWithNonNullVariableAndDefaultWhereValueIsNull()
{
// arrange
Schema schema = CreateSchema();
OperationDefinitionNode operation = CreateQuery(
"query test($test: String! = \"foo\") { a }");
var variableValues = new Dictionary <string, object>();
// act
var resolver = new VariableValueBuilder(schema, operation);
VariableValueCollection coercedVariableValues =
resolver.CreateValues(variableValues);
// assert
Assert.Equal("foo",
coercedVariableValues.GetVariable <string>("test"));
}
public void GetVariable_Variable_Does_Not_Exist()
{
// arrange
var values = new Dictionary <string, VariableValue>
{
{ "abc", new VariableValue("abc", new StringType(), "123") }
};
var variables = new VariableValueCollection(TypeConversion.Default, values);
// act
Action action = () => variables.GetVariable <int>("def");
// assert
Assert.Throws <QueryException>(action)
.Errors.MatchSnapshot();
}
public void GetVariable_Casted()
{
// arrange
var values = new Dictionary <string, object>
{
{ "abc", "def" }
};
var variables = new VariableValueCollection(
TypeConversion.Default,
values);
// act
string value = variables.GetVariable <string>("abc");
// assert
Assert.Equal("def", value);
}
public void QueryWithNullableVarAndNoDefaultWhereNoValueWasProvided()
{
// arrange
Schema schema = CreateSchema();
OperationDefinitionNode operation = CreateQuery(
"query test($test: String) { a }");
var variableValues = new Dictionary <string, object>
{
{ "test", NullValueNode.Default }
};
var resolver = new VariableValueBuilder(schema, operation);
// act
VariableValueCollection coercedVariableValues =
resolver.CreateValues(variableValues);
// assert
Assert.Null(coercedVariableValues.GetVariable <string>("test"));
}
public void Variable_List_NonNullListItemHasValue()
{
// arrange
Schema schema = CreateSchema();
OperationDefinitionNode operation = CreateQuery(
"query test($test: [String!]) { a }");
var variableValues = new Dictionary <string, object>
{
{ "test", new List <string> {
"abc"
} }
};
// act
var resolver = new VariableValueBuilder(schema, operation);
VariableValueCollection variables =
resolver.CreateValues(variableValues);
// assert
variables.GetVariable <List <string> >("test").MatchSnapshot();
}
public void Variable_InputObjectAsClrType_NonNullFieldNull()
{
// arrange
Schema schema = CreateSchema();
OperationDefinitionNode operation = CreateQuery(
"query test($test: BazInput) { a }");
var variableValues = new Dictionary <string, object>
{
{ "test", new Baz {
Bar = "bar"
} }
};
// act
var resolver = new VariableValueBuilder(schema, operation);
VariableValueCollection coercedVariableValues =
resolver.CreateValues(variableValues);
// assert
Assert.Equal("bar", coercedVariableValues.GetVariable <Baz>("test").Bar);
}
public void CoerceEnumFromEnumValueNode()
{
// arrange
Schema schema = CreateSchema();
OperationDefinitionNode operation = CreateQuery(
"query test($test: BarEnum!) { a }");
var variableValues = new Dictionary <string, object>
{
{ "test", new EnumValueNode("A") }
};
var resolver = new VariableValueBuilder(schema, operation);
// act
VariableValueCollection coercedVariableValues =
resolver.CreateValues(variableValues);
// assert
Assert.Equal(BarEnum.A,
coercedVariableValues.GetVariable <BarEnum>("test"));
}
public void CreateValues_SerializedDecimal_Decimal()
{
// arrange
Schema schema = CreateSchema();
OperationDefinitionNode operation = CreateQuery(
"query test($test: Decimal) { a }");
var input = 1.000000E-004;
var variableValues = new Dictionary <string, object>();
variableValues.Add("test", input);
var resolver = new VariableValueBuilder(schema, operation);
// act
VariableValueCollection coercedVariableValues =
resolver.CreateValues(variableValues);
// assert
var result = coercedVariableValues.GetVariable <decimal>("test");
Assert.Equal(0.0001m, result);
}
public void CreateValues_IntValue_Int(int value)
{
// arrange
Schema schema = CreateSchema();
OperationDefinitionNode operation = CreateQuery(
"query test($test: Int) { a }");
var variableValues = new Dictionary <string, object>
{
{ "test", value }
};
var resolver = new VariableValueBuilder(schema, operation);
// act
VariableValueCollection coercedVariableValues =
resolver.CreateValues(variableValues);
// assert
var result = coercedVariableValues.GetVariable <int>("test");
Assert.Equal(value, result);
}
public void Coerce_Variable_Value_Int_To_Float()
{
// arrange
Schema schema = CreateSchema();
OperationDefinitionNode operation = CreateQuery(
"query test($test: Float!) { a }");
var variableValues = new Dictionary <string, object>
{
{
"test",
123
}
};
// act
var resolver = new VariableValueBuilder(schema, operation);
VariableValueCollection coercedVariableValues =
resolver.CreateValues(variableValues);
// assert
Assert.Equal((float)123,
coercedVariableValues.GetVariable <float>("test"));
}
