roqua-support 0.4.4 → 0.4.5

data/spec/roqua/core_ext/active_interaction/duration_filter_spec.rb

@@ -1,90 +0,0 @@
-require 'active_interaction'
-require 'active_support/all'
-require 'roqua/core_ext/active_interaction/filters/duration_filter'
-
-class DurationFilterOperation < ActiveInteraction::Base
-  duration :duration
-  duration :stripped_duration, strip: true, default: nil
-
-  def execute
-    {duration: duration, stripped_duration: stripped_duration}
-  end
-end
-
-describe ActiveInteraction::DurationFilter do
-  let(:duration) { 1.week }
-  let(:stripped_duration) { 1.week }
-
-
-  subject { DurationFilterOperation.run!(duration: duration, stripped_duration: stripped_duration) }
-
-  describe 'when given a duration object' do
-    it 'receives the object correctly' do
-      expect(subject[:duration]).to be_a(ActiveSupport::Duration)
-      expect(subject[:duration]).to eq 1.week
-    end
-
-    it 'does not strip non-0 values' do
-      expect(subject[:stripped_duration]).to be_a(ActiveSupport::Duration)
-      expect(subject[:stripped_duration]).to eq 1.week
-    end
-  end
-
-  describe 'when given a 0 duration object' do
-    let(:duration) { 0.weeks }
-    let(:stripped_duration) { 0.weeks }
-
-    it 'receives the object correctly' do
-      expect(subject[:duration]).to be_a(ActiveSupport::Duration)
-      expect(subject[:duration]).to eq 0.weeks
-    end
-
-    it 'strips 0 values' do
-      expect(subject[:stripped_duration]).to eq nil
-    end
-  end
-
-  describe 'when given a hash object' do
-    let(:duration) { {value: '1', unit: 'weeks'} }
-    let(:stripped_duration) { {value: '1', unit: 'weeks'} }
-
-    it 'receives the object correctly' do
-      expect(subject[:duration]).to be_a(ActiveSupport::Duration)
-      expect(subject[:duration]).to eq 1.week
-    end
-
-    it 'does not strip non-0 values' do
-      expect(subject[:stripped_duration]).to be_a(ActiveSupport::Duration)
-      expect(subject[:stripped_duration]).to eq 1.week
-    end
-  end
-
-  describe 'when given a hash {value: "0"} object' do
-    let(:duration) { {value: '0', unit: 'weeks'} }
-    let(:stripped_duration) { {value: '0', unit: 'weeks'} }
-
-    it 'receives the object correctly' do
-      expect(subject[:duration]).to be_a(ActiveSupport::Duration)
-      expect(subject[:duration]).to eq 0.weeks
-    end
-
-    it 'strips 0 values' do
-      expect(subject[:stripped_duration]).to eq nil
-    end
-  end
-
-  describe 'when given a hash {value: ""} object' do
-    let(:duration) { {value: '', unit: 'weeks'} }
-
-    it 'throws a required error when not stripped' do
-      expect { subject }.to raise_error ActiveInteraction::InvalidInteractionError, 'Duration is required'
-    end
-  end
-
-  describe 'when given a hash {value: ""} object' do
-    let(:stripped_duration) { {value: '', unit: 'weeks'} }
-    it 'strips 0 values' do
-      expect(subject[:stripped_duration]).to eq nil
-    end
-  end
-end

data/spec/roqua/core_ext/active_interaction/rails_intrumentation_spec.rb

@@ -1,20 +0,0 @@
-require 'spec_helper'
-require 'rspec-instrumentation-matcher'
-require 'active_interaction'
-require 'active_support/all'
-require 'roqua/core_ext/active_interaction/rails_instrumentation'
-
-class AIRailsInstrumentationTest < ActiveInteraction::Base
-  string :foo, default: 'bar'
-
-  def execute
-  end
-end
-
-describe RoquaRailsActiveInteractionInstrumentation do
-  include RSpec::Instrumentation::Matcher
-  it 'creates an event' do
-    expect { AIRailsInstrumentationTest.run }.to instrument('operation.active_interaction').with(
-      class_name: 'ai_rails_instrumentation_test')
-  end
-end

data/spec/roqua/core_ext/activerecord/uniq_find_or_create_spec.rb

