g5_updatable 0.2.1 → 0.3.1

data/spec/lib/g5_updatable/client_feed_processor_spec.rb

@@ -1,38 +1,93 @@
 require "spec_helper"
 
 describe G5Updatable::ClientFeedProcessor do
-  let(:client_updater) { double(update: nil) }
-  let(:locations_updater) { double(update: nil) }
+  describe ".new" do
+    let(:processor) { described_class.new(passed_uid) }
+    subject(:client_uid) { processor.client_uid }
+    let(:configured_client_uid) { nil }
 
-  before do
-    allow(G5Updatable::ClientUpdater).to receive(:new) { client_updater }
-    allow(G5Updatable::LocationsUpdater).to receive(:new) { locations_updater }
-  end
-
-  describe "#work" do
-    after { described_class.new(urn).work }
-    let(:urn) { nil }
+    context "when CLIENT_UID is unset" do
+      context "with a passed-in client_uid" do
+        let(:passed_uid) { "passed" }
+        it { should eq("passed") }
+      end
 
-    context "a nil urn" do
-      before { allow(G5Updatable).to receive(:client_identifier) { nil } }
+      context "with no passed-in client_uid" do
+        let(:passed_uid) { nil }
 
-      it "does not call update on the client updater" do
-        expect(client_updater).to_not receive(:update)
+        it "explodes helpfully" do
+          expect { client_uid }.to raise_error(/client_uid/)
+        end
       end
+    end
 
-      it "does not call update on the locations updater" do
-        expect(locations_updater).to_not receive(:update)
+    context "when CLIENT_UID is set" do
+      before do
+        @old_client_uid   = ENV["CLIENT_UID"]
+        ENV["CLIENT_UID"] = "configured"
       end
-    end
+      after { ENV["CLIENT_UID"] = @old_client_uid }
 
-    context "a present urn" do
-      it "calls update on the client updater" do
-        expect(client_updater).to receive(:update)
+      context "with a passed-in client_uid" do
+        let(:passed_uid) { "passed" }
+        it { should eq("passed") }
       end
 
-      it "calls update on the locations updater" do
-        expect(locations_updater).to receive(:update)
+      context "with no passed-in client_uid" do
+        let(:passed_uid) { nil }
+        it { should eq("configured") }
       end
     end
   end
+
+  describe "#work" do
+    let(:client_updater) { double(update: nil) }
+    let(:locations_updater) { double(update: nil) }
+    let(:integration_settings_updater) { double(update: nil) }
+
+    let(:client) { G5FoundationClient::Client.new(uid:       client_uid,
+                                                  urn:       "urn",
+                                                  name:      "Client Name",
+                                                  locations: [{uid: location_uid, locations_integration_settings: [{uid: integration_setting_uid, vendor_action: 'inventory'}]}]) }
+    let(:client_uid) { "http://example.com/cilent_uid" }
+    let(:location_uid) { "http://example.com/cilent_uid/locations/location_uid" }
+    let(:integration_setting_uid) { "http://example.com/cilent_uid/locations/location_uid/integration_setting_uid" }
+
+    before do
+      stub_client_for_uid(client_uid, client)
+      allow(G5Updatable::ClientUpdater).to receive(:new) { client_updater }
+      allow(G5Updatable::LocationsUpdater).to receive(:new) { locations_updater }
+      allow(G5Updatable::IntegrationSettingsUpdater).to receive(:new) { integration_settings_updater }
+      G5Updatable::ClientFeedProcessor.new(client_uid).work
+    end
+
+    it "updates with the found client" do
+      expect(G5Updatable::ClientUpdater).to have_received(:new).with(client)
+      expect(client_updater).to have_received(:update)
+    end
+
+    it "updates with the client's associated locations" do
+      expect(G5Updatable::LocationsUpdater).to have_received(:new).with(client.locations)
+      expect(locations_updater).to have_received(:update)
+    end
+
+    it "updates with location's associated integration settings" do
+      expect(G5Updatable::IntegrationSettingsUpdater).to have_received(:new).with(client.locations.first.integration_settings)
+      expect(integration_settings_updater).to have_received(:update)
+    end
+  end
+
+  describe :load_all_clients do
+    let(:clients_url) { 'http://g5-hub-clients-url' }
+    let(:client_uids) { %w(uid-1 uid-2) }
+    before do
+      expect(G5FoundationClient::Client).to receive(:all_client_uids).with(clients_url).and_return(client_uids)
+      expect(G5Updatable::ClientFeedProcessor).to receive(:new).with('uid-1').and_return(double(:work1, work: 'work-1'))
+      expect(G5Updatable::ClientFeedProcessor).to receive(:new).with('uid-2').and_return(double(:work1, work: 'work-2'))
+    end
+
+    it 'loads every client' do
+      expect(G5Updatable::ClientFeedProcessor.load_all_clients(clients_url)).to eq(%w(work-1 work-2))
+    end
+  end
 end

