heroics 0.0.17 → 0.0.18

data/test/client_generator_test.rb

@@ -1,35 +0,0 @@
-# frozen_string_literal: true
-require 'helper'
-require 'netrc'
-require 'stringio'
-
-class GenerateClientTest  < MiniTest::Unit::TestCase
-  include ExconHelper
-
-  # generate_client takes a module, schema, API URL and options and returns a
-  # string containing generated Ruby client code.
-  def test_generate_client
-    Excon.stub(method: :get) do |request|
-      assert_equal('example.com', request[:host])
-      assert_equal('/schema', request[:path])
-      assert_equal('application/vnd.example+json; version=3',
-                   request[:headers]['Accept'])
-      Excon.stubs.pop
-      {status: 200, headers: {'Content-Type' => 'application/json'},
-       body: MultiJson.dump(SAMPLE_SCHEMA)}
-    end
-
-    netrc = Netrc.read
-    username, token = netrc['example.com']
-    schema_url = "https://example.com/schema"
-    options = {
-        default_headers: {'Accept' => 'application/vnd.example+json; version=3'},
-        cache: 'Moneta.new(:File, dir: "#{Dir.home}/.heroics/example")'
-    }
-    schema = Heroics.download_schema(schema_url, options)
-    client_source = Heroics.generate_client("ExampleAPI", schema,
-                                            "api.example.com", options)
-    # Ensure the generated code is syntactically valid.
-    eval(client_source)
-  end
-end

data/test/client_test.rb

