artemis 0.9.0 → 1.0.2

data/spec/autoloading_spec.rb

@@ -1,152 +0,0 @@
-describe "#{GraphQL::Client} Autoloading" do
-  describe ".load_constant" do
-    it "loads the specified constant if there is a matching graphql file" do
-      Github.send(:remove_const, :User) if Github.constants.include?(:User)
-
-      Github.load_constant(:User)
-
-      expect(defined?(Github::User)).to eq('constant')
-    end
-
-    it "does nothing and returns nil if there is no matching file" do
-      expect(Github.load_constant(:DoesNotExist)).to be_nil
-    end
-  end
-
-  describe ".preload!" do
-    it "preloads all the graphQL files in the query paths" do
-      %i(User UserRepositories Repository RepositoryFields)
-        .select {|const_name| Github.constants.include?(const_name) }
-        .each {|const_name| Github.send(:remove_const, const_name) }
-
-      Github.preload!
-
-      expect(defined?(Github::User)).to eq('constant')
-      expect(defined?(Github::Repository)).to eq('constant')
-    end
-  end
-
-  it "dynamically loads the matching GraphQL query and sets it to a constant" do
-    Github.send(:remove_const, :User) if Github.constants.include?(:User)
-
-    query = Github::User
-
-    expect(query.document.to_query_string).to eq(<<~GRAPHQL.strip)
-      query Github__User {
-        user(login: "yuki24") {
-          id
-          name
-        }
-      }
-    GRAPHQL
-  end
-
-  it "dynamically loads the matching GraphQL fragment and sets it to a constant" do
-    Github.send(:remove_const, :RepositoryFields) if Github.constants.include?(:RepositoryFields)
-
-    query = Github::RepositoryFields
-
-    expect(query.document.to_query_string).to eq(<<~GRAPHQL.strip)
-      fragment Github__RepositoryFields on Repository {
-        name
-        nameWithOwner
-        url
-        updatedAt
-        languages(first: 1) {
-          nodes {
-            name
-            color
-          }
-        }
-      }
-    GRAPHQL
-  end
-
-  it "correctly loads the matching GraphQL query even when the top-level constant with the same name exists" do
-    # In Ruby <= 2.4 top-level constants can be looked up through a namespace, which turned out to be a bad practice.
-    # This has been removed in 2.5, but in earlier versions still suffer from this behaviour.
-    Github.send(:remove_const, :User) if Github.constants.include?(:User)
-    Object.send(:remove_const, :User) if Object.constants.include?(:User)
-
-    begin
-      Object.send(:const_set, :User, 1)
-
-      Github.user
-    ensure
-      Object.send(:remove_const, :User)
-    end
-
-    query = Github::User
-
-    expect(query.document.to_query_string).to eq(<<~GRAPHQL.strip)
-      query Github__User {
-        user(login: "yuki24") {
-          id
-          name
-        }
-      }
-    GRAPHQL
-  end
-
-  it "raises an exception when the path was resolved but the file does not exist" do
-    begin
-      Github.graphql_file_paths << "github/removed.graphql"
-
-      expect { Github::Removed }.to raise_error(Errno::ENOENT)
-    ensure
-      Github.graphql_file_paths.delete("github/removed.graphql")
-    end
-  end
-
-  it "raises an NameError when there is no graphql file that matches the const name" do
-    expect { Github::DoesNotExist }.to raise_error(NameError)
-  end
-
-  xit "defines the query method when the matching class method gets called for the first time" do
-    Github.undef_method(:user) if Github.public_instance_methods.include?(:user)
-
-    Github.user
-
-    expect(Github.public_instance_methods).to include(:user)
-  end
-
-  it "raises an NameError when there is no graphql file that matches the class method name" do
-    expect { Github.does_not_exist }.to raise_error(NameError)
-  end
-
-  it "raises an NameError when the class method name matches a fragment name" do
-    expect { Github.repository_fields_fragment }.to raise_error(NameError)
-  end
-
-  it "responds to a class method that has a matching graphQL file" do
-    expect(Github).to respond_to(:user)
-  end
-
-  it "does not respond to class methods that do not have a matching graphQL file" do
-    expect(Github).not_to respond_to(:does_not_exist)
-  end
-
-  xit "defines the query method when the matching instance method gets called for the first time" do
-    Github.undef_method(:user) if Github.public_instance_methods.include?(:user)
-
-    Github.new.user
-
-    expect(Github.public_instance_methods).to include(:user)
-  end
-
-  it "raises an NameError when there is no graphql file that matches the instance method name" do
-    expect { Github.new.does_not_exist }.to raise_error(NameError)
-  end
-
-  it "raises an NameError when the instance method name matches a fragment name" do
-    expect { Github.new.repository_fields_fragment }.to raise_error(NameError)
-  end
-
-  it "responds to the method that has a matching graphQL file" do
-    expect(Github.new).to respond_to(:user)
-  end
-
-  it "does not respond to methods that do not have a matching graphQL file" do
-    expect(Github.new).not_to respond_to(:does_not_exist)
-  end
-end

