my_john_deere_api 2.4.1

data/lib/my_john_deere_api/validators.rb

@@ -0,0 +1,5 @@
+module MyJohnDeereApi::Validators
+  autoload :Base,               'my_john_deere_api/validators/base'
+  autoload :Asset,              'my_john_deere_api/validators/asset'
+  autoload :AssetLocation,      'my_john_deere_api/validators/asset_location'
+end

data/lib/my_john_deere_api/validators/asset.rb

@@ -0,0 +1,35 @@
+module MyJohnDeereApi::Validators
+  module Asset
+    include Base
+
+    VALID_CATEGORIES = {
+      'DEVICE' => {
+        'SENSOR' => ['GRAIN_BIN', 'ENVIRONMENTAL', 'IRRIGATION_PIVOT', 'OTHER']
+      },
+
+      'EQUIPMENT' => {
+        'MACHINE' => ['PICKUP_TRUCK', 'UTILITY_VEHICLE'],
+        'OTHER' => ['ANHYDROUS_AMMONIA_TANK', 'NURSE_TRUCK', 'NURSE_WAGON', 'TECHNICIAN_TRUCK']
+      },
+    }
+
+    private
+
+    def required_attributes
+      [:organization_id, :title]
+    end
+
+    def validate_attributes
+      unless valid_categories?(attributes[:asset_category], attributes[:asset_type], attributes[:asset_sub_type])
+        errors[:asset_category] = 'requires valid combination of category/type/subtype'
+      end
+    end
+
+    ##
+    # Returns boolean, true if this combination is valid
+
+    def valid_categories?(category, type, subtype)
+      VALID_CATEGORIES.dig(category, type).to_a.include?(subtype)
+    end
+  end
+end

data/lib/my_john_deere_api/validators/asset_location.rb

@@ -0,0 +1,34 @@
+module MyJohnDeereApi::Validators
+  module AssetLocation
+    include Base
+
+    private
+
+    def required_attributes
+      [:asset_id, :timestamp, :geometry, :measurement_data]
+    end
+
+    ##
+    # Custom validations for this class
+
+    def validate_attributes
+      validate_measurement_data
+    end
+
+    def validate_measurement_data
+      unless attributes[:measurement_data].is_a?(Array)
+        errors[:measurement_data] ||= 'must be an array'
+        return
+      end
+
+      attributes[:measurement_data].each do |measurement|
+        [:name, :value, :unit].each do |attr|
+          unless measurement.has_key?(attr)
+            errors[:measurement_data] ||= "must include #{attr}"
+            return
+          end
+        end
+      end
+    end
+  end
+end

data/lib/my_john_deere_api/validators/base.rb

@@ -0,0 +1,67 @@
+module MyJohnDeereApi
+  ##
+  # This is a mix-in for Create/Update Reqest classes. It assumes that
+  # the class in question has a hash of attributes that will be passed
+  # to the request.
+  #
+  # This module creates the errors hash as a reader. The key of the hash
+  # is the attribute name, and the value is an array of error messages
+  # for that attribute. Follow this format when defining custom
+  # validations in the `validate_attributes` method.
+
+  module Validators::Base
+    attr_reader :errors
+
+    ##
+    # Raises an error if the record is invalid. Passes the errors hash
+    # to the error, in order to build a useful message string.
+
+    def validate!
+      raise(InvalidRecordError, errors) unless valid?
+      true
+    end
+    ##
+
+    # Runs validations, adding to the errors hash as needed. Returns true
+    # if the errors hash is still empty after all validations have been run.
+
+    def valid?
+      return @is_valid if defined?(@is_valid)
+
+      @errors = {}
+      validate_required
+      validate_attributes
+
+      @is_valid = errors.empty?
+    end
+
+    private
+
+    ##
+    # Validates required attributes
+
+    def validate_required
+      required_attributes.each do |attr|
+        errors[attr] = 'is required' unless attributes[attr]
+      end
+    end
+
+    ##
+    # Attributes that must be specified, override in child module if needed
+
+    def required_attributes
+      []
+    end
+
+    ##
+    # Handle any custom validation for this class, override in child module if needed.
+    #
+    # Add messages to errors hash with the attribute name as the key, and an array
+    # of error messages as the value. 
+
+    def validate_attributes
+      # Example:
+      # errors[:name] = "can't be blank" if errors[:name].size == 0
+    end
+  end
+end

data/lib/my_john_deere_api/version.rb

