pisoni 1.23.1

data/spec/service_spec.rb

@@ -0,0 +1,159 @@
+require_relative './spec_helper'
+
+module ThreeScale
+  module Core
+    describe Service do
+      let(:default_service_id) { 7001 }
+      let(:non_default_service_id) { default_service_id.succ }
+      let(:non_existent_service_id) { non_default_service_id.succ }
+      let(:default_provider_key) { 'foo' }
+      let(:other_provider_key) { 'bazinga' }
+      let(:another_provider_key) { 'bar' }
+      let(:non_existent_provider_key) { 'bunga' }
+
+      before do
+        # We create a new service for our provider as the default, then
+        # delete the service id we'll be using as the default service and
+        # then create it -- this way we're sure we don't reuse anything from
+        # previous runs.
+        service = Service.save! provider_key: default_provider_key,
+                                id: non_default_service_id,
+                                default_service: true
+        Service.load_by_id(service.id)
+        Service.delete_by_id!(default_service_id) rescue nil
+
+        service = Service.save! provider_key: default_provider_key,
+                                id: default_service_id,
+                                referrer_filters_required: true,
+                                backend_version: 'oauth',
+                                default_user_plan_id: 15,
+                                default_user_plan_name: 'test name',
+                                default_service: true
+        raise unless service.default_service
+
+        Service.delete_by_id!(non_default_service_id)
+      end
+
+      describe '.load_by_id' do
+        describe 'with an existing service' do
+          it 'returns a Service object' do
+            Service.load_by_id(default_service_id).class.must_equal Service
+          end
+
+          it 'parses data from received JSON' do
+            service = Service.load_by_id(default_service_id)
+
+            service.wont_be_nil
+            service.provider_key.must_equal default_provider_key
+            service.id.must_equal default_service_id.to_s
+            service.referrer_filters_required?.must_equal true
+            service.user_registration_required?.must_equal true
+            service.backend_version.must_equal 'oauth'
+            service.default_user_plan_id.must_equal '15'
+            service.default_user_plan_name.must_equal 'test name'
+          end
+        end
+
+        describe 'with a missing service' do
+          it 'returns nil' do
+            Service.load_by_id(non_existent_service_id).must_be_nil
+          end
+        end
+      end
+
+      describe '.delete_by_id!' do
+        before do
+          Service.save! provider_key: default_provider_key,
+                        id: default_service_id,
+                        default_service: true
+        end
+
+        it 'returns true if deleting a non-default service' do
+          Service.save! provider_key: default_provider_key,
+                        id: non_default_service_id
+          Service.delete_by_id!(non_default_service_id).must_equal true
+        end
+
+        it 'raises an exception when deleting a default service' do
+          lambda do
+            Service.delete_by_id! default_service_id
+          end.must_raise ServiceIsDefaultService
+        end
+      end
+
+      describe '.save!' do
+        before do
+          @service_params = {
+            provider_key: default_provider_key,
+            id: non_default_service_id
+          }
+        end
+
+        it 'returns service object' do
+          service = Service.save!(@service_params)
+
+          service.wont_be_nil
+          service.class.must_equal Service
+          service.id.must_equal non_default_service_id
+          service.provider_key.must_equal default_provider_key
+        end
+
+        it 'raises an exception when missing a default user plan' do
+          @service_params.merge! user_registration_required: false
+
+          lambda do
+            Service.save!(@service_params)
+          end.must_raise ServiceRequiresDefaultUserPlan
+        end
+      end
+
+      describe '.make_default' do
+        it 'returns the updated service' do
+          service = Service.save!(id: non_default_service_id,
+                                  provider_key: default_provider_key)
+          Service.make_default(service.id).class.must_equal Service
+        end
+      end
+
+      describe '.change_provider_key!' do
+        def with_changed_provider_key(from, to)
+          val = Service.change_provider_key!(from, to)
+          yield val
+          # change it back
+          Service.change_provider_key!(to, from)
+        end
+
+        before do
+          Service.save! provider_key: default_provider_key,
+                        id: default_service_id
+        end
+
+        it 'returns true' do
+          with_changed_provider_key default_provider_key, other_provider_key do |val|
+            val.must_equal true
+          end
+        end
+
+        it 'raises an exception when the key to change doesn\'t exist' do
+          lambda do
+            with_changed_provider_key(non_existent_provider_key, 'baz') { }
+          end.must_raise ProviderKeyNotFound
+        end
+
+        it 'raises an exception when the new key already exists' do
+          Service.save! provider_key: another_provider_key, id: non_default_service_id
+
+          lambda do
+            with_changed_provider_key(default_provider_key, another_provider_key) { }
+          end.must_raise ProviderKeyExists
+        end
+
+        it 'raises an exception when the keys are invalid' do
+          lambda do
+            with_changed_provider_key(default_provider_key, '') { }
+          end.must_raise InvalidProviderKeys
+        end
+      end
+    end
+  end
+end