data/spec/lib/g5_updatable/client_updater_spec.rb

@@ -1,58 +1,45 @@
 require "spec_helper"
 
 describe G5Updatable::ClientUpdater do
-  let(:feed_endpoint) { "#{Rails.root}/spec/support/" }
-  let(:client_identifier) { "client_feed.html" }
-  let(:client_uid) { "#{Rails.root}/spec/support/client_feed.html" }
-  let(:g5_client) { G5Updatable::FeedMapper.new(client_identifier).client }
-  let(:updater) { described_class.new(g5_client) }
+  let(:uid) { "http://example.com/uid" }
+  let(:properties) { {uid:  uid,
+                      urn:  "urn",
+                      name: "Client Name", } }
+  let(:g5_client) { G5FoundationClient::Client.new(properties) }
 
-  before do
-    allow(G5Updatable).to receive(:feed_endpoint) { feed_endpoint }
-    allow(G5Updatable).to receive(:client_identifier) { client_identifier }
-  end
+  let(:updater) { described_class.new(g5_client) }
 
   describe "#update" do
-    let!(:client) do
-      Fabricate(:client, uid: client_uid, name: "Foo", vertical: "Self-Storage")
-    end
+    subject { G5Updatable::Client.first }
 
-    context "update client disabled" do
-      it "does nothing" do
-        expect(client).to_not receive(:save)
-        updater.update
-      end
-    end
+    context "with no existing Client records" do
+      before { updater.update }
 
-    context "update client enabled" do
-      before { allow(G5Updatable).to receive(:update_client) { true } }
-
-      context "default parameters" do
-        it "updates the name attribute" do
-          expect { updater.update }.to change { client.reload.name }.
-            from("Foo").to("Farmhouse")
-        end
+      it "creates a Client" do
+        expect(G5Updatable::Client.count).to eq(1)
+      end
 
-        it "does not update other attributes" do
-          expect { updater.update }.not_to change { client.reload.vertical }
-        end
+      it 'does not redact keys in properties' do
+        expect(subject.properties.keys.collect(&:to_sym)).to eq(properties.keys)
       end
 
-      context "custom parameters" do
-        before do
-          allow(G5Updatable).to receive(:client_parameters) { [:name, :vertical] }
-        end
+      its(:uid) { should eq(uid) }
+      its(:urn) { should eq("urn") }
+      its(:name) { should eq("Client Name") }
+    end
 
-        it "updates the name attribute" do
-          expect { updater.update }.to change { client.reload.name }.
-            from("Foo").to("Farmhouse")
-        end
+    context "with an existing Client record" do
+      before do
+        FactoryGirl.create(:client, uid: uid, urn: "old")
+        updater.update
+      end
 
-        it "updates other attributes" do
-          expect { updater.update }.to change { client.reload.vertical }.
-            from("Self-Storage").to("Apartments")
-        end
+      it "does not create a new Client" do
+        expect(G5Updatable::Client.count).to eq(1)
       end
+
+      its(:urn) { should eq("urn") }
+      its(:name) { should eq("Client Name") }
     end
   end
 end

data/spec/lib/g5_updatable/integration_settings_updater_spec.rb

