pisoni 1.23.1

data/spec/application_spec.rb

@@ -0,0 +1,188 @@
+require_relative './spec_helper'
+
+module ThreeScale
+  module Core
+    describe Application do
+      describe '.load' do
+        describe 'with an existing application' do
+          before do
+            Application.delete(2001, 8011)
+            Application.save service_id: 2001, id: 8011, state: 'suspended',
+                             plan_id: '3066', plan_name: 'crappy', redirect_url: 'blah'
+          end
+
+          it 'returns an Application object' do
+            Application.load(2001, 8011).class.must_equal Application
+          end
+
+          it 'parses data from received JSON' do
+            application = Application.load(2001, 8011)
+
+            application.service_id.must_equal '2001'
+            application.id.must_equal '8011'
+            application.state.must_equal 'suspended'
+            application.plan_id.must_equal '3066'
+            application.plan_name.must_equal 'crappy'
+            application.redirect_url.must_equal 'blah'
+          end
+        end
+
+        describe 'with a missing application' do
+          it 'returns nil' do
+            Application.load(2001, 7999).must_be_nil
+          end
+        end
+
+        describe 'with a missing service' do
+          it 'returns nil' do
+            Application.load(1999, 8011).must_be_nil
+          end
+        end
+
+        describe 'with both application and service missing' do
+          it 'returns nil' do
+            Application.load(1999, 7999).must_be_nil
+          end
+        end
+      end
+
+      describe '.delete' do
+        before do
+          Application.delete(2001, 8011)
+          Application.save service_id: 2001, id: 8011, state: 'suspended',
+                           plan_id: '3066', plan_name: 'crappy', redirect_url: 'blah'
+        end
+
+        describe 'with an existing application' do
+          it 'returns true when deleting an existing application' do
+            Application.delete(2001, 8011).must_equal true
+          end
+
+          it 'makes it non-existent' do
+            Application.delete(2001, 8011)
+            Application.load(2001, 8011).must_equal nil
+          end
+        end
+
+        describe 'with a non-existing application' do
+          it 'returns false when deleting an application with missing id' do
+            Application.delete(2001, 7999).must_equal false
+          end
+
+          it 'returns false when deleting an application with missing service id' do
+            Application.delete(1999, 8011).must_equal false
+          end
+        end
+      end
+
+      describe '.save' do
+        before do
+          Application.delete(2001, 8011)
+          @app = Application.save service_id: 2001, id: 8011, state: 'suspended',
+                                  plan_id: '3066', plan_name: 'crappy', redirect_url: 'blah'
+        end
+
+        it 'exists' do
+          Application.load(@app.service_id, @app.id).wont_be_nil
+        end
+
+        it 'returns an Application object' do
+          @app.must_be_kind_of Application
+        end
+
+        it 'returns an Application object with correct fields' do
+          @app.id.must_equal '8011'
+          @app.service_id.must_equal '2001'
+          @app.state.must_equal 'suspended'
+          @app.plan_id.must_equal '3066'
+          @app.plan_name.must_equal 'crappy'
+          @app.redirect_url.must_equal 'blah'
+        end
+
+        it 'modifies the application when saving an existing one' do
+          new_app = Application.save service_id: @app.service_id, id: @app.id, state: @app.state,
+                                     plan_id: @app.plan_id, plan_name: @app.plan_name, redirect_url: 'someurl'
+
+          new_app.id.must_equal(@app.id)
+          new_app.service_id.must_equal(@app.service_id)
+          new_app.state.must_equal(@app.state)
+          new_app.plan_id.must_equal(@app.plan_id)
+          new_app.plan_name.must_equal(@app.plan_name)
+          new_app.redirect_url.must_equal 'someurl'
+
+          reloaded_app = Application.load(@app.service_id, @app.id)
+
+          new_app.redirect_url.must_equal(reloaded_app.redirect_url)
+        end
+
+        it 'raises a client-side error when missing mandatory attributes' do
+          {service_id: 9000, foo: 'bar', bar: 'foo', id: 6077}.each_cons(2) do |attrs|
+            attrs = attrs.to_h
+            # note missing service_id, id
+            attrs.merge!(state: 'suspended', plan_id: '3066',
+              plan_name: 'crappy', redirect_url: 'blah')
+            lambda do
+              Application.save(attrs)
+            end.must_raise KeyError # minitest wont catch parent exceptions :/
+          end
+        end
+      end
+
+      describe '#save' do
+        before do
+          Application.delete(2001, 8011)
+          @app = Application.save service_id: 2001, id: 8011, state: 'suspended',
+                                  plan_id: '3066', plan_name: 'crappy', redirect_url: 'blah'
+        end
+
+        it 'exists' do
+          Application.load(@app.service_id, @app.id).wont_be_nil
+        end
+
+        it 'saves changes to an instance' do
+          @app.plan_name = 'some_other_plan'
+          @app.save
+          newapp = Application.load @app.service_id, @app.id
+
+          newapp.id.must_equal @app.id
+          newapp.service_id.must_equal @app.service_id
+          newapp.state.must_equal @app.state
+          newapp.plan_id.must_equal @app.plan_id
+          newapp.redirect_url.must_equal @app.redirect_url
+          newapp.plan_name.must_equal 'some_other_plan'
+        end
+
+      end
+
+      describe 'by_key' do
+        before do
+          Application.save_id_by_key(2001, 'a_key', 8011)
+        end
+
+        describe '.load_id_by_key' do
+          it 'returns the app ID linked to the specified service and key' do
+            Application.load_id_by_key(2001, 'a_key').must_equal '8011'
+          end
+        end
+
+        describe '.save_id_by_key' do
+          it 'changes the key linked to the app ID and service' do
+            Application.load_id_by_key(2001, 'another_key').must_be_nil
+            Application.save_id_by_key(2001, 'another_key', 8011).must_equal true
+            Application.load_id_by_key(2001, 'another_key').must_equal '8011'
+            # clean up this key
+            Application.delete_id_by_key(2001, 'another_key')
+          end
+        end
+
+        describe '.delete_id_by_key' do
+          it 'deletes the key linked to the app ID and service' do
+            Application.load_id_by_key(2001, 'a_key').must_equal '8011'
+            Application.delete_id_by_key(2001, 'a_key')
+            Application.load_id_by_key(2001, 'a_key').must_be_nil
+          end
+        end
+      end
+    end
+  end
+end

