3scale_toolbox 0.17.1 → 0.19.0

data/lib/3scale_toolbox/entities.rb

@@ -2,6 +2,9 @@ require '3scale_toolbox/entities/service'
 require '3scale_toolbox/entities/application_plan'
 require '3scale_toolbox/entities/metric'
 require '3scale_toolbox/entities/method'
+require '3scale_toolbox/entities/mapping_rule'
+require '3scale_toolbox/entities/limit'
+require '3scale_toolbox/entities/pricing_rule'
 require '3scale_toolbox/entities/activedocs'
 require '3scale_toolbox/entities/account'
 require '3scale_toolbox/entities/proxy_config'

data/lib/3scale_toolbox/entities/account.rb

@@ -62,7 +62,7 @@ module ThreeScaleToolbox
         end
 
         def generic_find(remote, criteria)
-          account = remote.find_account(criteria)
+          account = remote.find_account(**criteria)
           if (errors = account['errors'])
             raise ThreeScaleToolbox::ThreeScaleApiError.new(
               'Account find returned errors', errors

data/lib/3scale_toolbox/entities/activedocs.rb

@@ -51,6 +51,18 @@ module ThreeScaleToolbox
         @attrs ||= activedoc_attrs
       end
 
+      def system_name
+        attrs['system_name']
+      end
+
+      def body
+        attrs['body']
+      end
+
+      def name
+        attrs['name']
+      end
+
       def delete
         remote.delete_activedocs id
       end

data/lib/3scale_toolbox/entities/application_plan.rb

@@ -1,6 +1,8 @@
 module ThreeScaleToolbox
   module Entities
     class ApplicationPlan
+      include CRD::ApplicationPlanSerializer
+
       class << self
         def create(service:, plan_attrs:)
           plan = service.remote.create_application_plan service.id, create_plan_attrs(plan_attrs)
@@ -14,15 +16,12 @@ module ThreeScaleToolbox
         # ref can be system_name or service_id
         def find(service:, ref:)
           new(id: ref, service: service).tap(&:attrs)
-        rescue ThreeScale::API::HttpClient::NotFoundError
+        rescue ThreeScaleToolbox::InvalidIdError, ThreeScale::API::HttpClient::NotFoundError
           find_by_system_name(service: service, system_name: ref)
         end
 
         def find_by_system_name(service:, system_name:)
-          plan = service.plans.find { |p| p['system_name'] == system_name }
-          return if plan.nil?
-
-          new(id: plan.fetch('id'), service: service, attrs: plan)
+          service.plans.find { |p| p.system_name == system_name }
         end
 
         def create_plan_attrs(source_attrs)
@@ -49,6 +48,22 @@ module ThreeScaleToolbox
         @attrs ||= read_plan_attrs
       end
 
+      def system_name
+        attrs['system_name']
+      end
+
+      def name
+        attrs['name']
+      end
+
+      def state
+        attrs['state']
+      end
+
+      def custom
+        attrs.fetch('custom', false)
+      end
+
       def update(plan_attrs)
         return attrs if update_plan_attrs(plan_attrs).empty?
 
@@ -78,9 +93,9 @@ module ThreeScaleToolbox
         # b) metrics having limits set with eternity period, but not zero value, must be updated
         # c) metrics not having limits set with eternity period, must be created
 
-        eternity_limits = limits.select { |limit| limit.fetch('period') == 'eternity' }
-        eternity_metric_ids = eternity_limits.map { |limit| limit.fetch('metric_id') }
-        service_metric_ids = service.metrics.map { |metric| metric.fetch('id') }
+        eternity_limits = limits.select { |limit| limit.period == 'eternity' }
+        eternity_metric_ids = eternity_limits.map { |limit| limit.metric_id }
+        service_metric_ids = service.metrics.map { |metric| metric.id }
         metric_ids_without_eternity = service_metric_ids - eternity_metric_ids
 
         # create eternity zero limit for each metric without eternity limit set
@@ -89,16 +104,14 @@ module ThreeScaleToolbox
         end
 
         # update eternity zero limit those metrics already having eternity limit set
-        not_zero_eternity_limits = eternity_limits.reject { |limit| limit.fetch('value').zero? }
+        not_zero_eternity_limits = eternity_limits.reject { |limit| limit.value.zero? }
         not_zero_eternity_limits.each do |limit|
-          update_limit(limit.fetch('metric_id'), limit.fetch('id'), zero_eternity_limit_attrs)
+          limit.update(zero_eternity_limit_attrs)
         end
       end
 
       def enable
-        eternity_zero_limits.each do |limit|
-          delete_limit(limit.fetch('metric_id'), limit.fetch('id'))
-        end
+        eternity_zero_limits.each(&:delete)
       end
 
       def limits
@@ -107,7 +120,9 @@ module ThreeScaleToolbox
           raise ThreeScaleToolbox::ThreeScaleApiError.new('Limits per application plan not read', errors)
         end
 
-        plan_limits
+        plan_limits.map do |limit_attrs|
+          Limit.new(id: limit_attrs.fetch('id'), plan: self, metric_id: limit_attrs.fetch('metric_id'), attrs: limit_attrs)
+        end
       end
 
       def metric_limits(metric_id)
@@ -116,42 +131,15 @@ module ThreeScaleToolbox
         # Already reported. https://issues.jboss.org/browse/THREESCALE-2486
         # Meanwhile, the strategy will be to get all metrics from a given plan
         # and filter by metric_id
-        limits.select { |limit| limit['metric_id'] == metric_id }
+        limits.select { |limit| limit.metric_id == metric_id }
       end
 
       def create_limit(metric_id, limit_attrs)
-        limit = remote.create_application_plan_limit id, metric_id, limit_attrs
-        if (errors = limit['errors'])
-          raise ThreeScaleToolbox::ThreeScaleApiError.new('Limit has not been created', errors)
-        end
-
-        limit
-      end
-
-      def update_limit(metric_id, limit_id, limit_attrs)
-        limit = remote.update_application_plan_limit id, metric_id, limit_id, limit_attrs
-        if (errors = limit['errors'])
-          raise ThreeScaleToolbox::ThreeScaleApiError.new('Limit not updated', errors)
-        end
-
-        limit
-      end
-
-      def delete_limit(metric_id, limit_id)
-        remote.delete_application_plan_limit id, metric_id, limit_id
+        Limit.create(plan: self, metric_id: metric_id, attrs: limit_attrs)
       end
 
       def create_pricing_rule(metric_id, pr_attrs)
-        pricing_rule_attrs = remote.create_pricingrule id, metric_id, pr_attrs
-        if (errors = pricing_rule_attrs['errors'])
-          raise ThreeScaleToolbox::Error, "Pricing rule has not been created. #{errors}"
-        end
-
-        pricing_rule_attrs
-      end
-
-      def delete_pricing_rule(metric_id, rule_id)
-        remote.delete_application_plan_pricingrule(id, metric_id, rule_id)
+        PricingRule.create(plan: self, metric_id: metric_id, attrs: pr_attrs)
       end
 
       def pricing_rules
@@ -161,7 +149,9 @@ module ThreeScaleToolbox
           raise ThreeScaleToolbox::ThreeScaleApiError.new('pricing rules not read', errors)
         end
 
-        pr_list
+        pr_list.map do |pr_attrs|
+          PricingRule.new(id: pr_attrs.fetch('id'), plan: self, metric_id: pr_attrs.fetch('metric_id'), attrs: pr_attrs)
+        end
       end
 
       def features
@@ -203,9 +193,27 @@ module ThreeScaleToolbox
         attrs.fetch('state') == 'published'
       end
 
+      def approval_required?
+        attrs.fetch('approval_required', true)
+      end
+
+      def trial_period_days
+        attrs.fetch('trial_period_days', 0)
+      end
+
+      def setup_fee
+        attrs.fetch('setup_fee', 0.0)
+      end
+
+      def cost_per_month
+        attrs.fetch('cost_per_month', 0.0)
+      end
+
       private
 
       def read_plan_attrs
+        raise ThreeScaleToolbox::InvalidIdError if id.zero?
+
         plan_attrs = remote.show_application_plan service.id, id
         if (errors = plan_attrs['errors'])
           raise ThreeScaleToolbox::ThreeScaleApiError.new('Application plan not read', errors)
@@ -224,7 +232,7 @@ module ThreeScaleToolbox
       end
 
       def eternity_zero_limits
-        limits.select { |limit| zero_eternity_limit_attrs < limit }
+        limits.select { |limit| zero_eternity_limit_attrs < limit.attrs }
       end
 
       def zero_eternity_limit_attrs

data/lib/3scale_toolbox/entities/backend.rb

@@ -1,6 +1,8 @@
 module ThreeScaleToolbox
   module Entities
     class Backend
+      include CRD::BackendSerializer
+
       VALID_PARAMS = %w[name description system_name private_endpoint].freeze
       public_constant :VALID_PARAMS
 
@@ -22,17 +24,45 @@ module ThreeScaleToolbox
         end
 
         def find_by_system_name(remote:, system_name:)
-          list = remote.list_backends
-
-          if list.respond_to?(:has_key?) && (errors = list['errors'])
-            raise ThreeScaleToolbox::ThreeScaleApiError.new('Backend list not read', errors)
+          attrs = list_backends(remote: remote).find do |backend|
+            backend['system_name'] == system_name
           end
-
-          attrs = list.find { |backend| backend['system_name'] == system_name }
           return if attrs.nil?
 
           new(id: attrs.fetch('id'), remote: remote, attrs: attrs)
         end
+
+        private
+
+        def list_backends(remote:)
+          backends_enum(remote: remote).reduce([], :concat)
+        end
+
+        def backends_enum(remote:)
+          Enumerator.new do |yielder|
+            page = 1
+            loop do
+              list = remote.list_backends(
+                page: page,
+                per_page: ThreeScale::API::MAX_BACKENDS_PER_PAGE
+              )
+
+              if list.respond_to?(:has_key?) && (errors = list['errors'])
+                raise ThreeScaleToolbox::ThreeScaleApiError.new('Backend list not read', errors)
+              end
+
+              break if list.nil?
+
+              yielder << list
+
+              # The API response does not tell how many pages there are available
+              # If one page is not fully filled, it means that it is the last page.
+              break if list.length < ThreeScale::API::MAX_BACKENDS_PER_PAGE
+
+              page += 1
+            end
+          end
+        end
       end
 
       attr_reader :id, :remote
@@ -51,14 +81,20 @@ module ThreeScaleToolbox
         attrs['system_name']
       end
 
-      def metrics
-        # cache result to reuse
-        metric_and_method_list = metrics_and_methods
-        hits_metric_obj = hits_metric(metric_and_method_list)
+      def description
+        attrs['description']
+      end
 
-        metric_attr_list = ThreeScaleToolbox::Helper.array_difference(metric_and_method_list, methods(hits_metric_obj)) do |item, method|
-          method.id == item.fetch('id', nil)
-        end
+      def name
+        attrs['name']
+      end
+
+      def private_endpoint
+        attrs['private_endpoint']
+      end
+
+      def metrics
+        metric_attr_list = metrics_and_methods.select { |metric_attrs| metric_attrs['parent_id'].nil? }
 
         metric_attr_list.map do |metric_attrs|
           BackendMetric.new(id: metric_attrs.fetch('id'), backend: self, attrs: metric_attrs)
@@ -66,25 +102,24 @@ module ThreeScaleToolbox
       end
 
       def hits
-        hits_metric(metrics_and_methods)
+        metric_list = metrics_and_methods.map do |metric_attrs|
+          BackendMetric.new(id: metric_attrs.fetch('id'), backend: self, attrs: metric_attrs)
+        end
+        metric_list.find { |metric| metric.system_name == 'hits' }.tap do |hits_metric|
+          raise ThreeScaleToolbox::Error, 'missing hits metric' if hits_metric.nil?
+        end
       end
 
       # @api public
-      # @param [Object] parent_metric_id BackendMetric hits object
       # @return [List]
-      def methods(parent_metric_id)
-        return [] if parent_metric_id.nil?
-
-        method_attr_list = remote.list_backend_methods id, parent_metric_id.id
+      def methods
+        method_attr_list = remote.list_backend_methods id, hits.id
         if method_attr_list.respond_to?(:has_key?) && (errors = method_attr_list['errors'])
           raise ThreeScaleToolbox::ThreeScaleApiError.new('Backend methods not read', errors)
         end
 
         method_attr_list.map do |method_attrs|
-          BackendMethod.new(id: method_attrs.fetch('id'),
-                            backend: self,
-                            parent_id: parent_metric_id.id,
-                            attrs: method_attrs)
+          BackendMethod.new(id: method_attrs.fetch('id'), backend: self, attrs: method_attrs)
         end
       end
 
@@ -115,6 +150,13 @@ module ThreeScaleToolbox
         remote.delete_backend id
       end
 
+      # Compute matrics mapping
+      def metrics_mapping(other)
+        (metrics + methods).product(other.metrics + other.methods).select do |m_a, m_b|
+          m_a.system_name == m_b.system_name
+        end.map { |m_a, m_b| [m_a.id, m_b.id] }.to_h
+      end
+
       def ==(other)
         remote.http_client.endpoint == other.remote.http_client.endpoint && id == other.id
       end
@@ -130,13 +172,6 @@ module ThreeScaleToolbox
         m_m
       end
 
-      def hits_metric(metric_attr_list)
-        metric_list = metric_attr_list.map do |metric_attrs|
-          BackendMetric.new(id: metric_attrs.fetch('id'), backend: self, attrs: metric_attrs)
-        end
-        metric_list.find { |metric| metric.system_name == 'hits' }
-      end
-
       def fetch_backend_attrs
         raise ThreeScaleToolbox::InvalidIdError if id.zero?
 

data/lib/3scale_toolbox/entities/backend_mapping_rule.rb

@@ -1,6 +1,8 @@
 module ThreeScaleToolbox
   module Entities
     class BackendMappingRule
+      include CRD::BackendMappingRuleSerializer
+
       VALID_PARAMS = %w[metric_id pattern http_method delta position last].freeze
       public_constant :VALID_PARAMS
 
@@ -32,12 +34,36 @@ module ThreeScaleToolbox
         @attrs ||= mapping_rule_attrs
       end
 
+      def http_method
+        attrs['http_method']
+      end
+
+      def pattern
+        attrs['pattern']
+      end
+
+      def delta
+        attrs['delta']
+      end
+
+      def last
+        attrs['last']
+      end
+
       def metric_id
-        @attrs['metric_id']
+        attrs['metric_id']
+      end
+
+      def pattern
+        attrs['pattern']
+      end
+
+      def http_method
+        attrs['http_method']
       end
 
-      def metric_id=(metric_id)
-        @attrs['metric_id'] = metric_id
+      def delta
+        attrs['delta']
       end
 
       def update(mr_attrs)

data/lib/3scale_toolbox/entities/backend_method.rb

@@ -1,39 +1,40 @@
 module ThreeScaleToolbox
   module Entities
     class BackendMethod
+      include CRD::BackendMethodSerializer
+
       VALID_PARAMS = %w[friendly_name system_name description].freeze
       public_constant :VALID_PARAMS
 
       class << self
-        def create(backend:, parent_id:, attrs:)
-          method = backend.remote.create_backend_method(backend.id, parent_id,
+        def create(backend:, attrs:)
+          method = backend.remote.create_backend_method(backend.id, backend.hits.id,
                                                         Helper.filter_params(VALID_PARAMS, attrs))
           if (errors = method['errors'])
             raise ThreeScaleToolbox::ThreeScaleApiError.new('Backend Method has not been created',
                                                             errors)
           end
 
-          new(id: method.fetch('id'), parent_id: parent_id, backend: backend, attrs: method)
+          new(id: method.fetch('id'), backend: backend, attrs: method)
         end
 
         # ref can be system_name or method_id
-        def find(backend:, parent_id:, ref:)
-          new(id: ref, parent_id: parent_id, backend: backend).tap(&:attrs)
+        def find(backend:, ref:)
+          new(id: ref, backend: backend).tap(&:attrs)
         rescue ThreeScaleToolbox::InvalidIdError, ThreeScale::API::HttpClient::NotFoundError
-          find_by_system_name(backend: backend, parent_id: parent_id, system_name: ref)
+          find_by_system_name(backend: backend, system_name: ref)
         end
 
-        def find_by_system_name(backend:, parent_id:, system_name:)
-          backend.methods(parent_id).find { |m| m.system_name == system_name }
+        def find_by_system_name(backend:, system_name:)
+          backend.methods.find { |m| m.system_name == system_name }
         end
       end
 
-      attr_reader :id, :parent_id, :backend, :remote
+      attr_reader :id, :backend, :remote
 
-      def initialize(id:, parent_id:, backend:, attrs: nil)
+      def initialize(id:, backend:, attrs: nil)
         @id = id.to_i
         @backend = backend
-        @parent_id = parent_id
         @remote = backend.remote
         @attrs = process_attrs(attrs)
       end
@@ -43,15 +44,19 @@ module ThreeScaleToolbox
       end
 
       def system_name
-        @attrs['system_name']
+        attrs['system_name']
       end
 
       def friendly_name
-        @attrs['friendly_name']
+        attrs['friendly_name']
+      end
+
+      def description
+        attrs['description']
       end
 
       def update(m_attrs)
-        new_attrs = remote.update_backend_method(backend.id, parent_id, id,
+        new_attrs = remote.update_backend_method(backend.id, hits_id, id,
                                                  Helper.filter_params(VALID_PARAMS, m_attrs))
         if (errors = new_attrs['errors'])
           raise ThreeScaleToolbox::ThreeScaleApiError.new('Backend Method has not been updated',
@@ -63,11 +68,15 @@ module ThreeScaleToolbox
       end
 
       def delete
-        remote.delete_backend_method backend.id, parent_id, id
+        remote.delete_backend_method backend.id, hits_id, id
       end
 
       private
 
+      def hits_id
+        backend.hits.id
+      end
+
       def process_attrs(metric_attrs)
         return if metric_attrs.nil?
 
@@ -78,7 +87,7 @@ module ThreeScaleToolbox
       def method_attrs
         raise ThreeScaleToolbox::InvalidIdError if id.zero?
 
-        method = remote.backend_method backend.id, parent_id, id
+        method = remote.backend_method backend.id, hits_id, id
         if (errors = method['errors'])
           raise ThreeScaleToolbox::ThreeScaleApiError.new('Backend method not read', errors)
         end