g5_updatable 0.10.3 → 0.20.3.pre.1

data/spec/lib/g5_updatable/client_updater_spec.rb

@@ -1,23 +1,32 @@
-require "spec_helper"
+require 'spec_helper'
 
 describe G5Updatable::ClientUpdater do
-  let(:uid) { "http://example.com/uid" }
+  let(:uid) { 'http://example.com/uid' }
+  let(:urn) { 'urn' }
   let(:properties) { {uid:  uid,
-                      urn:  "urn",
-                      name: "Client Name", } }
-  let(:g5_client) { G5FoundationClient::Client.new(properties) }
+                      urn:  urn,
+                      name: 'Client Name', } }
 
-  let(:updater) { described_class.new(g5_client) }
+  let(:updater) { described_class.new(properties) }
 
-  describe "#update" do
+  describe '#update' do
+    let(:callback_1) { Proc.new { |g5_client| @callback_1_called = true } }
+    let(:callback_2) { Proc.new { |g5_client| @callback_2_called = true } }
     subject { G5Updatable::Client.first }
 
-    context "with no existing Client records" do
+    before do
+      described_class.on_create(&callback_1)
+      described_class.on_create(&callback_2)
+      @callback_1_called = false
+      @callback_2_called = false
+    end
+
+    context 'with no existing Client records' do
       before { updater.update }
 
       let(:name) { 'Client Name' }
 
-      it "creates a Client" do
+      it 'creates a Client' do
         expect(G5Updatable::Client.count).to eq(1)
       end
 
@@ -25,40 +34,63 @@ describe G5Updatable::ClientUpdater do
         expect(subject.properties.keys.collect(&:to_sym)).to eq(properties.keys)
       end
 
-      its(:uid) { should eq(uid) }
-      its(:urn) { should eq("urn") }
-      its(:name) { should eq(name) }
+      its(:uid) { is_expected.to eq(uid) }
+      its(:urn) { is_expected.to eq('urn') }
+      its(:name) { is_expected.to eq(name) }
 
       it 'sets name field so that consumers can easily sort by name' do
         subject
         expect(G5Updatable::Client.find_by_name(name)).to eq(subject)
       end
+
+      it 'fires the specified on_create callbacks' do
+        expect(@callback_1_called).to be true
+        expect(@callback_2_called).to be true
+      end
     end
 
-    context "with an existing Client record" do
+    context 'with an existing Client record' do
       before do
-        FactoryGirl.create(:client, uid: uid, urn: "old")
+        FactoryGirl.create(:client, uid: 'old', urn: urn)
         updater.update
       end
 
-      it "does not create a new Client" do
+      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  
+      its(:uid) { is_expected.to eq(uid) }
+      its(:name) { is_expected.to eq('Client Name') }
 
-    context "with an existing identical Client record" do
+      it 'does not fire any on_create callbacks' do
+        expect(@callback_1_called).to be false
+        expect(@callback_2_called).to be false
+      end
+    end
+
+    context 'with an existing identical Client record' do
       before do
-        client = FactoryGirl.create(:client, uid: uid, urn: "urn", name: "Client Name", properties: properties)
+        FactoryGirl.create(:client, uid: uid, urn: 'urn', name: 'Client Name', properties: properties)
         @original_updated_at = subject.updated_at
         updater.update
-      end  
+      end
 
-      it "updates its timestamp" do
+      it 'updates its timestamp' do
         expect(subject.reload.updated_at).to be > @original_updated_at
       end
-    end  
+    end
+
+    describe 'with locations' do
+      let(:created_client) { G5Updatable::Client.last }
+
+      let(:properties) do
+        JSON.parse(fixture('client-g5-c-1soj8m6e-g5-multifamily.json'))['client']
+      end
+
+      it 'creates the locations' do
+        expect { updater.update }.to change { G5Updatable::Location.count }.by(5)
+        expect(created_client.locations.collect(&:urn)).to match_array(%w(g5-cl-1soj9pe2-541-apartments g5-cl-1soja3fn-99-apartments g5-cl-560belmk8-denali g5-cl-i2xqm52t-mockup-design-3 g5-cl-i2gg3rv8-g5-apartments))
+      end
+    end
   end
 end

data/spec/lib/g5_updatable/locations_updater_spec.rb