data/spec/callbacks_spec.rb

@@ -1,60 +0,0 @@
-require 'active_support/core_ext/module/attribute_accessors'
-
-describe "#{GraphQL::Client} Callbacks" do
-  Client = Class.new(Artemis::Client) do
-    def self.name
-      'Github'
-    end
-
-    mattr_accessor :before_callback, :after_callback
-    self.before_callback = nil
-    self.after_callback = nil
-
-    before_execute do |document, operation_name, variables, context|
-      self.before_callback = document, operation_name, variables, context
-    end
-
-    after_execute do |data, errors, extensions|
-      self.after_callback = data, errors, extensions
-    end
-  end
-
-  Spotify = Class.new(Artemis::Client) do
-    def self.name
-      'Spotify'
-    end
-
-    before_execute do
-      raise "this callback should not get invoked"
-    end
-
-    after_execute do
-      raise "this callback should not get invoked"
-    end
-  end
-
-  describe ".before_execute" do
-    it "gets invoked before executing" do
-      Client.repository(owner: "yuki24", name: "artemis", context: { user_id: 'yuki24' })
-
-      document, operation_name, variables, context = Client.before_callback
-
-      expect(document).to eq(Client::Repository.document)
-      expect(operation_name).to eq('Client__Repository')
-      expect(variables).to eq("name" => "artemis", "owner" => "yuki24")
-      expect(context).to eq(user_id: 'yuki24')
-    end
-  end
-
-  describe ".after_execute" do
-    it "gets invoked after executing" do
-      Client.user
-
-      data, errors, extensions = Client.after_callback
-
-      expect(data).to eq("test" => "data")
-      expect(errors).to eq([])
-      expect(extensions).to eq({})
-    end
-  end
-end

data/spec/client_spec.rb

