my_john_deere_api 2.4.1

data/test/lib/my_john_deere_api/model/flag_test.rb

@@ -0,0 +1,48 @@
+require 'support/helper'
+require 'json'
+
+describe 'MyJohnDeereApi::Model::Flag' do
+  let(:klass) { JD::Model::Flag }
+
+  let(:record) do
+    {
+      "@type"=>"Flag",
+      "geometry"=>"{\"type\": \"Point\", \"coordinates\": [-93.14959274063109, 41.66881548411553] }",
+      "archived"=>true,
+      "proximityAlertEnabled"=>true,
+      "notes"=>"Our flag is a very, very, very nice flag!",
+      "id"=>"123456",
+      "links"=>[
+        {"@type"=>"Link", "rel"=>"field", "uri"=>"https://sandboxapi.deere.com/platform/organizations/#{organization_id}/fields/#{field_id}"},
+        {"@type"=>"Link", "rel"=>"createdBy", "uri"=>"https://sandboxapi.deere.com/platform/users/bobsmith"},
+        {"@type"=>"Link", "rel"=>"lastModifiedBy", "uri"=>"https://sandboxapi.deere.com/platform/users/jonsmith"},
+      ]
+    }
+  end
+
+  describe '#initialize' do
+    def link_for label
+      record['links'].detect{|link| link['rel'] == label}['uri'].gsub('https://sandboxapi.deere.com/platform', '')
+    end
+
+    it 'sets the attributes from the given record' do
+      flag = klass.new(client, record)
+
+      assert_equal client, flag.client
+      assert_equal accessor, flag.accessor
+
+      # basic attributes
+      assert_equal JSON.parse(record['geometry']), flag.geometry
+      assert_equal record['archived'], flag.archived?
+      assert_equal record['proximityAlertEnabled'], flag.proximity_alert_enabled?
+      assert_equal record['notes'], flag.notes
+      assert_equal record['id'], flag.id
+
+      # links to other things
+      assert_kind_of Hash, flag.links
+      assert_equal link_for('field'), flag.links['field']
+      assert_equal link_for('createdBy'), flag.links['created_by']
+      assert_equal link_for('lastModifiedBy'), flag.links['last_modified_by']
+    end
+  end
+end

data/test/lib/my_john_deere_api/model/organization_test.rb