@@ -1,24 +1,22 @@
 require "spec_helper"
 
 describe G5Updatable::LocationsUpdater do
-  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) }
-  let(:g5_locations) { [g5_location] }
-  let(:g5_foundation_client) { G5FoundationClient::Client.new(urn: "urn", uid: "client_uid") }
-
-  let(:updater) { described_class.new(g5_foundation_client) }
-
-  before do
-    allow(g5_foundation_client).to receive(:locations) { g5_locations }
+  let(:name) { properties['name'] }
+  let(:uid) { properties['uid'] }
+  let(:client_uid) { properties['client_uid'] }
+  let(:client_urn) { properties['client_uid'].split('/').last }
+  let(:urn) { properties['urn'] }
+  let(:latitude) { properties['latitude'] }
+  let(:longitude) { properties['longitude'] }
+  let(:properties) do
+    JSON.parse(fixture('location-g5-cl-1soj9pe2-541-apartments.json'))['location']
   end
+  let(:options) { {} }
+  let(:updater) { described_class.new(properties, options) }
 
   shared_examples 'does not destroy existing clients and locations' do
     let!(:existing_client) { FactoryGirl.create(:client) }
-    let!(:existing_location) { FactoryGirl.create(:location, client_uid: existing_client.uid)}
+    let!(:existing_location) { FactoryGirl.create(:location, client_uid: existing_client.uid) }
 
     it 'does not destroy the existing client or location' do
       expect(G5Updatable::Client.find(existing_client.id)).to_not be_nil
@@ -27,62 +25,94 @@ describe G5Updatable::LocationsUpdater do
   end
 
   describe "#update" do
-
-
     subject { G5Updatable::Location.last }
 
     context "with no existing Location records" do
       before { updater.update }
 
-      let(:name) { 'Location Name' }
-
       it "creates a Location" do
         expect(G5Updatable::Location.count).to eq(1)
       end
 
 
-      it 'does not redact keys in properties' do
-        expect(subject.properties.keys.collect(&:to_sym)).to eq(properties.keys)
+      it 'redacts amenities key' do
+        expect(subject.properties.keys.collect(&:to_sym)).to eq(properties.keys.collect(&:to_sym) - [:amenities])
       end
 
-      its(:uid) { should eq(uid) }
-      its(:urn) { should eq("urn") }
-      its(:client_uid) { should eq("client_uid") }
-      its(:name) { should eq(name) }
+      its(:uid) { is_expected.to eq(uid) }
+      its(:urn) { is_expected.to eq(urn) }
+      its(:client_uid) { is_expected.to eq(client_uid) }
+      its(:client_urn) { is_expected.to eq(client_urn
+                                        ) }
+      its(:name) { is_expected.to eq(name) }
+      its(:latitude) { is_expected.to eq(latitude) }
+      its(:longitude) { is_expected.to eq(longitude) }
 
       it 'sets name field so that consumers can easily sort by name' do
         subject
         expect(G5Updatable::Location.find_by_name(name)).to eq(subject)
       end
 
+      it 'creates amenities' do
+        subject
+        expect(subject.hub_amenities.count).to eq(2)
+        expect(subject.hub_amenities.collect(&:name)).to match_array(['Power', 'WIFI'])
+        expect(subject.hub_amenities.collect(&:icon)).to match_array(%w(fa-electric-outlet fa-wifi))
+        expect(subject.hub_amenities.first.external_updated_at).to be_present
+        expect(subject.hub_amenities.first.external_created_at).to be_present
+      end
+
       it_behaves_like 'does not destroy existing clients and locations'
     end
 
 
-    context "with an existing Location record" do
+    context 'with an existing Location record' do
+      let(:old_amenity) { create(:hub_amenity) }
       before do
-        FactoryGirl.create(:location, uid: uid, urn: "old")
+        location = FactoryGirl.create(:location, uid: 'old', urn: urn, client_uid: client_urn)
+        location.hub_amenities << old_amenity
         updater.update
       end
 
-      it "does not create a new Location" do
+      it 'does not create a new Location' do
         expect(G5Updatable::Location.count).to eq(1)
       end
 
+      its(:urn) { is_expected.to eq(urn) }
+      its(:name) { is_expected.to eq name }
 