@@ -0,0 +1,3 @@
+module MyJohnDeereApi
+  VERSION='2.4.1'
+end

data/test/lib/my_john_deere_api/authorize_test.rb

@@ -0,0 +1,81 @@
+require 'uri'
+require 'cgi'
+require 'support/helper'
+
+def contains_parameters?(uri)
+  !URI.parse(uri).query.nil?
+end
+
+def create_authorize
+  VCR.use_cassette('catalog'){ JD::Authorize.new(api_key, api_secret, environment: :sandbox) }
+end
+
+def fancy_url
+  'https://example.com/turtles'
+end
+
+describe 'MyJohnDeereApi::Authorize' do
+  describe 'initialization' do
+    it 'sets the api key/secret' do
+      authorize = VCR.use_cassette('catalog') { JD::Authorize.new(api_key, api_secret) }
+
+      assert_equal api_key, authorize.api_key
+      assert_equal api_secret, authorize.api_secret
+    end
+
+    it 'accepts the environment' do
+      environment = :sandbox
+
+      authorize = VCR.use_cassette('catalog') { JD::Authorize.new(api_key, api_secret, environment: environment) }
+      assert_equal environment, authorize.environment
+    end
+  end
+
+  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
+
+  describe '#authorize_url' do
+    it 'retrieves a request url' do
+      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, links[:authorize_request_token]
+
+      query = URI.parse(url).query
+      params = CGI::parse(query)
+
+      assert_match(TOKEN_PATTERN, params['oauth_token'].first)
+    end
+
+    it 'sets the request token/secret' do
+      authorize = create_authorize
+
+      VCR.use_cassette('get_request_token') { authorize.authorize_url }
+
+      assert_match TOKEN_PATTERN, authorize.request_token
+      assert_match SECRET_PATTERN, authorize.request_secret
+    end
+  end
+
+  describe '#verify(code, token, secret)' do
+    it 'sets the access token/secret' do
+      authorize = create_authorize
+      code = 'VERIFY'
+
+      VCR.use_cassette('get_request_token') { authorize.authorize_url }
+      VCR.use_cassette('get_access_token') { authorize.verify(code) }
+
+      assert_match TOKEN_PATTERN, authorize.access_token
+      assert_match SECRET_PATTERN, authorize.access_secret
+    end
+  end
+end

data/test/lib/my_john_deere_api/client_test.rb