data/spec/service_token_spec.rb

@@ -0,0 +1,121 @@
+require_relative './spec_helper'
+
+module ThreeScale
+  module Core
+    describe ServiceToken do
+
+      let(:service_id) { '12345' }
+      let(:token) { 'abcd' }
+      let(:save_service_token_params) do
+        {
+          ab: { service_id: '1' },
+          cd: { service_id: '2' },
+          ef: { service_id: '3' }
+        }
+      end
+      let(:delete_service_token_params) do
+        save_service_token_params.map do |token, params|
+          { service_id: params[:service_id], service_token: token }
+        end
+      end
+
+      describe '.save' do
+
+        describe 'when saving one token' do
+          before do
+            ServiceToken.delete([{ service_id: service_id, service_token: token }])
+          end
+
+          it 'saves a service token' do
+            assert ServiceToken.save!(token => { service_id: service_id })
+
+            result = ServiceToken.delete([{ service_id: service_id, service_token: token }])
+
+            assert_equal result, 1
+          end
+        end
+
+        describe 'when saving more tokens at once' do
+          before do
+            ServiceToken.delete(delete_service_token_params)
+          end
+
+          it 'saves service tokens' do
+            assert ServiceToken.save!(save_service_token_params)
+
+            result = ServiceToken.delete(delete_service_token_params)
+
+            assert_equal result, save_service_token_params.size
+          end
+        end
+
+        describe 'when the parameters are blank' do
+          it 'does not save a service token' do
+            assert_raises ServiceTokenMissingParameter do
+               ServiceToken.save!({})
+            end
+          end
+        end
+
+        describe 'when the service ID is nil' do
+          it 'does not save a service token' do
+            assert_raises ServiceTokenRequiresServiceId do
+              ServiceToken.save!(token => { service_id: nil })
+            end
+          end
+        end
+
+        describe 'when the service ID parameter does not exist' do
+          it 'does not save a service token' do
+            assert_raises ServiceTokenRequiresServiceId do
+              ServiceToken.save!(token => { id: service_id })
+            end
+          end
+        end
+
+        describe 'when the token parameter does not exist' do
+          it 'does not save a service token' do
+            assert_raises ServiceTokenRequiresToken do
+              ServiceToken.save!('' => { service_id: service_id })
+            end
+          end
+        end
+      end
+
+      describe '.delete' do
+
+        describe 'when deleting one token' do
+          before do
+            ServiceToken.save!(token => { service_id: service_id })
+          end
+
+          it 'deletes a service token' do
+            result = ServiceToken.delete([{ service_id: service_id, service_token: token }])
+
+            assert_equal result, 1
+          end
+        end
+
+        describe 'when deleting more tokens at once' do
+          before do
+            ServiceToken.save!(save_service_token_params)
+          end
+
+          it 'deletes service tokens' do
+            result = ServiceToken.delete(delete_service_token_params)
+
+            assert_equal result, delete_service_token_params.size
+          end
+        end
+
+        describe 'when deleting non existing token' do
+          it 'returns zero count' do
+            result = ServiceToken.delete([{ service_id: '1', service_token: 'a' }])
+
+            assert_equal result, 0
+          end
+        end
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,15 @@
+if ENV['COVERAGE'] && !ENV['COVERAGE'].empty?
+  require 'codeclimate-test-reporter'
+  SimpleCov.start do
+    formatter ENV['CODECLIMATE_REPO_TOKEN'] ?
+      CodeClimate::TestReporter::Formatter :
+      SimpleCov::Formatter::HTMLFormatter
+    add_filter '/spec/'
+  end
+end
+
+$:.unshift(File.dirname(__FILE__) + '/../lib')
+
+require 'minitest/autorun'
+require 'bundler/setup'
+Bundler.require(:default, :development, :test)

data/spec/transaction_spec.rb

@@ -0,0 +1,71 @@
+require_relative './spec_helper'
+require_relative './private_endpoints/transaction'
+
+module ThreeScale
+  module Core
+    describe Transaction do
+      before do
+        Service.delete_by_id!(service_id)
+        Service.save!(provider_key: 'foo', id: service_id)
+      end
+
+      describe '.load_all' do
+        let(:service_id) { '7575' }
+        let(:non_existing_service_id) { service_id.to_i.succ.to_s }
+
+        before do
+          Transaction.delete_all(service_id)
+        end
+
+        describe 'when there are transactions' do
+          let(:first_transaction_time) { Time.new(2015, 1, 1) }
+          let(:second_transaction_time) { Time.new(2015, 1, 2) }
+          let(:test_transactions) do
+            transactions = []
+            transactions << { application_id: 'first_test_application',
+                              usage: 'first_usage',
+                              timestamp: first_transaction_time.to_s }
+            transactions << { application_id: 'second_test_application',
+                              usage: 'second_usage',
+                              timestamp: second_transaction_time.to_s }
+          end
+
+          before do
+            Transaction.save(service_id, test_transactions)
+          end
+
+          it 'returns a collection with the transactions' do
+            transactions = Transaction.load_all(service_id)
+
+            transactions.total.must_equal test_transactions.size
+            transactions.size.must_equal test_transactions.size
+
+            latest_transaction = transactions[0]
+            latest_transaction.application_id.must_equal test_transactions[1][:application_id]
+            latest_transaction.usage.must_equal test_transactions[1][:usage]
+            latest_transaction.timestamp.must_equal second_transaction_time
+
+            previous_transaction = transactions[1]
+            previous_transaction.application_id.must_equal test_transactions[0][:application_id]
+            previous_transaction.usage.must_equal test_transactions[0][:usage]
+            previous_transaction.timestamp.must_equal first_transaction_time
+          end
+        end
+
+        describe 'when there are no transactions' do
+          it 'returns an empty collection' do
+            transactions = Transaction.load_all(service_id)
+            transactions.must_be_empty
+            transactions.total.must_equal 0
+          end
+        end
+
+        describe 'with an invalid service ID' do
+          it 'returns nil' do
+            Transaction.load_all(non_existing_service_id).must_be_nil
+          end
+        end
+      end
+    end
+  end
+end

data/spec/usagelimit_spec.rb

@@ -0,0 +1,52 @@
+require_relative './spec_helper'
+
+module ThreeScale
+  module Core
+    describe UsageLimit do
+      before do
+        @sample_period_limits = { eternity: 10_000_000, year: 2_000_000, month: 700_000,
+                                  week: 300_000, hour: 5_000, minute: 200 }
+        @sample_period_limits.each do |p, l|
+          UsageLimit.save(service_id: '2001', plan_id: '3001',
+                          metric_id: '4001', p => l)
+        end
+      end
+
+      it 'saves a UsageLimit' do
+        daylimit = 50
+
+        UsageLimit.save(service_id: '2001', plan_id: '3001', metric_id: '4002', day: daylimit)
+        UsageLimit.load_value('2001', '3001', '4002', :day).must_equal daylimit
+      end
+
+      it 'correctly loads all periods of a UsageLimit' do
+        @sample_period_limits.keys.map do |p|
+          [p, UsageLimit.load_value('2001', '3001', '4001', p)]
+        end.to_h.must_equal @sample_period_limits
+      end
+
+      it 'returns zero for a period without limit' do
+        period = (UsageLimit::PERIODS - @sample_period_limits.keys).sample
+        UsageLimit.load_value('2001', '3001', '4001', period).must_be_nil
+      end
+
+      it 'deletes a given period from a sample usage limit' do
+        UsageLimit.delete('2001', '3001', '4001', :week)
+
+        UsageLimit.load_value('2001', '3001', '4001', :week).must_be_nil
+      end
+
+      it 'raises if multiple periods are specified on .save' do
+        proc do
+          UsageLimit.save(service_id: '2001', plan_id: '3001', metric_id: '4002', day: 5, week: 10)
+        end.must_raise UsageLimitInvalidPeriods
+      end
+
+      it 'raises if no periods are specified on .save' do
+        proc do
+          UsageLimit.save(service_id: '2001', plan_id: '3001', metric_id: '4002')
+        end.must_raise UsageLimitInvalidPeriods
+      end
+    end
+  end
+end

data/spec/user_spec.rb

@@ -0,0 +1,164 @@
+require_relative './spec_helper'
+
+module ThreeScale
+  module Core
+    describe User do
+      def nothing_raised
+        yield
+        true
+      rescue => e
+        e
+      end
+
+      let(:service_id) { 2001 }
+      let(:nonexistent_service_id) { service_id.succ }
+      let(:provider_key) { 'provider_for_user_spec' }
+      let(:username) { 'pancho' }
+      let(:nonexistent_username) { 'rodolfo' }
+      let(:state) { :active }
+      let(:plan_id) { 6789 }
+      let(:plan_name) { 'plan_for_panchos' }
+
+      before do
+        Service.save! provider_key: provider_key,
+                      id: service_id, default_service: true
+
+        Service.delete_by_id! nonexistent_service_id rescue nil
+        User.delete! service_id, nonexistent_username
+        @user = User.save! service_id: service_id, username: username, state: state,
+                           plan_id: plan_id, plan_name: plan_name
+      end
+
+      describe '.load' do
+        it 'returns a User object' do
+          User.load(service_id, username).class.must_equal User
+        end
+
+        it 'parses data from received JSON' do
+          user = User.load(service_id, username)
+
+          user.wont_be_nil
+          user.service_id.must_equal service_id.to_s
+          user.state.must_equal state.to_s
+          user.plan_id.must_equal plan_id.to_s
+          user.plan_name.must_equal plan_name
+        end
+
+        it 'raises when the service id is missing or empty' do
+          ['', nil].each do |service_id|
+            lambda do
+              User.load service_id, username
+            end.must_raise UserRequiresServiceId
+          end
+        end
+
+        it 'raises when the user name is missing or empty' do
+          ['', nil].each do |user_name|
+            lambda do
+              User.load service_id, user_name
+            end.must_raise UserRequiresUsername
+          end
+        end
+
+        it 'returns nil when a non-existent service id is used' do
+          User.load(nonexistent_service_id, username).must_be_nil
+        end
+
+        it 'returns nil when a non-existent user name is used' do
+           User.load(service_id, nonexistent_username).must_be_nil
+        end
+      end
+
+      describe '.save!' do
+        before do
+          User.delete! service_id, nonexistent_username
+        end
+
+        it 'returns a User object' do
+          @user.wont_be_nil
+          @user.class.must_equal User
+        end
+
+        it 'returns an object with the saved attributes' do
+          @user.wont_be_nil
+          @user.service_id.must_equal service_id.to_s
+          @user.username.must_equal username
+          @user.state.must_equal state.to_s
+          @user.plan_id.must_equal plan_id
+          @user.plan_name.must_equal plan_name
+        end
+
+        it 'raises when the service id is missing or empty' do
+          ['', nil].each do |service_id|
+            lambda do
+              User.save! service_id: service_id, username: username, plan_id: plan_id,
+                plan_name: plan_name
+            end.must_raise UserRequiresServiceId
+          end
+        end
+
+        it 'raises when the user name is missing or empty' do
+          ['', nil].each do |user_name|
+            lambda do
+              User.save! service_id: service_id, username: user_name, plan_id: plan_id,
+                plan_name: plan_name
+            end.must_raise UserRequiresUsername
+          end
+        end
+
+        it 'raises when a non-existent service id is used' do
+          lambda do
+            User.save! service_id: nonexistent_service_id, username: username,
+                       plan_id: plan_id, plan_name: plan_name
+          end.must_raise UserRequiresValidServiceId
+        end
+
+        it 'raises when plan_id is nil' do
+          lambda do
+            User.save! service_id: service_id, username: username,
+                       plan_id: nil, plan_name: plan_name
+          end.must_raise UserRequiresDefinedPlan
+        end
+
+        it 'raises when plan_name is nil' do
+          lambda do
+            User.save! service_id: service_id, username: username,
+                       plan_id: plan_id, plan_name: nil
+          end.must_raise UserRequiresDefinedPlan
+        end
+
+        it 'returns a new user when a non-existent user name is used' do
+          nothing_raised do
+            User.save! service_id: service_id, username: nonexistent_username,
+                       plan_id: plan_id, plan_name: plan_name
+          end.must_equal true
+
+          user = User.load service_id, nonexistent_username
+
+          user.wont_be_nil
+          user.service_id.must_equal service_id.to_s
+          user.username.must_equal nonexistent_username
+          user.state.must_equal state.to_s
+          user.plan_id.must_equal plan_id.to_s
+          user.plan_name.must_equal plan_name
+        end
+      end
+
+      describe '.delete!' do
+        before do
+          User.save! service_id: service_id, username: username, state: state,
+                     plan_id: plan_id, plan_name: plan_name
+        end
+
+        it 'deletes the user' do
+          nothing_raised do
+            User.delete! service_id, username
+          end.must_equal true
+
+          User.save! service_id: service_id, username: username, state: state,
+                     plan_id: plan_id, plan_name: plan_name
+        end
+      end
+    end
+  end
+end

data/spec/utilization_spec.rb

@@ -0,0 +1,113 @@
+require_relative './spec_helper'
+
+module ThreeScale
+  module Core
+    describe Utilization do
+      let(:service_id) { '1001' }
+      let(:non_existing_service_id) { service_id.to_i.succ.to_s }
+      let(:provider_key) { 'foo' }
+
+      let(:app_id) { '2001' }
+      let(:non_existing_app_id) { app_id.to_i.succ.to_s }
+
+      let(:plan) { { id: '3001', name: 'test_plan' } }
+
+      let(:metric) { { service_id: service_id, id: '4001', name: 'hits' } }
+
+      let(:app) do
+        { service_id: service_id,
+          id: app_id,
+          state: :active,
+          plan_id: plan[:id],
+          plan_name: plan[:name] }
+      end
+
+      let(:usage_limits) do
+        [{ service_id: service_id,
+           plan_id: plan[:id],
+           metric_id: metric[:id],
+           day: 100 },
+         { service_id: service_id,
+           plan_id: plan[:id],
+           metric_id: metric[:id],
+           month: 200 }]
+      end
+
+      describe '.load' do
+        before do
+          Service.delete_by_id!(service_id)
+          Service.save!(provider_key: provider_key, id: service_id)
+
+          Application.delete(service_id, app_id)
+          Application.save(app)
+
+          Metric.delete(service_id, metric[:id])
+          Metric.save(metric)
+
+          UsageLimit::PERIODS.each do |period|
+            usage_limits.each do |limit|
+              UsageLimit.delete(limit[:service_id],
+                                limit[:plan_id],
+                                limit[:metric_id],
+                                period)
+            end
+          end
+          usage_limits.each { |limit| UsageLimit.save(limit) }
+
+          Transaction.delete_all(service_id)
+        end
+
+        # This is a basic test that only checks the structure of the response.
+        # The reason is that we do not have an endpoint in backend that allows
+        # us to save utilization transactions. We could have added one, but we
+        # decided it was not worth it because of two reasons:
+        # 1) The method to add transactions manually in backend would have been
+        # a bit complex because script/test_external does not run any workers,
+        # and transactions are saved creating tasks executed by workers.
+        # 2) There is no way in backend to delete utilization transactions, so
+        # even if we added a method to save them, we would not be able to know
+        # how many are saved in the system to perform a proper test.
+        describe 'with app that has daily and monthly limits for a metric' do
+          subject { Utilization.load(service_id, app_id) }
+
+          it 'has the correct number of reports' do
+            # We could think that subject.size should equal usage_limits.size.
+            # However, we could have other limits previously saved in the
+            # backend. Therefore, we can only be sure that the size is equal or
+            # greater than usage_limits.size
+            subject.size.must_be :>=, usage_limits.size
+            subject.total.must_be :>=, usage_limits.size
+          end
+
+          it 'has reports with all their attributes set' do
+            subject.each do |report|
+              Utilization.attributes.each do |utilization_attr|
+                report.send(utilization_attr).wont_be_nil
+              end
+            end
+          end
+
+          it 'has reports with fields that have the correct type' do
+            example_report = subject.first
+            example_report.period.must_be_kind_of String
+            example_report.metric_name.must_be_kind_of String
+            example_report.max_value.must_be_kind_of Numeric
+            example_report.current_value.must_be_kind_of Numeric
+          end
+        end
+
+        describe 'with an invalid service ID' do
+          it 'returns nil' do
+            Utilization.load(non_existing_service_id, app_id).must_be_nil
+          end
+        end
+
+        describe 'with an invalid application ID' do
+          it 'returns nil' do
+            Utilization.load(service_id, non_existing_app_id).must_be_nil
+          end
+        end
+      end
+    end
+  end
+end