public void Creates_Subquery_Expression()
{
Expression <Func <JObject, IEnumerable <IssueModel> > > expected =
data => (IEnumerable <IssueModel>)Rewritten.List.Select(
Rewritten.Interface.Cast(data["data"]["node"], "Repository")["issues"]["nodes"],
issue => new IssueModel
{
Number = issue["number"].ToObject <int>()
}).ToList();
var expectedString = expected.ToReadableString();
var actual = ExpressionCompiler.GetSourceExpression(TestQueryFirstSubquery.ResultBuilder);
var actualString = actual.ToReadableString();
Assert.Equal(ExpressionRewriterAssertions.StripWhitespace(expectedString), ExpressionRewriterAssertions.StripWhitespace(actualString));
}
public void Repository_Issues_Select_Multiple_Members()
{
var query = new Query()
.Repository("foo", "bar")
.Issues(10)
.Nodes
.Select(x => new { x.Body, x.Closed });
Expression <Func <JObject, IEnumerable <object> > > expected = data =>
(IEnumerable <object>)Rewritten.List.Select(data["data"]["repository"]["issues"]["nodes"], x => new
{
Body = x["body"].ToObject <string>(),
Closed = x["closed"].ToObject <bool>(),
}).ToList();
ExpressionRewriterAssertions.AssertExpressionQueryEqual(expected, query);
}
public void Creates_Subquery_2_MasterQuery_Expression()
{
Expression <Func <JObject, IEnumerable <CommentModel> > > expected =
data => (IEnumerable <CommentModel>)Rewritten.List.Select(
Rewritten.Interface.Cast(data["data"]["node"], "Issue")["comments"]["nodes"],
comment => new CommentModel
{
Id = comment["id"].ToString(),
Body = comment["body"].ToObject <string>()
}).ToList();
var expectedString = expected.ToReadableString();
var actual = ExpressionCompiler.GetSourceExpression(TestQuerySecondSubquery.ResultBuilder);
var actualString = actual.ToReadableString();
Assert.Equal(ExpressionRewriterAssertions.StripWhitespace(expectedString), ExpressionRewriterAssertions.StripWhitespace(actualString));
}
public void Can_Use_Conditional_To_Compare_To_Null()
{
var query = new Query()
.Repository("foo", "bar")
.Select(x => x.Name != null ? x.Name : null);
// Expression<Func<JObject, object>> expected = data =>
// Rewritten.Value.Select(
// data["data"]["repository"],
// x => x["name"].Type != JTokenType.Null ? x["name"].ToObject<string>() : null);
var readableString =
"data => Rewritten.Value.Select(data[\"data\"][\"repository\"],x => (x[\"name\"].Type != JTokenType.Null) ? x[\"name\"].ToObject<string>() : null)";
// Expression put through ReadableExpression outputs the following, so I'm using a hard coded string instead
// data => Rewritten.Value.Select(data["data"]["repository"], x => (((int)x["name"].Type) != 10) ? x["name"].ToObject<string>() : null)
ExpressionRewriterAssertions.AssertExpressionQueryEqual(readableString, query);
}
public void Nodes_OfType()
{
var query = new Query()
.Nodes(new[] { new ID("123") })
.OfType <Issue>()
.Select(x => new
{
x.Body,
});
Expression <Func <JObject, object> > expected = data =>
(IEnumerable <object>)Rewritten.List.Select(
Rewritten.List.OfType(data["data"]["nodes"], "Issue"),
x => new
{
Body = x["body"].ToObject <string>(),
}).ToList();
ExpressionRewriterAssertions.AssertExpressionQueryEqual(expected, query);
}
public void Licence_Conditions_Nested_Selects()
{
var query = new Query()
.Licenses
.Select(x => new
{
x.Body,
Items = x.Conditions.Select(i => i.Description).ToList(),
});
Expression <Func <JObject, object> > expected = data =>
(IEnumerable <object>)Rewritten.List.Select(
data["data"]["licenses"],
x => new
{
Body = x["body"].ToObject <string>(),
Items = Rewritten.List.ToList <string>(Rewritten.List.Select(x["items"], i => i["description"]))
}).ToList();
ExpressionRewriterAssertions.AssertExpressionQueryEqual(expected, query);
}
public void Creates_MasterQuery_Expression()
{
Expression <Func <JObject, RepositoryModel> > expected = data =>
Rewritten.Value.Select(
data["data"]["repository"],
repository => new RepositoryModel
{
Name = repository["name"].ToObject <string>(),
Issues = Rewritten.List.ToSubqueryList(
Rewritten.List.Select(
repository["issues"]["nodes"],
issue => new IssueModel
{
Number = issue["number"].ToObject <int>(),
}),
data.Annotation <ISubqueryRunner>(),
SubqueryPlaceholder.placeholder),
});
ExpressionRewriterAssertions.AssertCompiledQueryExpressionEqual(expected, TestMasterQuery,
"SimpleSubquery<IEnumerable<IssueModel>>");
}
public void Creates_MasterQuery_Expression()
{
Expression <Func <JObject, object> > expected = data =>
Rewritten.Value.Select(
data["data"]["repository"],
repository => new {
IntList1 = Rewritten.List.ToSubqueryList(
Rewritten.List.ToList <int>(Rewritten.List.Select(repository["intList1"]["nodes"], issue => issue["number"])),
data.Annotation <ISubqueryRunner>(),
SubqueryPlaceholder.placeholder),
IntList2 = Rewritten.List.ToSubqueryList(
Rewritten.List.ToList <int>(Rewritten.List.Select(repository["intList2"]["nodes"], issue => issue["number"])),
data.Annotation <ISubqueryRunner>(),
SubqueryPlaceholder.placeholder)
});
var query = new Query()
.Repository("foo", "bar")
.Select(repository => new
{
IntList1 = repository.Issues(null, null, null, null, null)
.AllPages()
.Select(issue => issue.Number)
.ToList(),
IntList2 = repository.Issues(null, null, null, null, null)
.AllPages()
.Select(issue => issue.Number)
.ToList()
}).Compile();
var masterQuery = query.GetMasterQuery();
ExpressionRewriterAssertions.AssertCompiledQueryExpressionEqual(expected, masterQuery,
"SimpleSubquery<IEnumerable<int>>",
"SimpleSubquery<IEnumerable<int>>");
}
public void Creates_Subquery_Expression_ParentPage()
{
Expression <Func <JObject, IEnumerable <JToken> > > expected = data => data.SelectTokens("$.data.repository.issues.pageInfo");
var expectedString = expected.ToReadableString();
var actualExpression = ExpressionCompiler.GetSourceExpression(TestQueryFirstSubquery().ParentPageInfo);
var actualString = actualExpression.ToReadableString();
Assert.Equal(ExpressionRewriterAssertions.StripWhitespace(expectedString), ExpressionRewriterAssertions.StripWhitespace(actualString));
}
public void Creates_Subquery_Expression_PageInfo()
{
Expression <Func <JObject, JToken> > expected = data => data.SelectToken("data.node.issues.pageInfo");
var expectedString = expected.ToReadableString();
var actual = ExpressionCompiler.GetSourceExpression(TestQueryFirstSubquery().PageInfo);
var actualString = actual.ToReadableString();
Assert.Equal(ExpressionRewriterAssertions.StripWhitespace(expectedString), ExpressionRewriterAssertions.StripWhitespace(actualString));
}
public void Creates_PagedSubquery_1_SubQuery_Expression_ParentPageInfo()
{
var actual = ExpressionCompiler.GetSourceExpression(TestQueryFirstSubqueryFirstSubquery.ParentPageInfo);
var actualString = actual.ToReadableString();
Expression <Func <JObject, IEnumerable <JToken> > > expected = data => data.SelectTokens("$.data.node.issues.nodes.[*].comments.pageInfo");
var expectedString = expected.ToReadableString();
Assert.Equal(ExpressionRewriterAssertions.StripWhitespace(expectedString), ExpressionRewriterAssertions.StripWhitespace(actualString));
}
public void Creates_PagedSubquery_1_MasterQuery_Expression()
{
Expression <Func <JObject, IEnumerable <IssueModel> > > expected =
data => (IEnumerable <IssueModel>)Rewritten.List.Select(
Rewritten.Interface.Cast(data["data"]["node"], "Repository")["issues"]["nodes"],
issue => new IssueModel
{
Number = issue["number"].ToObject <int>(),
Comments = Rewritten.List.ToSubqueryList(
Rewritten.List.Select(
issue["comments"]["nodes"],
comment => new CommentModel
{
Id = comment["id"].ToString(),
Body = comment["body"].ToObject <string>()
}),
data.Annotation <ISubqueryRunner>(),
SubqueryPlaceholder.placeholder)
}).ToList();
var expectedString = ExpressionRewriterAssertions.ReplaceSubqueryPlaceholders(expected.ToReadableString(), "SimpleSubquery<IEnumerable<CommentModel>>");
var actual = ExpressionCompiler.GetSourceExpression(TestQueryFirstSubqueryMasterQuery.ResultBuilder);
var actualString = actual.ToReadableString();
Assert.Equal(ExpressionRewriterAssertions.StripWhitespace(expectedString), ExpressionRewriterAssertions.StripWhitespace(actualString));
}
public void Creates_Subquery_2_Expression_ParentPageInfo()
{
var query = new Query()
.Repository("foo", "bar")
.Select(repository => new
{
IntList1 = repository.Issues(null, null, null, null, null)
.AllPages()
.Select(issue => issue.Number)
.ToList(),
IntList2 = repository.Issues(null, null, null, null, null)
.AllPages()
.Select(issue => issue.Number)
.ToList()
}).Compile();
var subqueries = query.GetSubqueries();
var queryFirstSubquery = (SimpleSubquery <IEnumerable <int> >)subqueries[1];
var actual = ExpressionCompiler.GetSourceExpression(queryFirstSubquery.ParentPageInfo);
var actualString = actual.ToReadableString();
Expression <Func <JObject, IEnumerable <JToken> > > expected = data => data.SelectTokens("$.data.repository.intList2.pageInfo");
var expectedString = expected.ToReadableString();
Assert.Equal(ExpressionRewriterAssertions.StripWhitespace(expectedString), ExpressionRewriterAssertions.StripWhitespace(actualString));
}
public void Creates_Subquery_2_Expression()
{
Expression <Func <JObject, IEnumerable <int> > > expected =
data => (IEnumerable <int>)Rewritten.List.Select(
Rewritten.Interface.Cast(data["data"]["node"], "Repository")["issues"]["nodes"],
issue => issue["number"].ToObject <int>()).ToList();
var expectedString = expected.ToReadableString();
var query = new Query()
.Repository("foo", "bar")
.Select(repository => new
{
IntList1 = repository.Issues(null, null, null, null, null)
.AllPages()
.Select(issue => issue.Number)
.ToList(),
IntList2 = repository.Issues(null, null, null, null, null)
.AllPages()
.Select(issue => issue.Number)
.ToList()
}).Compile();
var subqueries = query.GetSubqueries();
var queryFirstSubquery = (SimpleSubquery <IEnumerable <int> >)subqueries[1];
var actual = ExpressionCompiler.GetSourceExpression(queryFirstSubquery.ResultBuilder);
var actualString = actual.ToReadableString();
Assert.Equal(ExpressionRewriterAssertions.StripWhitespace(expectedString), ExpressionRewriterAssertions.StripWhitespace(actualString));
}
