hq-graphql 1.1.1 → 1.1.2

data/spec/lib/graphql/resource_spec.rb

@@ -1,392 +0,0 @@
-require 'rails_helper'
-
-describe ::HQ::GraphQL::Resource do
-  let(:organization_type) do
-    Class.new do
-      include ::HQ::GraphQL::Resource
-      self.model_name = "Organization"
-    end
-  end
-
-  let(:advisor_type) do
-    Class.new do
-      include ::HQ::GraphQL::Resource
-      self.model_name = "Advisor"
-
-      root_query
-    end
-  end
-
-  let(:root_query) do
-    Class.new(::HQ::GraphQL::RootQuery)
-  end
-
-  let(:root_mutation) do
-    Class.new(::HQ::GraphQL::RootMutation)
-  end
-
-  let(:schema) do
-    Class.new(GraphQL::Schema) do
-      query(RootQuery)
-      mutation(RootMutation)
-    end
-  end
-
-  before(:each) do
-    advisor_type
-    stub_const("RootQuery", root_query)
-    stub_const("RootMutation", root_mutation)
-  end
-
-  context "defaults" do
-    it "builds the query klass" do
-      expect(::HQ::GraphQL::Types[Advisor]).to eql(advisor_type.query_klass)
-    end
-
-    it "builds the input klass" do
-      expect(::HQ::GraphQL::Inputs[Advisor]).to eql(advisor_type.input_klass)
-    end
-
-    it "creates query fields" do
-      ::HQ::GraphQL::Types[Advisor].graphql_definition
-      expected = ["id", "organizationId", "name", "createdAt", "updatedAt"]
-      expect(::HQ::GraphQL::Types[Advisor].fields.keys).to contain_exactly(*expected)
-    end
-
-    it "creates query graphql name" do
-      ::HQ::GraphQL::Types[Advisor].graphql_definition
-      expect(::HQ::GraphQL::Types[Advisor].graphql_name).to eql("Advisor")
-    end
-
-    it "creates input arguments" do
-      ::HQ::GraphQL::Inputs[Advisor].graphql_definition
-      expected = ["id", "organizationId", "name", "createdAt", "updatedAt"]
-      expect(::HQ::GraphQL::Inputs[Advisor].arguments.keys).to contain_exactly(*expected)
-    end
-
-    it "creates input graphql name" do
-      ::HQ::GraphQL::Inputs[Advisor].graphql_definition
-      expect(::HQ::GraphQL::Inputs[Advisor].graphql_name).to eql("AdvisorInput")
-    end
-
-    it "doesn't create mutations" do
-      expect(advisor_type.mutation_klasses).to be_empty
-    end
-
-    context "with an association" do
-      before(:each) do
-        organization_type
-      end
-
-      it "adds organization type" do
-        ::HQ::GraphQL::Types[Advisor].graphql_definition
-        expected = ["id", "organization", "organizationId", "name", "createdAt", "updatedAt"]
-        expect(::HQ::GraphQL::Types[Advisor].fields.keys).to contain_exactly(*expected)
-      end
-
-      it "doesn't add organization type" do
-        ::HQ::GraphQL::Inputs[Advisor].graphql_definition
-        expected = ["id", "organizationId", "name", "createdAt", "updatedAt"]
-        expect(::HQ::GraphQL::Inputs[Advisor].arguments.keys).to contain_exactly(*expected)
-      end
-    end
-  end
-
-  context ".query" do
-    let(:advisor_type) do
-      Class.new do
-        include ::HQ::GraphQL::Resource
-        self.model_name = "Advisor"
-
-        query associations: false do
-          graphql_name "CustomAdvisorName"
-          remove_attr :name
-        end
-      end
-    end
-
-    before(:each) do
-      organization_type
-      advisor_type
-    end
-
-    it "removes name" do
-      ::HQ::GraphQL::Types[Advisor].graphql_definition
-      expected = ["id", "organizationId", "createdAt", "updatedAt"]
-      expect(::HQ::GraphQL::Types[Advisor].fields.keys).to contain_exactly(*expected)
-    end
-
-    it "customizes graphql name" do
-      ::HQ::GraphQL::Types[Advisor].graphql_definition
-      expect(::HQ::GraphQL::Types[Advisor].graphql_name).to eql("CustomAdvisorName")
-    end
-  end
-
-  context ".input" do
-    let(:advisor_type) do
-      Class.new do
-        include ::HQ::GraphQL::Resource
-        self.model_name = "Advisor"
-
-        input do
-          graphql_name "CustomAdvisorInput"
-          remove_attr :name
-        end
-      end
-    end
-
-    before(:each) do
-      organization_type
-      advisor_type
-    end
-
-    it "removes name" do
-      ::HQ::GraphQL::Inputs[Advisor].graphql_definition
-      expected = ["id", "organizationId", "createdAt", "updatedAt"]
-      expect(::HQ::GraphQL::Inputs[Advisor].arguments.keys).to contain_exactly(*expected)
-    end
-
-    it "customizes graphql name" do
-      ::HQ::GraphQL::Inputs[Advisor].graphql_definition
-      expect(::HQ::GraphQL::Inputs[Advisor].graphql_name).to eql("CustomAdvisorInput")
-    end
-  end
-
-  context ".mutations" do
-    let(:advisor_type) do
-      Class.new do
-        include ::HQ::GraphQL::Resource
-        self.model_name = "Advisor"
-
-        mutations
-
-        input do
-          remove_attr :name
-          add_association :organization
-        end
-      end
-    end
-
-    before(:each) do
-      organization_type
-    end
-
-    it "generates the create, update, and destroy mutations by default" do
-      expect(advisor_type.mutation_klasses.keys).to contain_exactly("create_advisor", "update_advisor", "destroy_advisor")
-    end
-
-    it "removes name on update" do
-      update_mutation = advisor_type.mutation_klasses[:update_advisor]
-      update_mutation.payload_type
-
-      input_object = advisor_type.input_klass
-      input_object.graphql_definition
-
-      aggregate_failures do
-        expected_arguments = ["id", "organizationId", "organization", "createdAt", "updatedAt"]
-        expect(input_object.arguments.keys).to contain_exactly(*expected_arguments)
-
-        expected_arguments = ["id", "attributes"]
-        expect(update_mutation.arguments.keys).to contain_exactly(*expected_arguments)
-
-        expected_fields = ["errors", "resource"]
-        expect(update_mutation.fields.keys).to contain_exactly(*expected_fields)
-      end
-    end
-  end
-
-  context "execution" do
-    let(:find_advisor) {
-      <<-gql
-        query findAdvisor($id: UUID!){
-          advisor(id: $id) {
-            name
-            organizationId
-
-            organization {
-              name
-            }
-          }
-        }
-      gql
-    }
-
-    let(:create_mutation) {
-      <<-gql
-        mutation createAdvisor($attributes: AdvisorInput!){
-          createAdvisor(attributes: $attributes) {
-            errors
-            resource {
-              id
-              name
-            }
-          }
-        }
-      gql
-    }
-
-    let(:update_mutation) {
-      <<-gql
-        mutation updateAdvisor($id: UUID!, $attributes: AdvisorInput!){
-          updateAdvisor(id: $id, attributes: $attributes) {
-            errors
-            resource {
-              name
-              organization {
-                name
-              }
-            }
-          }
-        }
-      gql
-    }
-
-    let(:destroy_mutation) {
-      <<-gql
-        mutation destroyAdvisor($id: UUID!){
-          destroyAdvisor(id: $id) {
-            errors
-            resource {
-              name
-            }
-          }
-        }
-      gql
-    }
-
-    before(:each) do
-      organization_type
-
-      advisor_type.class_eval do
-        mutations
-
-        input do
-          add_association :organization
-        end
-      end
-    end
-
-    it "fetches results" do
-      advisor = FactoryBot.create(:advisor)
-      results = schema.execute(find_advisor, variables: { id: advisor.id })
-      data = results["data"]["advisor"]
-
-      aggregate_failures do
-        expect(data["name"]).to eql(advisor.name)
-        expect(data["organizationId"]).to eql(advisor.organization_id)
-        expect(data["organization"]["name"]).to eql(advisor.organization.name)
-      end
-    end
-
-    it "creates" do
-      organization = FactoryBot.create(:organization)
-      name = "Bob"
-      results = schema.execute(create_mutation, variables: { attributes: { name: name, organizationId: organization.id } })
-
-      data = results["data"]
-      aggregate_failures do
-        expect(data["errors"]).to be_nil
-        expect(data["createAdvisor"]["resource"]["name"]).to eql name
-        expect(Advisor.where(id: data["createAdvisor"]["resource"]["id"]).exists?).to eql true
-      end
-    end
-
-    it "updates" do
-      advisor = FactoryBot.create(:advisor)
-      name = "Bob"
-      organization_name = "Foo"
-
-      results = schema.execute(update_mutation, variables: {
-        id: advisor.id,
-        attributes: {
-          name: name,
-          organization: { id: advisor.organization_id, name: organization_name }
-        }
-      })
-
-      data = results["data"]
-      aggregate_failures do
-        expect(data["errors"]).to be_nil
-        expect(data["updateAdvisor"]["resource"]["name"]).to eql name
-        expect(data["updateAdvisor"]["resource"]["organization"]["name"]).to eql organization_name
-        expect(Advisor.find(advisor.id).name).to eql name
-        expect(Organization.find(advisor.organization_id).name).to eql organization_name
-      end
-    end
-
-    it "destroys" do
-      advisor = FactoryBot.create(:advisor)
-      results = schema.execute(destroy_mutation, variables: { id: advisor.id })
-
-      data = results["data"]
-      aggregate_failures do
-        expect(data["errors"]).to be_nil
-        expect(data["destroyAdvisor"]["resource"]["name"]).to eql advisor.name
-        expect(Advisor.where(id: advisor.id).exists?).to eql false
-      end
-    end
-
-    context "with a global scope" do
-      before(:each) do
-        allow(::HQ::GraphQL).to receive(:default_scope) { Advisor.none }
-      end
-
-      it "returns nothing" do
-        advisor = FactoryBot.create(:advisor)
-        results = schema.execute(find_advisor, variables: { id: advisor.id })
-
-        expect(results["data"]["advisor"]).to be_nil
-      end
-
-      it "returns an error on a mutation" do
-        advisor = FactoryBot.create(:advisor)
-        results = schema.execute(update_mutation, variables: {
-          id: advisor.id,
-          attributes: {
-            name: "Bob"
-          }
-        })
-
-        data = results["data"]
-        aggregate_failures do
-          expect(data["updateAdvisor"]["errors"]).to be_present
-          expect(data["updateAdvisor"]["resource"]).to be_nil
-        end
-      end
-    end
-
-    context "with a local scope" do
-      before(:each) do
-        advisor_type.class_eval do
-          default_scope do
-            Advisor.none
-          end
-        end
-      end
-
-      it "returns nothing" do
-        advisor = FactoryBot.create(:advisor)
-        results = schema.execute(find_advisor, variables: { id: advisor.id })
-
-        expect(results["data"]["advisor"]).to be_nil
-      end
-
-      it "returns an error on a mutation" do
-        advisor = FactoryBot.create(:advisor)
-        results = schema.execute(update_mutation, variables: {
-          id: advisor.id,
-          attributes: {
-            name: "Bob"
-          }
-        })
-
-        data = results["data"]
-        aggregate_failures do
-          expect(data["updateAdvisor"]["errors"]).to be_present
-          expect(data["updateAdvisor"]["resource"]).to be_nil
-        end
-      end
-    end
-  end
-
-end

