api_client_builder 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 6a42589201e1aa43a64afa11738378eca1182f7a
+  data.tar.gz: 6c5fea2364dc9e85db7241ea02f9a8d66dced538
+SHA512:
+  metadata.gz: e6362629e413db828fdfefc719be94de0c10a23a099edf33e136a4a9e2cb7394d7087eb999844a324d89e1b710ddeeb4570914a990a683490bc7659b51f16b17
+  data.tar.gz: f201de0c2a4c149e2958cc772260f9fa0c17c1bdd29c102d3f370043427b647e229342d30a24053eccb88794c58c1656d079f50ff2903190bf85c1a99bd8e66a

data/api_client_builder.gemspec

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/api_client_builder/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.name          = "api_client_builder"
+  gem.summary       = "API Client Builder provides an easy to use interface for creating HTTP api clients"
+  gem.description   = "API Client Builder provides an easy to use interface for creating HTTP api clients"
+  gem.authors       = ['Jayce Higgins']
+  gem.email         = ['jhiggins@instructure.com', 'eng@instructure.com']
+
+  gem.files         = %w[api_client_builder.gemspec readme.md]
+
+  gem.test_files    = Dir.glob("spec/**/*")
+  gem.require_paths = ["lib"]
+  gem.version       = APIClientBuilder::VERSION
+  gem.required_ruby_version = '>= 2.0'
+
+  gem.license       = 'MIT'
+
+  gem.add_development_dependency 'pry'
+  gem.add_development_dependency 'rspec'
+  gem.add_development_dependency 'wwtd'
+end

data/readme.md