data/spec/event_spec.rb

@@ -0,0 +1,82 @@
+require_relative './spec_helper'
+require_relative './private_endpoints/event'
+
+module ThreeScale
+  module Core
+    describe Event do
+
+      let(:example_events) do
+        [{ type: 'first_traffic', object: { application_id: 1 } },
+         { type: 'first_daily_traffic', object: { application_id: 2 } },
+         { type: 'alert', object: { application_id: 3 } }]
+      end
+
+      before do
+        last_event = Event.load_all.last
+        Event.delete_upto(last_event.id) if last_event
+      end
+
+      describe '.load_all' do
+        before do
+          Event.save(example_events)
+        end
+
+        it 'returns a collection of Events' do
+          events = Event.load_all
+          events.size.must_equal example_events.size
+
+          events[0].type.must_equal example_events[0][:type]
+          events[0].object.must_equal example_events[0][:object]
+          events[0].timestamp.must_be_instance_of Time
+
+          events[1].type.must_equal example_events[1][:type]
+          events[1].object.must_equal example_events[1][:object]
+          events[1].timestamp.must_be_instance_of Time
+
+          events[2].type.must_equal example_events[2][:type]
+          events[2].object.must_equal example_events[2][:object]
+          events[2].timestamp.must_be_instance_of Time
+        end
+      end
+
+      describe '.delete' do
+        describe 'with an existing id event' do
+          before do
+            Event.save([example_events.first])
+          end
+
+          it 'returns true when deleting an existing event' do
+            Event.delete(Event.load_all.last.id).must_equal true
+          end
+        end
+
+        describe 'with a missing id event' do
+          # non_existing_id can be anything, because there are not any events
+          # saved at this point.
+          let(:non_existing_id) { 1000 }
+
+          it 'returns false when deleting an event with a non-existing id' do
+            Event.delete(non_existing_id).must_equal false
+          end
+        end
+      end
+
+      describe '.delete_upto' do
+        before do
+          Event.save(example_events)
+        end
+
+        let(:saved_events) { Event.load_all }
+
+        # Grab the ID of the event before the last one so we can delete all
+        # except one. Careful, this let will not work with if the number of
+        # saved events is less than 3.
+        let(:upto_id) { saved_events[saved_events.size - 2].id }
+
+        it 'returns the number of deleted events' do
+          Event.delete_upto(upto_id).must_equal example_events.size - 1
+        end
+      end
+    end
+  end
+end

data/spec/metric_spec.rb

