my_john_deere_api 0.0.3 → 0.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d9e4802c00252cf2770981858362b93cd8b97791e33107bcb7f5edb75c4466bc
-  data.tar.gz: bb0b07d289995ecd438978c6b5754e9e348e8f2cf7073d865f0e4b19c4afb934
+  metadata.gz: 1972b07d8f4e72723a8984e459a5fc97e7587914b06415dcd2ce181d6db3c43b
+  data.tar.gz: 6ecea1bd5fef0c60e04c510674c54adae3dd80967f3132fbba68e54d199a57e9
 SHA512:
-  metadata.gz: 46140b980eff6e3c8c8299b290219e168c822b4b91a405a6685af3453717e0d93e49e0eb9fba2fc601022279488802d638d5416dc8a406dda7fce2035bb5e275
-  data.tar.gz: ad162f92e55a7012997a15ee91b1c6040af309455e78bf25fcc7114770534f53cceb9fe69d1def94cc6ff0ab053de7c7459efc8776100abac55192ecad5e165a
+  metadata.gz: 905162ea13bdb92ef6a7a1c0d86db73e351c0edf8f3b8420a8cb93193eb6e0e4e717436ca535b705636c0fe01256ee2797e9ae20f9e020b515cc15ad0e649c3b
+  data.tar.gz: 28a612aab3944a40bf19e23bc3640db8cdcff1e78faed99e374320df64ceb7441df5b92171e5aa2c0beb56ef90c26aa3dd2bae3cd5a061d4c3ba96277142f837

data/lib/my_john_deere_api/authorize.rb

@@ -1,34 +1,25 @@
 class MyJohnDeereApi::Authorize
-  attr_reader :api_key, :api_secret, :request_token, :request_secret, :access_token, :access_secret, :environment
-  attr_accessor :base_url
-
-  URLS = {
-    sandbox: 'https://sandboxapi.deere.com',
-    production: 'https://api.soa-proxy.deere.com',
-  }
+  attr_reader :api_key, :api_secret,
+    :request_token, :request_secret,
+    :access_token, :access_secret,
+    :environment
 
   DEFAULTS = {
-    environment: :production,
+    environment: :production
   }
 
   ##
-  # Create an Authorize object using your John Deere API key/secret.
-  #
-  # Options:
-  #
-  # [:environment] *:production* or *:sandbox*, determines the base url
-  #                used to make oauth requests.
+  # Create an Authorize object.
   #
-  # [:base_url] set the base url directly, since in the future,
-  #             *environment* may affect other things.
+  # This is used to obtain authentication an access key/secret
+  # on behalf of a user.
 
-  def initialize(api_key, api_secret, options={})
+  def initialize(api_key, api_secret, options = {})
     options = DEFAULTS.merge(options)
 
     @api_key = api_key
     @api_secret = api_secret
     @environment = options[:environment]
-    @base_url = options[:base_url] || URLS[@environment]
   end
 
   ##
@@ -38,13 +29,21 @@ class MyJohnDeereApi::Authorize
   def authorize_url
     return @authorize_url if defined?(@authorize_url)
 
-    requester = app_consumer.get_request_token
+    requester = consumer.get_request_token
     @request_token = requester.token
     @request_secret = requester.secret
 
     @authorize_url = requester.authorize_url
   end
 
+  ##
+  # API consumer that makes non-user-specific GET requests
+
+  def consumer
+    return @consumer if defined?(@consumer)
+    @consumer = MyJohnDeereApi::Consumer.new(@api_key, @api_secret, environment: environment).app_get
+  end
+
   ##
   # Turn a verification code into access tokens. If this is
   # run from a separate process than the one that created
@@ -55,72 +54,10 @@ class MyJohnDeereApi::Authorize
     token ||= request_token
     secret ||= request_secret
 
-    requester = OAuth::RequestToken.new(app_consumer, token, secret)
+    requester = OAuth::RequestToken.new(consumer, token, secret)
     access_object = requester.get_access_token(oauth_verifier: code)
     @access_token = access_object.token
     @access_secret = access_object.secret
     nil
   end