@@ -1,275 +0,0 @@
-# frozen_string_literal: true
-require 'helper'
-
-class ClientTest < MiniTest::Unit::TestCase
-  include ExconHelper
-
-  # Client.to_s returns a simple human-readable description of the client
-  # instance with the URL embedded in it.  A password, if present in the URL,
-  # is redacted to avoid leaking credentials.
-  def test_to_s
-    client = Heroics::Client.new({}, 'http://foo:bar@example.com')
-    assert_equal('#<Heroics::Client url="http://foo:REDACTED@example.com">',
-                 client.to_s)
-  end
-
-  # Client.<resource> raises a NoMethodError when a method is invoked
-  # without a matching resource.
-  def test_invalid_resource
-    client = Heroics::Client.new({}, 'http://example.com')
-    error = assert_raises NoMethodError do
-      client.unknown
-    end
-    assert_equal("undefined method `unknown' for " +
-                 '#<Heroics::Client url="http://example.com">',
-                 error.message)
-  end
-
-  # Client.<resource>.<link> finds the appropriate link and invokes it.
-  def test_resource
-    schema = Heroics::Schema.new(SAMPLE_SCHEMA)
-    link = Heroics::Link.new('https://username:secret@example.com',
-                             schema.resource('resource').link('list'))
-    resource = Heroics::Resource.new({'link' => link})
-    client = Heroics::Client.new({'resource' => resource},
-                                 'http://example.com')
-    Excon.stub(method: :get) do |request|
-      assert_equal('Basic dXNlcm5hbWU6c2VjcmV0',
-                   request[:headers]['Authorization'])
-      assert_equal('example.com', request[:host])
-      assert_equal(443, request[:port])
-      assert_equal('/resource', request[:path])
-      Excon.stubs.pop
-      {status: 200, body: 'Hello, world!'}
-    end
-    assert_equal('Hello, world!', client.resource.link)
-  end
-
-  # Client.<resource>.<link> finds the appropriate link and invokes it with
-  #   query params, since it is a GET resource
-  def test_resource_with_query_param
-    schema = Heroics::Schema.new(SAMPLE_SCHEMA)
-    link = Heroics::Link.new('https://username:secret@example.com',
-                             schema.resource('resource').link('list'))
-    resource = Heroics::Resource.new({'link' => link})
-    client = Heroics::Client.new({'resource' => resource},
-                                 'http://example.com')
-    Excon.stub(method: :get) do |request|
-      assert_equal({:limit => '50', :page => '25'}, request[:query])
-      Excon.stubs.pop
-      {status: 200, body: 'Hello, world!'}
-    end
-    assert_equal('Hello, world!', client.resource.link(limit: '50', page: '25'))
-  end
-
-  # Client converts underscores in resource method names to dashes to match
-  # names specified in the schema.
-  def test_resource_with_dashed_name
-    schema = Heroics::Schema.new(SAMPLE_SCHEMA)
-    link = Heroics::Link.new('https://username:secret@example.com',
-                             schema.resource('another-resource').link('list'))
-    resource = Heroics::Resource.new({'link' => link})
-    client = Heroics::Client.new({'another-resource' => resource},
-                                 'http://example.com')
-    Excon.stub(method: :get) do |request|
-      assert_equal('Basic dXNlcm5hbWU6c2VjcmV0',
-                   request[:headers]['Authorization'])
-      assert_equal('example.com', request[:host])
-      assert_equal(443, request[:port])
-      assert_equal('/another-resource', request[:path])
-      Excon.stubs.pop
-      {status: 200, body: 'Hello, world!'}
-    end
-    assert_equal('Hello, world!', client.another_resource.link)
-  end
-
-  # Client.<resource>.<link> finds the appropriate link and invokes it, even if
-  # the resource has an underscore in its name
-  def test_resource_with_underscored_name
-    schema = Heroics::Schema.new(SAMPLE_SCHEMA)
-    link = Heroics::Link.new('https://username:secret@example.com',
-                             schema.resource('underscored_resource').link('list'))
-    resource = Heroics::Resource.new({'link' => link})
-    client = Heroics::Client.new({'underscored_resource' => resource},
-                                 'http://example.com')
-    Excon.stub(method: :get) do |request|
-      assert_equal('Basic dXNlcm5hbWU6c2VjcmV0',
-                   request[:headers]['Authorization'])
-      assert_equal('example.com', request[:host])
-      assert_equal(443, request[:port])
-      assert_equal('/underscored_resource', request[:path])
-      Excon.stubs.pop
-      {status: 200, body: 'Hello, world!'}
-    end
-    assert_equal('Hello, world!', client.underscored_resource.link)
-  end
-end
-
-class ClientFromSchemaTest < MiniTest::Unit::TestCase
-  include ExconHelper
-
-  # client_from_schema returns a Client generated from the specified schema.
-  def test_client_from_schema
-    schema = Heroics::Schema.new(SAMPLE_SCHEMA)
-    client = Heroics::client_from_schema(schema, 'https://example.com')
-    body = {'Hello' => 'World!'}
-    Excon.stub(method: :post) do |request|
-      assert_equal('/resource', request[:path])
-      Excon.stubs.pop
-      {status: 200, headers: {'Content-Type' => 'application/json'},
-       body: MultiJson.dump(body)}
-    end
-    assert_equal(body, client.resource.create)
-  end
-
-  # client_from_schema returns a Client that can make requests to APIs mounted
-  # under a prefix, such as http://example.com/api, for example.
-  def test_client_from_schema_with_url_prefix
-    schema = Heroics::Schema.new(SAMPLE_SCHEMA)
-    client = Heroics::client_from_schema(schema, 'https://example.com/api')
-    body = {'Hello' => 'World!'}
-    Excon.stub(method: :post) do |request|
-      assert_equal('/api/resource', request[:path])
-      Excon.stubs.pop
-      {status: 200, headers: {'Content-Type' => 'application/json'},
-       body: MultiJson.dump(body)}
-    end
-    assert_equal(body, client.resource.create)
-  end
-
-  # client_from_schema optionally accepts custom headers to pass with every
-  # request made by the generated client.
-  def test_client_from_schema_with_custom_headers
-    schema = Heroics::Schema.new(SAMPLE_SCHEMA)
-    client = Heroics::client_from_schema(
-      schema, 'https://example.com',
-      default_headers: {'Accept' => 'application/vnd.heroku+json; version=3'})
-    Excon.stub(method: :post) do |request|
-      assert_equal('application/vnd.heroku+json; version=3',
-                   request[:headers]['Accept'])
-      Excon.stubs.pop
-      {status: 200}
-    end
-    client.resource.create
-  end
-
-  # client_from_schema takes an optional :cache parameter which it uses when
-  # constructing Link instances.
-  def test_client_from_schema_with_cache
-    body = {'Hello' => 'World!'}
-    Excon.stub(method: :get) do |request|
-      Excon.stubs.pop
-      {status: 201, headers: {'Content-Type' => 'application/json',
-                              'ETag' => 'etag-contents'},
-       body: MultiJson.dump(body)}
-    end
-
-    schema = Heroics::Schema.new(SAMPLE_SCHEMA)
-    client = Heroics::client_from_schema(schema, 'https://example.com',
-                                         cache: Moneta.new(:Memory))
-    assert_equal(body, client.resource.list)
-
-    Excon.stub(method: :get) do |request|
-      assert_equal('etag-contents', request[:headers]['If-None-Match'])
-      Excon.stubs.pop
-      {status: 304, headers: {'Content-Type' => 'application/json'}}
-    end
-    assert_equal(body, client.resource.list)
-  end
-end
-
-class OAuthClientFromSchemaTest < MiniTest::Unit::TestCase
-  include ExconHelper
-
-  # oauth_client_from_schema injects an Authorization header, built from the
-  # specified OAuth token, into the default header options.
-  def test_oauth_client_from_schema
-    body = {'Hello' => 'World!'}
-    Excon.stub(method: :get) do |request|
-      assert_equal(
-        'Bearer c55ef0d8-40b6-4759-b1bf-4a6f94190a66',
-        request[:headers]['Authorization'])
-      Excon.stubs.pop
-      {status: 200, headers: {'Content-Type' => 'application/json'},
-       body: MultiJson.dump(body)}
-    end
-
-    oauth_token = 'c55ef0d8-40b6-4759-b1bf-4a6f94190a66'
-    schema = Heroics::Schema.new(SAMPLE_SCHEMA)
-    client = Heroics.oauth_client_from_schema(oauth_token, schema,
-                                              'https://example.com')
-    assert_equal(body, client.resource.list)
-  end
-
-  # oauth_client_from_schema doesn't mutate the options object, and in
-  # particular, it doesn't mutate the :default_headers Hash in that object.
-  def test_oauth_client_from_schema_with_options
-    body = {'Hello' => 'World!'}
-    Excon.stub(method: :get) do |request|
-      assert_equal('application/vnd.heroku+json; version=3',
-                   request[:headers]['Accept'])
-      assert_equal(
-        'Bearer c55ef0d8-40b6-4759-b1bf-4a6f94190a66',
-        request[:headers]['Authorization'])
-      Excon.stubs.pop
-      {status: 200, headers: {'Content-Type' => 'application/json'},
-       body: MultiJson.dump(body)}
-    end
-
-    oauth_token = 'c55ef0d8-40b6-4759-b1bf-4a6f94190a66'
-    options = {
-      default_headers: {'Accept' => 'application/vnd.heroku+json; version=3'}}
-    schema = Heroics::Schema.new(SAMPLE_SCHEMA)
-    client = Heroics.oauth_client_from_schema(oauth_token, schema,
-                                              'https://example.com', options)
-    assert_equal(body, client.resource.list)
-  end
-end
-
-class TokenClientFromSchemaTest < MiniTest::Unit::TestCase
-  include ExconHelper
-
-  # token_client_from_schema injects an Authorization header, built from the
-  # specified token, into the default header options.
-  def test_token_client_from_schema
-    body = {'Hello' => 'World!'}
-    Excon.stub(method: :get) do |request|
-      assert_equal(
-        'Token token=c55ef0d8-40b6-4759-b1bf-4a6f94190a66',
-        request[:headers]['Authorization'])
-      Excon.stubs.pop
-      {status: 200, headers: {'Content-Type' => 'application/json'},
-       body: MultiJson.dump(body)}
-    end
-
-    token = 'c55ef0d8-40b6-4759-b1bf-4a6f94190a66'
-    schema = Heroics::Schema.new(SAMPLE_SCHEMA)
-    client = Heroics.token_client_from_schema(token, schema,
-                                              'https://example.com')
-    assert_equal(body, client.resource.list)
-  end
-
-  # token_client_from_schema doesn't mutate the options object, and in
-  # particular, it doesn't mutate the :default_headers Hash in that object.
-  def test_token_client_from_schema_with_options
-    body = {'Hello' => 'World!'}
-    Excon.stub(method: :get) do |request|
-      assert_equal('application/vnd.heroku+json; version=3',
-                   request[:headers]['Accept'])
-      assert_equal(
-        'Token token=c55ef0d8-40b6-4759-b1bf-4a6f94190a66',
-        request[:headers]['Authorization'])
-      Excon.stubs.pop
-      {status: 200, headers: {'Content-Type' => 'application/json'},
-       body: MultiJson.dump(body)}
-    end
-
-    token = 'c55ef0d8-40b6-4759-b1bf-4a6f94190a66'
-    options = {
-      default_headers: {'Accept' => 'application/vnd.heroku+json; version=3'}}
-    schema = Heroics::Schema.new(SAMPLE_SCHEMA)
-    client = Heroics.token_client_from_schema(token, schema,
-                                              'https://example.com', options)
-    assert_equal(body, client.resource.list)
-  end
-end