@@ -1,228 +0,0 @@
-describe GraphQL::Client do
-  before do
-    requests.clear
-  end
-
-  describe ".lookup_graphql_file" do
-    it "returns the path to the matching graph file" do
-      expect(Github.resolve_graphql_file_path("user")).to eq("#{PROJECT_DIR}/spec/fixtures/github/user.graphql")
-    end
-
-    it "returns nil if the file is missing" do
-      expect(Github.resolve_graphql_file_path("does_not_exist")).to be_nil
-    end
-  end
-
-  describe ".graphql_file_paths" do
-    it "returns a list of GraphQL files (*.graphql) in the query_paths" do
-      Github.instance_variable_set :@graphql_file_paths, nil
-      original = Github.query_paths
-
-      Github.query_paths = [File.join(PROJECT_DIR, 'tmp')]
-
-      begin
-        FileUtils.mkdir "./tmp/github" if !Dir.exist?("./tmp/github")
-
-        with_files "./tmp/github/text.txt", "./tmp/github/sale.graphql" do
-          expect(Github.graphql_file_paths).to eq(["#{PROJECT_DIR}/tmp/github/sale.graphql"])
-        end
-      ensure
-        Github.instance_variable_set :@graphql_file_paths, nil
-        Github.query_paths = original
-      end
-    end
-  end
-
-  it "can make a GraphQL request without variables" do
-    Github.user
-
-    request = requests[0]
-
-    expect(request.operation_name).to eq('Github__User')
-    expect(request.variables).to be_empty
-    expect(request.context).to eq({})
-    expect(request.document.to_query_string).to eq(<<~GRAPHQL.strip)
-      query Github__User {
-        user(login: "yuki24") {
-          id
-          name
-        }
-      }
-    GRAPHQL
-  end
-
-  it "can make a GraphQL request with variables" do
-    Github.repository(owner: "yuki24", name: "artemis")
-
-    request = requests[0]
-
-    expect(request.operation_name).to eq('Github__Repository')
-    expect(request.variables).to eq("owner" => "yuki24", "name" => "artemis")
-    expect(request.context).to eq({})
-    expect(request.document.to_query_string).to eq(<<~GRAPHQL.strip)
-      query Github__Repository($owner: String!, $name: String!) {
-        repository(owner: $owner, name: $name) {
-          name
-          nameWithOwner
-        }
-      }
-    GRAPHQL
-  end
-
-  it "can make a GraphQL request with a query that contains fragments" do
-    Github.user_repositories(login: "yuki24", size: 10)
-
-    request = requests[0]
-
-    expect(request.operation_name).to eq('Github__UserRepositories')
-    expect(request.variables).to eq('login' => 'yuki24', 'size' => 10)
-    expect(request.context).to eq({})
-    expect(request.document.to_query_string).to eq(<<~GRAPHQL.strip)
-      query Github__UserRepositories($login: String!, $size: Int!) {
-        user(login: $login) {
-          id
-          name
-          repositories(first: $size) {
-            nodes {
-              name
-              description
-              ...Github__RepositoryFields
-            }
-          }
-        }
-      }
-
-      fragment Github__RepositoryFields on Repository {
-        name
-        nameWithOwner
-        url
-        updatedAt
-        languages(first: 1) {
-          nodes {
-            name
-            color
-          }
-        }
-      }
-    GRAPHQL
-  end
-
-  it "can make a GraphQL request with #execute" do
-    Github.execute(:repository, owner: "yuki24", name: "artemis")
-
-    request = requests[0]
-
-    expect(request.operation_name).to eq('Github__Repository')
-    expect(request.variables).to eq("owner" => "yuki24", "name" => "artemis")
-    expect(request.context).to eq({})
-    expect(request.document.to_query_string).to eq(<<~GRAPHQL.strip)
-      query Github__Repository($owner: String!, $name: String!) {
-        repository(owner: $owner, name: $name) {
-          name
-          nameWithOwner
-        }
-      }
-    GRAPHQL
-  end
-
-  it "raises an error when the specified graphql file does not exist" do
-    expect { Github.execute(:does_not_exist) }
-      .to raise_error(Artemis::GraphQLFileNotFound)
-      .with_message(/Query does_not_exist\.graphql not found/)
-  end
-
-  it "assigns context to the request when provided as an argument" do
-    context = { headers: { Authorization: 'bearer ...' } }
-
-    Github.repository(owner: "yuki24", name: "artemis", context: context)
-
-    expect(requests[0].context).to eq(context)
-  end
-
-  it "can create a client that always assigns the provided context to the request" do
-    context   = { headers: { Authorization: 'bearer ...' } }
-    client    = Github.with_context(context)
-
-    client.repository(owner: "yuki24", name: "artemis")
-    client.repository(owner: "yuki24", name: "artemis")
-
-    expect(requests[0].context).to eq(context)
-    expect(requests[1].context).to eq(context)
-  end
-
-  it "assigns the default context to a GraphQL request if present" do
-    begin
-      Github.default_context = { headers: { Authorization: 'bearer ...' } }
-      Github.repository(owner: "yuki24", name: "artemis")
-
-      expect(requests[0].context).to eq(headers: { Authorization: 'bearer ...' })
-    ensure
-      Github.default_context = { }
-    end
-  end
-
-  it "can make a GraphQL request with all of .default_context, with_context(...) and the :context argument" do
-    begin
-      Github.default_context = { headers: { 'User-Agent': 'Artemis', 'X-key': 'value', Authorization: 'token ...' } }
-      Github
-          .with_context({ headers: { 'X-key': 'overridden' } })
-          .repository(owner: "yuki24", name: "artemis", context: { headers: { Authorization: 'bearer ...' } })
-
-      expect(requests[0].context).to eq(
-        headers: {
-          'User-Agent': 'Artemis',
-          'X-key': 'overridden',
-          Authorization: 'bearer ...',
-        }
-      )
-    ensure
-      Github.default_context = { }
-    end
-  end
-
-  it "can batch multiple requests using Multiplex" do
-    Github.multiplex do |queue|
-      queue.repository(owner: "yuki24", name: "artemis", context: { headers: { Authorization: 'bearer ...' } })
-      queue.user
-    end
-
-    repository_query, user_query = requests[0].queries
-
-    expect(repository_query[:operationName]).to eq('Github__Repository')
-    expect(repository_query[:variables]).to eq("owner" => "yuki24", "name" => "artemis")
-    expect(repository_query[:context]).to eq({ headers: { Authorization: 'bearer ...' } })
-    expect(repository_query[:query]).to eq(<<~GRAPHQL.strip)
-      query Github__Repository($owner: String!, $name: String!) {
-        repository(owner: $owner, name: $name) {
-          name
-          nameWithOwner
-        }
-      }
-    GRAPHQL
-
-    expect(user_query[:operationName]).to eq('Github__User')
-    expect(user_query[:variables]).to be_empty
-    expect(user_query[:context]).to eq({})
-    expect(user_query[:query]).to eq(<<~GRAPHQL.strip)
-      query Github__User {
-        user(login: "yuki24") {
-          id
-          name
-        }
-      }
-    GRAPHQL
-  end
-
-  private
-
-  def requests
-    Artemis::Adapters::TestAdapter.requests
-  end
-
-  def with_files(*files)
-    files.each {|file| FileUtils.touch(file) }
-    yield
-  ensure
-    files.each {|file| File.delete(file) }
-  end
-end