@@ -1,77 +0,0 @@
-require 'spec_helper'
-
-require 'roqua/core_ext/activerecord/uniq_find_or_create'
-
-describe ActiveRecord::Base do
-  let(:attributes) { double('attributes') }
-  let(:block)      { -> (*args){} }
-  let(:record)     { double('record') }
-
-  describe '#uniq_find_or_create_by' do
-    it 'tries to find or create a record by the attributes provided' do
-      expect(ActiveRecord::Base).to receive(:find_or_create_by).with(attributes, &block).and_return record
-      ActiveRecord::Base.uniq_find_or_create_by attributes, &block
-    end
-
-    it 'returns a preexisting or created record by querying it' do
-      allow(ActiveRecord::Base).to receive(:find_or_create_by).with(attributes).and_return record
-      expect(ActiveRecord::Base.uniq_find_or_create_by attributes, &block).to eq(record)
-    end
-
-    it 'returns a concurrenlty created record' do
-      allow(ActiveRecord::Base).to receive(:find_by).with(attributes).and_return record
-      allow(ActiveRecord::Base).to receive(:find_or_create_by).with(attributes, &block)
-                                                              .and_raise ActiveRecord::RecordNotUnique.new('')
-      expect(ActiveRecord::Base.uniq_find_or_create_by attributes, &block).to eq(record)
-    end
-
-    it 'raises when a concurrent record is detected by the database but could not be queried for unknown reasons' do
-      allow(ActiveRecord::Base).to receive(:find_by).with(attributes).and_return nil
-      allow(ActiveRecord::Base).to receive(:find_or_create_by).with(attributes, &block)
-                                                              .and_raise ActiveRecord::RecordNotUnique.new('')
-      expect do
-        ActiveRecord::Base.uniq_find_or_create_by attributes, &block
-      end.to raise_error ActiveRecord::RecordNotUnique
-    end
-
-    it 'returns the created record for inspection when validation fails' do
-      allow(ActiveRecord::Base).to receive(:find_or_create_by).with(attributes, &block).and_return record
-      expect(ActiveRecord::Base.uniq_find_or_create_by attributes, &block).to eq(record)
-    end
-  end
-
-  describe '#uniq_find_or_create_by!' do
-    it 'tries to find or create a record by the attributes provided' do
-      allow(ActiveRecord::Base).to receive(:find_by).with(attributes).and_return record
-      expect(ActiveRecord::Base).to receive(:find_or_create_by!).with(attributes, &block)
-      ActiveRecord::Base.uniq_find_or_create_by! attributes, &block
-    end
-
-    it 'returns a preexisting or created record by querying it' do
-      allow(ActiveRecord::Base).to receive(:find_or_create_by!).with(attributes).and_return record
-      expect(ActiveRecord::Base.uniq_find_or_create_by! attributes, &block).to eq(record)
-    end
-
-    it 'returns a concurrenlty created record' do
-      allow(ActiveRecord::Base).to receive(:find_by).with(attributes).and_return record
-      allow(ActiveRecord::Base).to receive(:find_or_create_by!).with(attributes, &block)
-                                                               .and_raise ActiveRecord::RecordNotUnique.new('')
-      expect(ActiveRecord::Base.uniq_find_or_create_by! attributes, &block).to eq(record)
-    end
-
-    it 'raises when a concurrent record is detected by the database but could not be queried for unknown reasons' do
-      allow(ActiveRecord::Base).to receive(:find_by).with(attributes).and_return nil
-      allow(ActiveRecord::Base).to receive(:find_or_create_by!).with(attributes, &block)
-                                                               .and_raise ActiveRecord::RecordNotUnique.new('')
-      expect do
-        ActiveRecord::Base.uniq_find_or_create_by! attributes, &block
-      end.to raise_error ActiveRecord::RecordNotUnique
-    end
-
-    it 'raises when creating a new record causes validation failures not due to concurrency' do
-      exception = StandardError.new('some_validation_error')
-      allow(ActiveRecord::Base).to receive(:find_or_create_by!).with(attributes, &block).and_raise exception
-      expect { ActiveRecord::Base.uniq_find_or_create_by! attributes, &block }.to raise_error(exception)
-    end
-  end
-end

data/spec/roqua/core_ext/delayed_job/activity_monitoring_spec.rb