@@ -0,0 +1,84 @@
+require 'support/helper'
+
+describe 'MyJohnDeereApi::Model::Organization' do
+  let(:klass) { JD::Model::Organization }
+
+  let(:record) do
+    {
+      "@type"=>"Organization",
+      "name"=>"Century Farms",
+      "type"=>"customer",
+      "member"=>true,
+      "id"=>"123456",
+      "links"=>[
+        {"@type"=>"Link", "rel"=>"self", "uri"=>"https://sandboxapi.deere.com/platform/organizations/#{organization_id}"},
+        {"@type"=>"Link", "rel"=>"machines", "uri"=>"https://sandboxapi.deere.com/platform/organizations/#{organization_id}/machines"},
+        {"@type"=>"Link", "rel"=>"wdtCapableMachines", "uri"=>"https://sandboxapi.deere.com/platform/organizations/#{organization_id}/machines?capability=wdt"},
+        {"@type"=>"Link", "rel"=>"files", "uri"=>"https://sandboxapi.deere.com/platform/organizations/#{organization_id}/files"},
+        {"@type"=>"Link", "rel"=>"transferableFiles", "uri"=>"https://sandboxapi.deere.com/platform/organizations/#{organization_id}/files?transferable=true"},
+        {"@type"=>"Link", "rel"=>"uploadFile", "uri"=>"https://sandboxapi.deere.com/platform/organizations/#{organization_id}/files"},
+        {"@type"=>"Link", "rel"=>"sendFileToMachine", "uri"=>"https://sandboxapi.deere.com/platform/organizations/#{organization_id}/fileTransfers"},
+        {"@type"=>"Link", "rel"=>"addMachine", "uri"=>"https://sandboxapi.deere.com/platform/organizations/#{organization_id}/machines"},
+        {"@type"=>"Link", "rel"=>"addField", "uri"=>"https://sandboxapi.deere.com/platform/organizations/#{organization_id}/fields"},
+        {"@type"=>"Link", "rel"=>"assets", "uri"=>"https://sandboxapi.deere.com/platform/organizations/#{organization_id}/assets"},
+        {"@type"=>"Link", "rel"=>"fields", "uri"=>"https://sandboxapi.deere.com/platform/organizations/#{organization_id}/fields"},
+        {"@type"=>"Link", "rel"=>"farms", "uri"=>"https://sandboxapi.deere.com/platform/organizations/#{organization_id}/farms"},
+        {"@type"=>"Link", "rel"=>"boundaries", "uri"=>"https://sandboxapi.deere.com/platform/organizations/#{organization_id}/boundaries"},
+        {"@type"=>"Link", "rel"=>"clients", "uri"=>"https://sandboxapi.deere.com/platform/organizations/#{organization_id}/clients"},
+        {"@type"=>"Link", "rel"=>"controllers", "uri"=>"https://sandboxapi.deere.com/platform/organizations/#{organization_id}/orgController"}
+      ]
+    }
+  end
+
+  describe '#initialize(record, client = nil)' do
+    def link_for label
+      record['links'].detect{|link| link['rel'] == label}['uri'].gsub('https://sandboxapi.deere.com/platform', '')
+    end
+
+    it 'sets the attributes from the given record' do
+      organization = klass.new(client, record)
+
+      assert_equal client, organization.client
+      assert_equal accessor, organization.accessor
+
+      # basic attributes
+      assert_equal record['name'], organization.name
+      assert_equal record['type'], organization.type
+      assert_equal record['member'], organization.member?
+      assert_equal record['id'], organization.id
+
+      # links to other things
+      assert_kind_of Hash, organization.links
+
+      ['fields', 'machines', 'files', 'assets', 'farms', 'boundaries', 'clients', 'controllers'].each do |association|
+        assert_equal link_for(association), organization.links[association]
+      end
+    end
+  end
+
+  describe '#fields' do
+    it 'returns a collection of fields for this organization' do
+      organization = VCR.use_cassette('get_organizations') { client.organizations.first }
+      fields = VCR.use_cassette('get_fields') { organization.fields.all }
+
+      assert_kind_of Array, fields
+
+      fields.each do |field|
+        assert_kind_of JD::Model::Field, field
+      end
+    end
+  end
+
+  describe '#assets' do
+    it 'returns a collection of assets for this organization' do
+      organization = VCR.use_cassette('get_organizations') { client.organizations.first }
+      assets = VCR.use_cassette('get_assets') { organization.assets.all; organization.assets }
+
+      assert_kind_of JD::Request::Collection::Assets, assets
+
+      assets.each do |assets|
+        assert_kind_of JD::Model::Asset, assets
+      end
+    end
+  end
+end

data/test/lib/my_john_deere_api/model_test.rb

@@ -0,0 +1,37 @@
+require 'support/helper'
+
+describe 'MyJohnDeereApi::Model' do
+  describe 'loading dependencies' do
+    it 'loads Model::Base' do
+      assert JD::Model::Base
+    end
+
+    it 'loads Model::Asset' do
+      assert JD::Model::Asset
+    end
+
+    it 'loads Model::AssetLocation' do
+      assert JD::Model::AssetLocation
+    end
+
+    it 'loads Model::ContributionProduct' do
+      assert JD::Model::ContributionProduct
+    end
+
+    it 'loads Model::ContributionDefinition' do
+      assert JD::Model::ContributionDefinition
+    end
+
+    it 'loads Model::Organization' do
+      assert JD::Model::Organization
+    end
+
+    it 'loads Model::Field' do
+      assert JD::Model::Field
+    end
+
+    it 'loads Model::Flag' do
+      assert JD::Model::Flag
+    end
+  end
+end

data/test/lib/my_john_deere_api/net_http_retry/decorator_test.rb

