public async Task TestServerEnumHandling()
{
TestEnv.LogTestMethodStart();
TestEnv.LogTestDescr("input object with enum fields.");
var query = @"
query ($objWithEnums: InputObjWithEnums) {
echo: echoInputObjWithEnums(inpObj: $objWithEnums)
}";
var vars = new TDict()
{
{ "objWithEnums", new TDict()
{
{ "flags", new string[] { "FLAG_ONE", "FLAG_THREE" } },
{ "flagsArray", new object[] {
new [] { "FLAG_ONE", "FLAG_TWO" },
new [] { "FLAG_THREE" }
} },
{ "kind", "KIND_TWO" },
} },
};
var resp = await TestEnv.Client.PostAsync(query, vars);
resp.EnsureNoErrors();
Assert.IsNotNull(resp);
var theFlagsStr = (string)resp.data.echo;
theFlagsStr = theFlagsStr.Replace(" ", string.Empty);
Assert.AreEqual("Flags:FlagOne,FlagThree;kind:KindTwo;FlagsArray:[FlagOne,FlagTwo;FlagThree]", theFlagsStr,
"Invalid inputObjWithEnums echo");
}
public async Task TestGraphQLClient_StrongTypes()
{
TestEnv.LogTestMethodStart();
ServerResponse resp;
string query;
var vars = new TDict()
{
{ "id", 3 }
};
// Post requests
TestEnv.LogTestDescr("Basic test for strongly-typed return value.");
query = @"
query ($id: Int) {
thing: getThing(id: $id) {
id, name, kind, theFlags, randoms(count: 5), __typename
}
}";
resp = await TestEnv.Client.PostAsync(query, vars);
resp.EnsureNoErrors();
var thing = resp.GetTopField <Thing_>("thing");
Assert.IsNotNull(thing);
Assert.AreEqual("Name3", thing.Name, "thing name mismatch");
Assert.AreEqual(ThingKind.KindThree, thing.Kind, "Kind mismatch");
Assert.AreEqual(TheFlags.FlagOne | TheFlags.FlagTwo, thing.TheFlags, "Flags mismatch");
Assert.IsNotNull(thing.Randoms, "Expected randoms array");
Assert.AreEqual(5, thing.Randoms.Length, "expected 5 randoms");
// Check unmapped introspection field - to be implemented
// string typeName = resp.GetUnmappedFieldValue<string>(thing, "__typename");
// Assert.AreEqual("Thing", typeName, "type name does not match");
}
static public TDict BuildTDict(string s, int size, TDict t)
{
string prev = "";
foreach (string word in Chunk(s, size))
{
if (t.ContainsKey(prev))
{
WDict w = t[prev];
if (w.ContainsKey(word))
{
w[word] += 1;
}
else
{
w.Add(word, 1);
}
}
else
{
t.Add(prev, new WDict()
{
{ word, 1 }
});
}
prev = word;
}
return(t);
}
static void ValidateDict(TDict dict, TValue expectedValue)
{
IDictionary <string, TValue> genericIDict = (IDictionary <string, TValue>)dict;
Assert.Equal(1, genericIDict.Count);
Assert.Equal(expectedValue, genericIDict["key"]);
}
public void TypeDictionary_ObjectIsNotContained_ReturnsNull()
{
TDict.Set <int>("hei");
var str = TDict.Get <string>();
Assert.IsNull(str);
}
public void TypeDictionary_ReturnsObject()
{
TDict.Set <string>("hei");
var str = TDict.Get <string>();
Assert.AreEqual("hei", str);
}
public async Task TestGraphQLClient()
{
TestEnv.LogTestMethodStart();
ServerResponse resp;
string thingName;
var query1 = "query ($id: Int) { getThing(id: $id) {name kind theFlags} }";
var queryM = "query { things {name} }";
var vars = new TDict()
{
{ "id", 3 }
};
// Post requests
TestEnv.LogTestDescr("Testing Post requests");
// single thing with query parameter
resp = await TestEnv.Client.PostAsync(query1, vars);
resp.EnsureNoErrors();
var thing = resp.data.getThing;
thingName = thing.name;
Assert.AreEqual("Name3", thingName);
var thingKind = ResponseHelper.ToEnum <ThingKind>(thing.kind);
Assert.AreEqual(ThingKind.KindThree, thingKind, "Invalid kind field value.");
var flags = ResponseHelper.ToEnum <TheFlags>(thing.theFlags);
Assert.AreEqual(TheFlags.FlagOne | TheFlags.FlagTwo, flags, "Invalid flags field value");
// list of things
resp = await TestEnv.Client.PostAsync(queryM, vars);
resp.EnsureNoErrors();
thingName = resp.data.things[1].name;
Assert.AreEqual("Name2", thingName);
TestEnv.LogTestDescr("Testing Get requests");
// single thing with query parameter
resp = await TestEnv.Client.GetAsync(query1, vars);
resp.EnsureNoErrors();
thingName = resp.data.getThing.name;
Assert.AreEqual("Name3", thingName);
// list of things
resp = await TestEnv.Client.GetAsync(queryM, vars);
resp.EnsureNoErrors();
thingName = resp.data.things[1].name;
Assert.AreEqual("Name2", thingName);
TestEnv.LogTestDescr("Testing queries with errors");
resp = await TestEnv.Client.PostAsync(query1 + " ABCD ", vars);
var errs = resp.Errors;
Assert.IsTrue(errs.Count > 0, "Expected syntax error");
}
public void TypeDictionary_OverwritesEntries()
{
TDict.Set <string>("hei");
TDict.Set <string>("nei");
var str = TDict.Get <string>();
Assert.AreEqual("nei", str);
}
public void TypeDictionary_RemovesEntry()
{
TDict.Set <string>("hei");
TDict.Remove <string>();
var str = TDict.Get <string>();
Assert.IsNull(str);
}
public async Task Test_Input_Lists()
{
TestEnv.LogTestMethodStart();
string query;
GraphQLResponse resp;
TDict vars;
TestEnv.LogTestDescr("passing a list as an argument (list as literal).");
query = @"
query {
res: echoIntArray(intVals: [3,2,1])
}";
resp = await ExecuteAsync(query);
var result = resp.Data.GetValue <string>("res");
Assert.AreEqual("3,2,1", result, "Result mismatch");
TestEnv.LogTestDescr("passing an enum array in argument (mapped to c# enum with [Flags] attr).");
query = @"
query {
res: echoEnumArray(flagVals: [FLAG_ONE, FLAG_TWO]) # returns flagVals.ToString()
}";
resp = await ExecuteAsync(query);
result = resp.Data.GetValue <string>("res");
Assert.AreEqual("FlagOne,FlagTwo", result, "Result mismatch");
TestEnv.LogTestDescr("passing a list int[][], value from literal and variables.");
query = @"
query ($one: Int) {
res: echoIntListRank2(values: [ [3, 2, $one], [6, 5, 4] ] )
}";
vars = new TDict()
{
{ "one", 1 }
};
resp = await ExecuteAsync(query, vars);
var str = resp.GetValue <string>("res");
Assert.AreEqual("3,2,1,6,5,4", str, "Result mismatch");
}
public async Task Test_Input_Validation()
{
TestEnv.LogTestMethodStart();
string query;
TDict vars;
GraphQLResponse resp;
TestEnv.LogTestDescr("validation of input values in resolver code, posting response errors and aborting the request.");
query = @"
mutation ($id: Int!, $newName: String!) {
th: mutateThingWithValidation(id: $id, newName: $newName) {
id, name
}
}";
vars = new TDict()
{
{ "id", -1 }, { "newName", "Name Tooo Loooooooooooooooooooooong" }
};
resp = await ExecuteAsync(query, vars, throwOnError : false);
Assert.AreEqual(2, resp.Errors.Count, "expected errors");
Assert.AreEqual("Id value may not be negative.", resp.Errors[0].Message);
Assert.AreEqual("newName too long, max size = 10.", resp.Errors[1].Message);
TestEnv.LogTestDescr("same resolver method, different variable values, happy path - all values are OK.");
var newName2 = "Name2_";
vars = new TDict()
{
{ "id", 2 }, { "newName", newName2 }
};
resp = await ExecuteAsync(query, vars, throwOnError : false);
Assert.AreEqual(0, resp.Errors.Count, "expected no errors");
var thing2 = ThingsApp.Instance.Things.First(t => t.Id == 2);
Assert.AreEqual(newName2, thing2.Name);
// undo the change
thing2.Name = "Name2";
}
public async Task Test_Misc_IncludeSkip()
{
TestEnv.LogTestMethodStart();
string query;
GraphQLResponse resp;
TDict vars;
TestEnv.LogTestDescr(@" @include directive with arg value from variable.");
query = @"
query myQuery ($all: Boolean!) {
thing: getThing(id:1) {
id
name
kind @include(if: $all)
}
}";
vars = new TDict()
{
{ "all", true }
};
resp = await ExecuteAsync(query, vars);
var thingScope = resp.GetValue <IDict>("thing");
var hasKind = thingScope.ContainsKey("kind");
Assert.IsTrue(hasKind, "Expected kind field.");
TestEnv.LogTestDescr(@" same, with $all=false.");
// Now $all=false
vars["all"] = false;
resp = await ExecuteAsync(query, vars);
thingScope = resp.GetValue <IDict>("thing");
hasKind = thingScope.ContainsKey("kind");
Assert.IsFalse(hasKind, "Expected no kind field.");
}
public async Task Test_Fragments()
{
TestEnv.LogTestMethodStart();
string query;
GraphQLResponse resp;
TDict vars;
// --------------------------------------------------------------------------------------------
TestEnv.LogTestDescr("fragment with object field and selection subset.");
query = @"
query myQuery {
getThing(id: 1) {
...Flds
}
}
fragment Flds on Thing {
name
nextThing {
name
nextId: id
}
}
";
resp = await ExecuteAsync(query);
// check that nextId appears in the output
var nextId = resp.Data.GetValue <int>("getThing/nextThing/nextId");
Assert.IsTrue(nextId > 0, "next id expected > 0");
// --------------------------------------------------------------------------------------------
TestEnv.LogTestDescr("inline fragment with 'On' condition.");
query = @"
query myQuery {
getThing(id: 1) {
name
... on Thing {
id
}
}
}
";
resp = await ExecuteAsync(query);
// check that nextId appears in the output
var id = resp.Data.GetValue <int>("getThing/id");
Assert.IsTrue(nextId > 0, "id expected > 0");
// --------------------------------------------------------------------------------------------
TestEnv.LogTestDescr("inline fragment without 'On' condition and with @include(if:true).");
query = @"
query myQuery ($inc: Boolean) {
getThing(id: 1) {
name
... @include(if: $inc) {
id
}
}
}
";
vars = new TDict()
{
{ "inc", true }
};
resp = await ExecuteAsync(query, vars);
// check that id appears in the output
id = resp.Data.GetValue <int>("getThing/id");
Assert.IsTrue(id > 0, "id expected > 0");
TestEnv.LogTestDescr("same but with @include(if:false)");
vars = new TDict()
{
{ "inc", false }
};
resp = await ExecuteAsync(query, vars);
// check that id does not appear in the output; GetValue should return 0 (default for int)
id = resp.Data.GetValue <int>("getThing/id");
Assert.AreEqual(0, id, "id expected == 0");
}
public async Task TestVariables()
{
string query;
TDict varsDict;
ServerResponse resp;
TestEnv.LogTestMethodStart();
TestEnv.LogTestDescr("input variables of various types.");
query = @"
query myQuery($boolVal: Boolean, $longVal: Long, $doubleVal: Double, $strVal: String, $kindVal: ThingKind, $flags: [TheFlags!]) {
echo: echoInputValuesWithNulls (boolVal: $boolVal, longVal: $longVal, doubleVal: $doubleVal, strVal: $strVal,
kindVal: $kindVal, flags: $flags )
}";
varsDict = new TDict()
{
{ "boolVal", true }, { "longVal", 654321 }, { "doubleVal", 543.21 },
{ "kindVal", "KIND_ONE" }, { "flags", new string[] { "FLAG_ONE", "FLAG_TWO" } },
{ "strVal", "SomeString" }
};
resp = await TestEnv.Client.PostAsync(query, varsDict);
resp.EnsureNoErrors();
var echoResp = resp.data.echo;
Assert.AreEqual("True|654321|543.21|SomeString|KindOne|FlagOne, FlagTwo", echoResp); //this is InputObj.ToString()
TestEnv.LogTestDescr("error - invalid argument values, type mismatch.");
query = @"
query myQuery($boolVal: Boolean, $longVal: Long, $doubleVal: Double, $strVal: String, $kindVal: ThingKind, $flags: [TheFlags!]) {
echo: echoInputValuesWithNulls (boolVal: $longVal, longVal: $doubleVal, doubleVal: $strVal )
}";
resp = await TestEnv.Client.PostAsync(query, varsDict);
Assert.AreEqual(3, resp.Errors.Count, "Expected 3 errors");
TestEnv.LogTestDescr("complex object type in a variable.");
query = @"
query myQuery($inpObj: InputObj!) {
echoInputObj (inpObj: $inpObj)
}";
varsDict = new TDict();
varsDict["inpObj"] = new TDict()
{
{ "id", 123 }, { "num", 456 }, { "name", "SomeName" }
};
resp = await TestEnv.Client.PostAsync(query, varsDict);
resp.EnsureNoErrors();
var echoInpObj = resp.data.echoInputObj;
Assert.AreEqual("id:123,name:SomeName,num:456", echoInpObj); //this is InputObj.ToString()
TestEnv.LogTestDescr("literal object as argument, but with prop values coming from variables.");
query = @"
query myQuery($num: Int!, $name: String!) {
echoInputObj (inpObj: {id: 123, num: $num, name: $name})
}";
varsDict = new TDict();
// we cannot use InputObj here, serializer will send first-cap prop names and request will fail
varsDict["num"] = 456;
varsDict["name"] = "SomeName";
resp = await TestEnv.Client.PostAsync(query, varsDict);
resp.EnsureNoErrors();
var echoInpObj2 = resp.data.echoInputObj;
Assert.AreEqual("id:123,name:SomeName,num:456", echoInpObj2); //this is InputObj.ToString()
}
public async Task Test_Input_Variables()
{
TestEnv.LogTestMethodStart();
string query;
TDict vars;
GraphQLResponse resp;
string echoResp;
TestEnv.LogTestDescr("missing variable value.");
query = @"
query myQuery($longVal: Long!) {
echo: echoInputValuesWithNulls (longVal: $longVal)
}";
resp = await ExecuteAsync(query, throwOnError : false);
Assert.AreEqual(1, resp.Errors.Count, "Expected 1 error(s)");
Assert.AreEqual("Value for required variable longVal is not provided.", resp.Errors[0].Message);
TestEnv.LogTestDescr("unknown variable used in argument.");
query = @"
query myQuery($longVal: Long) {
echo: echoInputValuesWithNulls (longVal: $longValXYZ)
}";
vars = new TDict()
{
{ "longVal", 654321 }
};
resp = await ExecuteAsync(query, vars, throwOnError : false);
Assert.AreEqual(1, resp.Errors.Count, "Expected 1 error(s)");
Assert.AreEqual("Variable longValXYZ not defined.", resp.Errors[0].Message);
TestEnv.LogTestDescr("variable value type mismatch - sending string value for a long var.");
query = @"
query myQuery($longVal: Long) {
echo: echoInputValuesWithNulls ()
}";
vars = new TDict()
{
{ "longVal", "abc" }
};
resp = await ExecuteAsync(query, vars, throwOnError : false);
Assert.AreEqual(1, resp.Errors.Count, "expected 1 error");
Assert.AreEqual("Variable $longVal: failed to convert value 'abc' to type Long: Invalid Long value: 'abc'",
resp.Errors[0].Message);
TestEnv.LogTestDescr("string -> enum conversion; enum input values are sent as strings.");
query = @"
query myQuery($kindVal: ThingKind) {
echo: echoInputValuesWithNulls (kindVal: $kindVal)
}";
vars = new TDict()
{
{ "kindVal", "KIND_ONE" }
};
resp = await ExecuteAsync(query, vars);
echoResp = resp.GetValue <string>("echo");
Assert.AreEqual("||||KindOne|", echoResp);
TestEnv.LogTestDescr("int -> long? automatic conversion.");
query = @"
query myQuery($longVal: Long) {
echo: echoInputValuesWithNulls (longVal: $longVal)
}";
vars = new TDict()
{
{ "longVal", 654321 }
};
resp = await ExecuteAsync(query, vars);
echoResp = resp.GetValue <string>("echo");
Assert.AreEqual("|654321||||", echoResp);
TestEnv.LogTestDescr("multiple input variables of various types, happy path.");
query = @"
query myQuery($boolVal: Boolean, $longVal: Long, $doubleVal: Double, $strVal: String, $kindVal: ThingKind, $flags: [TheFlags!]) {
echo: echoInputValuesWithNulls (boolVal: $boolVal, longVal: $longVal, doubleVal: $doubleVal, strVal: $strVal,
kindVal: $kindVal, flags: $flags )
}";
vars = new TDict()
{
{ "boolVal", true }, { "longVal", 654321 }, { "doubleVal", 543.21 },
{ "kindVal", "KIND_ONE" }, { "flags", new string[] { "FLAG_ONE", "FLAG_TWO" } },
{ "strVal", "SomeString" }
};
resp = await ExecuteAsync(query, vars);
echoResp = resp.GetValue <string>("echo");
Assert.AreEqual("True|654321|543.21|SomeString|KindOne|FlagOne, FlagTwo", echoResp); //this is InputObj.ToString()
}
public async Task Test_Input_FieldArgs()
{
TestEnv.LogTestMethodStart();
string query;
TDict vars;
GraphQLResponse resp;
GraphQLError err;
TestEnv.LogTestDescr("error - invalid arg names.");
query = @"
query {
echo: echoInputValuesWithNulls(boolValXYZ: true, longValXYZ: 123, doubleVal: 23.45)
}";
resp = await ExecuteAsync(query, throwOnError : false);
Assert.IsTrue(resp.Errors.Count == 2, "Expected errors");
err = resp.Errors[0];
Assert.AreEqual("Field(dir) echoInputValuesWithNulls: argument boolValXYZ not defined.", err.Message);
Assert.AreEqual(2, err.Path.Count, "Expected 2 elem path");
Assert.IsTrue(err.Locations != null && err.Locations.Count > 0, "Expected error location.");
TestEnv.LogTestDescr("error - args referring to vars of wrong type.");
query = @"
query ($str: String) {
echo: echoInputValuesWithNulls(longVal: $str)
}";
resp = await ExecuteAsync(query, throwOnError : false);
Assert.IsTrue(resp.Errors.Count == 1, "Expected errors");
err = resp.Errors[0];
Assert.AreEqual("Incompatible types: variable $str cannot be converted to type 'Long'", err.Message);
TestEnv.LogTestDescr("error - invalid arg name for a directive.");
query = @"
query {
things { name @include(ifXYZ: true) }
}";
resp = await ExecuteAsync(query, throwOnError : false);
Assert.IsTrue(resp.Errors.Count == 1, "Expected 1 error(s)");
Assert.AreEqual("Field(dir) @include: argument ifXYZ not defined.", resp.Errors[0].Message);
TestEnv.LogTestDescr("error - passing wrong value types to field args using a literal.");
query = @"
query myQuery() {
echo: echoInputValuesWithNulls (longVal: ""abc"")
}";
vars = new TDict()
{
};
resp = await ExecuteAsync(query, vars, throwOnError : false);
Assert.AreEqual(1, resp.Errors.Count, "Expected 1 errors");
err = resp.Errors[0];
Assert.AreEqual("Invalid long value: '\"abc\"'", err.Message);
TestEnv.LogTestDescr("error - passing wrong value types to field args, using bad value in a variable.");
query = @"
query myQuery($longVal: Long, $doubleVal: Double) {
echo: echoInputValuesWithNulls (longVal: $longVal, doubleVal: $doubleVal)
}";
vars = new TDict()
{
{ "longVal", true }, { "doubleVal", "abc" }
};
resp = await ExecuteAsync(query, vars, throwOnError : false);
Assert.AreEqual(2, resp.Errors.Count, "Expected 2 errors");
TestEnv.LogTestDescr("error - passing wrong value types to field args, using variables; test multiple errors.");
query = @"
query myQuery($boolVal: Boolean, $longVal: Long, $doubleVal: Double, $strVal: String, $kindVal: ThingKind, $flags: [TheFlags!]) {
# totally wrong match of args, expected 3 errors
echo: echoInputValuesWithNulls (boolVal: $longVal, longVal: $doubleVal, doubleVal: $strVal )
}";
vars = new TDict()
{
{ "boolVal", true }, { "longVal", 654321 }, { "doubleVal", 543.21 },
{ "kindVal", "KIND_ONE" }, { "flags", new string[] { "FLAG_ONE", "FLAG_TWO" } },
{ "strVal", "SomeString" }
};
resp = await ExecuteAsync(query, vars, throwOnError : false);
Assert.AreEqual(3, resp.Errors.Count, "Expected 3 error(s)");
}
static public string BuildString(TDict t, int len, bool exact, string seed = "")
{
string last;
List <string> ucStr = new List <string>();
StringBuilder sb = new StringBuilder();
if (seed == "")
{
foreach (string word in t.Keys.Skip(1))
{
if (char.IsUpper(word.First()))
{
ucStr.Add(word);
}
}
}
else
{
ucStr.Add(seed);
}
if (ucStr.Count > 0)
{
sb.Append(ucStr.ElementAt(r.Next(0, ucStr.Count)));
}
last = sb.ToString();
sb.Append(" ");
WDict w = new WDict();
for (uint i = 0; i < len; ++i)
{
if (t.ContainsKey(last))
{
w = t[last];
}
else
{
w = t[""];
//sb.Append(" ");
}
last = MarkovHelper.Choose(w);
sb.Append(last.Split(' ').Last()).Append(" ");
}
if (!exact)
{
while (last.Last() != '.')
{
if (t.ContainsKey(last))
{
w = t[last];
}
else
{
w = t[""];
}
last = MarkovHelper.Choose(w);
sb.Append(last.Split(' ').Last()).Append(" ");
}
}
return(sb.ToString());
}
public async Task Test_Input_InputObjects()
{
string query;
GraphQLResponse resp;
string result;
TDict vars;
TestEnv.LogTestMethodStart();
TestEnv.LogTestDescr("literal input object as argument.");
query = @"
query {
res: echoInputObj(inpObj: {id: 1, name: ""abc"", num: 0}) # returns inpObj.ToString()
}";
resp = await ExecuteAsync(query);
result = (string)resp.Data["res"];
Assert.AreEqual("id:1,name:abc,num:0", result, "Result mismatch");
TestEnv.LogTestDescr("literal input object as argument, with some of its properties set from variables.");
query = @"
query myQuery($id : int) {
res: echoInputObj(inpObj: {id: $id, name: ""abc"", num:456})
}";
vars = new TDict()
{
{ "id", 1 }
};
resp = await ExecuteAsync(query, vars);
result = (string)resp.Data["res"];
Assert.AreEqual("id:1,name:abc,num:456", result, "Result mismatch");
TestEnv.LogTestDescr("literal input object as argument; variable value ($id) is not provided and is assigned from default.");
query = @"
query myQuery($num: Int!, $name: String!, $id: Int = 123) {
echoInputObj (inpObj: {id: $id, num: $num, name: $name})
}";
vars = new TDict();
vars["num"] = 456;
vars["name"] = "SomeName";
resp = await ExecuteAsync(query, vars);
var echoInpObj2 = resp.GetValue <string>("echoInputObj");
Assert.AreEqual("id:123,name:SomeName,num:456", echoInpObj2); //this is InputObj.ToString()
TestEnv.LogTestDescr("complex input object in a variable.");
query = @"
query myQuery($inpObj: InputObj!) {
echoInputObj (inpObj: $inpObj)
}";
vars = new TDict();
// we cannot use InputObj here, serializer will send first-cap prop names and request will fail
vars["inpObj"] = new InputObj()
{
Id = 123, Num = 456, Name = "SomeName"
};
resp = await ExecuteAsync(query, vars);
var echoInpObj = resp.GetValue <string>("echoInputObj");
Assert.AreEqual("id:123,name:SomeName,num:456", echoInpObj); //this is InputObj.ToString()
}
