artirix_data_models 0.7.5 → 0.8.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 820fdbf70691b6242e145718cc37914b07b629a5
-  data.tar.gz: b85426c590cd8760348f14a0d31a8f77d4fc143c
+  metadata.gz: 2359922337aa2624392a98ae869724c2a3afa640
+  data.tar.gz: ec9c7dfcc6fe58d603176940e0e0e4f39314fc41
 SHA512:
-  metadata.gz: 2ecbfa86d86bbda5bc24960a1577f3c1040b90ba2196c85761f8641babf58a8a43fe34b093b8e1d39aedb1de7c6d81c46bf9f88c70c64ec05e22d6e0126d110c
-  data.tar.gz: c7915a3de805272c8562f6d843f562873240be251f278723e9e61935bb4dffd54159d4d806ab494a1b846bb1b12723631dc53363e5df7a64d1b3681e68c93b0e
+  metadata.gz: 08cce0d7e14055cc719a79a202266becd424dc9a53689e00c45d788531bd9928f6880a597f28fd9b8c91cf780f33daab2fafefb713c83edfe421b90355046eb9
+  data.tar.gz: b68d7c20dc2741561c482917edd897abd97bb80d8bc77d0e9a9a27790a855ca3625657d38a271fa76a12dfa633ba53d0c17039e5f5f8195a4f24524dcde792e9

data/README.md

@@ -250,6 +250,17 @@ end
 
 ## Changes
 
+### 0.8.3
+
+- `DataGateway` refactor, plus adding `put` and `delete` support.
+- `BasicModelDAO` with `_put` and `_delete` support.
+- adding gateway mock helpers for `post`, `put` and `delete`, and adapting them to the new behaviour
+- including `ArtirixDataModels::Model::PublicWriters` after `ArtirixDataModels::Model::Attributes` (or after `ArtirixDataModels::Model` or `ArtirixDataModels::Model::OnlyData`) and before calling `attribute` method to make attribute writers public.
+
+### ~0.8.0~, ~0.8.1~, ~0.8.2~ (YANKED)
+
+Yanked because of the gateway mock helpers were missing an option, which made them not mocking properly. (moved all to `0.8.3`)
+
 ### 0.7.5
 
 - `FakeResponseFactory` using given `_score` if > 0.
@@ -278,6 +289,10 @@ end
 - changed classes to stop inheriting from `Struct`, had some problems with inheritance.
 - `Aggregation`, `Aggregation::Value` and `MetricAggregation` now using the same inspection as models.
 
+### ~0.7.0~ (YANKED)
+
+Yanked because of bug on Aggregations. Released 0.7.1 with the fix. Changeset moved too to 0.7.1 
+
 ### 0.6.7
 
 - aggregations use `key_as_string` as name of the bucket value if it exists, if not then it uses `key` and if that also does not exist then it uses `name`
@@ -301,26 +316,7 @@ end
 - Fix in EsCollection's aggregation parsing (nested + single from RAW now work ok)
 - `SortedBucketAggregationBase` introduced. now `ArtirixDataModels::AggregationsFactory.sorted_aggregation_class_based_on_index_on(index_array)` available to create a class for Aggregations which will sort the buckets based on the position of the elements on a given array.
 
-### 0.6.2
-
-*Fixed Breaking Change*: removal of `Aggregation.from_json` static method. Now back but delegating to default factory method is `aggregation_factory.aggregation_from_json` in the Aggregation Factory *instance*.
-
-- EsCollection's aggregations can now be build based on raw ElasticSearch responses, including nested aggregations. It ignores any aggregation that does not have "buckets", so that nested aggs for `global` or `filtered` are skipped and only the ones with real data are used. (TODO: write docs. In the mean time, have a look at the specs).
-- added `aggregation` method to `Aggregation::Value` class, and also the aggs to the `data_hash` if they are present.
-
-### 0.5.0
-
-- opening gem as is to the public.
-- still a lot of TODOs in the documentation
-
-
-## Yanked versions
-
-### ~0.7.0~
-
-Yanked because of bug on Aggregations. Released 0.7.1 with the fix. Changeset moved too to 0.7.1 
-
-### ~0.6.3~
+### ~0.6.3~ (YANKED)
 
 Yanked because of typo bug on SortedBucketAggregationBase. Released 0.6.3.1 with the fix.
 
