Initial commit

spec/services/schedule_pipeline/fetch_schedule_spec.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+RSpec.describe SchedulePipeline::FetchSchedule, type: :service do
+  let(:in_queue) { double(subscribe: nil) }
+  let(:out_queue) { double(push: nil) }
+  let(:errors) { double(push: nil) }
+  let(:service) { described_class.new(in_queue, out_queue, errors) }
+
+  describe '#start' do
+    it 'subscribes to the in_queue' do
+      service.start
+      expect(in_queue).to have_received(:subscribe)
+    end
+  end
+
+  describe '#process_msg' do
+    let(:player) { 'fake-player-identifier' }
+    let(:vendor) { :broad_sign }
+    let(:vendor_schedule) { JSON.parse(File.read('spec/services/vendors/broad_sign/broad_sign_player_schedule.json')).with_indifferent_access }
+    let(:vendor_fetch) { double(call: vendor_schedule) }
+    let(:params) { { player: player } }
+    let(:msg) { { params: params, vendor: vendor } }
+
+    before { allow(service).to receive(:for_vendor).and_return(vendor_fetch) }
+
+    context 'when successful' do
+      before { service.process_msg(msg) }
+
+      it 'fetches the player schedule from the vendor' do
+        expect(vendor_fetch).to have_received(:call).with(params).once
+      end
+
+      it 'pushes schedule to out_queue' do
+        expect(out_queue).to have_received(:push).with({ vendor: vendor, player: player, vendor_schedule: vendor_schedule }).once
+      end
+
+      it('raises no errors') { expect(errors).not_to have_received(:push) }
+    end
+
+    context 'when the vendor is unknown' do
+      before do
+        allow(service).to receive(:for_vendor).and_return(nil)
+        service.process_msg(msg)
+      end
+
+      it('raises an error') { expect(errors).to have_received(:push).once }
+    end
+  end
+end

spec/services/schedule_pipeline/process_schedule_spec.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+RSpec.describe SchedulePipeline::ProcessSchedule, type: :service do
+  let(:in_queue) { double(subscribe: nil) }
+  let(:out_queue) { double(push: nil) }
+  let(:errors) { double(push: nil) }
+  let(:service) { described_class.new(in_queue, out_queue, errors) }
+  let(:player) { 'fake-player-id' }
+  let(:vendor) { 'fake-vendor' }
+  let(:presigned_url) { SecureRandom.uuid }
+  let(:transformed_schedule) { {} }
+  let(:vendor_transform) { double(call: transformed_schedule) }
+
+  before do
+    allow(service).to receive(:create_asset).and_return({ asset: { meta: { presigned_url: presigned_url } } })
+    allow(service).to receive(:ingest_content) {}
+    allow(service).to receive(:for_vendor).and_return(vendor_transform)
+  end
+
+  describe '#start' do
+    it 'subscribes to the in_queue' do
+      service.start
+      expect(in_queue).to have_received(:subscribe)
+    end
+  end
+
+  describe '#process_msg' do
+    let(:vendor_schedule) { JSON.parse(File.read('spec/services/vendors/broad_sign/broad_sign_player_schedule.json')).with_indifferent_access }
+    let(:msg) { SchedulePipeline::Models::ScheduleProcessMsg.new(vendor, player, vendor_schedule) }
+    let(:content_count) { vendor_schedule[:contents].count }
+
+    context 'when successful' do
+      before { service.process_msg(msg) }
+
+      it 'processes the player schedule from the vendor' do
+        expect(vendor_transform).to have_received(:call).with(vendor, player, vendor_schedule, anything).once
+      end
+
+      it 'pushes schedule to out_queue' do
+        expect(out_queue).to have_received(:push).with(transformed_schedule).once
+      end
+
+      it 'creates each content asset' do
+        expect(service).to have_received(:create_asset).exactly(content_count).times
+      end
+
+      it 'ingests each content' do
+        expect(service).to have_received(:ingest_content).exactly(content_count).times
+      end
+
+      it('raises no errors') { expect(errors).not_to have_received(:push) }
+    end
+
+    context 'when the vendor is unknown' do
+      before do
+        allow(service).to receive(:for_vendor).and_return(nil)
+        service.process_msg(msg)
+      end
+
+      it('raises an error') { expect(errors).to have_received(:push).once }
+    end
+  end
+end

spec/services/schedule_pipeline/publish_schedule_spec.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+RSpec.describe SchedulePipeline::PublishSchedule, type: :service do
+  let(:queue) { double(subscribe: nil) }
+  let(:errors) { double(push: nil) }
+  let(:service) { described_class.new(queue, errors) }
+
+  describe '#start' do
+    it 'subscribes to the queue' do
+      service.start
+      expect(queue).to have_received(:subscribe)
+    end
+  end
+end

spec/services/schedule_pipeline/schedule_pipeline_spec.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+RSpec.describe SchedulePipeline::SchedulePipeline, type: :service do
+  let(:queue_factory) { double(for_name: nil) }
+
+  describe '#initialize' do
+    it 'uses 3 queues' do
+      described_class.new(queue_factory)
+      expect(queue_factory).to have_received(:for_name).with(:fetch_vendor_schedules)
+      expect(queue_factory).to have_received(:for_name).with(:unprocessed_schedules)
+      expect(queue_factory).to have_received(:for_name).with(:processed_schedules)
+    end
+  end
+
+  context 'after construction' do
+    let(:service) { described_class.new(queue_factory) }
+    let(:stages) { (1..3).collect{ double(start: nil, stop: nil) } }
+
+    before { allow(service).to receive(:stages).and_return(stages) }
+
+    describe '#start' do
+      it 'starts each stage' do
+        service.start
+        stages.each { |stg| expect(stg).to have_received(:start).once }
+      end
+    end
+
+    describe '#stop' do
+      it 'stops each stage' do
+        service.stop
+        stages.each { |stg| expect(stg).to have_received(:stop).once }
+      end
+    end
+  end
+end