@@ -0,0 +1,48 @@
+require "spec_helper"
+
+describe G5Updatable::IntegrationSettingsUpdater do
+  let(:uid) { "http://example.com/uid" }
+  let(:name) { "integration setting name" }
+  let(:properties) { {uid:           uid,
+                      urn:           "urn",
+                      vendor_action: "inventory",
+                      location_uid:  "location_uid",
+                      job_frequency_in_minutes: 22,
+                      name:          name} }
+  let(:integration_setting) { G5FoundationClient::IntegrationSetting.new(properties) }
+
+  let(:updater) { described_class.new([integration_setting]) }
+
+  describe "#update" do
+    subject { G5Updatable::IntegrationSetting.first }
+
+    context "with no existing integration-setting records" do
+      before { updater.update }
+
+      it "creates a Location" do
+        expect(G5Updatable::IntegrationSetting.count).to eq(1)
+      end
+
+      its(:job_frequency_in_minutes) { should eq(22) }
+      its(:uid) { should eq(uid) }
+      its(:urn) { should eq("urn") }
+      its(:location_uid) { should eq("location_uid") }
+      its(:name) { should eq(name) }
+      its(:vendor_action) { should eq("inventory") }
+    end
+
+    context "with an existing integration-setting record" do
+      before do
+        create(:integration_setting, uid: uid, urn: "old")
+        updater.update
+      end
+
+      it "does not create a new IntegrationSetting" do
+        expect(G5Updatable::IntegrationSetting.count).to eq(1)
+      end
+
+      its(:urn) { should eq("urn") }
+      its(:name) { should eq(name) }
+    end
+  end
+end

data/spec/lib/g5_updatable/locations_updater_spec.rb

@@ -1,71 +1,48 @@
 require "spec_helper"
 
 describe G5Updatable::LocationsUpdater do
-  let(:feed_endpoint) { "#{Rails.root}/spec/support/" }
-  let(:client_identifier) { "updated_client_feed.html" }
-  let(:locations) { G5Updatable::FeedMapper.new(client_identifier).locations }
-  let(:g5_location) { locations.first }
-  let(:urn) { g5_location.uid.to_s.split("/").last }
-  let(:updater) { described_class.new(locations) }
+  let(:uid) { "http://example.com/uid" }
+  let(:properties) { {uid:        uid,
+                      urn:        "urn",
+                      client_uid: "client_uid",
+                      name:       "Location Name"} }
+  let(:g5_location) { G5FoundationClient::Location.new(properties) }
 
-  before do
-    allow(G5Updatable).to receive(:feed_endpoint) { feed_endpoint }
-    allow(G5Updatable).to receive(:client_identifier) { client_identifier }
-  end
+  let(:updater) { described_class.new([g5_location]) }
 
   describe "#update" do
-    let!(:location) do
-      Fabricate(:location, urn: urn, name: "Foo", neighborhood: "Eastside")
-    end
-
-    context "update locations disabled" do
-      before { allow(G5Updatable).to receive(:update_locations) { false } }
+    subject { G5Updatable::Location.first }
 
-      it "does not update existing locations" do
-        expect(locations).to_not receive(:save)
-        updater.update
-      end
+    context "with no existing Location records" do
+      before { updater.update }
 
-      it "creates new locations" do
-        expect { updater.update }.to change { Location.all.size }.from(1).to(2)
+      it "creates a Location" do
+        expect(G5Updatable::Location.count).to eq(1)
       end
-    end
 
-    context "update locations enabled" do
-      context "default parameters" do
-        it "updates the name attribute" do
-          expect { updater.update }.to change { location.reload.name }.
-            from("Foo").to("Hollywood")
-        end
 
-        it "does not update other attributes" do
-          expect { updater.update }.not_to change { location.reload.neighborhood }
-        end
-
-        it "creates new locations" do
-          expect { updater.update }.to change { Location.all.size }.from(1).to(2)
-        end
+      it 'does not redact keys in properties' do
+        expect(subject.properties.keys.collect(&:to_sym)).to eq(properties.keys)
       end
 
-      context "custom parameters" do
-        before do
-          allow(G5Updatable).to receive(:location_parameters) { [:name, :neighborhood] }
-        end
-
-        it "updates the name attribute" do
-          expect { updater.update }.to change { location.reload.name }.
-            from("Foo").to("Hollywood")
-        end
+      its(:uid) { should eq(uid) }
+      its(:urn) { should eq("urn") }
+      its(:client_uid) { should eq("client_uid") }
+      its(:name) { should eq("Location Name") }
+    end
 