-
-  ##
-  # oAuth Consumer which uses just the base url, for
-  # app-wide, non user-specific requests.
-
-  def app_consumer
-    @app_consumer ||= consumer(base_url)
-  end
-
-  ##
-  # oAuth Consumer which uses the proper url for user-specific requests.
-
-  def user_consumer
-    @user_consumer ||= consumer("#{base_url}/platform")
-  end
-
-  private
-
-  def consumer(site)
-    OAuth::Consumer.new(
-      api_key,
-      api_secret,
-      site: site,
-      header: header,
-      http_method: :get,
-      request_token_url: links[:request_token],
-      access_token_url: links[:access_token],
-      authorize_url: links[:authorize_request_token]
-    )
-  end
-
-  def links
-    return @links if defined?(@links)
-
-    catalog = OAuth::Consumer.new(api_key, api_secret)
-      .request(
-        :get,
-        "#{base_url}/platform/",
-        nil,
-        {},
-        header
-      ).body
-
-      @links = {}
-
-      JSON.parse(catalog)['links'].each do |link|
-        uri = URI.parse(link['uri'])
-        uri.query = nil
-
-        @links[keyify(link['rel'])] = uri.to_s
-      end
-
-      @links
-  end
-
-  def header
-    {accept: 'application/vnd.deere.axiom.v3+json'}
-  end
-
-  def keyify key_name
-    key_name.gsub(/^oauth/, '').gsub(/([a-z])([A-Z])/, '\1_\2').downcase.to_sym
-  end
 end

data/lib/my_john_deere_api/client.rb

@@ -0,0 +1,51 @@
+class MyJohnDeereApi::Client
+  attr_reader :api_key, :api_secret, :access_token, :access_secret, :environment
+
+  DEFAULTS = {
+    environment: :production
+  }
+
+  ##
+  # Creates the client with everthing it needs to perform API requests.
+  # User-specific credentials are optional, but user-specific API
+  # requests are only possible if they are supplied.
+  #
+  # options:
+  #
+  # [:environment] :sandbox or :production
+  #
+  # [:access] an array with two elements, the access_token
+  #           and the access_secret of the given user
+
+  def initialize(api_key, api_secret, options = {})
+    options = DEFAULTS.merge(options)
+
+    @api_key = api_key
+    @api_secret = api_secret
+
+    if options.has_key?(:access) && options[:access].is_a?(Array)
+      @access_token, @access_secret = options[:access]
+    end
+
+    @environment = options[:environment]
+  end
+
+  private
+
+  ##
+  # Returns an oAuth consumer which can be used to build requests
+
+  def consumer
+    return @consumer if defined?(@consumer)
+    @consumer = MyJohnDeereApi::Consumer.new(@api_key, @api_secret, environment: environment)
+  end
+
+  ##
+  # Returns an oAuth AccessToken object which can be used to make
+  # user-specific API requests
+
+  def accessor
+    return @accessor if defined?(@accessor)
+    @accessor = OAuth::AccessToken.new(consumer.user_get, access_token, access_secret)
+  end
+end

data/lib/my_john_deere_api/consumer.rb

@@ -0,0 +1,85 @@
+class MyJohnDeereApi::Consumer
+  attr_reader :api_key, :api_secret, :environment, :base_url
+
+  # valid API urls
+  URLS = {
+    sandbox: 'https://sandboxapi.deere.com',
+    production: 'https://api.soa-proxy.deere.com',
+  }
+
+  DEFAULTS = {
+    environment: :production
+  }
+
+  def initialize(api_key, api_secret, options={})
+    options = DEFAULTS.merge(options)
+
+    @api_key = api_key
+    @api_secret = api_secret
+
+    @environment = options[:environment]
+    @base_url = options[:base_url] || URLS[@environment]
+  end
+
+  ##
+  # oAuth Consumer which uses just the base url, for
+  # app-wide, non user-specific GET requests.
+
+  def app_get
+    @app_get ||= consumer(base_url)
+  end
+
+  ##
+  # oAuth Consumer which uses the proper url for user-specific GET requests.
+
+  def user_get
+    @user_get ||= consumer("#{base_url}/platform")
+  end
+
+  private
+
+  def consumer(site)
+    OAuth::Consumer.new(
+      api_key,
+      api_secret,
+      site: site,
+      header: header,
+      http_method: :get,
+      request_token_url: links[:request_token],
+      access_token_url: links[:access_token],
+      authorize_url: links[:authorize_request_token]
+    )
+  end
+
+  def links
+    return @links if defined?(@links)
+
+    catalog = OAuth::Consumer.new(api_key, api_secret)
+      .request(
+        :get,
+        "#{base_url}/platform/",
+        nil,
+        {},
+        header
+      ).body
+
+      @links = {}
+
+      JSON.parse(catalog)['links'].each do |link|
+        uri = URI.parse(link['uri'])
+        uri.query = nil
+
+        @links[keyify(link['rel'])] = uri.to_s
+      end
+
+      @links
+  end
+
+  def header
+    @header ||= {accept: 'application/vnd.deere.axiom.v3+json'}
+  end
+
+  def keyify key_name
+    key_name.gsub(/^oauth/, '').gsub(/([a-z])([A-Z])/, '\1_\2').downcase.to_sym
+  end
+end