@@ -0,0 +1,163 @@
+require 'support/helper'
+
+describe 'JD::NetHttpRetry::Decorator' do
+  REQUESTS = {
+    get:    '/',
+    post:   '/organizations/000000/assets',
+    put:    '/assets/00000000-0000-0000-0000-000000000000',
+    delete: '/assets/00000000-0000-0000-0000-000000000000'
+  }
+
+  REQUEST_METHODS = REQUESTS.keys
+
+  let(:klass) { JD::NetHttpRetry::Decorator }
+  let(:object) { klass.new(mock, options) }
+
+  let(:options) do
+    {
+      request_methods: request_methods,
+      retry_delay_exponent: retry_delay_exponent,
+      max_retries: max_retries,
+      response_codes: response_codes
+    }
+  end
+
+  let(:request_methods) { nil }
+  let(:retry_delay_exponent) { nil }
+  let(:max_retries) { nil }
+  let(:response_codes) { nil }
+
+  let(:retry_values) { [13, 17, 19, 23] }
+  let(:exponential_retries) { (0..klass::DEFAULTS[:max_retries]-1).map{|i| 2 ** i} }
+
+  it 'wraps a "net-http"-responsive object' do
+    assert_kind_of OAuth::AccessToken, accessor.object
+  end
+
+  describe '#initialize' do
+    describe 'when request methods are specified' do
+      let(:request_methods) { [:banana, :fana, :fofana] }
+
+      it 'uses the supplied values' do
+        assert_equal request_methods, object.request_methods
+      end
+    end
+
+    describe 'when request methods are not specified' do
+      it 'uses the default values' do
+        assert_equal klass::DEFAULTS[:request_methods], object.request_methods
+      end
+    end
+
+    describe 'when retry_delay_exponent is specified' do
+      let(:retry_delay_exponent) { 42 }
+
+      it 'uses the supplied value' do
+        assert_equal retry_delay_exponent, object.retry_delay_exponent
+      end
+    end
+
+    describe 'when retry_delay_exponent is not specified' do
+      it 'uses the default value' do
+        assert_equal klass::DEFAULTS[:retry_delay_exponent], object.retry_delay_exponent
+      end
+    end
+
+    describe 'when max_retries is specified' do
+      let(:max_retries) { 42 }
+
+      it 'uses the supplied value' do
+        assert_equal max_retries, object.max_retries
+      end
+    end
+
+    describe 'when max_retries is not specified' do
+      it 'uses the default value' do
+        assert_equal klass::DEFAULTS[:max_retries], object.max_retries
+      end
+    end
+
+    describe 'when response_codes are specified' do
+      let(:response_codes) { ['200', '201'] }
+
+      it 'uses the supplied values' do
+        assert_equal response_codes, object.response_codes
+      end
+    end
+
+    describe 'when response_codes are specified as integers' do
+      let(:response_codes) { [200, 201] }
+
+      it 'uses the stringified versions of the supplied values' do
+        assert_equal response_codes.map(&:to_s), object.response_codes
+      end
+    end
+
+    describe 'when response_codes are not specified' do
+      it 'uses the default values' do
+        assert_equal klass::DEFAULTS[:response_codes], object.response_codes
+      end
+    end
+  end
+
+  describe "honors Retry-After headers" do
+    REQUEST_METHODS.each do |request_method|
+      it "in #{request_method.to_s.upcase} requests" do
+        retry_values.each do |retry_seconds|
+          accessor.expects(:sleep).with(retry_seconds)
+        end
+
+        VCR.use_cassette("accessor/#{request_method}_retry") do
+          accessor.send(request_method, REQUESTS[request_method])
+        end
+      end
+    end
+  end
+
+  describe 'employs exponential wait times for automatic retries' do
+    REQUEST_METHODS.each do |request_method|
+      it "in #{request_method.to_s.upcase} requests" do
+        exponential_retries[0,8].each do |retry_seconds|
+          accessor.expects(:sleep).with(retry_seconds)
+        end
+
+        VCR.use_cassette("accessor/#{request_method}_failed") do
+          accessor.send(request_method, REQUESTS[request_method])
+        end
+      end
+    end
+  end
+
+  describe 'when Retry-After is shorter than exponential wait time' do
+    REQUEST_METHODS.each do |request_method|
+      it "chooses longer exponential time in #{request_method.to_s.upcase} requests" do
+        exponential_retries[0,4].each do |retry_seconds|
+          accessor.expects(:sleep).with(retry_seconds)
+        end
+
+        VCR.use_cassette("accessor/#{request_method}_retry_too_soon") do
+          accessor.send(request_method, REQUESTS[request_method])
+        end
+      end
+    end
+  end
+
+  describe 'when max retries have been reached' do
+    REQUEST_METHODS.each do |request_method|
+      it "returns an error for #{request_method.to_s.upcase} requests" do
+        exponential_retries.each do |retry_seconds|
+          accessor.expects(:sleep).with(retry_seconds)
+        end
+
+        exception = assert_raises(JD::NetHttpRetry::MaxRetriesExceededError) do
+          VCR.use_cassette("accessor/#{request_method}_max_failed") do
+            accessor.send(request_method, REQUESTS[request_method])
+          end
+        end
+
+        expected_error = "Max retries exceeded for #{request_method.to_s.upcase} request: 429 Too Many Requests"
+        assert_equal expected_error, exception.message
+      end
+    end
+  end
+end