@@ -328,15 +324,27 @@ Yanked because of typo bug on SortedBucketAggregationBase. Released 0.6.3.1 with
 - Fix in EsCollection's aggregation parsing (nested + single from RAW now work ok)
 - `SortedBucketAggregationBase` introduced. now `ArtirixDataModels::AggregationsFactory.sorted_aggregation_class_based_on_index_on(index_array)` available to create a class for Aggregations which will sort the buckets based on the position of the elements on a given array.
 
+### 0.6.2
+
+*Fixed Breaking Change*: removal of `Aggregation.from_json` static method. Now back but delegating to default factory method is `aggregation_factory.aggregation_from_json` in the Aggregation Factory *instance*.
+
+- EsCollection's aggregations can now be build based on raw ElasticSearch responses, including nested aggregations. It ignores any aggregation that does not have "buckets", so that nested aggs for `global` or `filtered` are skipped and only the ones with real data are used. (TODO: write docs. In the mean time, have a look at the specs).
+- added `aggregation` method to `Aggregation::Value` class, and also the aggs to the `data_hash` if they are present.
 
-### ~0.6.1~
+### ~0.6.1~ (YANKED)
 
 Yanked because of breaking change introduction: removal of `Aggregation.from_json` method
 
 - added `aggregation` method to `Aggregation::Value` class, and also the aggs to the `data_hash` if they are present.
 
-### ~v0.6.0~
+### ~v0.6.0~ (YANKED)
 
 Yanked because of breaking change introduction: removal of `Aggregation.from_json` method
 
 - EsCollection's aggregations can now be build based on raw ElasticSearch responses, including nested aggregations. It ignores any aggregation that does not have "buckets", so that nested aggs for `global` or `filtered` are skipped and only the ones with real data are used. (TODO: write docs. In the mean time, have a look at the specs).
+
+### 0.5.0
+
+- opening gem as is to the public.
+- still a lot of TODOs in the documentation
+

data/lib/artirix_data_models/daos/basic_model_dao.rb

@@ -124,6 +124,14 @@ class ArtirixDataModels::BasicModelDAO
     gateway.post path, response_adaptor: response_adaptor, body: body, fake: fake?, fake_response: fake_response, cache_adaptor: cache_adaptor
   end
 
+  def _put(path, response_adaptor: nil, body: nil, fake_response: nil, cache_adaptor: nil)
+    gateway.put path, response_adaptor: response_adaptor, body: body, fake: fake?, fake_response: fake_response, cache_adaptor: cache_adaptor
+  end
+
+  def _delete(path, response_adaptor: nil, body: nil, fake_response: nil, cache_adaptor: nil)
+    gateway.delete path, response_adaptor: response_adaptor, body: body, fake: fake?, fake_response: fake_response, cache_adaptor: cache_adaptor
+  end
+
   def fake?
     return true if forced_fake_enabled?
     return false if forced_fake_disabled?

data/lib/artirix_data_models/gateways/data_gateway.rb

@@ -6,87 +6,93 @@ class ArtirixDataModels::DataGateway
     @post_as_json = !!post_as_json
   end
 
-  def get(path, response_adaptor: nil, body: nil, fake: false, fake_response: nil, cache_adaptor: nil, **ignored_options)
-    if fake
-      response_body = fake_response
-    elsif cache_adaptor.present?
-      response_body = cache_adaptor.call { perform_get(path, body) }
-    else
-      response_body = perform_get(path, body)
-    end
-    parse_get_response(response_body, response_adaptor)
+  def get(path, **opts)
+    call :get, path, **opts
+  end
+
+  def post(path, **opts)
+    call :post, path, **opts
+  end
+
+  def put(path, **opts)
+    call :put, path, **opts
+  end
+
+  def delete(path, **opts)
+    call :delete, path, **opts
   end
 
-  def post(path, response_adaptor: nil, body: nil, fake: false, fake_response: nil, **ignored_options)
+  def call(method, path, json_body: true, response_adaptor: nil, body: nil, fake: false, fake_response: nil, cache_adaptor: nil, **_ignored_options)
     if fake
       response_body = fake_response
+    elsif cache_adaptor.present?
+      response_body = cache_adaptor.call { perform(method, path, body, json_body) }
     else
-      response_body = perform_post(path, body)
+      response_body = perform(method, path, body, json_body)
     end
-    parse_post_response(response_body, response_adaptor)
+    parse_response(response_body, response_adaptor)
   end
 
   private
 
-  def perform_get(path, body = nil)
-    response = connect_get(path, body)
-    if response.success?
-      response.body
-    elsif response.status.to_i == 404
-      raise NotFound, path
-    else
-      raise GatewayError, "method: get, path: #{path}, status: #{response.status}, body: #{response.body}"
-    end
+  def perform_get(path, body = nil, json_body = true)
+    perform :get, path, body, json_body
   end
 