@@ -1,75 +0,0 @@
-require 'spec_helper'
-require 'pathname'
-require 'timecop'
-require 'fakefs/safe'
-
-require 'roqua/core_ext/delayed_job/activity_monitoring'
-
-describe DelayedJobActivityMonitoring do
-  after do
-    Timecop.return
-  end
-
-  def initialize_fake_rails_root
-    FileUtils.mkdir_p(File.join('/app', 'tmp'))
-    allow(Rails).to receive(:root).and_return(Pathname.new('/app'))
-  end
-
-  let(:monitoring_filename) { Rails.root.join('tmp', 'delayed_job_activity').to_s }
-
-  it 'creates a file' do
-    FakeFS.with_fresh do
-      initialize_fake_rails_root
-      expect { Delayed::Worker.new.work_off }
-        .to change { File.exist?(monitoring_filename) }
-
-      expect(File.mtime(monitoring_filename))
-        .to be_within(1.second).of(Time.now)
-    end
-  end
-
-  it 'updates the file modification time' do
-    FakeFS.with_fresh do
-      initialize_fake_rails_root
-
-      Delayed::Worker.new.work_off
-
-      Timecop.travel(1.minute)
-
-      expect { Delayed::Worker.new.work_off }
-        .to change { File.mtime(monitoring_filename) }
-
-      expect(File.mtime(monitoring_filename))
-        .to be_within(1.second).of(Time.now)
-    end
-  end
-
-  describe 'when a job is reserved' do
-    let(:max_run_time) { 2.hours }
-    let(:job) do
-      double(
-        name: 'name',
-        id: 123,
-        queue: 'queue',
-        max_run_time: max_run_time,
-        invoke_job: nil,
-        destroy: nil
-      )
-    end
-
-    it 'creates a file with a modification time in the future' do
-      FakeFS.with_fresh do
-        initialize_fake_rails_root
-
-        worker = Delayed::Worker.new
-        expect(Delayed::Job).to receive(:reserve).and_return(job)
-
-        expect { worker.send(:reserve_and_run_one_job) }
-          .to change { File.exist?(monitoring_filename) }
-
-        expect(File.mtime(monitoring_filename))
-          .to be_within(1.second).of(max_run_time.from_now)
-      end
-    end
-  end
-end

data/spec/roqua/core_ext/enumerable/sort_by_alphanum_spec.rb