-        it "updates other attributes" do
-          expect { updater.update }.to change { location.reload.neighborhood }.
-            from("Eastside").to("River West")
-        end
+    context "with an existing Location record" do
+      before do
+        FactoryGirl.create(:location, uid: uid, urn: "old")
+        updater.update
+      end
 
-        it "creates new locations" do
-          expect { updater.update }.to change { Location.all.size }.from(1).to(2)
-        end
+      it "does not create a new Location" do
+        expect(G5Updatable::Location.count).to eq(1)
       end
+
+      its(:urn) { should eq("urn") }
+      its(:name) { should eq("Location Name") }
     end
   end
 end

data/spec/lib/generators/g5_updatable/install_generator_spec.rb

@@ -11,18 +11,6 @@ describe G5Updatable::InstallGenerator, type: :generator do
     run_generator
   end
 
-  it "should copy the g5_updatable initializer" do
-    expect(destination_root).to have_structure {
-      directory "config" do
-        directory "initializers" do
-          file "g5_updatable.rb" do
-            contains "G5Updatable.setup do |config|"
-          end
-        end
-      end
-    }
-  end
-
   it "should mount the engine" do
     expect(destination_root).to have_structure {
       directory "config" do

data/spec/models/g5_updatable/client_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe G5Updatable::Client do
+  describe "validations" do
+    subject(:client) { G5Updatable::Client.new }
+
+    it { expect(client).to validate_presence_of(:uid) }
+    it { expect(client).to validate_presence_of(:urn) }
+  end
+
+  it_behaves_like "a model with first-class properties" do
+    let(:instance_factory_name) { :client }
+  end
+
+  it_behaves_like "a model that uses its URN as its parameter" do
+    let(:instance_factory_name) { :client }
+  end
+
+  describe :locations do
+    let!(:location) { create(:location, client_uid: subject.uid) }
+    subject { create(:client) }
+
+    its(:locations) { is_expected.to eq([location]) }
+  end
+end

data/spec/models/g5_updatable/integration_setting_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+describe G5Updatable::IntegrationSetting do
+  describe 'validations' do
+    subject(:integration_setting) { G5Updatable::IntegrationSetting.new }
+    it { expect(integration_setting).to validate_presence_of(:location_uid) }
+    it { expect(integration_setting).to validate_presence_of(:uid) }
+  end
+
+  it_behaves_like 'a model with first-class properties' do
+    let(:instance_factory_name) { :integration_setting }
+  end
+
+  it_behaves_like 'a model that uses its URN as its parameter' do
+    let(:instance_factory_name) { :client }
+  end
+
+  describe "#location" do
+    let(:integration_setting) { create(:integration_setting, location_uid: location.uid) }
+    let(:location) { create(:location) }
+    subject { integration_setting.location }
+
+    it { should eq(location) }
+  end
+
+  describe :by_vendor_action do
+    let!(:inventory) { create(:integration_setting, vendor_action: G5Updatable::IntegrationSetting::INVENTORY) }
+    let!(:lead) { create(:integration_setting, vendor_action: G5Updatable::IntegrationSetting::LEAD) }
+
+    it { expect(G5Updatable::IntegrationSetting.by_lead).to eq([lead]) }
+    it { expect(G5Updatable::IntegrationSetting.by_inventory).to eq([inventory]) }
+  end
+end

data/spec/models/g5_updatable/location_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+describe G5Updatable::Location do
+  describe "validations" do
+    subject(:location) { G5Updatable::Location.new }
+
+    it { expect(location).to validate_presence_of(:uid) }
+    it { expect(location).to validate_presence_of(:urn) }
+    it { expect(location).to validate_presence_of(:client_uid) }
+  end
+
+  it_behaves_like "a model with first-class properties" do
+    let(:instance_factory_name) { :location }
+  end
+
+  it_behaves_like "a model that uses its URN as its parameter" do
+    let(:instance_factory_name) { :location }
+  end
+
+  describe "#client" do
+    let(:client) { FactoryGirl.create(:client) }
+    let(:location) { FactoryGirl.create(:location, client_uid: client.uid) }
+    subject { location.client }
+
+    it { should eq(client) }
+  end
+
+  describe :integration_settings do
+    let!(:integration_setting) { create(:integration_setting, location_uid: subject.uid) }
+    subject { create(:location) }
+
+    its(:integration_settings) { is_expected.to eq([integration_setting]) }
+  end
+end