Include flows for creating suppliers and associated workers.

lib/concierge/entities/background_worker.rb

@@ -20,6 +20,22 @@
 class BackgroundWorker
   include Hanami::Entity
 
+  # possible values for the +type+ column of a background worker:
+  #
+  # +metadata+       - where processing of property metadata is fetched, parsed and
+  #                    synchronised with Roomorama. Includes property images.
+  # +availabilities+ - processing of the calendar of availabilities for a property.
+  #                    Indicates availabilities and prices.
+  TYPES    = %w(metadata availabilities)
+
+  # possibile statuses a worker can be in:
+  #
+  # +idle+    - the background worker is not being run, and the +next_run_at+ column
+  #             stores a timestamp in the future.
+  # +running+ - the background worker is currently running and therefore should not
+  #             be rescheduled.
+  STATUSES = %w(idle running)
+
   attributes :id, :supplier_id, :next_run_at, :interval, :type, :status,
     :created_at, :updated_at
 end

lib/concierge/flows/external_error_creation.rb

@@ -1,6 +1,6 @@
 module Concierge::Flows
 
-  # +UseCases::ExtennalErrorCreation+
+  # +Concierge::Flows::ExternalErrorCreation+
   #
   # This use case class wraps the creation of an +ExternalError+ record, performing
   # attribute validations prior to triggering the database call.

lib/concierge/flows/supplier_creation.rb

@@ -0,0 +1,121 @@
+module Concierge::Flows
+
+  # +Concierge::Flows::BackgroundWorkerCreation+
+  #
+  # This class encapsulates the flow of creating a background worker for a given
+  # supplier, validating the parameters and interpreting human-readable interval
+  # times, such as "1d" for one day, and generating the resulting number of seconds
+  # to be stored in the database.
+  class BackgroundWorkerCreation
+    include Hanami::Validations
+
+    INTERVAL_FORMAT = /^\s*(?<amount>\d+)\s*(?<unit>[smhd])\s*$/
+
+    attribute :supplier_id, presence: true
+    attribute :interval,    presence: true, format:    INTERVAL_FORMAT
+    attribute :type,        presence: true, inclusion: BackgroundWorker::TYPES
+    attribute :status,      presence: true, inclusion: BackgroundWorker::STATUSES
+
+    def perform
+      if valid?
+        worker = find_existing || build_new
+
+        # set the values passed to make sure that changes in the parameters update
+        # existing records.
+        worker.interval = interpret_interval(interval)
+        worker.type     = type
+        worker.status   = status
+
+        worker = BackgroundWorkerRepository.persist(worker)
+        Result.new(worker)
+      else
+        Result.error(:invalid_parameters)
+      end
+    end
+
+    private
+
+    def find_existing
+      workers = BackgroundWorkerRepository.for_supplier(supplier).to_a
+      workers.find { |worker| worker.type == type }
+    end
+
+    def build_new
+      BackgroundWorker.new(supplier_id: supplier_id)
+    end
+
+    def interpret_interval(interval)
+      match    = INTERVAL_FORMAT.match(interval)
+      absolute = match[:amount].to_i
+
+      case match[:unit]
+      when "s"
+        absolute
+      when "m"
+        absolute * 60
+      when "h"
+        absolute * 60 * 60
+      when "d"
+        absolute * 60 * 60 * 24
+      end
+    end
+
+    def supplier
+      @supplier ||= SupplierRepository.find(supplier_id)
+    end
+
+    def attributes
+      to_h
+    end
+  end
+
+  # +Concierge::Flows::SupplierCreation+
+  #
+  # This class encapsulates the creation of supplier, a including associated
+  # background workers. Suppleirs are composed of a +name+ only. A definition of
+  # the workers is also expected by this class.
+  class SupplierCreation
+    include Hanami::Validations
+
+    attribute :name,    presence: true
+    attribute :workers, presence: true
+
+    # creates database records for the supplier and background workers.
+    # Returns a +Result+ instance wrapping the resulting +Supplier+ instance,
+    # or an error in case the parameters are not valid.
+    def perform
+      if valid?
+        name     = attributes[:name]
+        supplier = SupplierRepository.named(name) || create_supplier(attributes[:name])
+
+        attributes[:workers].each do |type, data|
+          result = BackgroundWorkerCreation.new(
+            supplier_id: supplier.id,
+            interval:    data[:every],
+            type:        type.to_s,
+            status:      "idle"
+          ).perform
+
+          return result unless result.success?
+        end
+
+        Result.new(supplier)
+      else
+        Result.error(:invalid_parameters)
+      end
+    end
+
+    private
+
+    def create_supplier(name)
+      SupplierRepository.create(
+        Supplier.new(name: attributes[:name])
+      )
+    end
+
+    def attributes
+      to_h
+    end
+  end
+
+end