data/test/lib/my_john_deere_api/request/collection/asset_locations_test.rb

@@ -0,0 +1,102 @@
+require 'support/helper'
+require 'yaml'
+require 'json'
+
+describe 'MyJohnDeereApi::Request::Collection::AssetLocations' do
+  let(:klass) { JD::Request::Collection::AssetLocations }
+  let(:collection) { klass.new(client, asset: asset_id) }
+  let(:object) { collection }
+
+  inherits_from JD::Request::Collection::Base
+
+  describe '#initialize(client)' do
+    it 'accepts a client' do
+      assert_equal client, collection.client
+    end
+
+    it 'accepts associations' do
+      collection = klass.new(client, asset: asset_id)
+
+      assert_kind_of Hash, collection.associations
+      assert_equal asset_id, collection.associations[:asset]
+    end
+  end
+
+  describe '#resource' do
+    it 'returns /assets/{asset_id}/locations' do
+      assert_equal "/assets/#{asset_id}/locations", collection.resource
+    end
+  end
+
+  describe '#all' do
+    it 'returns all records' do
+      all = VCR.use_cassette('get_asset_locations') { collection.all }
+
+      assert_kind_of Array, all
+      assert_equal collection.count, all.size
+      assert all.size > 0
+
+      all.each do |item|
+        assert_kind_of JD::Model::AssetLocation, item
+      end
+    end
+  end
+
+  describe '#create(attributes)' do
+    it 'creates a new asset with the given attributes' do
+      attributes = CONFIG.asset_location_attributes
+
+      object = VCR.use_cassette('post_asset_locations') { collection.create(attributes) }
+
+      assert_kind_of JD::Model::AssetLocation, object
+
+      # API returns seconds with decimals, even though they're always zero
+      integer_stamp = DateTime.parse(object.timestamp).strftime('%Y-%m-%dT%H:%M:%SZ')
+      expected_stamp = DateTime.parse(attributes[:timestamp]).strftime('%Y-%m-%dT%H:%M:%SZ')
+
+      # API returns string keys and an extra '@type' key
+      object_measurement_data = object.measurement_data.first.transform_keys{|k| k.to_sym}.slice(:name, :value, :unit)
+
+      assert_equal expected_stamp, integer_stamp
+      assert_equal attributes[:geometry].to_json, object.geometry.to_json
+      assert_equal attributes[:measurement_data].first, object_measurement_data
+    end
+  end
+
+  describe '#count' do
+    let(:server_response) do
+      contents = File.read('test/support/vcr/get_asset_locations.yml')
+      body = YAML.load(contents)['http_interactions'].last['response']['body']['string']
+      JSON.parse(body)
+    end
+
+    let(:server_count) { server_response['total'] }
+
+    it 'returns the total count of records in the collection' do
+      count = VCR.use_cassette('get_asset_locations') { collection.count }
+
+      assert_equal server_count, count
+    end
+  end
+
+  describe 'results' do
+    let(:location_timestamps) do
+      contents = File.read('test/support/vcr/get_asset_locations.yml')
+      body = YAML.load(contents)['http_interactions'].last['response']['body']['string']
+      JSON.parse(body)['values'].map{|v| v['timestamp']}
+    end
+
+    it 'returns all records as a single enumerator' do
+      count = VCR.use_cassette('get_asset_locations') { collection.count }
+      timestamps = VCR.use_cassette('get_asset_locations') { collection.map(&:timestamp) }
+
+      assert_kind_of Array, timestamps
+      assert_equal count, timestamps.size
+      assert timestamps.size > 0
+
+      location_timestamps.each do |expected_timestamp|
+        assert_includes timestamps, expected_timestamp
+      end
+    end
+  end
+end