data/test/command_test.rb

@@ -1,215 +0,0 @@
-# frozen_string_literal: true
-require 'helper'
-require 'stringio'
-
-class CommandTest < MiniTest::Unit::TestCase
-  include ExconHelper
-
-  # Command.name returns the name of the command, which is made up by joining
-  # the resource name and link title with a colon.
-  def test_name
-    schema = Heroics::Schema.new(SAMPLE_SCHEMA)
-    client = Heroics::client_from_schema(schema, 'https://example.com')
-    output = StringIO.new
-    command = Heroics::Command.new(
-      'cli', schema.resource('resource').link('list'), client, output)
-    assert_equal('resource:list', command.name)
-  end
-
-  # Command.description returns a description for the command.
-  def test_description
-    schema = Heroics::Schema.new(SAMPLE_SCHEMA)
-    client = Heroics::client_from_schema(schema, 'https://example.com')
-    output = StringIO.new
-    command = Heroics::Command.new(
-      'cli', schema.resource('resource').link('list'), client, output)
-    assert_equal('Show all sample resources', command.description)
-  end
-
-  # Command.run calls the correct method on the client when no link parameters
-  # are provided.
-  def test_run_without_parameters
-    schema = Heroics::Schema.new(SAMPLE_SCHEMA)
-    client = Heroics::client_from_schema(schema, 'https://example.com')
-    output = StringIO.new
-    command = Heroics::Command.new(
-      'cli', schema.resource('resource').link('list'), client, output)
-
-    body = ['Hello', 'World!']
-    Excon.stub(method: :get) do |request|
-      assert_equal('/resource', request[:path])
-      Excon.stubs.pop
-      {status: 200, headers: {'Content-Type' => 'application/json'},
-       body: MultiJson.dump(body)}
-    end
-
-    command.run
-    assert_equal(MultiJson.dump(body, pretty: true) + "\n", output.string)
-  end
-
-  # Command.run calls the correct method on the client and passes link
-  # parameters when they're provided.
-  def test_run_with_parameters
-    schema = Heroics::Schema.new(SAMPLE_SCHEMA)
-    client = Heroics::client_from_schema(schema, 'https://example.com')
-    output = StringIO.new
-    command = Heroics::Command.new(
-      'cli', schema.resource('resource').link('info'), client, output)
-
-    uuid = '1ab1c589-df46-40aa-b786-60e83b1efb10'
-    body = {'Hello' => 'World!'}
-    Excon.stub(method: :get) do |request|
-      assert_equal("/resource/#{uuid}", request[:path])
-      Excon.stubs.pop
-      {status: 200, headers: {'Content-Type' => 'application/json'},
-       body: MultiJson.dump(body)}
-    end
-
-    command.run(uuid)
-    assert_equal(MultiJson.dump(body, pretty: true) + "\n", output.string)
-  end
-
-  # Command.run calls the correct method on the client and passes a request
-  # body to the link when it's provided.
-  def test_run_with_request_body_and_text_response
-    schema = Heroics::Schema.new(SAMPLE_SCHEMA)
-    client = Heroics::client_from_schema(schema, 'https://example.com')
-    output = StringIO.new
-    command = Heroics::Command.new(
-      'cli', schema.resource('resource').link('create'), client, output)
-
-    body = {'Hello' => 'World!'}
-    Excon.stub(method: :post) do |request|
-      assert_equal('/resource', request[:path])
-      assert_equal('application/json', request[:headers]['Content-Type'])
-      assert_equal(body, MultiJson.load(request[:body]))
-      Excon.stubs.pop
-      {status: 201}
-    end
-
-    command.run(body)
-    assert_equal('', output.string)
-  end
-
-  # Command.run calls the correct method on the client and converts the result
-  # to an array, if a range response is received, before writing it out.
-  def test_run_with_range_response
-    schema = Heroics::Schema.new(SAMPLE_SCHEMA)
-    client = Heroics::client_from_schema(schema, 'https://example.com')
-    output = StringIO.new
-    command = Heroics::Command.new(
-      'cli', schema.resource('resource').link('list'), client, output)
-
-    Excon.stub(method: :get) do |request|
-      Excon.stubs.shift
-      {status: 206, headers: {'Content-Type' => 'application/json',
-                              'Content-Range' => 'id 1..2; max=200'},
-       body: MultiJson.dump([2])}
-    end
-
-    Excon.stub(method: :get) do |request|
-      Excon.stubs.shift
-      {status: 206, headers: {'Content-Type' => 'application/json',
-                              'Content-Range' => 'id 0..1; max=200',
-                              'Next-Range' => '201'},
-       body: MultiJson.dump([1])}
-    end
-
-    command.run
-    assert_equal(MultiJson.dump([1, 2], pretty: true) + "\n", output.string)
-  end
-
-  # Command.run calls the correct method on the client and passes parameters
-  # and a request body to the link when they're provided.
-  def test_run_with_request_body_and_parameters
-    schema = Heroics::Schema.new(SAMPLE_SCHEMA)
-    client = Heroics::client_from_schema(schema, 'https://example.com')
-    output = StringIO.new
-    command = Heroics::Command.new(
-      'cli', schema.resource('resource').link('update'), client, output)
-
-    uuid = '1ab1c589-df46-40aa-b786-60e83b1efb10'
-    body = {'Hello' => 'World!'}
-    result = {'Goodbye' => 'Universe!'}
-    Excon.stub(method: :patch) do |request|
-      assert_equal("/resource/#{uuid}", request[:path])
-      assert_equal('application/json', request[:headers]['Content-Type'])
-      assert_equal(body, MultiJson.load(request[:body]))
-      Excon.stubs.pop
-      {status: 200, headers: {'Content-Type' => 'application/json'},
-       body: MultiJson.dump(result)}
-    end
-
-    command.run(uuid, body)
-    assert_equal(MultiJson.dump(result, pretty: true) + "\n", output.string)
-  end
-
-  # Command.run raises an ArgumentError if too few parameters are provided.
-  def test_run_with_too_few_parameters
-    schema = Heroics::Schema.new(SAMPLE_SCHEMA)
-    client = Heroics::client_from_schema(schema, 'https://example.com')
-    output = StringIO.new
-    command = Heroics::Command.new(
-      'cli', schema.resource('resource').link('info'), client, output)
-    assert_raises ArgumentError do
-      command.run
-    end
-  end
-
-  # Command.run raises an ArgumentError if too many parameters are provided.
-  def test_run_with_too_many_parameters
-    schema = Heroics::Schema.new(SAMPLE_SCHEMA)
-    client = Heroics::client_from_schema(schema, 'https://example.com')
-    output = StringIO.new
-    command = Heroics::Command.new(
-      'cli', schema.resource('resource').link('info'), client, output)
-    assert_raises ArgumentError do
-      command.run('too', 'many', 'parameters')
-    end
-  end
-
-  # Command.usage displays usage information.
-  def test_usage
-    schema = Heroics::Schema.new(SAMPLE_SCHEMA)
-    client = Heroics::client_from_schema(schema, 'https://example.com')
-    output = StringIO.new
-    command = Heroics::Command.new(
-      'cli', schema.resource('resource').link('update'), client, output)
-    command.usage
-    expected = <<-USAGE
-Usage: cli resource:update <uuid_field> <body>
-
-Description:
-  Update a sample resource
-
-Body example:
-  {
-    "date_field": "2013-10-19 22:10:29Z",
-    "string_field": "Sample text.",
-    "boolean_field": true,
-    "uuid_field": "44724831-bf66-4bc2-865f-e2c4c2b14c78",
-    "email_field": "username@example.com"
-  }
-USAGE
-    assert_equal(expected, output.string)
-  end
-
-  # Command.usage correctly handles parameters that are described by 'oneOf'
-  # and 'anyOf' sub-parameter lists.
-  def test_usage_with_one_of_field
-    schema = Heroics::Schema.new(SAMPLE_SCHEMA)
-    client = Heroics::client_from_schema(schema, 'https://example.com')
-    output = StringIO.new
-    command = Heroics::Command.new(
-      'cli', schema.resource('resource').link('identify_resource'), client,
-      output)
-    command.usage
-    expected = <<-USAGE
-Usage: cli resource:identify-resource <uuid_field|email_field>
-
-Description:
-  Show a sample resource
-USAGE
-    assert_equal(expected, output.string)
-  end
-end