my_john_deere_api 2.4.1

data/test/lib/my_john_deere_api/request/collection_test.rb

@@ -0,0 +1,37 @@
+require 'support/helper'
+
+describe 'MyJohnDeereApi::Request::Collection' do
+  describe 'loading dependencies' do
+    it 'loads Request::Collection::Base' do
+      assert JD::Request::Collection::Base
+    end
+
+    it 'loads Request::Collection::Assets' do
+      assert JD::Request::Collection::Assets
+    end
+
+    it 'loads Request::Collection::AssetLocations' do
+      assert JD::Request::Collection::AssetLocations
+    end
+
+    it 'loads Request::Collection::ContributionProducts' do
+      assert JD::Request::Collection::ContributionProducts
+    end
+
+    it 'loads Request::Collection::ContributionDefinitions' do
+      assert JD::Request::Collection::ContributionDefinitions
+    end
+
+    it 'loads Request::Collection::Organizations' do
+      assert JD::Request::Collection::Organizations
+    end
+
+    it 'loads Request::Collection::Fields' do
+      assert JD::Request::Collection::Fields
+    end
+
+    it 'loads Request::Collection::Flags' do
+      assert JD::Request::Collection::Flags
+    end
+  end
+end

data/test/lib/my_john_deere_api/request/create/asset_location_test.rb