+      it 'updates amenities' do
+        expect(subject.hub_amenities.collect(&:name)).to match_array(['Power', 'WIFI'])
+      end
 
-      its(:urn) { should eq("urn") }
-      its(:name) { should eq("Location Name") }
+      it 'sets flat amenities for easier exclusive querying' do
+        expect(subject.flat_amenity_names).to eq('|Power|WIFI|')
+      end
 
       it_behaves_like 'does not destroy existing clients and locations'
+
+      context 'destroy_orphaned_locations set to false' do
+        before do
+          expect(updater).to_not receive :destroy_orphaned_locations!
+        end
+
+        it "does not create a new Location" do
+          expect(G5Updatable::Location.count).to eq(1)
+        end
+
+        its(:urn) { is_expected.to eq(urn) }
+        its(:name) { is_expected.to eq name }
+
+        it_behaves_like 'does not destroy existing clients and locations'
+      end
     end
 
     context "with an existing identical Location record" do
       before do
-        loc = FactoryGirl.create(:location, uid: uid, urn: "urn", client_uid: "client_uid", name: "Location Name", properties: properties)
+        FactoryGirl.create(:location, uid: uid, urn: urn, client_uid: "client_uid", name: name, properties: properties, updated_at: 1.hour.ago)
         @original_updated_at = subject.updated_at
         updater.update
-      end  
+      end
 
       it "updates its timestamp" do
         expect(subject.reload.updated_at).to be > @original_updated_at
@@ -90,47 +120,69 @@ describe G5Updatable::LocationsUpdater do
 
       it_behaves_like 'does not destroy existing clients and locations'
 
-    end  
+    end
 
     context "with no locations" do
       let(:g5_locations) { [] }
+      let(:options) { {destroy_orphaned_locations: true} }
 
       before do
-        FactoryGirl.create(:location, uid: uid, urn: "another_urn", client_uid: "client_uid", name: "Location Name", properties: properties)
-        FactoryGirl.create(:location, uid: uid, urn: "some_urn", client_uid: "another_client_uid", name: "Location Name", properties: properties)
+        FactoryGirl.create(:location, uid: uid, urn: "another_urn", client_urn: client_urn, client_uid: "client_uid", name: name, properties: properties)
+        FactoryGirl.create(:location, uid: uid, urn: "some_urn", client_uid: "another_client_uid", name: name, properties: properties)
         updater.update
-      end 
+      end
 
       it "deletes locations" do
         expect(G5Updatable::Location.by_client_uid("client_uid").count).to eq(0)
         expect(G5Updatable::Location.by_client_uid("another_client_uid").count).to eq(1)
-      end  
-    end  
+      end
+    end
 
     context "with an orphaned location" do
+      let(:options) { {destroy_orphaned_locations: true} }
       before do
-        FactoryGirl.create(:location, uid: "another_uid", urn: "dead_urn", client_uid: "client_uid")
+        FactoryGirl.create(:location, uid: "another_uid", urn: "dead_urn", client_urn: client_urn)
         updater.update
-      end  
+      end
 
       it "deletes locations" do
-        expect(G5Updatable::Location.by_urn("urn").by_client_uid("client_uid").count).to eq(1)
-        expect(G5Updatable::Location.by_urn("dead_urn").by_client_uid("client_uid").count).to eq(0)
-      end  
-    end 
+        expect(G5Updatable::Location.by_urn(urn).by_client_urn(client_urn).count).to eq(1)
+        expect(G5Updatable::Location.by_urn("dead_urn").by_client_urn(client_urn).count).to eq(0)
+      end
+    end
 
     context "callbacks" do
       before do
-        FactoryGirl.create(:location, uid: uid, urn: "old")
-        @callback_called = false
+        FactoryGirl.create(:location, uid: 'old', urn: urn)
+        @update_callback_called = false
+        @create_callback_called = false
+        described_class.on_update { |_location| @update_callback_called = true }
+        described_class.on_create { |_location| @create_callback_called = true }
       end
 
-      it "calls callbacks passing the location that was updated" do
-        described_class.on_update { |location| @callback_called = true }
+      describe "update callbacks" do
+        it "calls update callbacks passing the location that was updated" do
+          expect(@update_callback_called).to be false
+          updater.update
+          expect(@update_callback_called).to be true
+        end
+      end
 