@@ -0,0 +1,225 @@
+require 'support/helper'
+
+describe 'MyJohnDeereApi::Client' do
+  it 'includes the CaseConversion helper' do
+    client = JD::Client.new(api_key, api_secret)
+    assert_equal 'thisIsATest', client.send(:camelize, :this_is_a_test)
+  end
+
+  describe '#initialize(api_key, api_secret, options={})' 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 the environment' do
+      environment = :sandbox
+
+      client = JD::Client.new(api_key, api_secret, environment: environment)
+      assert_equal environment, client.environment
+    end
+
+    it 'accepts a contribution_definition_id' do
+      client = JD::Client.new(api_key, api_secret, contribution_definition_id: contribution_definition_id)
+      assert_equal contribution_definition_id, client.contribution_definition_id
+    end
+
+    it 'accepts a list of parameters for NetHttpRetry' do
+      custom_retries = JD::NetHttpRetry::Decorator::DEFAULTS[:max_retries] + 10
+
+      VCR.use_cassette('catalog') do
+        new_client = JD::Client.new(
+          api_key,
+          api_secret,
+          contribution_definition_id: contribution_definition_id,
+          environment: :sandbox,
+          access: [access_token, access_secret],
+          http_retry: {max_retries: custom_retries}
+        )
+
+        assert_equal custom_retries, new_client.accessor.max_retries
+      end
+    end
+  end
+
+  describe '#contribution_definition_id' do
+    it 'can be set after instantiation' do
+      client = JD::Client.new(api_key, api_secret)
+      assert_nil client.contribution_definition_id
+
+      client.contribution_definition_id = '123'
+      assert_equal '123', client.contribution_definition_id
+    end
+  end
+
+  describe '#get' do
+    it 'returns the response as a Hash' do
+      response = VCR.use_cassette('get_organizations') { client.get('/organizations') }
+
+      assert_kind_of Hash, response
+      assert_kind_of Integer, response['total']
+      assert response['values'].all?{|value| value['@type'] == 'Organization'}
+      assert response['values'].all?{|value| value.has_key?('links')}
+    end
+
+    it 'prepends the leading slash if needed' do
+      response = VCR.use_cassette('get_organizations') { client.get('organizations') }
+
+      assert_kind_of Hash, response
+      assert_kind_of Integer, response['total']
+      assert response['values'].all?{|value| value['@type'] == 'Organization'}
+      assert response['values'].all?{|value| value.has_key?('links')}
+    end
+
+    it 'allows symbols for simple resources' do
+      response = VCR.use_cassette('get_organizations') { client.get(:organizations) }
+
+      assert_kind_of Hash, response
+      assert_kind_of Integer, response['total']
+      assert response['values'].all?{|value| value['@type'] == 'Organization'}
+      assert response['values'].all?{|value| value.has_key?('links')}
+    end
+  end
+
+  describe '#post' do
+    let(:attributes) do
+      CONFIG.asset_attributes.merge(
+        links: [
+          {
+            '@type' => 'Link',
+            'rel' => 'contributionDefinition',
+            'uri' => "#{CONFIG.url}/contributionDefinitions/#{contribution_definition_id}"
+          }
+        ]
+      )
+    end
+
+    it 'returns the response as a Hash' do
+      response = VCR.use_cassette('post_assets') do
+        client.post("/organizations/#{organization_id}/assets", attributes)
+      end
+
+      assert_equal '201', response.code
+      assert_equal 'Created', response.message
+      assert_equal "#{base_url}/assets/#{asset_id}", response['Location']
+    end
+
+    it 'prepends the leading slash if needed' do
+      response = VCR.use_cassette('post_assets') do
+        client.post("organizations/#{organization_id}/assets", attributes)
+      end
+
+      assert_equal '201', response.code
+      assert_equal 'Created', response.message
+      assert_equal "#{base_url}/assets/#{asset_id}", response['Location']
+    end
+  end
+
+  describe '#put' do
+    let(:new_title) { 'i REALLY like turtles!' }
+
+    let(:attributes) do
+      CONFIG.asset_attributes.slice(
+        :asset_category, :asset_type, :asset_sub_type, :links
+      ).merge(
+        title: new_title,
+        links: [
+          {
+            '@type' => 'Link',
+            'rel' => 'contributionDefinition',
+            'uri' => "#{CONFIG.url}/contributionDefinitions/#{contribution_definition_id}"
+          }
+        ]
+      )
+    end
+
+    it 'sends the request' do
+      response = VCR.use_cassette('put_asset') { client.put("/assets/#{asset_id}", attributes) }
+
+      assert_equal '204', response.code
+      assert_equal 'No Content', response.message
+    end
+
+    it 'prepends the leading slash if needed' do
+      response = VCR.use_cassette('put_asset') { client.put("assets/#{asset_id}", attributes) }
+
+      assert_equal '204', response.code
+      assert_equal 'No Content', response.message
+    end
+  end
+
+  describe '#delete' do
+    it 'sends the request' do
+      response = VCR.use_cassette('delete_asset') { client.delete("/assets/#{asset_id}") }
+
+      assert_equal '204', response.code
+      assert_equal 'No Content', response.message
+    end
+
+    it 'prepends the leading slash if needed' do
+      response = VCR.use_cassette('delete_asset') { client.delete("assets/#{asset_id}") }
+
+      assert_equal '204', response.code
+      assert_equal 'No Content', response.message
+    end
+  end
+
+  describe '#organizations' do
+    it 'returns a collection of organizations for this account' do
+      organizations = VCR.use_cassette('get_organizations') { client.organizations.all; client.organizations }
+
+      assert_kind_of JD::Request::Collection::Organizations, organizations
+
+      organizations.each do |organization|
+        assert_kind_of JD::Model::Organization, organization
+      end
+    end
+  end
+
+  describe '#contribution_products' do
+    it 'returns a collection of contribution products for this account' do
+      contribution_products = VCR.use_cassette('get_contribution_products') { client.contribution_products.all; client.contribution_products }
+
+      assert_kind_of JD::Request::Collection::ContributionProducts, contribution_products
+
+      contribution_products.each do |contribution_product|
+        assert_kind_of JD::Model::ContributionProduct, contribution_product
+      end
+    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
+      assert_kind_of JD::NetHttpRetry::Decorator, accessor
+      assert_kind_of OAuth::Consumer, accessor.consumer
+      assert_equal access_token, accessor.token
+      assert_equal access_secret, accessor.secret
+    end
+  end
+end