data/spec/lib/graphql/types/object_spec.rb

@@ -1,96 +0,0 @@
-require 'rails_helper'
-
-describe ::HQ::GraphQL::Types::Object do
-  let(:hql_object_klass) do
-    Class.new(::HQ::GraphQL::Object) do
-      graphql_name "TestQuery"
-
-      field :valid_object, ::HQ::GraphQL::Types::Object, null: false
-      field :invalid_object, ::HQ::GraphQL::Types::Object, null: false
-
-      def valid_object
-        { name: object.name }
-      end
-
-      def invalid_object
-        :not_an_object
-      end
-    end
-  end
-
-  let(:query) do
-    Class.new(::HQ::GraphQL::Object) do
-      graphql_name "Query"
-
-      field :advisor, AdvisorType, null: false do
-        argument :filters, ::HQ::GraphQL::Types::Object, required: true
-      end
-
-      def advisor(filters:)
-        Advisor.find_by(filters)
-      end
-    end
-  end
-
-  let(:schema) do
-    Class.new(GraphQL::Schema) do
-      query(Query)
-    end
-  end
-
-  let(:query_str) do
-    <<-gql
-      query findAdvisor($filters: Object!){
-        advisor(filters: $filters) {
-          validObject
-        }
-      }
-    gql
-  end
-
-  let(:invalid_query_str) do
-    <<-gql
-      query findAdvisor($filters: Object!){
-        advisor(filters: $filters) {
-          invalidObject
-        }
-      }
-    gql
-  end
-
-  let(:advisor) { FactoryBot.create(:advisor) }
-  let(:advisor_filter) { { name: advisor.name } }
-
-  before(:each) do
-    stub_const("AdvisorType", hql_object_klass)
-    stub_const("Query", query)
-  end
-
-  describe ".coerce_result" do
-    it "returns an object" do
-      results = schema.execute(query_str, variables: { filters: advisor_filter })
-      expect(results["data"]["advisor"]["validObject"]).to eql({ name: advisor.name })
-    end
-
-    it "raises an error when returning am invalid object " do
-      expect { schema.execute(invalid_query_str, variables: { filters: advisor_filter }) }.to raise_error(
-        ::GraphQL::CoercionError, ":not_an_object is not a valid Object"
-      )
-    end
-  end
-
-  describe ".coerce_input" do
-    it "accepts an object as input" do
-      result = schema.execute(query_str, variables: { filters: advisor_filter })
-      expect(result["data"]["advisor"]["validObject"]).to eql({ name: advisor.name })
-    end
-
-    it "raises an error when an argument is an invalid object" do
-      result = schema.execute(query_str, variables: { filters: advisor.name })
-      aggregate_failures do
-        expect(result["errors"].length).to eql(1)
-        expect(result["errors"][0]["message"]).to eql("Variable filters of type Object! was provided invalid value")
-      end
-    end
-  end
-end