@@ -0,0 +1,163 @@
+require 'support/helper'
+require 'date'
+
+describe 'MyJohnDeereApi::Request::Create::AssetLocation' do
+  def attributes_without(*keys)
+    keys = keys.to_a
+    attributes.reject{|k,v| keys.include?(k)}
+  end
+
+  let(:valid_attributes) do
+    CONFIG.asset_location_attributes.merge(
+      asset_id: asset_id
+    )
+  end
+
+  let(:attributes) { valid_attributes }
+
+  let(:klass) { JD::Request::Create::AssetLocation }
+  let(:object) { klass.new(client, attributes) }
+
+  inherits_from MyJohnDeereApi::Request::Create::Base
+
+  describe '#initialize(client, attributes)' do
+    it 'accepts a client and attributes' do
+      assert_equal client, object.client
+      assert_equal accessor, object.accessor
+      assert_equal attributes, object.attributes
+    end
+
+    it 'accepts simple coordinates and generates the geometry' do
+      attributes = {
+        asset_id: asset_id,
+        timestamp: valid_attributes[:timestamp],
+        coordinates: CONFIG.coordinates,
+        measurement_data: valid_attributes[:measurement_data]
+      }
+
+      object = klass.new(client, attributes)
+      assert_equal valid_attributes[:geometry].to_json, object.attributes[:geometry]
+    end
+
+    it 'defaults timestamp to current time' do
+      attributes = valid_attributes.slice(:asset_id, :geometry, :measurement_data)
+      object = klass.new(client, attributes)
+
+      expected_stamp = Time.now.utc.to_i
+      actual_stamp = DateTime.parse(object.attributes[:timestamp]).to_time.to_i
+
+      assert_in_delta expected_stamp, actual_stamp, 1
+    end
+  end
+
+  describe '#valid?' do
+    it 'returns true when all required attributes are present' do
+      assert object.valid?
+      assert_empty object.errors
+    end
+
+    it 'requires asset_id' do
+      object = klass.new(client, attributes_without(:asset_id))
+
+      refute object.valid?
+      assert_equal 'is required', object.errors[:asset_id]
+    end
+
+    it 'requires geometry' do
+      object = klass.new(client, attributes_without(:geometry))
+
+      refute object.valid?
+      assert_equal 'is required', object.errors[:geometry]
+    end
+
+    it 'requires measurement_data' do
+      object = klass.new(client, attributes_without(:measurement_data))
+
+      refute object.valid?
+      assert_equal 'is required', object.errors[:measurement_data]
+    end
+
+    describe 'validating measurement_data' do
+      it 'must be an array' do
+        object = klass.new(client, attributes.merge(measurement_data: 'something'))
+
+        refute object.valid?
+        assert_equal 'must be an array', object.errors[:measurement_data]
+      end
+
+      it 'must include a name' do
+        without_attr = [attributes[:measurement_data].first.reject{|k,v| k == :name}]
+        object = klass.new(client, attributes.merge(measurement_data: without_attr))
+
+        refute object.valid?
+        assert_equal 'must include name', object.errors[:measurement_data]
+      end
+
+      it 'must include a value' do
+        without_attr = [attributes[:measurement_data].first.reject{|k,v| k == :value}]
+        object = klass.new(client, attributes.merge(measurement_data: without_attr))
+
+        refute object.valid?
+        assert_equal 'must include value', object.errors[:measurement_data]
+      end
+
+      it 'must include a unit' do
+        without_attr = [attributes[:measurement_data].first.reject{|k,v| k == :unit}]
+        object = klass.new(client, attributes.merge(measurement_data: without_attr))
+
+        refute object.valid?
+        assert_equal 'must include unit', object.errors[:measurement_data]
+      end
+    end
+  end
+
+  describe '#validate!' do
+    it 'raises an error when invalid' do
+      object = klass.new(client, attributes_without(:asset_id))
+
+      exception = assert_raises(JD::InvalidRecordError) { object.validate! }
+      assert_includes exception.message, 'Record is invalid'
+      assert_includes exception.message, 'asset_id is required'
+    end
+  end
+
+  describe '#request_body' do
+    it 'properly forms the request body' do
+      body = object.send(:request_body)
+
+      expected_stamp = DateTime.parse(attributes[:timestamp]).strftime('%Y-%m-%dT%H:%M:%S.000Z')
+
+      assert_kind_of Array, body
+      assert_equal expected_stamp, body.first[:timestamp]
+      assert_equal attributes[:geometry], body.first[:geometry]
+      assert_equal attributes[:measurement_data], body.first[:measurementData]
+    end
+  end
+
+  describe '#request' do
+    it 'makes the request' do
+      VCR.use_cassette('post_asset_locations') { object.request }
+
+      assert_kind_of Net::HTTPCreated, object.response
+    end
+  end
+
+  describe '#object' do
+    it 'returns the asset location model instance' do
+      result = VCR.use_cassette('post_asset_locations') { object.object }
+
+      assert_kind_of JD::Model::AssetLocation, result
+
+      # API returns seconds with decimals, even though they're always zero
+      integer_stamp = DateTime.parse(result.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
+      result_measurement_data = result.measurement_data.first.transform_keys{|k| k.to_sym}.slice(:name, :value, :unit)
+
+      assert_equal expected_stamp, integer_stamp
+      assert_equal attributes[:geometry], result.geometry.to_json
+      assert_equal attributes[:measurement_data].first, result_measurement_data
+    end
+  end
+end

data/test/lib/my_john_deere_api/request/create/asset_test.rb

@@ -0,0 +1,182 @@
+require 'support/helper'
+
+describe 'MyJohnDeereApi::Request::Create::Asset' do
+  def attributes_without(*keys)
+    keys = keys.to_a
+    attributes.reject{|k,v| keys.include?(k)}
+  end
+
+  let(:valid_attributes) do
+    CONFIG.asset_attributes.merge(
+      organization_id: organization_id,
+    )
+  end
+
+  let(:klass) { JD::Request::Create::Asset }
+  let(:object) { klass.new(client, attributes) }
+
+  let(:attributes) { valid_attributes }
+
+  inherits_from MyJohnDeereApi::Request::Create::Base
+
+  describe '#initialize(client, attributes)' do
+    it 'accepts a client and attributes' do
+      assert_equal client, object.client
+      assert_equal accessor, object.accessor
+      assert_equal attributes, object.attributes
+    end
+  end
+
+  describe '#valid?' do
+    it 'returns true when all required attributes are present' do
+      assert object.valid?
+      assert_empty object.errors
+    end
+
+    it 'requires organization_id' do
+      object = klass.new(client, attributes_without(:organization_id))
+
+      refute object.valid?
+      assert_equal 'is required', object.errors[:organization_id]
+    end
+
+    it 'requires title' do
+      object = klass.new(client, attributes_without(:title))
+
+      refute object.valid?
+      assert_equal 'is required', object.errors[:title]
+    end
+
+    it 'requires a valid category' do
+      object = klass.new(client, attributes.merge(asset_category: 'TURTLES'))
+
+      refute object.valid?
+      assert_equal 'requires valid combination of category/type/subtype', object.errors[:asset_category]
+    end
+
+    it 'requires a valid type' do
+      object = klass.new(client, attributes.merge(asset_type: 'TURTLES'))
+
+      refute object.valid?
+      assert_equal 'requires valid combination of category/type/subtype', object.errors[:asset_category]
+    end
+
+    it 'requires a valid subtype' do
+      object = klass.new(client, attributes.merge(asset_sub_type: 'TURTLES'))
+
+      refute object.valid?
+      assert_equal 'requires valid combination of category/type/subtype', object.errors[:asset_category]
+    end
+  end
+
+  describe '#validate!' do
+    it 'raises an error when invalid' do
+      object = klass.new(client, attributes_without(:organization_id))
+
+      exception = assert_raises(JD::InvalidRecordError) { object.validate! }
+      assert_includes exception.message, 'Record is invalid'
+      assert_includes exception.message, 'organization_id is required'
+    end
+  end
+
+  describe '#valid_categories?(category, type, subtype)' do
+    it 'only allows pre-defined combinations' do
+      object = klass.new(client, {})
+
+      valid_combos = [
+        ['DEVICE', 'SENSOR', 'ENVIRONMENTAL'],
+        ['DEVICE', 'SENSOR', 'GRAIN_BIN'],
+        ['DEVICE', 'SENSOR', 'IRRIGATION_PIVOT'],
+        ['DEVICE', 'SENSOR', 'OTHER'],
+        ['EQUIPMENT', 'MACHINE', 'PICKUP_TRUCK'],
+        ['EQUIPMENT', 'MACHINE', 'UTILITY_VEHICLE'],
+        ['EQUIPMENT', 'OTHER', 'ANHYDROUS_AMMONIA_TANK'],
+        ['EQUIPMENT', 'OTHER', 'NURSE_TRUCK'],
+        ['EQUIPMENT', 'OTHER', 'NURSE_WAGON'],
+        ['EQUIPMENT', 'OTHER', 'TECHNICIAN_TRUCK']
+      ]
+
+      # cycle through all possible permutations, only proving valid if
+      # listed above
+
+      ['DEVICE', 'EQUIPMENT', 'RANDOM_INVALID'].each do |category|
+        ['MACHINE', 'OTHER', 'SENSOR', 'RANDOM_INVALID'].each do |type|
+          [
+            'ANHYDROUS_AMMONIA_TANK', 'ENVIRONMENTAL', 'GRAIN_BIN',
+            'IRRIGATION_PIVOT', 'NURSE_TRUCK', 'NURSE_WAGON',
+            'OTHER', 'PICKUP_TRUCK', 'TECHNICIAN_TRUCK',
+            'UTILITY_VEHICLE', 'RANDOM_INVALID'
+          ].each do |subtype|
+            if valid_combos.include?([category, type, subtype])
+              assert object.send(:valid_categories?, category, type, subtype)
+            else
+              refute object.send(:valid_categories?, category, type, subtype)
+            end
+          end
+        end
+      end
+    end
+  end
+
+  describe '#resource' do
+    it 'is built from the organization id' do
+      object = klass.new(client, attributes)
+      assert_equal "/organizations/#{organization_id}/assets", object.send(:resource)
+    end
+  end
+
+  describe '#request_body' do
+    it 'properly forms the request body' do
+      object = klass.new(client, attributes)
+      body = object.send(:request_body)
+
+      assert_equal attributes[:title], body[:title]
+      assert_equal attributes[:asset_category], body[:assetCategory]
+      assert_equal attributes[:asset_type], body[:assetType]
+      assert_equal attributes[:asset_sub_type], body[:assetSubType]
+
+      assert_kind_of Array, body[:links]
+      assert_equal 1, body[:links].size
+
+      assert_kind_of Hash, body[:links].first
+      assert_equal 'Link', body[:links].first['@type']
+      assert_equal 'contributionDefinition', body[:links].first['rel']
+      assert_equal  "#{base_url}/contributionDefinitions/#{contribution_definition_id}",
+                    body[:links].first['uri']
+    end
+
+    it 'raises an exception when contribution_definition_id is not set' do
+      client.contribution_definition_id = nil
+      object = klass.new(client, attributes)
+
+      assert_raises(JD::MissingContributionDefinitionIdError) do
+        object.send(:request_body)
+      end
+    end
+  end
+
+  describe '#request' do
+    it 'makes the request' do
+      VCR.use_cassette('post_assets') { object.request }
+
+      assert_kind_of Net::HTTPCreated, object.response
+    end
+  end
+
+  describe '#object' do
+    it 'returns the asset model instance' do
+      object = klass.new(client, attributes)
+      result = VCR.use_cassette('post_assets') { object.object }
+
+      assert_kind_of JD::Model::Asset, result
+
+      expected_id = object.response['location'].split('/').last
+
+      assert_equal expected_id, result.id
+      assert_equal attributes[:title], result.title
+      assert_equal attributes[:asset_category], result.asset_category
+      assert_equal attributes[:asset_type], result.asset_type
+      assert_equal attributes[:asset_sub_type], result.asset_sub_type
+    end
+  end
+end

data/test/lib/my_john_deere_api/request/create/base_test.rb

@@ -0,0 +1,29 @@
+require 'support/helper'
+
+describe 'MyJohnDeereApi::Request::Create::Base' do
+  let(:klass) { JD::Request::Create::Base }
+  let(:attributes) { {} }
+
+  describe '#initialize(client, attributes)' do
+    it 'accepts a client and attributes' do
+      object = klass.new(client, attributes)
+
+      assert_equal client, object.client
+      assert_equal accessor, object.accessor
+      assert_equal attributes, object.attributes
+    end
+  end
+
+  describe '#headers' do
+    it 'sets the accept and content-type headers' do
+      object = klass.new(client, attributes)
+      headers = object.send(:headers)
+
+      expected = 'application/vnd.deere.axiom.v3+json'
+
+      assert_kind_of Hash, headers
+      assert_equal expected, headers['Accept']
+      assert_equal expected, headers['Content-Type']
+    end
+  end
+end

data/test/lib/my_john_deere_api/request/create_test.rb

@@ -0,0 +1,17 @@
+require 'support/helper'
+
+describe 'MyJohnDeereApi::Request::Create' do
+  describe 'loading dependencies' do
+    it 'loads Request::Create::Base' do
+      assert JD::Request::Create::Base
+    end
+
+    it 'loads Request::Create::Asset' do
+      assert JD::Request::Create::Asset
+    end
+
+    it 'loads Request::Create::AssetLocation' do
+      assert JD::Request::Create::AssetLocation
+    end
+  end
+end

data/test/lib/my_john_deere_api/request/individual/asset_test.rb

@@ -0,0 +1,33 @@
+require 'support/helper'
+require 'yaml'
+require 'json'
+
+describe 'MyJohnDeereApi::Request::Individual::Asset' do
+  let(:object) { JD::Request::Individual::Asset.new(client, asset_id) }
+
+  inherits_from JD::Request::Individual::Base
+
+  describe '#initialize(client, asset_id)' do
+    it 'accepts a client' do
+      assert_equal client, object.client
+      assert_equal accessor, object.accessor
+    end
+
+    it 'accepts asset_id as id' do
+      assert_equal asset_id, object.id
+    end
+  end
+
+  describe '#resource' do
+    it 'returns /assets/<asset_id>' do
+      assert_equal "/assets/#{asset_id}", object.resource
+    end
+  end
+
+  describe '#object' do
+    it 'returns all records' do
+      asset = VCR.use_cassette('get_asset') { object.object }
+      assert_kind_of JD::Model::Asset, asset
+    end
+  end
+end