-  def perform_post(path, body = nil)
-    response = connect_post(path, body)
-    if response.success?
-      response.body
-    elsif response.status.to_i == 404
-      raise NotFound, path
-    else
-      raise GatewayError, "method: post, path: #{path}, status: #{response.status}, body: #{response.body}"
-    end
+  def perform_post(path, body = nil, json_body = true)
+    perform :post, path, body, json_body
   end
 
-  def connect_get(path, body)
-    connection.get path do |req|
-      req.body = body_to_json body unless body.nil?
-    end
-  rescue Faraday::ConnectionFailed => e
-    raise ConnectionError, "method: get, path: #{path}, error: #{e}"
+  def perform_put(path, body = nil, json_body = true)
+    perform :put, path, body, json_body
+  end
+
+  def perform_delete(path, body = nil, json_body = true)
+    perform :delete, path, body, json_body
   end
 
-  def connect_post(path, body)
-    connection.post path do |req|
+  def perform(method, path, body = nil, json_body = true)
+    response = connect(method, path, body, json_body)
+    treat_response(response, method, path)
+  end
+
+  def connect(method, path, body = nil, json_body = true)
+    # binding.pry if method == :delete
+    connection.send(method, path) do |req|
+      # binding.pry if method == :delete
       unless body.nil?
-        req.body = body_to_json body
-        req.headers['Content-Type'] = 'application/json'
+        if json_body
+          req.body                    = body_to_json body
+          req.headers['Content-Type'] = 'application/json'
+        else
+          req.body = body
+        end
       end
     end
   rescue Faraday::ConnectionFailed => e
-    raise ConnectionError, "method: post, path: #{path}, error: #{e}"
+    raise ConnectionError, "method: #{method}, path: #{path}, error: #{e}"
   end
 
-  def body_to_json(body)
-    case body
-      when String
-        body
-      else
-        body.to_json
+  def treat_response(response, method, path)
+    if response.success?
+      response.body
+    elsif response.status.to_i == 404
+      raise NotFound, path
+    else
+      raise GatewayError, "method: #{method}, path: #{path}, status: #{response.status}, body: #{response.body}"
     end
   end
 
-  def parse_post_response(result, response_adaptor)
-    parse_common_response(result, response_adaptor)
-  end
-
-  def parse_get_response(result, response_adaptor)
-    parse_common_response(result, response_adaptor)
+  def body_to_json(body)
+    case body
+    when String
+      body
+    else
+      body.to_json
+    end
   end
 
-  def parse_common_response(result, response_adaptor)
+  def parse_response(result, response_adaptor)
     if result.present?
       parsed_response = Oj.load result, symbol_keys: true
     else

data/lib/artirix_data_models/model.rb

@@ -51,6 +51,14 @@ module ArtirixDataModels
       end
     end
 
+    module PublicWriters
+      extend ActiveSupport::Concern
+
+      included do
+        include Attributes::PublicWriters
+      end
+    end
+
     module WithBaseEntity
       extend ActiveSupport::Concern
 
@@ -144,6 +152,15 @@ module ArtirixDataModels
           child_class.attribute_config.parent_attribute_config = attribute_config
         end
 
+        def writer_visibility
+          @writer_visibility ||= :private
+        end
+
+        def writer_visibility=(visibility)
+          raise InvalidArgumentError, "Invalid visibility #{visibility.inspect}" unless [:public, :private, :protected].include? visibility
+          @writer_visibility = visibility
+        end
+
         private
         def _define_attribute(attribute)
           at = attribute.to_sym
@@ -157,7 +174,14 @@ module ArtirixDataModels
         def _define_writer(attribute)
           attr_writer attribute
           writer = "#{attribute}="
-          private writer
+
+          if writer_visibility == :private
+            private writer
+          elsif writer_visibility == :protected
+            protected writer
+          end
+
+          writer
         end
 
         def _define_presence(attribute)
@@ -186,6 +210,13 @@ module ArtirixDataModels
         end
       end
 
+      module PublicWriters
+        extend ActiveSupport::Concern
+        included do
+          self.writer_visibility = :public
+        end
+      end
+
       module OnlyData
         # return nil as it is, we do not have DAO for an OnlyData model
         def nil_attribute(_)

data/lib/artirix_data_models/spec_support/gateway_mock.rb