@@ -0,0 +1,115 @@
+require_relative './spec_helper'
+
+module ThreeScale
+  module Core
+    describe Metric do
+      describe '.save' do
+        before do
+          Metric.delete(1001, 2001)
+          @metric = Metric.save(service_id: 1001, id: 2001, name: 'hits')
+        end
+
+        it 'exists' do
+          Metric.load(@metric.service_id, @metric.id).wont_be_nil
+        end
+
+        it 'returns a Metric object' do
+          @metric.must_be_kind_of Metric
+        end
+
+        it 'returns a Metric object with correct fields' do
+          @metric.service_id.must_equal '1001'
+          @metric.id.must_equal '2001'
+          @metric.name.must_equal 'hits'
+          @metric.parent_id.must_be_nil
+        end
+
+        it 'modifies a Metric when saving an existing one' do
+          new_metric = Metric.save(service_id: @metric.service_id, id: @metric.id, name: 'rqps')
+
+          new_metric.wont_be_nil
+          new_metric.id.must_equal(@metric.id)
+          new_metric.service_id.must_equal(@metric.service_id)
+          new_metric.name.wont_equal(@metric.name)
+          new_metric.name.must_equal 'rqps'
+
+          reloaded_metric = Metric.load(@metric.service_id, @metric.id)
+
+          reloaded_metric.wont_be_nil
+          new_metric.name.must_equal(reloaded_metric.name)
+        end
+
+        it 'raises a client-side error when missing mandatory attributes' do
+          {service_id: 9000, foo: 'bar', id: 6077}.each_cons(2) do |attrs|
+            attrs = attrs.to_h
+            # note missing service_id, id
+            attrs.merge!(name: 'somename')
+            lambda do
+              Metric.save(attrs)
+            end.must_raise KeyError # minitest wont catch parent exceptions :/
+          end
+        end
+      end
+
+      describe '.load' do
+        before do
+          Metric.delete(1001, 2001)
+          Metric.save(service_id: 1001, id: 2001, name: 'hits')
+        end
+
+        it 'returns a Metric object' do
+          Metric.load(1001, 2001).class.must_equal Metric
+        end
+
+        it 'parses data from received JSON' do
+          metric = Metric.load(1001, 2001)
+
+          metric.wont_be_nil
+          metric.id.must_equal '2001'
+          metric.service_id.must_equal '1001'
+          metric.name.must_equal 'hits'
+        end
+
+        describe 'with a non-existing service id' do
+          it 'returns nil' do
+            Metric.load(7999, 2001).must_be_nil
+          end
+        end
+
+        describe 'with a non-existing id' do
+          it 'returns nil' do
+            Metric.load(1001, 7999).must_be_nil
+          end
+        end
+      end
+
+      describe '.delete' do
+        before do
+          Metric.delete(1001, 2001)
+          Metric.save(service_id: 1001, id: 2001, name: 'hits')
+        end
+
+        describe 'with an existing metric' do
+          it 'returns true' do
+            Metric.delete(1001, 2001).must_equal true
+          end
+
+          it 'makes it non-existent' do
+            Metric.delete(1001, 2001)
+            Metric.load(1001, 2001).must_be_nil
+          end
+        end
+
+        describe 'with a non-existent metric' do
+          it 'returns false when using a non-existing service id' do
+            Metric.delete(7999, 2001).must_equal false
+          end
+
+          it 'returns false when using a non-existing metric id' do
+            Metric.delete(1001, 7999).must_equal false
+          end
+        end
+      end
+    end
+  end
+end

data/spec/private_endpoints/event.rb

@@ -0,0 +1,9 @@
+module PrivateEndpoints
+  module Event
+    def save(events)
+      api_create(events, { uri: default_uri, prefix: :events })
+    end
+  end
+end
+
+ThreeScale::Core::Event.extend PrivateEndpoints::Event

data/spec/private_endpoints/service_error.rb

@@ -0,0 +1,10 @@
+module PrivateEndpoints
+  module ServiceError
+    def save(service_id, errors)
+      api_create(
+          errors, { uri: service_errors_uri(service_id), prefix: :errors })
+    end
+  end
+end
+
+ThreeScale::Core::ServiceError.extend PrivateEndpoints::ServiceError

data/spec/private_endpoints/transaction.rb

@@ -0,0 +1,16 @@
+module PrivateEndpoints
+  module Transaction
+    def save(service_id, transactions)
+      api_create(transactions,
+                 { uri: transactions_uri(service_id),
+                   prefix: :transactions })
+    end
+
+    def delete_all(service_id)
+      api_delete({}, uri: transactions_uri(service_id))
+    end
+  end
+end
+
+ThreeScale::Core::Transaction.extend PrivateEndpoints::Transaction
+

data/spec/service_error_spec.rb

@@ -0,0 +1,128 @@
+require_relative './spec_helper'
+require_relative './private_endpoints/service_error'
+
+module ThreeScale
+  module Core
+    describe ServiceError do
+      let(:service_id) { '7575' }
+      let(:non_existing_service_id) { service_id.to_i.succ.to_s }
+
+      describe '.load_all' do
+        let(:error_messages) do
+          ["application with id=\"boo\" was not found",
+           "usage value \"lots\" for metric \"hits\" is invalid",
+           "metric \"foo\" is invalid",
+           "provider key \"test_app\" is invalid"]
+        end
+
+        before do
+          Service.delete_by_id!(service_id)
+          Service.save!(provider_key: 'foo', id: service_id)
+          ServiceError.delete_all(service_id)
+          ServiceError.save(service_id, error_messages)
+        end
+
+        describe 'without using pagination' do
+          it 'returns a collection with the correct size and a total' do
+            errors = ServiceError.load_all(service_id)
+            errors.size.must_equal error_messages.size
+            errors.total.must_equal error_messages.size
+            errors.map(&:message).must_equal error_messages.reverse
+          end
+        end
+
+        describe 'specifying page and per_page' do
+          let(:page) { 2 }
+          let(:per_page) { 2 }
+          let(:first_err_in_page) do
+            # Need to reverse because the last message to be saved is the first
+            # that we get when loading the messages
+            error_messages.reverse[per_page*(page - 1)]
+          end
+          let(:second_err_in_page) do
+            error_messages.reverse[per_page*(page - 1) + 1]
+          end
+
+          it 'returns per_page results and the errors of the page specified' do
+            service_errors = ServiceError.load_all(
+                service_id, { page: page, per_page: per_page })
+            service_errors.size.must_equal per_page
+            service_errors.total.must_equal error_messages.size
+
+            service_errors[0].message.must_equal first_err_in_page
+            service_errors[0].timestamp.must_be_instance_of Time
+            service_errors[1].message.must_equal second_err_in_page
+            service_errors[1].timestamp.must_be_instance_of Time
+          end
+        end
+
+        describe 'with a negative per-page value' do
+          let(:page) { 1 }
+          let(:per_page) { -1 }
+          it 'raises exception' do
+            lambda {
+              ServiceError.load_all(
+                  service_id, { page: page, per_page: per_page })
+            }.must_raise InvalidPerPage
+          end
+        end
+
+        describe 'asking for an empty page' do
+          let(:page) { 2 }
+          let(:per_page) { error_messages.size }
+          it 'returns empty collection of errors and correct count' do
+            service_errors = ServiceError.load_all(
+                service_id, { page: page, per_page: per_page })
+
+            service_errors.size.must_equal 0
+            service_errors.total.must_equal error_messages.size
+          end
+        end
+
+        describe 'asking for the page that contains just the last error' do
+          let(:page) { 2 }
+          let(:per_page) { error_messages.size - 1 }
+          let(:oldest_error) { error_messages.reverse.last }
+
+          it 'returns one error and correct count' do
+            service_errors = ServiceError.load_all(
+                service_id, { page: page, per_page: per_page })
+
+            service_errors.size.must_equal 1
+            service_errors.total.must_equal error_messages.size
+
+            service_errors[0].message.must_equal oldest_error
+            service_errors[0].timestamp.must_be_instance_of Time
+          end
+        end
+      end
+
+      describe '.delete_all' do
+        before do
+          Service.delete_by_id!(service_id)
+          Service.save!(provider_key: 'foo', id: service_id)
+          ServiceError.delete_all(service_id)
+        end
+
+        describe 'with an existing service' do
+          it 'returns true' do
+            ServiceError.delete_all(service_id).must_equal true
+          end
+
+          it 'deletes the errors' do
+            service_errors = ServiceError.load_all(service_id)
+
+            service_errors.must_be_empty
+            service_errors.total.must_equal 0
+          end
+        end
+
+        describe 'with a non-existing service' do
+          it 'returns false' do
+            ServiceError.delete_all(non_existing_service_id).must_equal false
+          end
+        end
+      end
+    end
+  end
+end