@@ -0,0 +1,389 @@
+# API Client Builder
+
+API Client Builder was created to reduce the overhead of creating API clients.
+
+It provides a DSL for defining endpoints and only requires you to define handlers
+for http requests and responses.
+
+---
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'api_client_builder'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install api_client_builder
+
+---
+
+## Defining a client
+
+The basic client structure looks like this.
+
+```ruby
+require 'api_client_builder/api_client'
+require 'path/to/your/http_client_handler'
+require 'path/to/your/response_handler'
+
+class Client < APIClientBulder::APIClient
+  def initialize(**opts)
+    super(domain: opts[:domain],
+          http_client: HTTPClientHandler)
+  end
+end
+```
+
+The client requires a response handler to be defined in the following method.
+Unlike the HTTPClientHandler that can be sent in as a reference to a class
+and instantiated, the response handler has a few extra options that must
+be defined concretely on a per-client basis.
+
+Exponential back-off is optional for handling retries of requests. If unset,
+the builder will ignore it and will resort to just calling error handlers
+upon failure.
+
+```ruby
+def response_handler_build(http_client, start_url, type)
+  ResponseHandler.new(http_client, start_url, type, exponential_backoff: true)
+end
+```
+
+
+### Defining routes on the client
+To define routes on the api client, use the DSL provided by the
+builder's APIClient class. Four parts have been defined to help:
+
+1) Action - `#get`, `#post`, or `#put`:  will define the HTTP action and the first part
+  of the defined method.
+
+2) Resource Type:  will define the "type" of the route and finishes out the
+  defined method "get_resource_type".
+  - Note that this portion of the route has a special property
+  that allows you to add `_for_something_else` to the end while maintaining
+  everything before the "for" as the "type" that is sent back. This is helpful when
+  parsing the responses because you might want to get "students" for say "schools",
+  and "courses", and "sections", where the response object type is "students" for
+  all three routes.
+
+3) Plurality - `:singular`, `:collection`:  determines whether
+  or not the response will be a single object or multiple to know whether or
+  not pagination is required.
+  - Note that "put" and "post" don't need plurality defined
+
+4) Route:  defines the route to be appended to the provided domain.
+  - Note that any symbols in the route will be interpolated as required
+   params when calling the method on the client.
+
+
+---
+
+## Route Examples
+
+#### Single Item Gets: Yields GetItemRequest
+
+Define the route on the client
+
+```ruby
+  get :some_object, :singular, 'some_objects/:id'
+```
+
+Use the defined route
+
+```ruby
+single_request = client.get_some_object(id: 123)
+
+response_body = single_request.response
+```
+
+#### Collection Item Gets: Yields GetCollectionRequest
+
+Define the route on the client
+
+```ruby
+  get :some_objects, :collection, 'some_objects'
+```
+
+Use the defined route
+
+```ruby
+collection_request = client.get_some_objects
+
+collection_request.each do |item|
+  #Item will be a Hash if you use the default response in the response handler
+end
+```
+
+#### Put Item: Yields PutRequest
+
+Define the route on the client
+
+```ruby
+put :some_object, 'some_objects/:id'
+```
+
+Use the defined route (Takes a hash/JSON as the first arg)
+
+```ruby
+request = client.put_some_object({}, id: 123)
+
+response_body = request.response
+```
+
+#### Collection Item Gets: Yields PostRequest
+
+Define the route on the client
+
+```ruby
+post :some_objects, 'some_objects'
+```
+
+Use the defined route (Takes a hash/JSON as the first arg)
+
+```ruby
+request = client.post_some_object({})
+
+response_body = request.response
+```
+
+#### Multiple routes for same object
+
+All of these routes will yield a collection with type "some_objects"
+
+```ruby
+get :some_objects, :collection, 'some_objects'
+get :some_objects_for_school, :collection, 'school/:school_id/some_objects'
+get :some_objects_for_course, :collection, 'course/:course_id/some_objects'
+```
+
+---
+
+## Defining an HTTP Client Handler
+
+The HTTP Client Handler is designed to manage the http requests themselves. Since
+actually making an HTTP request typically requires some amount of authentication,
+it is suggested that authentication and headers are managed here as well.
+
+The http client handler requires '#get', '#post', and '#put' to be defined here
+with the shown method signature.
+
+```ruby
+class HTTPClientHandler
+  #Do initialization here, generally authentication creds and a domain is sent in
+
+  def get(route, params = nil, headers = {})
+    client.get(route, params, headers)
+  end
+
+  def put(route, params = nil, headers = {})
+    client.put(route, params, headers)
+  end
+
+  def post(route, params = nil, headers = {})
+    client.post(route, params, headers)
+  end
+
+  #Define a client to use here. The HTTPClient gem is a good option
+
+  #Build up headers and authentication handling here as well
+end
+```
+
+---
+
+## Defining a Response Handler
+
+The response handler is where everything comes together. As the name suggests,
+defining how to get responses but also how to handle them is done here.
+
+Define only the methods that match the requests that the client needs. For
+simpler API's this considerably reduces the overhead of setting up the response
+handler.
+
+Through the methods defined here the builder will manage how requests are handled.
+When defining the response handler, in general, a start url and an http_client_handler
+is provided to the initializer. Since most API's send the "type" as the top level key,
+the `#response_handler_build` that was defined in the client receives that type
+as a parameter. It is used to extract the actual body from the response
+as well. Furthermore, feel free to send any other options required to make
+these actions simpler.
+
+  - Note: `#build_response` will be used in all examples and explained once
+  all required methods are defined
+
+```ruby
+class ResponseHandler
+    def initialize(http_client_handler, start_url, type)
+      @http_client = http_client_handler
+      @start_url = start_url
+      @type = type
+    end
+end
+```
+
+---
+
+## Response Handler Examples
+
+#### For single gets
+
+The builder will only call `#get_first_page` when handling `:singular` for get routes.
+If pagination is required this is a good place to figure out the number
+of pages and also start the page counter.
+
+```ruby
+def get_first_page
+  #Build the URL -- this could be to add pagination params to the route, or add
+  #  whatever else is necessary to the route
+  http_response = @http_client.get("a URL")
+
+  #Generally the first page will contain information about how many pages a paginated
+  #  response will have. Set that here. `@max_pages`
+  #Be sure to set the current page count as well -- @current_page
+  build_response(http_response)
+end
+```
+
+#### For collection gets
+
+The builder will call `#get_next_page` when handling `:collection` for get routes. It will
+determine whether or not there are more pages by calling `#more_pages?` which must
+return a boolean denoting the presence of more pages.
+
+```ruby
+def get_next_page
+  #Build the URL -- this could be to add pagination params to the route, or add
+  #  whatever else is necessary to the route
+  http_response = @http_client.get("a URL")
+
+  #If the http_response is valid then increment the page counter here
+  build_response(http_response)
+end
+
+def more_pages?
+  return false if @current_page > @max_pages
+  return true
+end
+```
+
+#### For puts
+
+The builder will call `#put_request` when handling put routes.
+
+```ruby
+def put_request
+  #Build the URL -- this could be to add pagination params to the route, or add
+  #  whatever else is necessary to the route
+  #Also send the body if thats how the client handler is configured
+  http_response = @http_client.put("a URL", {})
+  build_response(http_response)
+end
+```
+
+#### For posts
+
+The builder will call `#post_request` when handling post routes.
+
+```ruby
+def post_request
+  #Build the URL -- this could be to add pagination params to the route, or add
+  #  whatever else is necessary to the route
+  #Also send the body if thats how the client handler is configured
+  http_response = @http_client.post("a URL", {})
+  build_response(http_response)
+end
+```
+
+#### Handling retry-able requests
+
+If requests defined need to be retry-able, extend the response handler by providing
+the following methods.
+
+```ruby
+def retryable?(status_code)
+  if @opts[:exponential_backoff]
+    #Define the conditions of whether or not the provided status code is retry-able
+  else
+    return false
+  end
+end
+
+def reset_retries
+  #Track the number of retries so the request is not retried indefinitely.
+  #  The builder will reset them when it no longer is retrying by calling this
+  #  method
+  @retries = 0
+end
+
+def retry_request
+  #Increment the retries here so the request is not retried indefinitely.
+  @retries += 1
+
+  #Build the URL -- this could be to add pagination params to the route, or add
+  #  whatever else is necessary to the route
+  response = @http_client.the_action_to_retry("a URL")
+  build_response(response)
+end
+```
+
+#### Managing the http response
+
+The builder defines a default `Response` object that will provide the minimally
+required interface for managing an http response.
+
+```ruby
+def build_response(http_response)
+  items = JSON.parse(http_response.body)
+
+  status = http_response.status
+
+  APIClientBuilder::Response.new(items, status, SUCCESS_RANGE)
+end
+```
+
+The block above is the simplest use case for using the built-in `Response` object.
+If a custom `Response` is required, define `#success?` and it will comply with
+the builders contract with that object.
+
+---
+
+## Error handling
+
+All requests made with the client will return a `Request` object of whatever type
+of action that it was defined as. All `Request` objects will have a default error
+handler defined, which will give you minimal insight into the issue and also
+describe how to define a new error handler.
+
+The actual request is not made until you call the `Request` response interface
+either by `#each` or `#response`. Define an error handler before accessing the
+response if custom error handling is required. Any number of error handlers
+can be defined on a single request and will be called as soon as the response
+is not a "success."
+
+  - Note that the error handlers will be ignored if you opted into retry-able
+  requests until the retry loop results in a success or completes its iterations.
+
+```ruby
+single_request = client.get_some_object(id: 123)
+
+single_request.on_error do |page, handler|
+  #The page will have all of the status information
+  #The handler is the defined response_handler
+  #Use either to glean more information about why the request was an error and
+  # handle the error here
+end
+
+response_body = single_request.response
+```
+
+---
+
+## License
+
+API Client Builder is released under the MIT License.

