graphql 0.16.0 → 2.0.15

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

@@ -1,53 +0,0 @@
-require "spec_helper"
-
-describe GraphQL::StaticValidation::VariablesAreUsedAndDefined do
-  let(:query_string) {'
-    query getCheese(
-      $usedVar: Int,
-      $usedInnerVar: String,
-      $usedInlineFragmentVar: Boolean,
-      $usedFragmentVar: Int,
-      $notUsedVar: Float,
-    ) {
-      cheese(id: $usedVar) {
-        source(str: $usedInnerVar)
-        whatever(undefined: $undefinedVar)
-        ... on Cheese {
-          something(bool: $usedInlineFragmentVar)
-        }
-        ... outerCheeseFields
-      }
-    }
-
-    fragment outerCheeseFields on Cheese {
-      ... innerCheeseFields
-    }
-
-    fragment innerCheeseFields on Cheese {
-      source(notDefined: $undefinedFragmentVar)
-      someField(someArg: $usedFragmentVar)
-    }
-  '}
-
-  let(:validator) { GraphQL::StaticValidation::Validator.new(schema: DummySchema, rules: [GraphQL::StaticValidation::VariablesAreUsedAndDefined]) }
-  let(:query) { GraphQL::Query.new(DummySchema, query_string) }
-  let(:errors) { validator.validate(query)[:errors] }
-
-  it "finds variables which are used-but-not-defined or defined-but-not-used" do
-    expected = [
-      {
-        "message"=>"Variable $notUsedVar is declared by getCheese but not used",
-        "locations"=>[{"line"=>2, "column"=>5}]
-      },
-      {
-        "message"=>"Variable $undefinedVar is used by getCheese but not declared",
-        "locations"=>[{"line"=>11, "column"=>29}]
-      },
-      {
-        "message"=>"Variable $undefinedFragmentVar is used by innerCheeseFields but not declared",
-        "locations"=>[{"line"=>24, "column"=>26}]
-      },
-    ]
-    assert_equal(expected, errors)
-  end
-end

data/spec/graphql/static_validation/type_stack_spec.rb

@@ -1,37 +0,0 @@
-require "spec_helper"
-
-class TypeCheckValidator
-  def self.checks
-    @checks ||= []
-  end
-
-  def validate(context)
-    self.class.checks.clear
-    context.visitor[GraphQL::Language::Nodes::Field] << -> (node, parent) {
-      self.class.checks << context.object_types.map(&:name)
-    }
-  end
-end
-
-describe GraphQL::StaticValidation::TypeStack do
-  let(:query_string) {%|
-    query getCheese {
-      cheese(id: 1) { id, ... edibleFields }
-    }
-    fragment edibleFields on Edible { fatContent @skip(if: false)}
-  |}
-
-  let(:validator) { GraphQL::StaticValidation::Validator.new(schema: DummySchema, rules: [TypeCheckValidator]) }
-  let(:query) { GraphQL::Query.new(DummySchema, query_string) }
-
-
-  it "stores up types" do
-    validator.validate(query)
-    expected = [
-      ["Query", "Cheese"],
-      ["Query", "Cheese", "Non-Null"],
-      ["Edible", "Non-Null"]
-    ]
-    assert_equal(expected, TypeCheckValidator.checks)
-  end
-end

data/spec/graphql/static_validation/validator_spec.rb

@@ -1,69 +0,0 @@
-require "spec_helper"
-
-describe GraphQL::StaticValidation::Validator do
-  let(:validator) { GraphQL::StaticValidation::Validator.new(schema: DummySchema) }
-  let(:query) { GraphQL::Query.new(DummySchema, query_string) }
-  let(:errors) { validator.validate(query)[:errors] }
-
-
-  describe "validation order" do
-    let(:document) { GraphQL.parse(query_string)}
-
-    describe "fields & arguments" do
-      let(:query_string) { %|
-        query getCheese($id: Int!) {
-          cheese(id: $undefinedVar, bogusArg: true) {
-            source,
-            nonsenseField,
-            id(nonsenseArg: 1)
-            bogusField(bogusArg: true)
-          }
-
-          otherCheese: cheese(id: $id) {
-            source,
-          }
-        }
-      |}
-
-      it "handles args on invalid fields" do
-        # nonsenseField, nonsenseArg, bogusField, bogusArg, undefinedVar
-        assert_equal(5, errors.length)
-      end
-    end
-
-    describe "infinite fragments" do
-      let(:query_string) { %|
-        query getCheese {
-          cheese(id: 1) {
-            ... cheeseFields
-          }
-        }
-        fragment cheeseFields on Cheese {
-          id, ... cheeseFields
-        }
-      |}
-
-      it "handles infinite fragment spreads" do
-        assert_equal(1, errors.length)
-      end
-    end
-
-    describe "fragment spreads with no selections" do
-      let(:query_string) {%|
-        query SimpleQuery {
-          cheese(id: 1) {
-            # OK:
-            ... {
-              id
-            }
-            # NOT OK:
-            ...cheeseFields
-          }
-        }
-      |}
-      it "marks an error" do
-        assert_equal(1, errors.length)
-      end
-    end
-  end
-end

data/spec/graphql/string_type_spec.rb

@@ -1,15 +0,0 @@
-require "spec_helper"
-
-describe GraphQL::STRING_TYPE do
-  describe "coerce_input" do
-    it "accepts strings" do
-      assert_equal "str", GraphQL::STRING_TYPE.coerce_input("str")
-    end
-
-    it "doesn't accept other types" do
-      assert_equal nil, GraphQL::STRING_TYPE.coerce_input(100)
-      assert_equal nil, GraphQL::STRING_TYPE.coerce_input(true)
-      assert_equal nil, GraphQL::STRING_TYPE.coerce_input(0.999)
-    end
-  end
-end

data/spec/graphql/union_type_spec.rb

@@ -1,31 +0,0 @@
-require "spec_helper"
-
-describe GraphQL::UnionType do
-  let(:type_1) { OpenStruct.new(kind: GraphQL::TypeKinds::OBJECT)}
-  let(:type_2) { OpenStruct.new(kind: GraphQL::TypeKinds::OBJECT)}
-  let(:type_3) { OpenStruct.new(kind: GraphQL::TypeKinds::SCALAR)}
-  let(:union) {
-    types = [type_1, type_2]
-    GraphQL::UnionType.define {
-      name("MyUnion")
-      description("Some items")
-      possible_types(types)
-    }
-  }
-  it "has a name" do
-    assert_equal("MyUnion", union.name)
-  end
-
-
-  it "infers type from an object" do
-    assert_equal(CheeseType, DairyProductUnion.resolve_type(CHEESES[1], OpenStruct.new(schema: DummySchema)))
-  end
-
-  it '#include? returns true if type in in possible_types' do
-    assert union.include?(type_1)
-  end
-
-  it '#include? returns false if type is not in possible_types' do
-    assert_equal(false, union.include?(type_3))
-  end
-end

data/spec/spec_helper.rb

@@ -1,18 +0,0 @@
-require "codeclimate-test-reporter"
-CodeClimate::TestReporter.start
-require "graphql"
-require "benchmark"
-require "minitest/autorun"
-require "minitest/focus"
-require "minitest/reporters"
-require "pry"
-Minitest::Reporters.use! Minitest::Reporters::SpecReporter.new
-
-Minitest::Spec.make_my_diffs_pretty!
-
-# Filter out Minitest backtrace while allowing backtrace from other libraries
-# to be shown.
-Minitest.backtrace_filter = Minitest::BacktraceFilter.new
-
-# # Load support files
-Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each { |f| require f }

data/spec/support/dairy_app.rb

@@ -1,309 +0,0 @@
-require_relative "./dairy_data"
-
-class NoSuchDairyError < StandardError; end
-
-EdibleInterface = GraphQL::InterfaceType.define do
-  name "Edible"
-  description "Something you can eat, yum"
-  field :fatContent, !types.Float, "Percentage which is fat"
-  field :origin, !types.String, "Place the edible comes from"
-end
-
-AnimalProductInterface = GraphQL::InterfaceType.define do
-  name "AnimalProduct"
-  description "Comes from an animal, no joke"
-  field :source, !types.String, "Animal which produced this product"
-end
-
-DairyAnimalEnum = GraphQL::EnumType.define do
-  name "DairyAnimal"
-  description "An animal which can yield milk"
-  value("COW",    "Animal with black and white spots", value: 1)
-  value("GOAT",   "Animal with horns")
-  value("SHEEP",  "Animal with wool")
-  value("YAK",    "Animal with long hair", deprecation_reason: "Out of fashion")
-end
-
-CheeseType = GraphQL::ObjectType.define do
-  name "Cheese"
-  description "Cultured dairy product"
-  interfaces ["EdibleInterface", -> { AnimalProductInterface }]
-
-  # Can have (name, type, desc)
-  field :id, !types.Int, "Unique identifier"
-  field :flavor, !types.String, "Kind of Cheese"
-  field :origin, !types.String, "Place the cheese comes from"
-
-  field :source, !DairyAnimalEnum,
-    "Animal which produced the milk for this cheese"
-
-  # Or can define by block:
-  field :similarCheese, -> { CheeseType }, "Cheeses like this one" do
-    argument :source, !types[!DairyAnimalEnum]
-    resolve -> (t, a, c) {
-      # get the strings out:
-      sources = a["source"]
-      if sources.include?("YAK")
-        raise NoSuchDairyError.new("No cheeses are made from Yak milk!")
-      else
-        CHEESES.values.find { |c| sources.include?(c.source) }
-      end
-    }
-  end
-
-  field :nullableCheese, -> { CheeseType }, "Cheeses like this one" do
-    argument :source, types[!DairyAnimalEnum]
-    resolve -> (t, a, c) { raise("NotImplemented") }
-  end
-
-  field :deeplyNullableCheese, -> { CheeseType }, "Cheeses like this one" do
-    argument :source, types[types[DairyAnimalEnum]]
-    resolve -> (t, a, c) { raise("NotImplemented") }
-  end
-
-  field :fatContent, property: :fat_content do
-    type(!GraphQL::FLOAT_TYPE)
-    description("Percentage which is milkfat")
-    deprecation_reason("Diet fashion has changed")
-  end
-end
-
-MilkType = GraphQL::ObjectType.define do
-  name "Milk"
-  description "Dairy beverage"
-  interfaces [EdibleInterface, AnimalProductInterface]
-  field :id, !types.ID
-  field :source, DairyAnimalEnum, "Animal which produced this milk"
-  field :origin, !types.String, "Place the milk comes from"
-  field :flavors, types[types.String], "Chocolate, Strawberry, etc" do
-    argument :limit, types.Int
-    resolve -> (milk, args, ctx) {
-      args[:limit] ? milk.flavors.first(args[:limit]) : milk.flavors
-    }
-  end
-end
-
-SweetenerInterface = GraphQL::InterfaceType.define do
-  name "Sweetener"
-  field :sweetness, types.Int
-end
-
-# No actual data; This type is an "orphan", only accessible through Interfaces
-HoneyType = GraphQL::ObjectType.define do
-  name "Honey"
-  description "Sweet, dehydrated bee barf"
-  field :flowerType, types.String, "What flower this honey came from"
-  interfaces [EdibleInterface, AnimalProductInterface, SweetenerInterface]
-end
-
-DairyType = GraphQL::ObjectType.define do
-  name "Dairy"
-  description "A farm where milk is harvested and cheese is produced"
-  field :id, !types.ID
-  field :cheese, CheeseType
-  field :milks, types[MilkType]
-end
-
-MaybeNullType = GraphQL::ObjectType.define do
-  name "MaybeNull"
-  description "An object whose fields return nil"
-  field :cheese, CheeseType
-end
-
-DairyProductUnion = GraphQL::UnionType.define do
-  name "DairyProduct"
-  description "Kinds of food made from milk"
-  possible_types ["MilkType", -> { CheeseType }]
-end
-
-CowType = GraphQL::ObjectType.define do
-  name "Cow"
-  description "A farm where milk is harvested and cheese is produced"
-  field :id, !types.ID
-  field :name, types.String
-  field :last_produced_dairy, DairyProductUnion
-
-  field :cantBeNullButIs do
-    type !GraphQL::STRING_TYPE
-    resolve -> (t, a, c) { nil }
-  end
-
-  field :cantBeNullButRaisesExecutionError do
-    type !GraphQL::STRING_TYPE
-    resolve -> (t, a, c) { raise GraphQL::ExecutionError, "BOOM" }
-  end
-end
-
-DairyProductInputType = GraphQL::InputObjectType.define {
-  name "DairyProductInput"
-  description "Properties for finding a dairy product"
-  input_field :source, !DairyAnimalEnum do
-    # ensure we can define description in block
-    description "Where it came from"
-  end
-
-  input_field :originDairy, types.String, "Dairy which produced it", default_value: "Sugar Hollow Dairy" do
-    description   "Ignored because arg takes precedence"
-    default_value "Ignored because keyword arg takes precedence"
-  end
-
-  input_field :fatContent, types.Float, "How much fat it has" do
-    # ensure we can define default in block
-    default_value 0.3
-  end
-
-  # ensure default can be false
-  input_field :organic, types.Boolean, default_value: false
-}
-
-DeepNonNullType = GraphQL::ObjectType.define do
-  name "DeepNonNull"
-  field :nonNullInt, !types.Int do
-    argument :returning, types.Int
-    resolve -> (obj, args, ctx) { args[:returning] }
-  end
-
-  field :deepNonNull, -> { DeepNonNullType.to_non_null_type } do
-    resolve -> (obj, args, ctx) { :deepNonNull }
-  end
-end
-
-class FetchField
-  def self.create(type:, data:, id_type: !GraphQL::INT_TYPE)
-    desc = "Find a #{type.name} by id"
-    return_type = type
-    GraphQL::Field.define do
-      type(return_type)
-      description(desc)
-      argument :id, id_type
-
-      resolve -> (t, a, c) {
-        id_string = a["id"].to_s # Cheese has Int type, Milk has ID type :(
-        id, item = data.find { |id, item| id.to_s == id_string }
-        item
-      }
-    end
-  end
-end
-
-class SingletonField
-  def self.create(type:, data:)
-    desc = "Find the only #{type.name}"
-    return_type = type
-    GraphQL::Field.define do
-      type(return_type)
-      description(desc)
-
-      resolve -> (t, a, c) {data}
-    end
-  end
-end
-
-SourceFieldDefn = Proc.new {
-  type GraphQL::ListType.new(of_type: CheeseType)
-  description "Cheese from source"
-  argument :source, DairyAnimalEnum, default_value: "COW"
-  resolve -> (target, arguments, context) {
-    CHEESES.values.select{ |c| c.source == arguments["source"] }
-  }
-}
-
-FavoriteFieldDefn = Proc.new {
-  description "My favorite food"
-  type EdibleInterface
-  resolve -> (t, a, c) { MILKS[1] }
-}
-
-QueryType = GraphQL::ObjectType.define do
-  name "Query"
-  description "Query root of the system"
-  field :root, types.String do
-    resolve ->(root_value, args, c) { root_value }
-  end
-  field :cheese, field: FetchField.create(type: CheeseType, data: CHEESES)
-  field :milk, field: FetchField.create(type: MilkType, data: MILKS, id_type: !types.ID)
-  field :dairy, field: SingletonField.create(type: DairyType, data: DAIRY)
-  field :fromSource, &SourceFieldDefn
-  field :favoriteEdible, &FavoriteFieldDefn
-  field :cow, field: SingletonField.create(type: CowType, data: COW)
-  field :searchDairy do
-    description "Find dairy products matching a description"
-    type !DairyProductUnion
-    # This is a list just for testing 😬
-    argument :product, types[DairyProductInputType], default_value: [{"source" => "SHEEP"}]
-    resolve -> (t, args, c) {
-      source = args["product"][0][:source] # String or Sym is ok
-      products = CHEESES.values + MILKS.values
-      if !source.nil?
-        products = products.select { |pr| pr.source == source }
-      end
-      products.first
-    }
-  end
-
-  field :error do
-    description "Raise an error"
-    type GraphQL::STRING_TYPE
-    resolve -> (t, a, c) { raise("This error was raised on purpose") }
-  end
-
-  field :executionError do
-    type GraphQL::STRING_TYPE
-    resolve -> (t, a, c) { raise(GraphQL::ExecutionError, "There was an execution error") }
-  end
-
-  # To test possibly-null fields
-  field :maybeNull, MaybeNullType do
-    resolve -> (t, a, c) { OpenStruct.new(cheese: nil) }
-  end
-
-  field :deepNonNull, !DeepNonNullType do
-    resolve -> (o, a, c) { :deepNonNull }
-  end
-end
-
-GLOBAL_VALUES = []
-
-ReplaceValuesInputType = GraphQL::InputObjectType.define do
-  name "ReplaceValuesInput"
-  input_field :values, !types[!types.Int]
-end
-
-MutationType = GraphQL::ObjectType.define do
-  name "Mutation"
-  description "The root for mutations in this schema"
-  field :pushValue, !types[!types.Int] do
-    description("Push a value onto a global array :D")
-    argument :value, !types.Int
-    resolve -> (o, args, ctx) {
-      GLOBAL_VALUES << args[:value]
-      GLOBAL_VALUES
-    }
-  end
-
-  field :replaceValues, !types[!types.Int] do
-    description("Replace the global array with new values")
-    argument :input, !ReplaceValuesInputType
-    resolve -> (o, args, ctx) {
-      GLOBAL_VALUES.clear
-      GLOBAL_VALUES.push(*args[:input][:values])
-      GLOBAL_VALUES
-    }
-  end
-end
-
-SubscriptionType = GraphQL::ObjectType.define do
-  name "Subscription"
-  field :test, types.String do
-    resolve -> (o, a, c) { "Test" }
-  end
-end
-
-DummySchema = GraphQL::Schema.new(
-  query: QueryType,
-  mutation: MutationType,
-  subscription: SubscriptionType,
-  max_depth: 5,
-  types: [HoneyType],
-)
-DummySchema.rescue_from(NoSuchDairyError) { |err| err.message  }

data/spec/support/dairy_data.rb

@@ -1,23 +0,0 @@
-Cheese = Struct.new(:id, :flavor, :origin, :fat_content, :source)
-CHEESES = {
-  1 => Cheese.new(1, "Brie", "France", 0.19, 1),
-  2 => Cheese.new(2, "Gouda", "Netherlands", 0.3, 1),
-  3 => Cheese.new(3, "Manchego", "Spain", 0.065, "SHEEP")
-}
-
-Milk = Struct.new(:id, :fatContent, :origin, :source, :flavors)
-MILKS = {
-  1 => Milk.new(1, 0.04, "Antiquity", 1, ["Natural", "Chocolate", "Strawberry"]),
-}
-
-DAIRY = OpenStruct.new(
-  id: 1,
-  cheese: CHEESES[1],
-  milks: [MILKS[1]]
-)
-
-COW = OpenStruct.new(
-  id: 1,
-  name: "Billy",
-  last_produced_dairy: MILKS[1]
-)

data/spec/support/minimum_input_object.rb

@@ -1,16 +0,0 @@
-# This is the minimum required interface for an input object
-class MinimumInputObject
-  include Enumerable
-
-  def initialize(values)
-    @values = values
-  end
-
-  def each(&block)
-    @values.each(&block)
-  end
-
-  def [](key)
-    @values[key]
-  end
-end

data/spec/support/star_wars_data.rb

@@ -1,71 +0,0 @@
-luke = OpenStruct.new({
-  id: "1000",
-  name: "Luke Skywalker",
-  friends: ["1002", "1003", "2000", "2001"],
-  appearsIn: [4, 5, 6],
-  homePlanet: "Tatooine",
-})
-
-vader = OpenStruct.new({
-  id: "1001",
-  name: "Darth Vader",
-  friends: ["1004"],
-  appearsIn: [4, 5, 6],
-  homePlanet: "Tatooine",
-})
-
-han = OpenStruct.new({
-  id: "1002",
-  name: "Han Solo",
-  friends: ["1000", "1003", "2001"],
-  appearsIn: [4, 5, 6],
-})
-
-leia = OpenStruct.new({
-  id: "1003",
-  name: "Leia Organa",
-  friends: ["1000", "1002", "2000", "2001"],
-  appearsIn: [4, 5, 6],
-  homePlanet: "Alderaan",
-})
-
-tarkin = OpenStruct.new({
-  id: "1004",
-  name: "Wilhuff Tarkin",
-  friends: ["1001"],
-  appearsIn: [4],
-})
-
-HUMAN_DATA = {
-  "1000" => luke,
-  "1001" => vader,
-  "1002" => han,
-  "1003" => leia,
-  "1004" => tarkin,
-}
-
-threepio = OpenStruct.new({
-  id: "2000",
-  name: "C-3PO",
-  friends: ["1000", "1002", "1003", "2001"],
-  appearsIn: [4, 5, 6],
-  primaryFunction: "Protocol",
-})
-
-artoo = OpenStruct.new({
-  id: "2001",
-  name: "R2-D2",
-  friends: ["1000", "1002", "1003"],
-  appearsIn: [4, 5, 6],
-  primaryFunction: "Astromech",
-})
-
-DROID_DATA = {
-  "2000" => threepio,
-  "2001" => artoo,
-}
-
-# Get friends from IDs
-GET_FRIENDS = -> (obj, args, ctx) do
-  obj.friends.map { |id| HUMAN_DATA[id] || DROID_DATA[id]}
-end