data/spec/endpoint_spec.rb

@@ -1,49 +0,0 @@
-describe Artemis::GraphQLEndpoint do
-  after do
-    Artemis::GraphQLEndpoint.const_get(:ENDPOINT_INSTANCES).delete("gitlab")
-  end
-
-  describe ".lookup" do
-    it "raises an exception when the service is missing" do
-      expect { Artemis::GraphQLEndpoint.lookup(:does_not_exit) }.to raise_error(Artemis::EndpointNotFound)
-    end
-  end
-
-  it "can register an endpoint" do
-    endpoint = Artemis::GraphQLEndpoint.register!(:gitlab, url: "https://api.gitlab.com/graphql")
-
-    expect(endpoint.url).to eq("https://api.gitlab.com/graphql")
-    expect(endpoint.connection).to be_instance_of(Artemis::Adapters::NetHttpAdapter)
-  end
-
-  it "can look up a registered endpoint" do
-    Artemis::GraphQLEndpoint.register!(:gitlab, url: "https://api.gitlab.com/graphql")
-
-    endpoint = Artemis::GraphQLEndpoint.lookup(:gitlab)
-
-    expect(endpoint.url).to eq("https://api.gitlab.com/graphql")
-    expect(endpoint.connection).to be_instance_of(Artemis::Adapters::NetHttpAdapter) # Not a fan of this test but for now
-
-    # FIXME: This #schema method makes a network call.
-    # expect(endpoint.schema).to eq(...)
-  end
-
-  it "can register an endpoint with options" do
-    options = {
-      adapter: :test,
-      timeout: 10,
-      # schema_path: nil,
-      pool_size: 25,
-    }
-
-    endpoint = Artemis::GraphQLEndpoint.register!(:gitlab, url: "https://api.gitlab.com/graphql", **options)
-
-    expect(endpoint.url).to eq("https://api.gitlab.com/graphql")
-    expect(endpoint.timeout).to eq(10)
-    expect(endpoint.pool_size).to eq(25)
-    expect(endpoint.connection).to be_instance_of(Artemis::Adapters::TestAdapter) # Not a fan of this test but for now
-
-    # FIXME: needs an example schema (and specify the :schema_path option) to test this.
-    # expect(endpoint.schema).to eq(...)
-  end
-end

data/spec/fixtures/github/_repository_fields.graphql

@@ -1,12 +0,0 @@
-fragment on Repository {
-  name
-  nameWithOwner
-  url
-  updatedAt
-  languages(first: 1) {
-    nodes {
-      name
-      color
-    }
-  }
-}

data/spec/fixtures/github/repository.graphql

@@ -1,6 +0,0 @@
-query($owner: String!, $name: String!) {
-  repository(owner: $owner, name: $name) {
-    name
-    nameWithOwner
-  }
-}