data/spec/lib/graphql/types/uuid_spec.rb

@@ -1,65 +0,0 @@
-require 'rails_helper'
-
-describe ::HQ::GraphQL::Types::UUID do
-  let(:hql_object_klass) do
-    Class.new(::HQ::GraphQL::Object) do
-      graphql_name "TestQuery"
-
-      field :name, ::HQ::GraphQL::Types::UUID, null: false
-    end
-  end
-
-  let(:query) do
-    Class.new(::HQ::GraphQL::Object) do
-      graphql_name "Query"
-
-      field :advisor, AdvisorType, null: false do
-        argument :id, ::HQ::GraphQL::Types::UUID, required: true
-      end
-
-      def advisor(id:)
-        Advisor.find(id)
-      end
-    end
-  end
-
-  let(:schema) do
-    Class.new(GraphQL::Schema) do
-      query(Query)
-    end
-  end
-
-  let(:query_str) do
-    <<-gql
-      query findAdvisor($id: UUID!){
-        advisor(id: $id) {
-          name
-        }
-      }
-    gql
-  end
-
-  before(:each) do
-    stub_const("AdvisorType", hql_object_klass)
-    stub_const("Query", query)
-  end
-
-  describe ".coerce_result" do
-    it "raises an error on incorrect type" do
-      advisor = FactoryBot.create(:advisor)
-      expect { schema.execute(query_str, variables: { id: advisor.id }) }.to raise_error(
-        ::GraphQL::CoercionError, "\"#{advisor.name}\" is not a valid UUID"
-      )
-    end
-  end
-
-  describe ".coerce_input" do
-    it "displays an error message" do
-      result = schema.execute(query_str, variables: { id: "1" })
-      aggregate_failures do
-        expect(result["errors"].length).to eql(1)
-        expect(result["errors"][0]["message"]).to eql("Variable id of type UUID! was provided invalid value")
-      end
-    end
-  end
-end

data/spec/lib/graphql/types_spec.rb

@@ -1,86 +0,0 @@
-require 'rails_helper'
-
-describe ::HQ::GraphQL::Types do
-
-  describe ".[]" do
-    let(:graphql_klass) do
-      Class.new do
-        include ::HQ::GraphQL::Resource
-
-        self.model_name = "Advisor"
-
-        query(attributes: false, associations: false) do
-          field :custom_field, String, null: false
-        end
-      end
-    end
-
-    it "finds the type" do
-      type_object = graphql_klass.query_klass
-
-      aggregate_failures do
-        expect(type_object.superclass).to eql(::HQ::GraphQL::Object)
-        expect(type_object).to eql(described_class[Advisor])
-        expect(type_object.fields.keys).to contain_exactly("customField")
-        type_object.to_graphql
-        expect(type_object.fields.keys).to contain_exactly("customField")
-      end
-    end
-
-    it "finds the type when lookup is a string" do
-      type_object = graphql_klass.query_klass
-      expect(type_object).to eql(described_class["Advisor"])
-    end
-
-    it "raises an exception for unknown types" do
-      expect { described_class[Advisor] }.to raise_error(described_class::Error)
-    end
-  end
-
-  describe ".type_from_column" do
-    context "UUID" do
-      it "matches uuid" do
-        expect(type_from_column("id")).to eq ::HQ::GraphQL::Types::UUID
-      end
-    end
-
-    context "Object" do
-      it "matches json" do
-        expect(type_from_column("data_json")).to eq ::HQ::GraphQL::Types::Object
-      end
-
-      it "matches jsonb" do
-        expect(type_from_column("data_jsonb")).to eq ::HQ::GraphQL::Types::Object
-      end
-    end
-
-    context "Int" do
-      it "matches integer" do
-        expect(type_from_column("count")).to eq ::GraphQL::Types::Int
-      end
-    end
-
-    context "Float" do
-      it "matches decimal" do
-        expect(type_from_column("amount")).to eq ::GraphQL::Types::Float
-      end
-    end
-
-    context "Boolean" do
-      it "matches boolean" do
-        expect(type_from_column("is_bool")).to eq ::GraphQL::Types::Boolean
-      end
-    end
-
-    context "String" do
-      it "matches string" do
-        expect(type_from_column("name")).to eq ::GraphQL::Types::String
-      end
-    end
-
-    def type_from_column(name)
-      described_class.type_from_column(TestType.columns_hash[name])
-    end
-  end
-
-end

data/spec/rails_helper.rb

@@ -1,43 +0,0 @@
-require "testhq/coverage"  # Needs to be require at the top of this file!
-                           # Coverage must also be enabled in the environment by setting
-                           # environment variables, e.g. `COVERAGE=true` or `CODECLIMATE_REPO_TOKEN=...`.
-                           # See https://github.com/OneHQ/testhq#code-coverage.
-
-require "bundler/setup"
-require "combustion"
-
-silence_stream(STDOUT) do  # Hides a lot of output from Combustion init such as schema loading.
-  Combustion.initialize! :all do
-    # Disable strong parameters
-    config.action_controller.permit_all_parameters = true
-  end
-end
-
-require "byebug"
-require "rspec/rails"
-require "testhq"
-
-RSpec.configure do |config|
-  config.expect_with :rspec do |c|
-    c.syntax = [:expect]
-  end
-
-  config.use_transactional_fixtures = false
-
-  config.include FactoryBot::Syntax::Methods
-
-  config.before(:suite) do
-    DatabaseCleaner.strategy = :transaction
-    DatabaseCleaner.clean_with :truncation # Clear everything
-  end
-
-  config.before(:each) do
-    ::HQ::GraphQL.reset!
-    DatabaseCleaner.start
-  end
-
-  config.after(:each) do
-    DatabaseCleaner.clean
-    ::HQ::GraphQL.reset!
-  end
-end

data/spec/spec_helper.rb

@@ -1,22 +0,0 @@
-RSpec.configure do |config|
-  config.expect_with :rspec do |expectations|
-    # This option will default to `true` in RSpec 4. It makes the `description`
-    # and `failure_message` of custom matchers include text for helper methods
-    # defined using `chain`, e.g.:
-    # be_bigger_than(2).and_smaller_than(4).description
-    #   # => "be bigger than 2 and smaller than 4"
-    # ...rather than:
-    #   # => "be bigger than 2"
-    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
-  end
-
-  # rspec-mocks config goes here. You can use an alternate test double
-  # library (such as bogus or mocha) by changing the `mock_with` option here.
-  config.mock_with :rspec do |mocks|
-    # Prevents you from mocking or stubbing a method that does not exist on
-    # a real object. This is generally recommended, and will default to
-    # `true` in RSpec 4.
-    mocks.verify_partial_doubles = true
-  end
-  config.order = :random
-end