spec/lib/concierge/flows/supplier_creation_spec.rb

@@ -0,0 +1,140 @@
+require "spec_helper"
+
+RSpec.describe Concierge::Flows::SupplierCreation do
+  let(:parameters) {
+    {
+      name: "Supplier X",
+      workers: {
+        metadata: {
+          every: "1d"
+        },
+        availabilities: {
+          every: "2h"
+        }
+      }
+    }
+  }
+
+  subject { described_class.new(parameters) }
+
+  describe "#perform" do
+    it "returns an unsuccessful result without a valid name" do
+      [nil, ""].each do |invalid_name|
+        parameters[:name] = invalid_name
+
+        result = subject.perform
+        expect(result).to be_a Result
+        expect(result).not_to be_success
+        expect(result.error.code).to eq :invalid_parameters
+      end
+    end
+
+    it "returns an unsuccessful result without a workers definition" do
+      parameters.delete(:workers)
+
+      result = subject.perform
+      expect(result).to be_a Result
+      expect(result).not_to be_success
+      expect(result.error.code).to eq :invalid_parameters
+    end
+
+    it "returns an unsuccessful result if parameters for the workers are missing" do
+      parameters[:workers][:metadata].delete(:every)
+
+      result = subject.perform
+      expect(result).to be_a Result
+      expect(result).not_to be_success
+      expect(result.error.code).to eq :invalid_parameters
+    end
+
+    it "returns an unsuccessful result if the worker type is unknown" do
+      parameters[:workers][:invalid] = parameters[:workers].delete(:metadata)
+
+      result = subject.perform
+      expect(result).to be_a Result
+      expect(result).not_to be_success
+      expect(result.error.code).to eq :invalid_parameters
+    end
+
+    it "returns an unsuccessful result if the interval specified is not recognised" do
+      parameters[:workers][:metadata][:every] = "invalid"
+
+      result = subject.perform
+      expect(result).to be_a Result
+      expect(result).not_to be_success
+      expect(result.error.code).to eq :invalid_parameters
+    end
+
+    it "creates supplier and associated workers" do
+      expect {
+        expect {
+          expect(subject.perform).to be_success
+        }.to change { SupplierRepository.count }.by(1)
+      }.to change { BackgroundWorkerRepository.count }.by(2)
+
+      supplier = SupplierRepository.last
+      workers  = BackgroundWorkerRepository.for_supplier(supplier).to_a
+
+      expect(supplier.name).to eq "Supplier X"
+      expect(workers.size).to eq 2
+
+      worker = workers.first
+      expect(worker.type).to eq "metadata"
+      expect(worker.next_run_at).to be_nil
+      expect(worker.interval).to eq 24 * 60 * 60 # one day
+      expect(worker.status).to eq "idle"
+
+      worker = workers.last
+      expect(worker.type).to eq "availabilities"
+      expect(worker.next_run_at).to be_nil
+      expect(worker.interval).to eq 2 * 60 * 60 # two hours
+      expect(worker.status).to eq "idle"
+    end
+
+    it "updates changed data on consecutive runs" do
+      subject.perform
+
+      supplier = SupplierRepository.named("Supplier X")
+      workers  = BackgroundWorkerRepository.for_supplier(supplier).to_a
+      metadata_worker = workers.find { |w| w.type == "metadata" }
+
+      expect(metadata_worker.interval).to eq 24 * 60 * 60
+
+      # updates metadata worker interval to every 2 days
+      parameters[:workers][:metadata][:every] = "2d"
+
+      expect {
+        subject.perform
+      }.not_to change { SupplierRepository.count }
+
+      metadata_worker = BackgroundWorkerRepository.find(metadata_worker.id)
+      expect(metadata_worker.interval).to eq 2 * 24 * 60 * 60 # 2 days
+    end
+
+    context "interval parsing" do
+      it "understands seconds notation" do
+        parameters[:workers][:availabilities][:every] = "10s"
+        subject.perform
+
+        supplier = SupplierRepository.named("Supplier X")
+        worker   = BackgroundWorkerRepository.
+          for_supplier(supplier).
+          find { |w| w.type == "availabilities" }
+
+        expect(worker.interval).to eq 10
+      end
+
+      it "understands minutes notation" do
+        parameters[:workers][:availabilities][:every] = "10m"
+        subject.perform
+
+        supplier = SupplierRepository.named("Supplier X")
+        worker   = BackgroundWorkerRepository.
+          for_supplier(supplier).
+          find { |w| w.type == "availabilities" }
+
+        expect(worker.interval).to eq 10 * 60
+      end
+    end
+  end
+end