public override MaxComplexityVisitorContext AddField(
IOutputField fieldDefinition,
FieldNode fieldSelection)
{
IDirective directive = fieldDefinition.Directives
.FirstOrDefault(t => t.Type is CostDirectiveType);
int complexity;
CostDirective cost = directive == null
? DefaultCost
: directive.ToObject <CostDirective>();
complexity = Complexity + CalculateComplexity(
new ComplexityContext(
fieldDefinition, fieldSelection,
FieldPath, _variables, cost));
if (complexity > MaxComplexity)
{
MaxComplexity = complexity;
}
return(new MaxComplexityWithMultipliersVisitorContext(
FragmentPath,
FieldPath.Add(fieldDefinition),
this));
}
public void AnnotateCostToInterfaceFieldCodeFirst()
{
// arrange
// act
ISchema schema = SchemaBuilder.New()
.AddQueryType(d => d
.Name("Query")
.Field("field")
.Argument("a", a => a.Type <StringType>())
.Type <StringType>())
.AddInterfaceType(d => d
.Name("IQuery")
.Field("field")
.Argument("a", a => a.Type <StringType>())
.Type <StringType>()
.Cost(5))
.AddDirectiveType <CostDirectiveType>()
.Use(_ => _)
.Create();
InterfaceType queryInterface = schema.GetType <InterfaceType>("IQuery");
IDirective directive = queryInterface.Fields["field"].Directives
.Single(t => t.Name == "cost");
CostDirective obj = directive.ToObject <CostDirective>();
Assert.Equal(5, obj.Complexity);
}
public void AnnotateCostToObjectFieldCodeFirstTwoMultiplier()
{
// arrange
// act
ISchema schema = SchemaBuilder.New()
.AddQueryType(d => d
.Name("Query")
.Field("field")
.Argument("a", a => a.Type <StringType>())
.Type <StringType>()
.Cost(5, "a", "b"))
.AddDirectiveType <CostDirectiveType>()
.Use(_ => _)
.Create();
ObjectType query = schema.GetType <ObjectType>("Query");
IDirective directive = query.Fields["field"].Directives
.Single(t => t.Name == "cost");
CostDirective obj = directive.ToObject <CostDirective>();
Assert.Equal(5, obj.Complexity);
Assert.Collection(obj.Multipliers,
t => Assert.Equal("a", t),
t => Assert.Equal("b", t));
}
public void AnnotateCostToInterfaceFieldSchemaFirst()
{
// arrange
// act
ISchema schema = SchemaBuilder.New()
.AddDocumentFromString(
@"
type Query {
field(a: Int): String
@cost(complexity: 5 multipliers: [""a""])
}
interface IQuery {
field(a: Int): String
@cost(complexity: 5 multipliers: [""a""])
}
")
.AddDirectiveType <CostDirectiveType>()
.Use(_ => _)
.Create();
InterfaceType queryInterface = schema.GetType <InterfaceType>("IQuery");
IDirective directive =
queryInterface.Fields["field"].Directives.Single(t => t.Name == "cost");
CostDirective obj = directive.ToObject <CostDirective>();
Assert.Equal(5, obj.Complexity);
Assert.Collection(obj.Multipliers, t => Assert.Equal("a", t));
}
public void NoMultipliers()
{
// arrange
// act
var cost = new CostDirective(5);
// assert
Assert.Equal(5, cost.Complexity);
Assert.Empty(cost.Multipliers);
}
public void ValidMultipliers()
{
// arrange
// act
var cost = new CostDirective(6, "", "b", "c", null);
// assert
Assert.Equal(6, cost.Complexity);
Assert.Collection(cost.Multipliers,
s => Assert.Equal("b", s),
s => Assert.Equal("c", s));
}
internal ComplexityContext(
IOutputField fieldDefinition,
FieldNode fieldSelection,
ICollection <IOutputField> path,
IVariableValueCollection variables,
CostDirective cost)
{
FieldDefinition = fieldDefinition;
FieldSelection = fieldSelection;
Path = path;
Variables = variables;
Cost = cost;
}
public static int Calculate(
IOutputField field,
FieldNode selection,
CostDirective costDirective,
int fieldDepth,
int nodeDepth,
int childComplexity,
IVariableValueCollection variables,
InputParser inputParser,
ComplexityAnalyzerSettings analyzerSettings)
{
return(analyzerSettings.Calculation.Invoke(
new ComplexityContext(
field,
selection,
costDirective,
fieldDepth,
nodeDepth,
childComplexity,
analyzerSettings.DefaultComplexity,
variables,
inputParser)));
}