data/spec/lib/api_client_builder/api_client_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+require 'lib/api_client_builder/test_client/client'
+require 'api_client_builder/api_client'
+
+module APIClientBuilder
+  describe APIClient do
+    let(:domain) {'https://www.domain.com/api/endpoints/'}
+    let(:client) {TestClient::Client.new(domain: domain)}
+
+    describe '.get' do
+      context 'plurality is :collection' do
+        it 'defines a get method that returns a GetCollectionRequest' do
+          expect(client).to respond_to(:get_some_objects)
+          expect(client.get_some_objects).to be_a(APIClientBuilder::GetCollectionRequest)
+        end
+      end
+
+      context 'plurality is :singular' do
+        it 'defines a get method that returns a GetItemRequest' do
+          expect(client).to respond_to(:get_some_object)
+          expect(client.get_some_object(some_id: '123')).to be_a(APIClientBuilder::GetItemRequest)
+        end
+      end
+    end
+
+    describe '.post' do
+      it 'defines a post method on the client' do
+        expect(client).to respond_to(:post_some_object)
+      end
+
+      it 'returns a PostRequest object' do
+        expect(client.post_some_object({})).to be_a(APIClientBuilder::PostRequest)
+      end
+    end
+
+    describe '.put' do
+      it 'defines a put method on the client' do
+        expect(client).to respond_to(:put_some_object)
+      end
+
+      it 'returns a PutRequest object' do
+        expect(client.put_some_object({})).to be_a(APIClientBuilder::PutRequest)
+      end
+    end
+  end
+end