data/test/lib/my_john_deere_api/request/collection/assets_test.rb

@@ -0,0 +1,99 @@
+require 'support/helper'
+require 'yaml'
+require 'json'
+
+describe 'MyJohnDeereApi::Request::Collection::Assets' do
+  let(:klass) { JD::Request::Collection::Assets }
+  let(:collection) { klass.new(client, organization: organization_id) }
+  let(:object) { collection }
+
+  inherits_from JD::Request::Collection::Base
+
+  describe '#initialize(client)' do
+    it 'accepts a client' do
+      assert_equal client, collection.client
+    end
+
+    it 'accepts associations' do
+      collection = klass.new(client, organization: organization_id)
+
+      assert_kind_of Hash, collection.associations
+      assert_equal organization_id, collection.associations[:organization]
+    end
+  end
+
+  describe '#resource' do
+    it 'returns /organizations/{org_id}/assets' do
+      assert_equal "/organizations/#{organization_id}/assets", collection.resource
+    end
+  end
+
+  describe '#all' do
+    it 'returns all records' do
+      all = VCR.use_cassette('get_assets') { collection.all }
+
+      assert_kind_of Array, all
+      assert_equal collection.count, all.size
+
+      all.each do |item|
+        assert_kind_of JD::Model::Asset, item
+      end
+    end
+  end
+
+  describe '#create(attributes)' do
+    it 'creates a new asset with the given attributes' do
+      attributes = CONFIG.asset_attributes
+      object = VCR.use_cassette('post_assets') { collection.create(attributes) }
+
+      assert_kind_of JD::Model::Asset, object
+      assert_equal attributes[:title], object.title
+      assert_equal attributes[:asset_category], object.asset_category
+      assert_equal attributes[:asset_type], object.asset_type
+      assert_equal attributes[:asset_sub_type], object.asset_sub_type
+    end
+  end
+
+  describe '#find(asset_id)' do
+    it 'retrieves the asset' do
+      asset = VCR.use_cassette('get_asset') { collection.find(asset_id) }
+      assert_kind_of JD::Model::Asset, asset
+    end
+  end
+
+  describe '#count' do
+    let(:server_response) do
+      contents = File.read('test/support/vcr/get_assets.yml')
+      body = YAML.load(contents)['http_interactions'].last['response']['body']['string']
+      JSON.parse(body)
+    end
+
+    let(:server_count) { server_response['total'] }
+
+    it 'returns the total count of records in the collection' do
+      count = VCR.use_cassette('get_assets') { collection.count }
+
+      assert_equal server_count, count
+    end
+  end
+
+  describe 'results' do
+    let(:asset_titles) do
+      contents = File.read('test/support/vcr/get_assets.yml')
+      body = YAML.load(contents)['http_interactions'].last['response']['body']['string']
+      JSON.parse(body)['values'].map{|v| v['title']}
+    end
+
+    it 'returns all records as a single enumerator' do
+      count = VCR.use_cassette('get_assets') { collection.count }
+      titles = VCR.use_cassette('get_assets') { collection.map(&:title) }
+
+      assert_kind_of Array, titles
+      assert_equal count, titles.size
+
+      asset_titles.each do |expected_title|
+        assert_includes titles, expected_title
+      end
+    end
+  end
+end