@@ -11,16 +11,63 @@ def given_gateway_config(connection_url = nil)
   end
 end
 
-def mock_gateway_get_response(response:, path:, body: nil, gateway: nil)
+
+def mock_gateway_response(response:, method:, path:, body: nil, json_body: true, gateway: nil)
   gateway ||= ArtirixDataModels::DAORegistry.gateway
+  allow(gateway).to receive(:perform).with(method, path, body, json_body).and_return response
 
-  allow(gateway).to receive(:perform_get).with(path, body).and_return response
+  # check with body already parsed
+  unless body.nil?
+    body = body.kind_of?(String) ? body : body.to_json
+    allow(gateway).to receive(:perform).with(method, path, body, json_body).and_return response
+  end
 end
 
-def mock_gateway_get_not_found_response(path:, body: nil, gateway: nil)
+def mock_gateway_not_found_response(method:, path:, body: nil, json_body: true, gateway: nil)
   gateway ||= ArtirixDataModels::DAORegistry.gateway
+  allow(gateway).to receive(:perform).with(method, path, body, json_body).and_raise ArtirixDataModels::DataGateway::NotFound
+
+  # check with body already parsed
+  unless body.nil?
+    body = body.kind_of?(String) ? body : body.to_json
+    allow(gateway).to receive(:perform).with(method, path, body, json_body).and_raise ArtirixDataModels::DataGateway::NotFound
+  end
+end
+
+# GET
+def mock_gateway_get_response(**params)
+  mock_gateway_response method: :get, **params
+end
+
+def mock_gateway_get_not_found_response(**params)
+  mock_gateway_not_found_response method: :get, **params
+end
+
+# POST
+def mock_gateway_post_response(**params)
+  mock_gateway_response method: :post, **params
+end
+
+def mock_gateway_post_not_found_response(**params)
+  mock_gateway_not_found_response method: :post, **params
+end
+
+# PUT
+def mock_gateway_put_response(**params)
+  mock_gateway_response method: :put, **params
+end
+
+def mock_gateway_put_not_found_response(**params)
+  mock_gateway_not_found_response method: :put, **params
+end
+
+# DELETE
+def mock_gateway_delete_response(**params)
+  mock_gateway_response method: :delete, **params
+end
 
-  allow(gateway).to receive(:perform_get).with(path, body).and_raise ArtirixDataModels::DataGateway::NotFound
+def mock_gateway_delete_not_found_response(**params)
+  mock_gateway_not_found_response method: :delete, **params
 end
 
 # :nocov:

data/lib/artirix_data_models/version.rb

@@ -1,3 +1,3 @@
 module ArtirixDataModels
-  VERSION = '0.7.5'
+  VERSION = '0.8.3'
 end

data/spec/artirix_data_models/gateways/data_gateway_spec.rb

@@ -48,7 +48,7 @@ RSpec.describe ArtirixDataModels::DataGateway, type: :model do
     Given(:connection_stubs) { Faraday::Adapter::Test::Stubs.new }
     Given(:connection) do
       Faraday.new(url: connection_url, request: { params_encoder: Faraday::FlatParamsEncoder }) do |faraday|
-        faraday.request :url_encoded # form-encode POST params
+        faraday.request :url_encoded # form-encode without body only path params
         faraday.response :logger # log requests to STDOUT
         faraday.adapter :test, connection_stubs
       end
@@ -101,6 +101,18 @@ RSpec.describe ArtirixDataModels::DataGateway, type: :model do
         connection_stubs.post(path_to_fail) { |env| [500, {}, ''] }
         connection_stubs.post(path_to_be_bad_json) { |env| [200, {}, 'oh yeah'] }
         connection_stubs.post(path_to_be_empty) { |env| [200, {}, ''] }
+
+        # stub put
+        connection_stubs.put(path_to_be_not_found) { |env| [404, {}, ''] }
+        connection_stubs.put(path_to_fail) { |env| [500, {}, ''] }
+        connection_stubs.put(path_to_be_bad_json) { |env| [200, {}, 'oh yeah'] }
+        connection_stubs.put(path_to_be_empty) { |env| [200, {}, ''] }
+
+        # stub put
+        connection_stubs.delete(path_to_be_not_found) { |env| [404, {}, ''] }
+        connection_stubs.delete(path_to_fail) { |env| [500, {}, ''] }
+        connection_stubs.delete(path_to_be_bad_json) { |env| [200, {}, 'oh yeah'] }
+        connection_stubs.delete(path_to_be_empty) { |env| [200, {}, ''] }
       end
 
       describe '#get' do
