Add constness to input value generation (#811)

* Add constness to input value generation.

As per the spec: https://spec.graphql.org/October2021/#Value
Values should not be variables in a const context.
The TLDR of this is that within schema definitions variables should bot be used on arguments.
Within operations variables can should be used.

Fixes #810

Author: BrynCooke

crates/apollo-smith/src/argument.rs

@@ -1,3 +1,4 @@
+use crate::input_value::Constness;
 use crate::{
     input_value::{InputValue, InputValueDef},
     name::Name,
@@ -76,10 +77,10 @@ impl TryFrom<apollo_parser::cst::Argument> for Argument {
 
 impl<'a> DocumentBuilder<'a> {
     /// Create an arbitrary vector of `Argument`
-    pub fn arguments(&mut self) -> ArbitraryResult<Vec<Argument>> {
+    pub fn arguments(&mut self, constness: Constness) -> ArbitraryResult<Vec<Argument>> {
         let num_arguments = self.u.int_in_range(0..=4)?;
         let arguments = (0..num_arguments)
-            .map(|_| self.argument())
+            .map(|_| self.argument(constness))
             .collect::<ArbitraryResult<Vec<_>>>()?;
 
         Ok(arguments)
@@ -100,9 +101,9 @@ impl<'a> DocumentBuilder<'a> {
     }
 
     /// Create an arbitrary `Argument`
-    pub fn argument(&mut self) -> ArbitraryResult<Argument> {
+    pub fn argument(&mut self, constness: Constness) -> ArbitraryResult<Argument> {
         let name = self.name()?;
-        let value = self.input_value()?;
+        let value = self.input_value(constness)?;
 
         Ok(Argument { name, value })
     }

crates/apollo-smith/src/input_value.rs

@@ -10,6 +10,12 @@ use apollo_compiler::Node;
 use arbitrary::Result as ArbitraryResult;
 use indexmap::IndexMap;
 
+#[derive(Debug, Clone, Copy)]
+pub enum Constness {
+    Const,
+    NonConst,
+}
+
 #[derive(Debug, Clone, PartialEq)]
 pub enum InputValue {
     Variable(Name),
@@ -160,8 +166,12 @@ impl TryFrom<apollo_parser::cst::InputValueDefinition> for InputValueDef {
 
 impl<'a> DocumentBuilder<'a> {
     /// Create an arbitrary `InputValue`
-    pub fn input_value(&mut self) -> ArbitraryResult<InputValue> {
-        let val = match self.u.int_in_range(0..=8usize)? {
+    pub fn input_value(&mut self, constness: Constness) -> ArbitraryResult<InputValue> {
+        let index = match constness {
+            Constness::Const => self.u.int_in_range(0..=7usize)?,
+            Constness::NonConst => self.u.int_in_range(0..=8usize)?,
+        };
+        let val = match index {
             // Int
             0 => InputValue::Int(self.u.arbitrary()?),
             // Float
@@ -179,22 +189,22 @@ impl<'a> DocumentBuilder<'a> {
                     let enum_choosed = self.choose_enum()?.clone();
                     InputValue::Enum(self.arbitrary_variant(&enum_choosed)?.clone())
                 } else {
-                    self.input_value()?
+                    self.input_value(constness)?
                 }
             }
             // List
             6 => {
                 // FIXME: it's semantically wrong it should always be the same type inside
                 InputValue::List(
                     (0..self.u.int_in_range(2..=4usize)?)
-                        .map(|_| self.input_value())
+                        .map(|_| self.input_value(constness))
                         .collect::<ArbitraryResult<Vec<_>>>()?,
                 )
             }
             // Object
             7 => InputValue::Object(
                 (0..self.u.int_in_range(2..=4usize)?)
-                    .map(|_| Ok((self.name()?, self.input_value()?)))
+                    .map(|_| Ok((self.name()?, self.input_value(constness)?)))
                     .collect::<ArbitraryResult<Vec<_>>>()?,
             ),
             // Variable TODO: only generate valid variable name (existing variables)
@@ -287,7 +297,7 @@ impl<'a> DocumentBuilder<'a> {
                 .u
                 .arbitrary()
                 .unwrap_or(false)
-                .then(|| self.input_value())
+                .then(|| self.input_value(Constness::Const))
                 .transpose()?;
 
             input_values.push(InputValueDef {
@@ -318,7 +328,7 @@ impl<'a> DocumentBuilder<'a> {
             .u
             .arbitrary()
             .unwrap_or(false)
-            .then(|| self.input_value())
+            .then(|| self.input_value(Constness::Const))
             .transpose()?;
 
         Ok(InputValueDef {

crates/apollo-smith/src/variable.rs

@@ -1,3 +1,4 @@
+use crate::input_value::Constness;
 use crate::{
     directive::{Directive, DirectiveLocation},
     input_value::InputValue,
@@ -51,7 +52,7 @@ impl<'a> DocumentBuilder<'a> {
             .u
             .arbitrary()
             .unwrap_or(false)
-            .then(|| self.input_value())
+            .then(|| self.input_value(Constness::Const))
             .transpose()?;
         let directives = self.directives(DirectiveLocation::VariableDefinition)?;