@@ -1,33 +0,0 @@
-require 'roqua/core_ext/enumerable/sort_by_alphanum'
-
-describe Enumerable do
-  describe '#sort_by_alphanum' do
-    let(:input) { ["004some11thing", "004some10thing", "3another"] }
-    it 'sorts by chunks' do
-      expect(input.sort_by_alphanum).to eq ["3another", "004some10thing", "004some11thing"]
-    end
-
-    it 'can take a block which can transform values before comparison' do
-      expect(input.sort_by_alphanum(&:reverse)).to eq ["004some10thing", "004some11thing", "3another"]
-    end
-
-    it 'sorts shorter strings first' do
-      input = %w[a_2_ a_2 a a_1]  # curlies are above alpha in utf-8, Ԙ is multi-byte
-      expect(input.sort_by_alphanum).to eq %w[a a_1 a_2 a_2_]
-    end
-
-    it 'treats non-alphanum as lower than alpha and num' do
-      input = %w[b3a b{c bԘb]  # curlies are above alpha in utf-8, Ԙ is multi-byte
-      expect(input.sort_by_alphanum).to eq %w[b{c bԘb b3a]
-    end
-
-    it 'compares number chunks as integers' do
-      expect(%w(004 3).sort_by_alphanum).to eq %w(3 004)
-    end
-
-    it 'sorts identical integers by asci'  do
-      input = %w[b4e b0004e b04e b004e]
-      expect(input.sort_by_alphanum).to  eq %w[b0004e b004e b04e b4e]
-    end
-  end
-end

data/spec/roqua/core_ext/fabrication/singleton_spec.rb

@@ -1,23 +0,0 @@
-require 'roqua/core_ext/fabrication/singleton'
-
-def Fabricate(name, overrides={}, &block)
-  rand
-end
-
-describe Fabricate do
-  it "returns singleton objects" do
-    # Fabricate.singleton(:one).should == Fabricate.singleton(:one)
-    expect(Fabricate.singleton(:one)).to eq Fabricate.singleton(:one)
-  end
-
-  it 'maintains multiple singletons' do
-    # Fabricate.singleton(:one).should_not == Fabricate.singleton(:two)
-    expect(Fabricate.singleton(:one)).not_to eq Fabricate.singleton(:two)
-  end
-
-  it 'clears singletons' do
-    the_one = Fabricate.singleton(:one)
-    Fabricate.clear_singletons!
-    expect(Fabricate.singleton(:one)).not_to eq(the_one)
-  end
-end

data/spec/roqua/logging/roqua_logging_railtie_spec.rb

@@ -1,48 +0,0 @@
-require 'spec_helper'
-
-require 'roqua/support/request_logger'
-require 'roqua/logging/roqua_logging_railtie'
-
-RSpec.shared_examples 'RoQua logging setup' do
-  def configure_roqua_logging(log_to_stdout)
-    ClimateControl.modify RAILS_LOG_TO_STDOUT_USING_ROQUA_LOGGER: log_to_stdout do
-      RoquaLoggingRailtie.configure
-    end
-  end
-
-  it 'attaches Roqua::Support::RequestLogger to action_controller' do
-    expect(Roqua::Support::RequestLogger).to receive(:attach_to).with(:action_controller)
-    configure_roqua_logging(log_to_stdout)
-  end
-end
-
-Rspec.describe RoquaLoggingRailtie do
-  context 'when RAILS_LOG_TO_STDOUT_USING_ROQUA_LOGGER is present' do
-    include_examples 'RoQua logging setup'
-
-    let(:log_to_stdout) { 'true' }
-
-    it 'logs to STDOUT' do
-      expect(
-        ActiveSupport::Logger.logger_outputs_to?(Roqua.logger.logger, STDOUT)
-      ).to be_truthy
-    end
-
-    it 'logs using a datetimeformat including timezone' do
-      time = Time.zone.local(2021,10,10,16,13)
-      got = Roqua.logger.logger.formatter.call 'INFO', time, 'progname', '{}'
-      expect(got).to match(/I, \[2021-10-10T16:13:00.000\+0000 #\d+]  INFO -- progname: {}/)
-    end
-  end
-
-  context 'when RAILS_LOG_TO_STDOUT_USING_ROQUA_LOGGER is blank' do
-    include_examples 'RoQua logging setup'
-
-    let(:log_to_stdout) { '' }
-
-    it 'logs to a log file' do
-      expect(Roqua.logger.logger.instance_variable_get("@logdev").dev.path)
-        .to eql(Rails.root.join('log/test-events.log').to_s)
-    end
-  end
-end

data/spec/roqua/probes/delayed_job_probe_spec.rb

@@ -1,56 +0,0 @@
-require 'spec_helper'
-require 'delayed_job_active_record'
-require 'timecop'
-
-require 'roqua/probes/delayed_job_probe'
-
-describe Roqua::Probes::DelayedJobProbe do
-  before { Timecop.freeze }
-  after { Timecop.return }
-  subject(:probe) { described_class.new }
-
-  describe 'backlog_count' do
-    context 'if a single job unlocked job exists that has a run_at in the past' do
-      def create_jobs
-        Delayed::Job.create!(run_at: 1.second.ago)
-        2.times { Delayed::Job.create!(run_at: 1.second.ago, locked_at: Time.zone.now) }
-        Delayed::Job.create!(run_at: Time.zone.now)
-        Delayed::Job.create!(run_at: 1.second.from_now)
-      end
-
-      it 'returns 1' do
-        expect { create_jobs }.to change { probe.backlog_count }.from(0).to(1)
-      end
-    end
-  end
-
-  describe '#call' do
-    it 'sends the correct metric to Appsignal' do
-      expect(probe).to receive(:backlog_count).and_return(12)
-      expect(Appsignal).to receive(:set_gauge).with('delayed_job_backlog_count', 12)
-      probe.call
-    end
-
-    it 'increments the probe call counter' do
-      expect(Appsignal).to receive(:increment_counter).with('probe.call.completed', 1, probe_name: "delayed_job_probe")
-      probe.call
-    end
-  end
-
-  context '.enable' do
-    before { Appsignal::Minutely.probes.clear }
-    after { Appsignal::Minutely.probes.clear }
-
-    it 'adds our custom probes to Appsignal' do
-      expect { Roqua::Probes::DelayedJobProbe.enable }
-        .to change { Appsignal::Minutely.probes.count }.by(1)
-
-      expect(Appsignal::Minutely.probes[:"Roqua::Probes::DelayedJobProbe"]).to be
-    end
-
-    it 'will not add the same probe twice if called multiple times' do
-      expect { 2.times { Roqua::Probes::DelayedJobProbe.enable } }
-        .to change { Appsignal::Minutely.probes.count }.by(1)
-    end
-  end
-end

data/spec/roqua/probes/monitoring_probe_spec.rb

@@ -1,69 +0,0 @@
-require 'spec_helper'
-require 'delayed_job_active_record'
-require 'timecop'
-
-require 'roqua/probes/delayed_job_probe'
-
-describe Roqua::Probes::MonitoringProbe do
-  before { Timecop.freeze }
-  after { Timecop.return }
-  subject(:probe) { described_class.new }
-
-  before do
-    Roqua::Scheduling::CronJob.delete_all
-  end
-
-  describe '#call' do
-    it 'sends data to AppSignal' do
-      expect(Appsignal).to receive(:set_gauge).with('scheduler_delay_in_minutes', 10)
-      expect(probe).to receive(:longest_delay_in_minutes).and_return(10)
-      probe.call
-    end
-
-    it 'increments the probe call counter' do
-      expect(Appsignal).to receive(:increment_counter).with('probe.call.completed', 1, probe_name: "monitoring_probe")
-      probe.call
-    end
-  end
-
-  describe 'longest_delay' do
-    it 'returns 0 if there are no schedules' do
-      expect(probe.longest_delay_in_minutes).to eql(0)
-    end
-
-    it 'if there is a job that should have run 10 minutes ago' do
-      Roqua::Scheduling::CronJob.create!(
-        name: 'hourly', next_run_at: 10.minutes.ago
-      )
-      expect(probe.longest_delay_in_minutes).to eql(10)
-    end
-
-    it 'if there is a job that should have run 10 minutes ago and the previous job was completed 15 minutes ago' do
-      Roqua::Scheduling::CronJob.create!(
-        name: 'hourly', next_run_at: 10.minutes.ago, completed_at: 15.minutes.ago
-      )
-      expect(probe.longest_delay_in_minutes).to eql(10)
-    end
-
-    it 'if there is a job that should have run 10 minutes ago and was completed 5 minutes ago' do
-      Roqua::Scheduling::CronJob.create!(
-        name: 'hourly', next_run_at: 10.minutes.ago, completed_at: 5.minutes.ago
-      )
-      expect(probe.longest_delay_in_minutes).to eql(0)
-    end
-
-    it 'when there is a job in the future that was never completed' do
-      Roqua::Scheduling::CronJob.create!(
-        name: 'hourly', next_run_at: 3.minutes.from_now
-      )
-      expect(probe.longest_delay_in_minutes).to eql(0)
-    end
-
-    it 'when there is a job in the future that was completed' do
-      Roqua::Scheduling::CronJob.create!(
-        name: 'hourly', next_run_at: 3.minutes.from_now, completed_at: 1.minute.ago
-      )
-      expect(probe.longest_delay_in_minutes).to eql(0)
-    end
-  end
-end

data/spec/roqua/responders/active_interaction_aware_responder_spec.rb

@@ -1,54 +0,0 @@
-require "spec_helper"
-
-require 'roqua/responders/active_interaction_aware_responder'
-class AIAResponder < ActionController::Responder
-  include Roqua::Responders::ActiveInteractionAwareResponder
-end
-
-require 'active_interaction'
-class TestInteraction < ActiveInteraction::Base
-  string :some_string
-  def execute
-    {foo: some_string}
-  end
-end
-
-class ApplicationController < ActionController::Base
-  respond_to :json
-end
-
-describe Roqua::Responders::ActiveInteractionAwareResponder, type: :controller do
-  context 'with a valid interaction' do
-    controller(ApplicationController) do
-      self.responder  = AIAResponder
-      def index
-        use_case = TestInteraction.run some_string: 'bla'
-        respond_with use_case
-      end
-    end
-
-    subject { get :index, format: :json }
-
-    it 'returns the result if valid' do
-      subject
-      expect(response.body).to eq '{"foo":"bla"}'
-    end
-
-  end
-
-  context 'with an invalid interaction' do
-    controller(ApplicationController) do
-      self.responder  = AIAResponder
-      def index
-        use_case = TestInteraction.run
-        respond_with use_case
-      end
-    end
-    subject { post :index, format: :json }
-
-    it 'returns the interaction' do
-      subject
-      expect(response.body).to eq '{"errors":{"some_string":["is required"]}}'
-    end
-  end
-end

data/spec/roqua/responders/api_errors_responder_spec.rb

@@ -1,34 +0,0 @@
-require 'spec_helper'
-require 'roqua/responders/api_errors_responder'
-class AEResponder < ActionController::Responder
-  include Roqua::Responders::ApiErrorsResponder
-end
-
-class ApplicationController < ActionController::Base
-  respond_to :json
-end
-
-class SomeModel
-  include ActiveModel::Model
-
-  attr_accessor :name
-end
-
-describe Roqua::Responders::ApiErrorsResponder, type: :controller do
-  context 'with an invalid model' do
-    controller(ApplicationController) do
-      self.responder  = AEResponder
-      def index
-        sm = SomeModel.new name: 'foo'
-        sm.errors.add :name, "That is not a real name"
-        respond_with sm
-      end
-    end
-    subject { post :index, format: :json }
-
-    it 'returns the errors scoped on the object name' do
-      subject
-      expect(response.body).to eq '{"errors":{"some_model":{"name":["That is not a real name"]}}}'
-    end
-  end
-end