@@ -236,6 +248,132 @@ RSpec.describe ArtirixDataModels::DataGateway, type: :model do
           end
         end
       end
+
+      describe '#put' do
+        context 'without body' do
+          Given do
+            connection_stubs.put(path, nil) do |env|
+              [200, {}, response_string]
+            end
+          end
+
+          context 'when failure (500 error)' do
+            When(:result) { gateway.put path_to_fail }
+            Then { result == Failure(ArtirixDataModels::DataGateway::GatewayError) }
+          end
+
+          context 'when not found (404 error)' do
+            When(:result) { gateway.put path_to_be_not_found }
+            Then { result == Failure(ArtirixDataModels::DataGateway::NotFound) }
+          end
+
+          context 'when receiving bad json' do
+            When(:result) { gateway.put path_to_be_bad_json }
+            Then { result == Failure(ArtirixDataModels::DataGateway::ParseError) }
+          end
+
+          context 'when receiving empty response' do
+            When(:result) { gateway.put path_to_be_empty }
+            Then { result.nil? }
+          end
+
+          context 'only path given -> return parsed response (JSON -> Hash)' do
+            When(:result) { gateway.put path }
+            Then { result == response_hash }
+          end
+
+          context 'with adaptor -> call the adaptor with the parsed response (JSON -> Hash -> AdaptedObject)' do
+            Given(:model_class) do
+              Class.new do
+                attr_reader :data
+
+                def initialize(data)
+                  @data = { given: data }
+                end
+              end
+            end
+
+            Given(:adaptor) { ArtirixDataModels::GatewayResponseAdaptors::ModelAdaptor.single model_class }
+
+            When(:result) { gateway.get path, response_adaptor: adaptor }
+            Then { result.class == model_class }
+            And { result.data == { given: response_hash } }
+          end
+
+        end
+        context 'with body', focus: true do
+          Given(:body) { test_hash }
+          Given(:body_json) { body.to_json }
+
+          Given do
+            connection_stubs.put(path, body_json, { 'Content-Type' => 'application/json' }) do
+              response_body = response_string_with_body.call(body_json)
+              [200, {}, response_body]
+            end
+          end
+
+          context 'STRING body => use body as is' do
+            When(:result) { gateway.put path, body: body_json }
+            Then { result == { body: test_hash } }
+          end
+
+          context 'object (or hash) body => use body.to_json' do
+            When(:result) { gateway.put path, body: body }
+            Then { result == { body: test_hash } }
+          end
+        end
+      end
+
+      describe '#delete' do
+        Given do
+          connection_stubs.delete(path) do |env|
+            [200, {}, response_string]
+          end
+        end
+
+        context 'when failure (500 error)' do
+          When(:result) { gateway.delete path_to_fail }
+          Then { result == Failure(ArtirixDataModels::DataGateway::GatewayError) }
+        end
+
+        context 'when not found (404 error)' do
+          When(:result) { gateway.delete path_to_be_not_found }
+          Then { result == Failure(ArtirixDataModels::DataGateway::NotFound) }
+        end
+
+        context 'when receiving bad json' do
+          When(:result) { gateway.delete path_to_be_bad_json }
+          Then { result == Failure(ArtirixDataModels::DataGateway::ParseError) }
+        end
+
+        context 'when receiving empty response' do
+          When(:result) { gateway.delete path_to_be_empty }
+          Then { result.nil? }
+        end
+
+        context 'only path given -> return parsed response (JSON -> Hash)' do
+          When(:result) { gateway.delete path }
+          Then { result == response_hash }
+        end
+
+        context 'with adaptor -> call the adaptor with the parsed response (JSON -> Hash -> AdaptedObject)' do
+          Given(:model_class) do
+            Class.new do
+              attr_reader :data
+
+              def initialize(data)
+                @data = { given: data }
+              end
+            end
+          end
+
+          Given(:adaptor) { ArtirixDataModels::GatewayResponseAdaptors::ModelAdaptor.single model_class }
+
+          When(:result) { gateway.delete path, response_adaptor: adaptor }
+          Then { result.class == model_class }
+          And { result.data == { given: response_hash } }
+        end
+      end
     end
   end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: artirix_data_models
 version: !ruby/object:Gem::Version
-  version: 0.7.5
+  version: 0.8.3
 platform: ruby
 authors:
 - Eduardo Turiño
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-01-14 00:00:00.000000000 Z
+date: 2016-01-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport