mercy 1.3.0

data/spec/lib/bidu/mercy/report/multiple_spec.rb

@@ -0,0 +1,122 @@
+require 'spec_helper'
+
+describe Bidu::Mercy::Report::Multiple do
+  class Bidu::Mercy::Report::DocTypeError < Bidu::Mercy::Report::Error
+    ALLOWED_PARAMETERS=[:period, :threshold]
+    DEFAULT_OPTION = {
+      threshold: 0.25,
+      clazz: Document,
+      external_key: :external_id
+    }
+
+    json_parse :doc_type, case: :snake
+
+    def base
+      super.where(doc_type: doc_type)
+    end
+  end
+
+  class Bidu::Mercy::Report::Multiple::Dummy < Bidu::Mercy::Report
+    include Bidu::Mercy::Report::Multiple
+    DEFAULT_OPTION = {
+      doc_type: [:a, :b]
+    }
+    json_parse :doc_type, case: :snake
+
+    def reports_ids
+      [ doc_type ].flatten
+    end
+
+    def sub_report_class
+      Bidu::Mercy::Report::DocTypeError
+    end
+
+    def key
+      :doc_type
+    end
+  end
+
+  let(:subject) { described_class::Dummy.new }
+  let(:a_errors) { 1 }
+  let(:a_successes) { 1 }
+  let(:b_errors) { 1 }
+  let(:b_successes) { 1 }
+  let(:setup) do
+    {
+      success: { a: a_successes, b: b_successes },
+      error: { a: a_errors, b: b_errors }
+    }
+  end
+
+  before do
+    Document.delete_all
+    setup.each do |status, map|
+      map.each do |doc_type, quantity|
+        quantity.times do
+          Document.create(status: status, doc_type: doc_type, external_id: Document.count)
+        end
+      end
+    end
+  end
+
+  describe '#error?' do
+    context 'when all subreports are with error' do
+      it { expect(subject.error?).to be_truthy }
+    end
+
+    context 'when one of the reports is not an error' do
+      let(:a_successes) { 4 }
+
+      it { expect(subject.error?).to be_truthy }
+    end
+
+    context 'when none of the reports is an error' do
+      let(:a_successes) { 4 }
+      let(:b_successes) { 4 }
+
+      it { expect(subject.error?).to be_falsey }
+    end
+  end
+
+  describe '#as_json' do
+    let(:expected) do
+      {
+        'a' => { ids: [2], percentage: 0.5, status: :error },
+        'b' => { ids: [3], percentage: 0.5, status: :error },
+        status: :error
+      }
+    end
+
+    context 'when all subreports are with error' do
+      it { expect(subject.as_json).to eq(expected) }
+    end
+
+    context 'when one of the reports is not an error' do
+      let(:a_successes) { 4 }
+      let(:expected) do
+        {
+          'a' => { ids: [5], percentage: 0.2, status: :ok },
+          'b' => { ids: [6], percentage: 0.5, status: :error },
+          status: :error
+        }
+      end
+
+      it { expect(subject.as_json).to eq(expected) }
+    end
+
+    context 'when none of the reports is an error' do
+      let(:a_successes) { 4 }
+      let(:b_successes) { 4 }
+      let(:expected) do
+        {
+          'a' => { ids: [8], percentage: 0.2, status: :ok },
+          'b' => { ids: [9], percentage: 0.2, status: :ok },
+          status: :ok
+        }
+      end
+
+      it { expect(subject.as_json).to eq(expected) }
+    end
+  end
+end
+

data/spec/lib/bidu/mercy/report/range_spec.rb

@@ -0,0 +1,302 @@
+require 'spec_helper'
+
+describe Bidu::Mercy::Report::Range do
+  let(:errors) { 1 }
+  let(:successes) { 1 }
+  let(:old_errors) { 2 }
+  let(:old_sucesses) { 2 }
+  let(:period) { 1.day }
+  let(:scope) { :with_error }
+  let(:maximum) { nil }
+  let(:minimum) { nil }
+  let(:options) do
+    {
+      period: period,
+      scope: scope,
+      clazz: Document,
+      minimum: minimum,
+      maximum: maximum
+    }
+  end
+  let(:subject) { described_class.new(options) }
+  let(:types) { [:a] }
+  before do
+    Document.all.each(&:destroy)
+    types.each do |type|
+      successes.times { Document.create status: :success, doc_type: type }
+      errors.times do |i|
+        Document.create status: :error, external_id: 10 * successes + i, outter_external_id: i, doc_type: type
+      end
+      old_errors.times do
+        Document.create status: :error, created_at: 2.days.ago, updated_at: 2.days.ago, doc_type: type
+      end
+      old_sucesses.times do
+        Document.create status: :success, created_at: 2.days.ago, updated_at: 2.days.ago, doc_type: type
+      end
+    end
+  end
+
+  describe '#status' do
+    context 'when looking for maximum counts' do
+      context 'when there are more errors than the allowed by the maximum' do
+        let(:errors) { 2 }
+        let(:maximum) { 1 }
+        it { expect(subject.status).to eq(:error) }
+      end
+
+      context 'when the maximum is 0 and there are no errors' do
+        let(:errors) { 0 }
+        let(:maximum) { 0 }
+        it { expect(subject.status).to eq(:ok) }
+      end
+
+      context 'when the maximum is nil and there are no errors' do
+        let(:errors) { 0 }
+        let(:maximum) { nil }
+        it { expect(subject.status).to eq(:ok) }
+      end
+
+      context 'when the count is the same as the maximum' do
+        let(:errors) { 1 }
+        let(:maximum) { 1 }
+        it { expect(subject.status).to eq(:ok) }
+      end
+
+      context 'when the count is less than the maximum' do
+        let(:errors) { 1 }
+        let(:maximum) { 2 }
+        it { expect(subject.status).to eq(:ok) }
+      end
+
+      context 'when there are older errors out of the period' do
+        let(:maximum) { 1 }
+
+        it 'ignores the older errros' do
+          expect(subject.status).to eq(:ok)
+        end
+
+        context 'when passing a bigger period' do
+          let(:period) { 3.days }
+  
+          it 'consider the older errros' do
+            expect(subject.status).to eq(:error)
+          end
+        end
+      end
+    end
+
+    context 'when looking for minimum' do
+      let(:scope) { :with_success }
+      context 'when there are less successes than the allowed by the minimum' do
+        let(:successes) { 1 }
+        let(:minimum) { 2 }
+        it { expect(subject.status).to eq(:error) }
+      end
+
+      context 'when the minimum is 0 and there are no sucesses' do
+        let(:successes) { 0 }
+        let(:minimum) { 0 }
+        it { expect(subject.status).to eq(:ok) }
+      end
+
+      context 'when the minimum is nil and there are no sucesses' do
+        let(:successes) { 0 }
+        let(:minimum) { nil }
+        it { expect(subject.status).to eq(:ok) }
+      end
+
+      context 'when the count is the same as the minimum' do
+        let(:successes) { 1 }
+        let(:minimum) { 1 }
+        it { expect(subject.status).to eq(:ok) }
+      end
+
+      context 'when the count is greater than the minimum' do
+        let(:successes) { 2 }
+        let(:minimum) { 1 }
+        it { expect(subject.status).to eq(:ok) }
+      end
+
+      context 'when there are older sucesses out of the period' do
+        let(:successes) { 0 }
+        let(:minimum) { 1 }
+
+        it 'ignores the older sucesses' do
+          expect(subject.status).to eq(:error)
+        end
+
+        context 'when passing a bigger period' do
+          let(:period) { 3.days }
+  
+          it 'consider the older sucesses' do
+            expect(subject.status).to eq(:ok)
+          end
+        end
+      end
+    end
+
+    context 'when looking for a range' do
+      let(:scope) { :all }
+      let(:minimum) { 2 }
+      let(:maximum) { 4 }
+
+      context 'when there are less documents than the allowed by the minimum' do
+        let(:successes) { 1 }
+        let(:errors) { 0 }
+        it { expect(subject.status).to eq(:error) }
+      end
+
+      context 'when the count is the same as the minimum' do
+        let(:successes) { 1 }
+        let(:errors) { 2 }
+        it { expect(subject.status).to eq(:ok) }
+      end
+
+      context 'when the count is inside the range' do
+        let(:successes) { 1 }
+        let(:errors) { 2 }
+        it { expect(subject.status).to eq(:ok) }
+      end
+
+      context 'when the count is the same as the maximum' do
+        let(:successes) { 2 }
+        let(:errors) { 2 }
+        it { expect(subject.status).to eq(:ok) }
+      end
+
+      context 'when the count is greater than the maximum' do
+        let(:successes) { 3 }
+        let(:errors) { 2 }
+        it { expect(subject.status).to eq(:error) }
+      end
+
+      context 'when the minimum is 0 and the count is 0' do
+        let(:successes) { 0 }
+        let(:errors) { 0 }
+        let(:minimum) { 0 }
+        it { expect(subject.status).to eq(:ok) }
+      end
+
+      context 'when there are older sucesses out of the period' do
+        let(:old_errors) { 1 }
+        let(:old_sucesses) { 2 }
+
+        context 'and the regular documents are not enough' do
+          let(:successes) { 1 }
+          let(:errors) { 0 }
+ 
+          it 'ignores the older sucesses' do
+            expect(subject.status).to eq(:error)
+          end
+
+          context 'when passing a bigger period' do
+            let(:period) { 3.days }
+  
+            it 'consider the older sucesses' do
+              expect(subject.status).to eq(:ok)
+            end
+          end
+        end
+
+        context 'and the regular documents are almost in the limit' do
+          let(:successes) { 2 }
+          let(:errors) { 1 }
+ 
+          it 'ignores the older sucesses' do
+            expect(subject.status).to eq(:ok)
+          end
+
+          context 'when passing a bigger period' do
+            let(:period) { 3.days }
+  
+            it 'consider the older documents' do
+              expect(subject.status).to eq(:error)
+            end
+          end
+        end
+      end
+    end
+  end
+
+  describe '#count' do 
+    let(:types) { [:a, :b] }
+    let(:errors) { 1 }
+    let(:scope) { :with_error }
+
+    it 'returns all the documents found' do
+      expect(subject.count).to eq(2)
+    end
+    
+    context 'when configuring with a complex scope' do
+      let(:old_errors) { 0 }
+      let(:scope) { :'with_error.type_b' }
+      let(:errors) { 1 }
+
+      context 'as symbol' do
+        let(:scope) { :'with_error.type_b' }
+
+        it 'fetches from each scope in order' do
+          expect(subject.count).to eq(1)
+        end
+      end
+
+      context 'as string where scope' do
+        let(:scope) { "status = 'error' and doc_type = 'b'" }
+
+        it 'fetches from each scope in order' do
+          expect(subject.count).to eq(1)
+        end
+      end
+
+      context 'as hash where scope' do
+        let(:scope) { { status: :error, doc_type: :b } }
+
+        it 'fetches from each scope in order' do
+          expect(subject.count).to eq(1)
+        end
+      end
+    end
+  end
+
+  describe '#error?' do
+    let(:errors) { 2 }
+    let(:maximum) { 1 }
+
+    context 'when errors count overcome maximum' do
+      it { expect(subject.error?).to be_truthy }
+    end
+
+    context 'when errors count do not overcome maximum' do
+      let(:errors) { 0 }
+      it { expect(subject.error?).to be_falsey }
+    end
+  end
+
+  describe '#as_json' do
+    let(:expected) do
+      { count: count_expected, status: status_expected }
+    end
+
+    context 'when everything is ok' do
+      let(:errors) { 1 }
+      let(:status_expected) { :ok }
+      let(:count_expected) { errors }
+      let(:maximum) { 2 }
+
+      it 'returns the count and status' do
+        expect(subject.as_json).to eq(expected)
+      end
+    end
+
+    context 'when there is an error' do
+      let(:errors) { 2 }
+      let(:status_expected) { :error }
+      let(:count_expected) { errors }
+      let(:maximum) { 1 }
+
+      it 'returns the count and status' do
+        expect(subject.as_json).to eq(expected)
+      end
+    end
+  end
+end

data/spec/lib/bidu/mercy/report/report_config_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+describe Bidu::Mercy::ReportConfig do
+  let(:config) { {} }
+  let(:parameters) { {} }
+  let(:subject) { described_class.new(config) }
+
+  describe '#build' do
+    context 'when no config is given' do
+      it do
+        expect(subject.build(parameters)).to be_a(Bidu::Mercy::Report::Error)
+      end
+    end
+
+    context 'when a dummy type is given' do
+      let(:config) { { type: :dummy } }
+
+      it do
+        expect(subject.build(parameters)).to be_a(Bidu::Mercy::Report::Dummy)
+      end
+    end
+
+    context 'when a class is given as type' do
+      let(:config) { { type: Bidu::Mercy::Report::Dummy } }
+
+      it do
+        expect(subject.build(parameters)).to be_a(Bidu::Mercy::Report::Dummy)
+      end
+    end
+
+    context 'when a global class is given as type' do
+      let(:config) { { type: Dummy } }
+
+      it do
+        expect(subject.build(parameters)).to be_a(Dummy)
+      end
+    end
+  end
+end