data/lib/my_john_deere_api/version.rb

@@ -1,3 +1,3 @@
 module MyJohnDeereApi
-  VERSION='0.0.3'
+  VERSION='0.0.4'
 end

data/lib/my_john_deere_api.rb

@@ -5,4 +5,6 @@ require 'json'
 module MyJohnDeereApi
   autoload :VERSION,        'my_john_deere_api/version'
   autoload :Authorize,      'my_john_deere_api/authorize'
+  autoload :Client,         'my_john_deere_api/client'
+  autoload :Consumer,        'my_john_deere_api/consumer'
 end

data/test/lib/test_authorize.rb

@@ -2,50 +2,49 @@ require 'uri'
 require 'cgi'
 require 'support/helper'
 
-TOKEN_PATTERN = /^[0-9a-z\-]+$/
-SECRET_PATTERN = /^[0-9A-Za-z\-+=\/]+$/
-API_KEY = ENV['API_KEY']
-API_SECRET = ENV['API_SECRET']
-
 def contains_parameters?(uri)
   !URI.parse(uri).query.nil?
 end
 
 def create_authorize
-  JD::Authorize.new(API_KEY, API_SECRET, environment: :sandbox)
+  VCR.use_cassette('catalog'){ JD::Authorize.new(API_KEY, API_SECRET, environment: :sandbox) }
 end
 
 def fancy_url
   'https://example.com/turtles'
 end
 
-class AuthorizeTest < MiniTest::Test
+describe 'MyJohnDeereApi::Authorize' do
   describe 'initialization' do
-    it "accepts an API key and secret" do
-      authorize = JD::Authorize.new('key', 'secret')
+    it 'sets the api key/secret' do
+      authorize = VCR.use_cassette('catalog') { JD::Authorize.new(API_KEY, API_SECRET) }
 
-      assert_equal 'key', authorize.api_key
-      assert_equal 'secret', authorize.api_secret
+      assert_equal API_KEY, authorize.api_key
+      assert_equal API_SECRET, authorize.api_secret
     end
 
-    it 'defaults to production environment' do
-      authorize = JD::Authorize.new('key', 'secret')
-      assert_equal :production, authorize.environment
-    end
+    it 'sets the environment' do
+      environment = :sandbox
 
-    it 'defaults to production oauth url' do
-      authorize = JD::Authorize.new('key', 'secret')
-      assert_equal 'https://api.soa-proxy.deere.com', authorize.base_url
+      authorize = VCR.use_cassette('catalog') { JD::Authorize.new(API_KEY, API_SECRET, environment: environment) }
+      assert_equal environment, authorize.environment
     end
 
-    it "can set the environment" do
-      authorize = JD::Authorize.new('key', 'secret', environment: :sandbox)
-      assert_equal :sandbox, authorize.environment
+    it 'defaults the environment to production' do
+      environment = :production
+
+      authorize = VCR.use_cassette('catalog') { JD::Authorize.new(API_KEY, API_SECRET) }
+      assert_equal environment, authorize.environment
     end
+  end
 
-    it "can set the base_url via the environment" do
-      authorize = JD::Authorize.new('key', 'secret', environment: :sandbox)
-      assert_equal 'https://sandboxapi.deere.com', authorize.base_url
+  describe '#consumer' do
+    it "returns a non-user-specific consumer configured for GET requests" do
+      authorize = create_authorize
+      consumer = VCR.use_cassette('catalog') { authorize.consumer }
+
+      assert_kind_of OAuth::Consumer, consumer
+      assert_equal :get, consumer.http_method
     end
   end
 
@@ -54,8 +53,9 @@ class AuthorizeTest < MiniTest::Test
       authorize = create_authorize
 
       url = VCR.use_cassette('get_request_token') { authorize.authorize_url }
+      links = VCR.use_cassette('catalog') { JD::Consumer.new(API_KEY, API_SECRET, environment: :sandbox).send(:links) }
 
-      assert_includes url, "#{authorize.send(:links)[:authorize_request_token]}?oauth_token="
+      assert_includes url, "#{links[:authorize_request_token]}?oauth_token="
 
       query = URI.parse(url).query
       params = CGI::parse(query)
