graphql 0.16.0 → 2.0.15

data/spec/graphql/static_validation/rules/arguments_are_defined_spec.rb

@@ -1,48 +0,0 @@
-require "spec_helper"
-
-describe GraphQL::StaticValidation::ArgumentsAreDefined do
-  let(:query_string) {"
-    query getCheese {
-      cheese(id: 1) { source }
-      cheese(silly: false) { source }
-      searchDairy(product: [{wacky: 1}])
-    }
-
-    fragment cheeseFields on Cheese {
-      similarCheese(source: SHEEP, nonsense: 1)
-      id @skip(something: 3.4)
-    }
-  "}
-
-  let(:validator) { GraphQL::StaticValidation::Validator.new(schema: DummySchema, rules: [GraphQL::StaticValidation::ArgumentsAreDefined]) }
-  let(:query) { GraphQL::Query.new(DummySchema, query_string) }
-  let(:errors) { validator.validate(query)[:errors] }
-
-  it "finds undefined arguments to fields and directives" do
-    assert_equal(4, errors.length)
-
-    query_root_error = {
-      "message"=>"Field 'cheese' doesn't accept argument 'silly'",
-      "locations"=>[{"line"=>4, "column"=>7}]
-    }
-    assert_includes(errors, query_root_error)
-
-    input_obj_record = {
-      "message"=>"InputObject 'DairyProductInput' doesn't accept argument 'wacky'",
-      "locations"=>[{"line"=>5, "column"=>29}]
-    }
-    assert_includes(errors, input_obj_record)
-
-    fragment_error = {
-      "message"=>"Field 'similarCheese' doesn't accept argument 'nonsense'",
-      "locations"=>[{"line"=>9, "column"=>7}]
-    }
-    assert_includes(errors, fragment_error)
-
-    directive_error = {
-      "message"=>"Directive 'skip' doesn't accept argument 'something'",
-      "locations"=>[{"line"=>10, "column"=>10}]
-    }
-    assert_includes(errors, directive_error)
-  end
-end

data/spec/graphql/static_validation/rules/directives_are_defined_spec.rb

@@ -1,34 +0,0 @@
-require "spec_helper"
-
-describe GraphQL::StaticValidation::DirectivesAreDefined do
-  let(:query_string) {"
-    query getCheese {
-      okCheese: cheese(id: 1) {
-        id @skip(if: true),
-        source @nonsense(if: false)
-        ... on Cheese {
-          flavor @moreNonsense
-        }
-      }
-    }
-  "}
-
-  let(:validator) { GraphQL::StaticValidation::Validator.new(schema: DummySchema, rules: [GraphQL::StaticValidation::DirectivesAreDefined]) }
-  let(:query) { GraphQL::Query.new(DummySchema, query_string) }
-  let(:errors) { validator.validate(query)[:errors] }
-
-  describe "non-existent directives" do
-    it "makes errors for them" do
-      expected = [
-        {
-          "message"=>"Directive @nonsense is not defined",
-          "locations"=>[{"line"=>5, "column"=>16}]
-        }, {
-          "message"=>"Directive @moreNonsense is not defined",
-          "locations"=>[{"line"=>7, "column"=>18}]
-        }
-      ]
-      assert_equal(expected, errors)
-    end
-  end
-end

data/spec/graphql/static_validation/rules/directives_are_in_valid_locations_spec.rb

@@ -1,39 +0,0 @@
-require "spec_helper"
-
-describe GraphQL::StaticValidation::DirectivesAreInValidLocations do
-  let(:query_string) {"
-    query getCheese @skip(if: true) {
-      okCheese: cheese(id: 1) {
-        id @skip(if: true),
-        source
-        ... on Cheese @skip(if: true) {
-          flavor
-        }
-      }
-    }
-
-    fragment whatever on Cheese @skip(if: true) {
-      id
-    }
-  "}
-
-  let(:validator) { GraphQL::StaticValidation::Validator.new(schema: DummySchema, rules: [GraphQL::StaticValidation::DirectivesAreInValidLocations]) }
-  let(:query) { GraphQL::Query.new(DummySchema, query_string) }
-  let(:errors) { validator.validate(query)[:errors] }
-
-  describe "invalid directive locations" do
-    it "makes errors for them" do
-      expected = [
-        {
-          "message"=> "'@skip' can't be applied to queries (allowed: fields, fragment spreads, inline fragments)",
-          "locations"=>[{"line"=>2, "column"=>21}]
-        },
-        {
-          "message"=>"'@skip' can't be applied to fragment definitions (allowed: fields, fragment spreads, inline fragments)",
-          "locations"=>[{"line"=>12, "column"=>33}]
-        },
-      ]
-      assert_equal(expected, errors)
-    end
-  end
-end

data/spec/graphql/static_validation/rules/fields_are_defined_on_type_spec.rb

@@ -1,60 +0,0 @@
-require "spec_helper"
-
-describe GraphQL::StaticValidation::FieldsAreDefinedOnType do
-  let(:query_string) { "
-    query getCheese($sourceVar: DairyAnimal!) {
-      notDefinedField { name }
-      cheese(id: 1) { nonsenseField, flavor }
-      fromSource(source: COW) { bogusField }
-    }
-
-    fragment cheeseFields on Cheese { fatContent, hogwashField }
-  "}
-
-  let(:validator) { GraphQL::StaticValidation::Validator.new(schema: DummySchema, rules: [GraphQL::StaticValidation::FieldsAreDefinedOnType]) }
-  let(:query) { GraphQL::Query.new(DummySchema, query_string) }
-  let(:errors) { validator.validate(query)[:errors] }
-  let(:error_messages) { errors.map { |e| e["message"] } }
-
-  it "finds fields that are requested on types that don't have that field" do
-    expected_errors = [
-      "Field 'notDefinedField' doesn't exist on type 'Query'",  # from query root
-      "Field 'nonsenseField' doesn't exist on type 'Cheese'",   # from another field
-      "Field 'bogusField' doesn't exist on type 'Cheese'",      # from a list
-      "Field 'hogwashField' doesn't exist on type 'Cheese'",    # from a fragment
-    ]
-    assert_equal(expected_errors, error_messages)
-  end
-
-  describe "on interfaces" do
-    let(:query_string) { "query getStuff { favoriteEdible { amountThatILikeIt } }"}
-
-    it "finds invalid fields" do
-      expected_errors = [
-        {"message"=>"Field 'amountThatILikeIt' doesn't exist on type 'Edible'", "locations"=>[{"line"=>1, "column"=>18}]}
-      ]
-      assert_equal(expected_errors, errors)
-    end
-  end
-
-  describe "on unions" do
-    let(:query_string) { "
-      query notOnUnion { favoriteEdible { ...dpFields } }
-      fragment dbFields on DairyProduct { source }
-      fragment dbIndirectFields on DairyProduct { ... on Cheese { source } }
-    "}
-
-
-    it "doesnt allow selections on unions" do
-      expected_errors = [
-        {
-          "message"=>"Selections can't be made directly on unions (see selections on DairyProduct)",
-          "locations"=>[
-            {"line"=>3, "column"=>7}
-          ]
-        }
-      ]
-      assert_equal(expected_errors, errors)
-    end
-  end
-end

data/spec/graphql/static_validation/rules/fields_have_appropriate_selections_spec.rb

@@ -1,31 +0,0 @@
-require "spec_helper"
-
-describe GraphQL::StaticValidation::FieldsHaveAppropriateSelections do
-  let(:query_string) {"
-    query getCheese {
-      okCheese: cheese(id: 1) { fatContent, similarCheese(source: YAK) { source } }
-      missingFieldsCheese: cheese(id: 1)
-      illegalSelectionCheese: cheese(id: 1) { id { something, ... someFields } }
-    }
-  "}
-
-  let(:validator) { GraphQL::StaticValidation::Validator.new(schema: DummySchema, rules: [GraphQL::StaticValidation::FieldsHaveAppropriateSelections]) }
-  let(:query) { GraphQL::Query.new(DummySchema, query_string) }
-  let(:errors) { validator.validate(query)[:errors] }
-
-  it "adds errors for selections on scalars" do
-    assert_equal(2, errors.length)
-
-    illegal_selection_error = {
-      "message"=>"Selections can't be made on scalars (field 'id' returns Int but has selections [something, someFields])",
-      "locations"=>[{"line"=>5, "column"=>47}]
-    }
-    assert_includes(errors, illegal_selection_error, "finds illegal selections on scalarss")
-
-    selection_required_error = {
-      "message"=>"Objects must have selections (field 'cheese' returns Cheese but has no selections)",
-      "locations"=>[{"line"=>4, "column"=>7}]
-    }
-    assert_includes(errors, selection_required_error, "finds objects without selections")
-  end
-end

data/spec/graphql/static_validation/rules/fields_will_merge_spec.rb

@@ -1,48 +0,0 @@
-require "spec_helper"
-
-describe GraphQL::StaticValidation::FieldsWillMerge do
-  let(:query_string) {"
-    query getCheese($sourceVar: DairyAnimal!) {
-      cheese(id: 1) {
-        id,
-        nickname: name,
-        nickname: fatContent,
-        fatContent
-        differentLevel: fatContent
-        similarCheese(source: $sourceVar)
-
-        similarCow: similarCheese(source: COW) {
-          similarCowSource: source,
-          differentLevel: fatContent
-        }
-        ...cheeseFields
-        ... on Cheese {
-          fatContent: name
-          similarCheese(source: SHEEP)
-        }
-      }
-    }
-    fragment cheeseFields on Cheese {
-      fatContent,
-      similarCow: similarCheese(source: COW) { similarCowSource: id, id }
-      id @someFlag
-    }
-  "}
-
-  let(:validator) { GraphQL::StaticValidation::Validator.new(schema: DummySchema, rules: [GraphQL::StaticValidation::FieldsWillMerge]) }
-  let(:query) { GraphQL::Query.new(DummySchema, query_string) }
-  let(:errors) { validator.validate(query)[:errors] }
-  let(:error_messages) { errors.map { |e| e["message" ] }}
-
-  it "finds field naming conflicts" do
-    expected_errors = [
-      "Field 'id' has a directive conflict: [] or [someFlag]?",                 # different directives
-      "Field 'id' has a directive argument conflict: [] or [{}]?",              # not sure this is a great way to handle it but here we are!
-      "Field 'nickname' has a field conflict: name or fatContent?",             # alias conflict in query
-      "Field 'fatContent' has a field conflict: fatContent or name?",           # alias/name conflict in query and fragment
-      "Field 'similarCheese' has an argument conflict: {\"source\":\"sourceVar\"} or {\"source\":\"SHEEP\"}?", # different arguments
-      "Field 'similarCowSource' has a field conflict: source or id?",           # nested conflict
-    ]
-    assert_equal(expected_errors, error_messages)
-  end
-end

data/spec/graphql/static_validation/rules/fragment_spreads_are_possible_spec.rb

@@ -1,47 +0,0 @@
-require "spec_helper"
-
-describe GraphQL::StaticValidation::FragmentSpreadsArePossible do
-  let(:query_string) {%|
-    query getCheese {
-      cheese(id: 1) {
-        ... milkFields
-        ... cheeseFields
-        ... on Milk { fatContent }
-        ... on AnimalProduct { source }
-        ... on DairyProduct {
-          fatContent
-          ... on Edible { fatContent }
-        }
-      }
-    }
-
-    fragment milkFields on Milk { fatContent }
-    fragment cheeseFields on Cheese {
-      fatContent
-      ... milkFields
-    }
-  |}
-
-  let(:validator) { GraphQL::StaticValidation::Validator.new(schema: DummySchema, rules: [GraphQL::StaticValidation::FragmentSpreadsArePossible]) }
-  let(:query) { GraphQL::Query.new(DummySchema, query_string) }
-  let(:errors) { validator.validate(query)[:errors] }
-
-  it "doesnt allow spreads where they'll never apply" do
-    # TODO: more negative, abstract examples here, add stuff to the schema
-    expected = [
-      {
-        "message"=>"Fragment on Milk can't be spread inside Cheese",
-        "locations"=>[{"line"=>6, "column"=>9}]
-      },
-      {
-        "message"=>"Fragment milkFields on Milk can't be spread inside Cheese",
-        "locations"=>[{"line"=>4, "column"=>9}]
-      },
-      {
-        "message"=>"Fragment milkFields on Milk can't be spread inside Cheese",
-        "locations"=>[{"line"=>18, "column"=>7}]
-      }
-    ]
-    assert_equal(expected, errors)
-  end
-end

data/spec/graphql/static_validation/rules/fragment_types_exist_spec.rb

@@ -1,39 +0,0 @@
-require "spec_helper"
-
-describe GraphQL::StaticValidation::FragmentTypesExist do
-  let(:query_string) {"
-    query getCheese {
-      cheeese(id: 1) {
-        ... on Cheese { source }
-        ... on Nothing { whatever }
-        ... somethingFields
-        ... cheeseFields
-      }
-    }
-
-    fragment somethingFields on Something {
-      something
-    }
-    fragment cheeseFields on Cheese {
-      fatContent
-    }
-  "}
-
-  let(:validator) { GraphQL::StaticValidation::Validator.new(schema: DummySchema, rules: [GraphQL::StaticValidation::FragmentTypesExist]) }
-  let(:query) { GraphQL::Query.new(DummySchema, query_string) }
-  let(:errors) { validator.validate(query)[:errors] }
-
-  it "finds non-existent types on fragments" do
-    assert_equal(2, errors.length)
-    inline_fragment_error =  {
-      "message"=>"No such type Something, so it can't be a fragment condition",
-      "locations"=>[{"line"=>11, "column"=>5}]
-    }
-    assert_includes(errors, inline_fragment_error, "on inline fragments")
-    fragment_def_error = {
-      "message"=>"No such type Nothing, so it can't be a fragment condition",
-      "locations"=>[{"line"=>5, "column"=>9}]
-    }
-    assert_includes(errors, fragment_def_error, "on fragment definitions")
-  end
-end

data/spec/graphql/static_validation/rules/fragments_are_finite_spec.rb

@@ -1,44 +0,0 @@
-require "spec_helper"
-
-describe GraphQL::StaticValidation::FragmentsAreFinite do
-  let(:query_string) {%|
-    query getCheese {
-      cheese(id: 1) {
-        ... idField
-        ... sourceField
-        ... flavorField
-      }
-    }
-
-    fragment sourceField on Cheese {
-      source,
-      ... flavorField
-      ... idField
-    }
-    fragment flavorField on Cheese {
-      flavor,
-      ... sourceField
-    }
-    fragment idField on Cheese {
-      id
-    }
-  |}
-
-  let(:validator) { GraphQL::StaticValidation::Validator.new(schema: DummySchema, rules: [GraphQL::StaticValidation::FragmentsAreFinite]) }
-  let(:query) { GraphQL::Query.new(DummySchema, query_string) }
-  let(:errors) { validator.validate(query)[:errors] }
-
-  it "doesnt allow infinite loops" do
-    expected = [
-      {
-        "message"=>"Fragment sourceField contains an infinite loop",
-        "locations"=>[{"line"=>10, "column"=>5}]
-      },
-      {
-        "message"=>"Fragment flavorField contains an infinite loop",
-        "locations"=>[{"line"=>15, "column"=>5}]
-      }
-    ]
-    assert_equal(expected, errors)
-  end
-end

data/spec/graphql/static_validation/rules/fragments_are_on_composite_types_spec.rb

@@ -1,49 +0,0 @@
-require "spec_helper"
-
-describe GraphQL::StaticValidation::FragmentsAreOnCompositeTypes do
-  let(:query_string) {%|
-    query getCheese {
-      cheese(id: 1) {
-        ... on Cheese {
-          source
-          ... on Boolean {
-            something
-          }
-        }
-        ... intFields
-        ... on DairyProduct {
-          name
-        }
-        ... on DairyProductInput {
-          something
-        }
-      }
-    }
-
-    fragment intFields on Int {
-      something
-    }
-  |}
-
-  let(:validator) { GraphQL::StaticValidation::Validator.new(schema: DummySchema, rules: [GraphQL::StaticValidation::FragmentsAreOnCompositeTypes]) }
-  let(:query) { GraphQL::Query.new(DummySchema, query_string) }
-  let(:errors) { validator.validate(query)[:errors] }
-
-  it "requires Object/Union/Interface fragment types" do
-    expected = [
-      {
-        "message"=>"Invalid fragment on type Boolean (must be Union, Interface or Object)",
-        "locations"=>[{"line"=>6, "column"=>11}]
-      },
-      {
-        "message"=>"Invalid fragment on type DairyProductInput (must be Union, Interface or Object)",
-        "locations"=>[{"line"=>14, "column"=>9}],
-      },
-      {
-        "message"=>"Invalid fragment on type Int (must be Union, Interface or Object)",
-        "locations"=>[{"line"=>20, "column"=>5}]
-      },
-    ]
-    assert_equal(expected, errors)
-  end
-end

data/spec/graphql/static_validation/rules/fragments_are_used_spec.rb

@@ -1,25 +0,0 @@
-require "spec_helper"
-
-describe GraphQL::StaticValidation::FragmentsAreUsed do
-  let(:query_string) {"
-    query getCheese {
-      name,
-      ...cheeseFields
-      ...undefinedFields
-    }
-    fragment cheeseFields on Cheese { fatContent }
-    fragment unusedFields on Cheese { is, not, used }
-  "}
-
-  let(:validator) { GraphQL::StaticValidation::Validator.new(schema: DummySchema, rules: [GraphQL::StaticValidation::FragmentsAreUsed]) }
-  let(:query) { GraphQL::Query.new(DummySchema, query_string) }
-  let(:errors) { validator.validate(query)[:errors] }
-
-  it "adds errors for unused fragment definitions" do
-    assert_includes(errors, {"message"=>"Fragment unusedFields was defined, but not used", "locations"=>[{"line"=>8, "column"=>5}]})
-  end
-
-  it "adds errors for undefined fragment spreads" do
-    assert_includes(errors, {"message"=>"Fragment undefinedFields was used, but not defined", "locations"=>[{"line"=>5, "column"=>7}]})
-  end
-end

data/spec/graphql/static_validation/rules/required_arguments_are_present_spec.rb

@@ -1,42 +0,0 @@
-require "spec_helper"
-
-describe GraphQL::StaticValidation::RequiredArgumentsArePresent do
-  let(:query_string) {"
-    query getCheese {
-      cheese(id: 1) { source }
-      cheese { source }
-    }
-
-    fragment cheeseFields on Cheese {
-      similarCheese(id: 1)
-      flavor @include(if: true)
-      id @skip
-    }
-  "}
-
-  let(:validator) { GraphQL::StaticValidation::Validator.new(schema: DummySchema, rules: [GraphQL::StaticValidation::RequiredArgumentsArePresent]) }
-  let(:query) { GraphQL::Query.new(DummySchema, query_string) }
-  let(:errors) { validator.validate(query)[:errors] }
-
-  it "finds undefined arguments to fields and directives" do
-    assert_equal(3, errors.length)
-
-    query_root_error = {
-      "message"=>"Field 'cheese' is missing required arguments: id",
-      "locations"=>[{"line"=>4, "column"=>7}]
-    }
-    assert_includes(errors, query_root_error)
-
-    fragment_error = {
-      "message"=>"Field 'similarCheese' is missing required arguments: source",
-      "locations"=>[{"line"=>8, "column"=>7}]
-    }
-    assert_includes(errors, fragment_error)
-
-    directive_error = {
-      "message"=>"Directive 'skip' is missing required arguments: if",
-      "locations"=>[{"line"=>10, "column"=>10}]
-    }
-    assert_includes(errors, directive_error)
-  end
-end

data/spec/graphql/static_validation/rules/variable_default_values_are_correctly_typed_spec.rb

@@ -1,44 +0,0 @@
-require "spec_helper"
-
-describe GraphQL::StaticValidation::VariableDefaultValuesAreCorrectlyTyped do
-  let(:query_string) {%|
-    query getCheese(
-      $id:        Int = 1,
-      $int:       Int = 3.4e24, # can be coerced
-      $str:       String!,
-      $badFloat:  Float = true,
-      $badInt:    Int = "abc",
-      $input:     DairyProductInput = {source: YAK, fatContent: 1},
-      $badInput:  DairyProductInput = {source: YAK, fatContent: true},
-      $nonNull:  Int! = 1,
-    ) {
-      cheese(id: $id) { source }
-    }
-  |}
-
-  let(:validator) { GraphQL::StaticValidation::Validator.new(schema: DummySchema, rules: [GraphQL::StaticValidation::VariableDefaultValuesAreCorrectlyTyped]) }
-  let(:query) { GraphQL::Query.new(DummySchema, query_string) }
-  let(:errors) { validator.validate(query)[:errors] }
-
-  it "finds default values that don't match their types" do
-    expected = [
-      {
-        "message"=>"Default value for $badFloat doesn't match type Float",
-        "locations"=>[{"line"=>6, "column"=>7}]
-      },
-      {
-        "message"=>"Default value for $badInt doesn't match type Int",
-        "locations"=>[{"line"=>7, "column"=>7}]
-      },
-      {
-        "message"=>"Default value for $badInput doesn't match type DairyProductInput",
-        "locations"=>[{"line"=>9, "column"=>7}]
-      },
-      {
-        "message"=>"Non-null variable $nonNull can't have a default value",
-        "locations"=>[{"line"=>10, "column"=>7}]
-      }
-    ]
-    assert_equal(expected, errors)
-  end
-end

data/spec/graphql/static_validation/rules/variable_usages_are_allowed_spec.rb

@@ -1,63 +0,0 @@
-require "spec_helper"
-
-describe GraphQL::StaticValidation::VariableUsagesAreAllowed do
-  let(:query_string) {'
-    query getCheese(
-        $goodInt: Int = 1,
-        $okInt: Int!,
-        $badInt: Int,
-        $badStr: String!,
-        $goodAnimals: [DairyAnimal!]!,
-        $badAnimals: [DairyAnimal]!,
-        $deepAnimals: [[DairyAnimal!]!]!,
-        $goodSource: DairyAnimal!,
-    ) {
-      goodCheese:   cheese(id: $goodInt)  { source }
-      okCheese:     cheese(id: $okInt)    { source }
-      badCheese:    cheese(id: $badInt)   { source }
-      badStrCheese: cheese(id: $badStr)   { source }
-      cheese(id: 1) {
-        similarCheese(source: $goodAnimals)
-        other: similarCheese(source: $badAnimals)
-        tooDeep: similarCheese(source: $deepAnimals)
-        nullableCheese(source: $goodAnimals)
-        deeplyNullableCheese(source: $deepAnimals)
-      }
-
-      milk(id: 1) {
-        flavors(limit: $okInt)
-      }
-
-      searchDairy(product: [{source: $goodSource}]) {
-        ... on Cheese { id }
-      }
-    }
-  '}
-
-  let(:validator) { GraphQL::StaticValidation::Validator.new(schema: DummySchema, rules: [GraphQL::StaticValidation::VariableUsagesAreAllowed]) }
-  let(:query) { GraphQL::Query.new(DummySchema, query_string) }
-  let(:errors) { validator.validate(query)[:errors] }
-
-  it "finds variables used as arguments but don't match the argument's type" do
-    assert_equal(4, errors.length)
-    expected = [
-      {
-        "message"=>"Nullability mismatch on variable $badInt and argument id (Int / Int!)",
-        "locations"=>[{"line"=>14, "column"=>28}]
-      },
-      {
-        "message"=>"Type mismatch on variable $badStr and argument id (String! / Int!)",
-        "locations"=>[{"line"=>15, "column"=>28}]
-      },
-      {
-        "message"=>"Nullability mismatch on variable $badAnimals and argument source ([DairyAnimal]! / [DairyAnimal!]!)",
-        "locations"=>[{"line"=>18, "column"=>30}]
-      },
-      {
-        "message"=>"List dimension mismatch on variable $deepAnimals and argument source ([[DairyAnimal!]!]! / [DairyAnimal!]!)",
-        "locations"=>[{"line"=>19, "column"=>32}]
-      }
-    ]
-    assert_equal(expected, errors)
-  end
-end

data/spec/graphql/static_validation/rules/variables_are_input_types_spec.rb

@@ -1,37 +0,0 @@
-require "spec_helper"
-
-describe GraphQL::StaticValidation::VariablesAreInputTypes do
-  let(:query_string) {'
-    query getCheese(
-      $id:        Int = 1,
-      $str:       [String!],
-      $interface: AnimalProduct!,
-      $object:    Milk = 1,
-      $objects:   [Cheese]!,
-    ) {
-      cheese(id: $id) { source }
-    }
-  '}
-
-  let(:validator) { GraphQL::StaticValidation::Validator.new(schema: DummySchema, rules: [GraphQL::StaticValidation::VariablesAreInputTypes]) }
-  let(:query) { GraphQL::Query.new(DummySchema, query_string) }
-  let(:errors) { validator.validate(query)[:errors] }
-
-  it "finds variables whose types are invalid" do
-    expected = [
-      {
-        "message"=>"AnimalProduct isn't a valid input type (on $interface)",
-        "locations"=>[{"line"=>5, "column"=>7}]
-      },
-      {
-        "message"=>"Milk isn't a valid input type (on $object)",
-        "locations"=>[{"line"=>6, "column"=>7}]
-      },
-      {
-        "message"=>"Cheese isn't a valid input type (on $objects)",
-        "locations"=>[{"line"=>7, "column"=>7}]
-      }
-    ]
-    assert_equal(expected, errors)
-  end
-end