-        expect(@callback_called).to be false
-        updater.update
-        expect(@callback_called).to be true
+      describe "create callbacks" do
+        it "skips create callbacks when the location already exists" do
+          updater.update
+          expect(@create_callback_called).to be false
+        end
+
+        context 'with some new locations' do
+          let(:new_properties) do
+            JSON.parse(fixture('client-g5-c-1soj8m6e-g5-multifamily.json'))['client']['locations']
+          end
+          it "calls create callbacks for a new location" do
+            described_class.new(new_properties, options).update
+            expect(@create_callback_called).to be true
+          end
+        end
       end
     end
   end
@@ -141,18 +193,18 @@ describe G5Updatable::LocationsUpdater do
     end
 
     it "adds to the #update callbacks" do
-      callback_1 = -> (location) {}
-      callback_2 = -> (location) {}
+      callback_1 = -> (location, anything) {}
+      callback_2 = -> (location, anything) {}
       described_class.on_update(&callback_1)
       described_class.on_update(&callback_2)
 
       expect(described_class.on_update_callbacks).
-        to eq([callback_1, callback_2])
+          to eq([callback_1, callback_2])
     end
 
     it "passes the location into each callback" do
       accumulator = []
-      callback = -> (location) { accumulator << location.id }
+      callback    = -> (location, anything) { accumulator << location.id }
       described_class.on_update(&callback)
 
       updater.update
@@ -169,4 +221,38 @@ describe G5Updatable::LocationsUpdater do
     end
   end
 
+  describe ".on_create and .on_create_callbacks" do
+    before do
+      described_class.on_create_callbacks = []
+    end
+
+    it "adds to the #update callbacks" do
+      callback_1 = -> (location) {}
+      callback_2 = -> (location) {}
+      described_class.on_create(&callback_1)
+      described_class.on_create(&callback_2)
+
+      expect(described_class.on_create_callbacks).
+          to eq([callback_1, callback_2])
+    end
+
+    it "passes the location into each callback" do
+      accumulator = []
+      callback    = -> (location) { accumulator << location.id }
+      described_class.on_create(&callback)
+
+      updater.update
+      location = G5Updatable::Location.first
+
+      expect(accumulator).to include(location.id)
+    end
+  end
+
+  describe ".on_create_callbacks" do
+    it "defaults to an empty array" do
+      described_class.on_create_callbacks = nil
+      expect(described_class.on_create_callbacks).to be_empty
+    end
+  end
+
 end

data/spec/models/g5_updatable/client_spec.rb

@@ -6,6 +6,8 @@ describe G5Updatable::Client do
 
     it { expect(client).to validate_presence_of(:uid) }
     it { expect(client).to validate_presence_of(:urn) }
+    it { expect(client).to validate_uniqueness_of(:urn) }
+    it { expect(client).to have_many :locations }
   end
 
   it_behaves_like "a model with first-class properties" do

data/spec/models/g5_updatable/hub_amenities_location_spec.rb

@@ -0,0 +1,6 @@
+require 'spec_helper'
+
+describe G5Updatable::HubAmenitiesLocation do
+  it { is_expected.to belong_to :location }
+  it { is_expected.to belong_to :hub_amenity }
+end

data/spec/models/g5_updatable/hub_amenity_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+describe G5Updatable::HubAmenity do
+  it { is_expected.to validate_presence_of :external_id }
+
+  describe 'scopes' do
+    let!(:location) { create(:g5mf_location) }
+    let!(:amenity) { create(:hub_amenity) }
+    let!(:amenity2) { create(:hub_amenity) }
+    let!(:amenity3) { create(:hub_amenity) }
+
+    before do
+      location.hub_amenities << amenity
+      location.hub_amenities << amenity2
+    end
+
+    describe '#by_client_urn' do
+      specify { expect(described_class.by_client_urn(location.client_urn)).to match_array([amenity, amenity2]) }
+    end
+
+    describe '#by_client_urns' do
+      specify { expect(described_class.by_client_urns([location.client_urn])).to match_array([amenity, amenity2]) }
+    end
+
+    describe '#by_client_uid' do
+      specify { expect(described_class.by_client_uid(location.client_uid)).to match_array([amenity, amenity2]) }
+    end
+  end
+end