@@ -85,57 +85,4 @@ class AuthorizeTest < MiniTest::Test
       assert_match SECRET_PATTERN, authorize.access_secret
     end
   end
-
-  describe '#links' do
-    it "returns a list of catalog urls" do
-      authorize = create_authorize
-
-      links = VCR.use_cassette("catalog"){ authorize.send(:links) }
-
-      assert_kind_of Hash, links
-
-      [:request_token, :authorize_request_token, :access_token].each do |link|
-        assert links.has_key?(link)
-        refute contains_parameters?(links[link])
-      end
-    end
-  end
-
-  describe '#base_url' do
-    it 'defaults to production deere url' do
-      authorize = JD::Authorize.new('key', 'secret')
-      assert_equal 'https://api.soa-proxy.deere.com', authorize.base_url
-    end
-
-    it 'can be set via accessor' do
-      authorize = create_authorize
-      authorize.base_url = fancy_url
-
-      assert_equal fancy_url, authorize.base_url
-    end
-  end
-
-  describe '#app_consumer' do
-    it 'creates a working oAuth consumer for non-user-specific requests' do
-      auth = create_authorize
-      app_consumer = VCR.use_cassette('app_consumer') { auth.app_consumer }
-
-      assert_kind_of OAuth::Consumer, app_consumer
-      assert_equal API_KEY, app_consumer.key
-      assert_equal API_SECRET, app_consumer.secret
-      assert_equal auth.base_url, app_consumer.site
-    end
-  end
-
-  describe '#user_consumer' do
-    it 'creates a working oAuth consumer for user-specific requests' do
-      auth = create_authorize
-      user_consumer = VCR.use_cassette('app_consumer') { auth.user_consumer }
-
-      assert_kind_of OAuth::Consumer, user_consumer
-      assert_equal API_KEY, user_consumer.key
-      assert_equal API_SECRET, user_consumer.secret
-      assert_equal "#{auth.base_url}/platform", user_consumer.site
-    end
-  end
 end

data/test/lib/test_client.rb

@@ -0,0 +1,63 @@
+require 'support/helper'
+
+describe 'MyJohnDeereApi::Client' do
+  describe '#initialize(api_key, api_secret)' do
+    it 'sets the api key/secret' do
+      client = JD::Client.new(API_KEY, API_SECRET)
+
+      assert_equal API_KEY, client.api_key
+      assert_equal API_SECRET, client.api_secret
+    end
+
+    it 'accepts access token/secret' do
+      access_token = 'token'
+      access_secret = 'secret'
+
+      client = JD::Client.new(API_KEY, API_SECRET, access: [access_token, access_secret])
+
+      assert_equal access_token, client.access_token
+      assert_equal access_secret, client.access_secret
+    end
+
+    it 'accepts environment' do
+      environment = :sandbox
+
+      client = JD::Client.new(API_KEY, API_SECRET, environment: environment)
+      assert_equal environment, client.environment
+    end
+
+    it 'defaults the environment to production' do
+      environment = :production
+
+      client = JD::Client.new(API_KEY, API_SECRET)
+      assert_equal environment, client.environment
+    end
+  end
+
+  describe '#consumer' do
+    it 'receives the api key/secret and environment of the client' do
+      environment = :sandbox
+
+      client = JD::Client.new(API_KEY, API_SECRET, environment: environment)
+      consumer = client.send :consumer
+
+      assert_kind_of JD::Consumer, consumer
+      assert_equal API_KEY, consumer.api_key
+      assert_equal API_SECRET, consumer.api_secret
+      assert_equal environment, consumer.environment
+    end
+  end
+
+  describe '#accessor' do
+    it 'returns an object that can make user-specific requests' do
+      client = JD::Client.new(API_KEY, API_SECRET, environment: :sandbox, access: [ACCESS_TOKEN, ACCESS_SECRET])
+      consumer = client.send(:consumer)
+      accessor = VCR.use_cassette('catalog') { client.send :accessor }
+
+      assert_kind_of OAuth::AccessToken, accessor
+      assert_kind_of OAuth::Consumer, accessor.consumer
+      assert_equal ACCESS_TOKEN, accessor.token
+      assert_equal ACCESS_SECRET, accessor.secret
+    end
+  end
+end

data/test/lib/test_consumer.rb

@@ -0,0 +1,74 @@
+require 'support/helper'
+
+describe 'JD::Consumer' do
+  describe '#initialize' do
+    it 'requires an api key and secret' do
+      consumer = JD::Consumer.new(API_KEY, API_SECRET)
+
+      assert_equal API_KEY, consumer.api_key
+      assert_equal API_SECRET, consumer.api_secret
+    end
+
+    it 'accepts sandbox environment' do
+      environment = :sandbox
+      consumer = JD::Consumer.new(API_KEY, API_SECRET, environment: environment)
+
+      assert_equal environment, consumer.environment
+      assert_equal JD::Consumer::URLS[environment], consumer.base_url
+    end
+
+    it 'accepts production environment' do
+      environment = :production
+      consumer = JD::Consumer.new(API_KEY, API_SECRET, environment: environment)
+
+      assert_equal environment, consumer.environment
+      assert_equal JD::Consumer::URLS[environment], consumer.base_url
+    end
+
+    it 'defaults to production environment' do
+      default_environment = :production
+      consumer = JD::Consumer.new(API_KEY, API_SECRET)
+
+      assert_equal default_environment, consumer.environment
+      assert_equal JD::Consumer::URLS[default_environment], consumer.base_url
+    end
+
+    it 'accepts an arbitrary base_url' do
+      base_url = 'https://example.com'
+      consumer = JD::Consumer.new(API_KEY, API_SECRET, base_url: base_url)
+
+      assert_equal base_url, consumer.base_url
+    end
+
+    it 'uses specified base_url regardless of specified environment' do
+      base_url = 'https://example.com'
+      consumer = JD::Consumer.new(API_KEY, API_SECRET, base_url: base_url, environment: :sandbox)
+
+      assert_equal base_url, consumer.base_url
+    end
+  end
+
+  describe '#app_get' do
+    it 'creates a working oAuth consumer for non-user-specific GET requests' do
+      consumer = JD::Consumer.new(API_KEY, API_SECRET, environment: :sandbox)
+      app_get = VCR.use_cassette('app_consumer') { consumer.app_get }
+
+      assert_kind_of OAuth::Consumer, app_get
+      assert_equal API_KEY, app_get.key
+      assert_equal API_SECRET, app_get.secret
+      assert_equal JD::Consumer::URLS[:sandbox], app_get.site
+    end
+  end
+
+  describe '#user_get' do
+    it 'creates a working oAuth consumer for user-specific GET requests' do
+      consumer = JD::Consumer.new(API_KEY, API_SECRET, environment: :sandbox)
+      user_get = VCR.use_cassette('app_consumer') { consumer.user_get }
+
+      assert_kind_of OAuth::Consumer, user_get
+      assert_equal API_KEY, user_get.key
+      assert_equal API_SECRET, user_get.secret
+      assert_equal "#{JD::Consumer::URLS[:sandbox]}/platform", user_get.site
+    end
+  end
+end

data/test/support/helper.rb

@@ -8,6 +8,15 @@ require 'my_john_deere_api'
 # shortcut for long module name
 JD = MyJohnDeereApi
 
+API_KEY = ENV['API_KEY']
+API_SECRET = ENV['API_SECRET']
+
+ACCESS_TOKEN = ENV['ACCESS_TOKEN']
+ACCESS_SECRET = ENV['ACCESS_SECRET']
+
+TOKEN_PATTERN = /^[0-9a-z\-]+$/
+SECRET_PATTERN = /^[0-9A-Za-z\-+=\/]+$/
+
 VCR.configure do |config|
   config.cassette_library_dir = 'test/support/vcr'
   config.hook_into :webmock

data/test/test_my_john_deere_api.rb

@@ -9,5 +9,13 @@ class MyJohnDeereApiTest < MiniTest::Test
     it 'loads Authorize' do
       assert JD::Authorize
     end
+
+    it 'loads Client' do
+      assert JD::Client
+    end
+
+    it 'loads Consumer' do
+      assert JD::Consumer
+    end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: my_john_deere_api
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.4
 platform: ruby
 authors:
 - Jaime. Bellmyer
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-01-06 00:00:00.000000000 Z
+date: 2020-01-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: vcr
@@ -97,8 +97,12 @@ files:
 - Rakefile
 - lib/my_john_deere_api.rb
 - lib/my_john_deere_api/authorize.rb
+- lib/my_john_deere_api/client.rb
+- lib/my_john_deere_api/consumer.rb
 - lib/my_john_deere_api/version.rb
 - test/lib/test_authorize.rb
+- test/lib/test_client.rb
+- test/lib/test_consumer.rb
 - test/lib/test_version.rb
 - test/support/helper.rb
 - test/support/vcr/app_consumer.yml