data/spec/lib/api_client_builder/get_collection_request_spec.rb

@@ -0,0 +1,63 @@
+require 'spec_helper'
+require 'api_client_builder/get_collection_request'
+require 'lib/api_client_builder/test_client/client'
+
+module APIClientBuilder
+  describe GetCollectionRequest do
+    describe '#each' do
+      context 'request was successful' do
+        it 'paginates the collection' do
+          client = TestClient::Client.new(domain: 'https://www.domain.com/api/endpoints/')
+
+          some_objects = client.get_some_objects
+          expect(some_objects.count).to eq(9)
+        end
+      end
+
+      context 'request was unsuccessful' do
+        it 'calls the error handlers' do
+          client = TestClient::Client.new(domain: 'https://www.domain.com/api/endpoints/')
+
+          bad_response = APIClientBuilder::Response.new('bad request', 500, [200])
+          allow_any_instance_of(TestClient::ResponseHandler).to receive(:get_first_page).and_return(bad_response)
+          allow_any_instance_of(TestClient::ResponseHandler).to receive(:retry_request).and_return(bad_response)
+          expect{ client.get_some_objects.each{} }.to raise_error(
+            APIClientBuilder::DefaultPageError,
+            "Default error for bad response. If you want to handle this error use #on_error on the response in your api consumer. Error Code: 500"
+          )
+        end
+
+        context 'request was successful after retryable error' do
+          it 'yields the good response' do
+            client = TestClient::Client.new(domain: 'https://www.domain.com/api/endpoints/')
+
+            bad_response = APIClientBuilder::Response.new('bad request', 500, [200])
+            good_response = APIClientBuilder::Response.new([1,2,3], 200, [200])
+            allow_any_instance_of(TestClient::ResponseHandler).to receive(:get_first_page).and_return(bad_response)
+            allow_any_instance_of(TestClient::ResponseHandler).to receive(:more_pages?).and_return(false)
+            allow_any_instance_of(TestClient::ResponseHandler).to receive(:retry_request).and_return(good_response)
+
+            some_objects = client.get_some_objects
+            expect(some_objects.count).to eq(3)
+          end
+        end
+
+        context 'request was unsuccessful after non-retryable error' do
+          it 'calls the error handlers' do
+            client = TestClient::Client.new(domain: 'https://www.domain.com/api/endpoints/')
+
+            bad_response = APIClientBuilder::Response.new('bad request', 400, [200])
+            good_response = APIClientBuilder::Response.new([1,2,3], 200, [200])
+            allow_any_instance_of(TestClient::ResponseHandler).to receive(:get_first_page).and_return(bad_response)
+            allow_any_instance_of(TestClient::ResponseHandler).to receive(:more_pages?).and_return(false)
+            allow_any_instance_of(TestClient::ResponseHandler).to receive(:retry_request).and_return(good_response)
+            expect{ client.get_some_objects.each{} }.to raise_error(
+              APIClientBuilder::DefaultPageError,
+              "Default error for bad response. If you want to handle this error use #on_error on the response in your api consumer. Error Code: 400"
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/spec/lib/api_client_builder/get_item_request_spec.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+require 'api_client_builder/get_item_request'
+require 'lib/api_client_builder/test_client/client'
+
+module APIClientBuilder
+  describe GetItemRequest do
+    describe '#read' do
+      context 'request was successful' do
+        it 'gives only the first page of the response' do
+          client = TestClient::Client.new(domain: 'https://www.domain.com/api/endpoints/')
+
+          some_object = client.get_some_object(some_id: '123').response
+          expect(some_object.count).to eq(3)
+        end
+      end
+
+      context 'request was unsuccessful' do
+        it 'calls the error handlers' do
+          client = TestClient::Client.new(domain: 'https://www.domain.com/api/endpoints/')
+
+          bad_response = APIClientBuilder::Response.new('bad request', 500, [200])
+          allow_any_instance_of(TestClient::ResponseHandler).to receive(:get_first_page).and_return(bad_response)
+          allow_any_instance_of(TestClient::ResponseHandler).to receive(:retry_request).and_return(bad_response)
+          expect{ client.get_some_object(some_id: '123').response }.to raise_error(
+            APIClientBuilder::DefaultPageError,
+            "Default error for bad response. If you want to handle this error use #on_error on the response in your api consumer. Error Code: 500"
+          )
+        end
+
+        context 'retry is successful' do
+          it 'yields the good response' do
+            client = TestClient::Client.new(domain: 'https://www.domain.com/api/endpoints/')
+
+            bad_response = APIClientBuilder::Response.new('bad request', 500, [200])
+            good_response = APIClientBuilder::Response.new([1,2,3], 200, [200])
+            allow_any_instance_of(TestClient::ResponseHandler).to receive(:get_first_page).and_return(bad_response)
+            allow_any_instance_of(TestClient::ResponseHandler).to receive(:more_pages?).and_return(false)
+            allow_any_instance_of(TestClient::ResponseHandler).to receive(:retry_request).and_return(good_response)
+
+            some_objects = client.get_some_objects
+            expect(some_objects.count).to eq(3)
+          end
+        end
+      end
+    end
+  end
+end

data/spec/lib/api_client_builder/post_request_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+require 'api_client_builder/post_request'
+require 'lib/api_client_builder/test_client/client'
+
+module APIClientBuilder
+  describe PostRequest do
+    describe '#response' do
+      context 'request was successful' do
+        it 'returns a response object' do
+          client = TestClient::Client.new(domain: 'https://www.domain.com/api/endpoints/')
+
+          some_object = client.post_some_object({}).response
+          expect(some_object.body).to eq('good request')
+        end
+      end
+
+      context 'request was unsuccessful' do
+        it 'calls the error handlers' do
+          client = TestClient::Client.new(domain: 'https://www.domain.com/api/endpoints/')
+
+          bad_response = APIClientBuilder::Response.new('bad request', 400, [200])
+          allow_any_instance_of(TestClient::ResponseHandler).to receive(:post_request).and_return(bad_response)
+          expect{ client.post_some_object({}).response }.to raise_error(
+            APIClientBuilder::DefaultPageError,
+            "Default error for bad response. If you want to handle this error use #on_error on the response in your api consumer. Error Code: 400"
+          )
+        end
+      end
+    end
+  end
+end

data/spec/lib/api_client_builder/put_request_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+require 'api_client_builder/put_request'
+require 'lib/api_client_builder/test_client/client'
+
+module APIClientBuilder
+  describe PutRequest do
+    describe '#response' do
+      context 'request was successful' do
+        it 'returns a response object' do
+          client = TestClient::Client.new(domain: 'https://www.domain.com/api/endpoints/')
+
+          some_object = client.put_some_object({}).response
+          expect(some_object.body).to eq('good request')
+        end
+      end
+
+      context 'request was unsuccessful' do
+        it 'calls the error handlers' do
+          client = TestClient::Client.new(domain: 'https://www.domain.com/api/endpoints/')
+
+          bad_response = APIClientBuilder::Response.new('bad request', 400, [200])
+          allow_any_instance_of(TestClient::ResponseHandler).to receive(:put_request).and_return(bad_response)
+          expect{ client.put_some_object({}).response }.to raise_error(
+            APIClientBuilder::DefaultPageError,
+            "Default error for bad response. If you want to handle this error use #on_error on the response in your api consumer. Error Code: 400"
+          )
+        end
+      end
+    end
+  end
+end

data/spec/lib/api_client_builder/request_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+require 'lib/api_client_builder/test_client/client'
+require 'api_client_builder/request'
+
+module APIClientBuilder
+  describe Request do
+    describe '#error_handlers' do
+      context 'no error handlers' do
+        it 'returns the default error handler' do
+          client = TestClient::Client.new(domain: 'https://www.domain.com/api/endpoints/')
+
+          bad_response = APIClientBuilder::Response.new('bad request', 400, [200])
+          allow_any_instance_of(TestClient::ResponseHandler).to receive(:get_first_page).and_return(bad_response)
+          allow_any_instance_of(TestClient::ResponseHandler).to receive(:retry_request).and_return(bad_response)
+          expect{ client.get_some_object(some_id: '123').response }.to raise_error(
+            APIClientBuilder::DefaultPageError,
+            "Default error for bad response. If you want to handle this error use #on_error on the response in your api consumer. Error Code: 400"
+          )
+        end
+      end
+
+      context 'defined error handler' do
+        it 'returns the custom handler' do
+          client = TestClient::Client.new(domain: 'https://www.domain.com/api/endpoints/')
+
+          bad_response = APIClientBuilder::Response.new('bad request', 400, [200])
+          allow_any_instance_of(TestClient::ResponseHandler).to receive(:get_first_page).and_return(bad_response)
+          allow_any_instance_of(TestClient::ResponseHandler).to receive(:retry_request).and_return(bad_response)
+          object_response = client.get_some_object(some_id: '123')
+
+          object_response.on_error do |page, response|
+            raise StandardError, "Something Bad Happened"
+          end
+
+          expect{object_response.response}.to raise_error(
+            StandardError,
+            "Something Bad Happened"
+          )
+        end
+      end
+    end
+  end
+end

data/spec/lib/api_client_builder/response_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+require 'api_client_builder/response'
+
+module APIClientBuilder
+  describe Response do
+    describe '#success?' do
+      it 'returns true when the given code is included in the given range' do
+        page = Response.new([], 200, [200])
+
+        expect(page.success?).to eq(true)
+      end
+
+      it 'returns false when the given code is included in the given range' do
+        page = Response.new([], 400, [200])
+
+        expect(page.success?).to eq(false)
+      end
+
+      it 'returns false when the response is otherwise marked as failed' do
+        page = Response.new([], 200, [200])
+        page.mark_failed "Something happened"
+
+        expect(page.success?).to eq(false)
+      end
+    end
+  end
+end

data/spec/lib/api_client_builder/test_client/client.rb

@@ -0,0 +1,22 @@
+require 'api_client_builder/api_client'
+require 'lib/api_client_builder/test_client/response_handler'
+require 'lib/api_client_builder/test_client/http_client_handler'
+
+module TestClient
+  class Client < APIClientBuilder::APIClient
+    def initialize(**opts)
+      super(domain: opts[:domain],
+            http_client: TestClient::HTTPClientHandler)
+    end
+
+    def response_handler_build(http_client, start_url, type)
+      ResponseHandler.new(http_client, start_url, type, exponential_backoff: @exponential_backoff)
+    end
+
+    get :some_objects, :collection, 'some/url'
+    get :some_object, :singular, 'some/url/:some_id'
+
+    post :some_object, 'some/post/url'
+    put :some_object, 'som/put/url'
+  end
+end

data/spec/lib/api_client_builder/test_client/http_client_handler.rb

@@ -0,0 +1,10 @@
+module TestClient
+  class HTTPClientHandler
+    def initialize(domain)
+      @domain = domain
+    end
+
+    def get(route, params = nil, headers = {})
+    end
+  end
+end

data/spec/lib/api_client_builder/test_client/response_handler.rb

@@ -0,0 +1,47 @@
+require 'api_client_builder/response'
+
+module TestClient
+  class ResponseHandler
+    SUCCESS_STATUS = 200
+    SUCCESS_RANGE = [200]
+    MAX_RETRIES = 4
+
+    def initialize(client, start_url, type, **opts)
+      @retries = 0
+    end
+
+    def get_first_page
+      @current_page = 0
+      APIClientBuilder::Response.new([1,2,3], SUCCESS_STATUS, SUCCESS_RANGE)
+    end
+
+    def get_next_page
+      @current_page += 1
+      APIClientBuilder::Response.new([4,5,6], SUCCESS_STATUS, SUCCESS_RANGE)
+    end
+
+    def put_request(body)
+      APIClientBuilder::Response.new('good request', SUCCESS_STATUS, SUCCESS_RANGE)
+    end
+
+    def post_request(body)
+      APIClientBuilder::Response.new('good request', SUCCESS_STATUS, SUCCESS_RANGE)
+    end
+
+    def more_pages?
+      return false if @current_page >= 2
+      return true
+    end
+
+    def retryable?(status_code)
+      @retries += 1
+      status_code != 400 && @retries < MAX_RETRIES
+    end
+
+    def retry_request
+    end
+
+    def reset_retries
+    end
+  end
+end

data/spec/lib/api_client_builder/url_generator_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+require 'api_client_builder/url_generator'
+
+module APIClientBuilder
+  describe URLGenerator do
+    describe '#build_route' do
+      context 'route with colon params and matching keys' do
+        it 'replaces to route keys with their respective values' do
+          url_generator = URLGenerator.new("https://www.domain.com/api/endpoints/")
+
+          route = url_generator.build_route(
+            'object_one/:object_one_id/:object_one_id/route_to_object/:other_object_id/object',
+            object_one_id: '4',
+            other_object_id: '10'
+          )
+
+          expect(route).to eq(URI.parse('https://www.domain.com/api/endpoints/object_one/4/4/route_to_object/10/object'))
+        end
+      end
+
+      context 'route with colon params and non matching keys' do
+        it 'raises an argument error' do
+          url_generator = URLGenerator.new("https://www.domain.com/api/endpoints/")
+
+          expect{url_generator.build_route(
+            'object_one/:object_one_id/:object_one_id/route_to_object/:other_object_id/object',
+            other_object_id: '10'
+          )}.to raise_error(ArgumentError, "Param :object_one_id is required")
+        end
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,4 @@
+require 'bundler/setup'
+require 'api_client_builder'
+
+SPEC_DIR = File.dirname(__FILE__)

metadata

@@ -0,0 +1,115 @@
+--- !ruby/object:Gem::Specification
+name: api_client_builder
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Jayce Higgins
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-06-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: wwtd
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: API Client Builder provides an easy to use interface for creating HTTP
+  api clients
+email:
+- jhiggins@instructure.com
+- eng@instructure.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- api_client_builder.gemspec
+- readme.md
+- spec/lib/api_client_builder/api_client_spec.rb
+- spec/lib/api_client_builder/get_collection_request_spec.rb
+- spec/lib/api_client_builder/get_item_request_spec.rb
+- spec/lib/api_client_builder/post_request_spec.rb
+- spec/lib/api_client_builder/put_request_spec.rb
+- spec/lib/api_client_builder/request_spec.rb
+- spec/lib/api_client_builder/response_spec.rb
+- spec/lib/api_client_builder/test_client/client.rb
+- spec/lib/api_client_builder/test_client/http_client_handler.rb
+- spec/lib/api_client_builder/test_client/response_handler.rb
+- spec/lib/api_client_builder/url_generator_spec.rb
+- spec/spec_helper.rb
+homepage: 
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '2.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.14
+signing_key: 
+specification_version: 4
+summary: API Client Builder provides an easy to use interface for creating HTTP api
+  clients
+test_files:
+- spec/lib/api_client_builder/api_client_spec.rb
+- spec/lib/api_client_builder/get_collection_request_spec.rb
+- spec/lib/api_client_builder/get_item_request_spec.rb
+- spec/lib/api_client_builder/post_request_spec.rb
+- spec/lib/api_client_builder/put_request_spec.rb
+- spec/lib/api_client_builder/request_spec.rb
+- spec/lib/api_client_builder/response_spec.rb
+- spec/lib/api_client_builder/test_client/client.rb
+- spec/lib/api_client_builder/test_client/http_client_handler.rb
+- spec/lib/api_client_builder/test_client/response_handler.rb
+- spec/lib/api_client_builder/url_generator_spec.rb
+- spec/spec_helper.rb