patronus_fati 1.1.2 → 1.2.0

data/spec/patronus_fati/data_models/client_spec.rb

@@ -0,0 +1,350 @@
+require 'spec_helper'
+
+RSpec.describe(PatronusFati::DataModels::Client) do
+  subject { described_class.new('00:11:22:33:44:55') }
+
+  it_behaves_like 'a common stateful model'
+
+  context '#add_access_point' do
+    it 'should not add an access point more than once' do
+      sample_mac = '33:33:33:44:44:44'
+      subject.access_point_bssids = [ sample_mac ]
+
+      expect { subject.add_access_point(sample_mac) }
+        .to_not change { subject.access_point_bssids }
+    end
+
+    it 'should add an access point if it\'s not presently in the list' do
+      sample_mac = '99:11:22:ff:23:00'
+
+      expect(subject.access_point_bssids).to be_empty
+      expect { subject.add_access_point(sample_mac) }
+        .to change { subject.access_point_bssids }.from([]).to([sample_mac])
+    end
+  end
+
+  context '#announce_changes' do
+    before(:each) do
+      PatronusFati::DataModels::AccessPoint.instance_variable_set(:@instances, nil)
+      PatronusFati::DataModels::Client.instance_variable_set(:@instances, nil)
+      PatronusFati::DataModels::Connection.instance_variable_set(:@instances, nil)
+    end
+
+    it 'should emit no events when the client isn\'t valid' do
+      expect(subject).to receive(:dirty?).and_return(true)
+      expect(subject).to receive(:valid?).and_return(false)
+
+      expect(PatronusFati.event_handler).to_not receive(:event)
+      subject.announce_changes
+    end
+
+    it 'should emit no events when the instance isn\'t dirty' do
+      expect(subject).to receive(:dirty?).and_return(false)
+
+      expect(PatronusFati.event_handler).to_not receive(:event)
+      subject.announce_changes
+    end
+
+    it 'should emit a new client event when dirty and unsynced' do
+      expect(subject).to receive(:dirty?).and_return(true)
+      expect(subject).to receive(:valid?).and_return(true)
+      subject.presence.mark_visible
+
+      expect(PatronusFati.event_handler)
+        .to receive(:event).with(:client, :new, anything, anything)
+      subject.announce_changes
+    end
+
+    it 'should emit a changed client event when dirty and synced as online' do
+      subject.presence.mark_visible
+      subject.mark_synced
+
+      expect(subject).to receive(:dirty?).and_return(true)
+      expect(subject).to receive(:valid?).and_return(true)
+
+      expect(PatronusFati.event_handler)
+        .to receive(:event).with(:client, :changed, anything, anything)
+      subject.announce_changes
+    end
+
+    it 'should emit a changed client event when dirty and synced as offline' do
+      subject.mark_synced
+      expect(subject.active?).to be_falsey
+
+      subject.presence.mark_visible
+
+      expect(subject).to receive(:valid?).and_return(true)
+      expect(PatronusFati.event_handler)
+        .to receive(:event).with(:client, :changed, anything, anything)
+      subject.announce_changes
+    end
+
+    it 'should emit an offline client event when the client becomes inactive' do
+      subject.presence.mark_visible
+      subject.mark_synced
+      expect(subject.active?).to be_truthy
+
+      expect(subject).to receive(:valid?).and_return(true)
+      expect(subject).to receive(:active?).and_return(false).exactly(3).times
+
+      expect(PatronusFati.event_handler)
+        .to receive(:event).with(:client, :offline, anything, anything)
+      subject.announce_changes
+    end
+
+    it 'should reset the presence first_seen value when announced offline' do
+      subject.presence.mark_visible
+      subject.mark_synced
+      expect(subject.active?).to be_truthy
+
+      expect(subject).to receive(:valid?).and_return(true)
+      expect(subject).to receive(:active?).and_return(false).exactly(3).times
+
+      expect { subject.announce_changes }
+        .to change { subject.presence.first_seen }.to(nil)
+    end
+
+    it 'should remove itself from access points as a connected client when announced offline' do
+      bssid = 'fa:eb:dc:45:23:67'
+      dbl = double(PatronusFati::DataModels::AccessPoint)
+      PatronusFati::DataModels::AccessPoint.instances[bssid] = dbl
+
+      subject.presence.mark_visible
+      subject.add_access_point(bssid)
+      subject.mark_synced
+
+      expect(dbl).to receive(:remove_client).with(subject.local_attributes[:mac])
+      expect(subject).to receive(:active?).and_return(false).exactly(3).times
+
+      subject.announce_changes
+    end
+
+    it 'should mark active connections with a lost link when announced offline' do
+      bssid = 'fa:eb:dc:45:23:67'
+      conn_key = "#{bssid}^#{subject.local_attributes[:mac]}"
+
+      dbl = double(PatronusFati::DataModels::Connection)
+      PatronusFati::DataModels::Connection.instances[conn_key] = dbl
+
+      subject.presence.mark_visible
+      subject.add_access_point(bssid)
+      subject.mark_synced
+
+      expect(dbl).to receive(:link_lost=).with(true)
+      expect(subject).to receive(:active?).and_return(false).exactly(3).times
+
+      subject.announce_changes
+    end
+
+    it 'short not be dirty after being synced' do
+      expect(subject).to receive(:valid?).and_return(true)
+      subject.update(channel: 8)
+
+      expect { subject.announce_changes }.to change { subject.dirty? }.from(true).to(false)
+    end
+
+    it 'should announce the full state of the client with online syncs' do
+      subject.presence.mark_visible
+      subject.mark_synced
+
+      data_sample = { data: 'test' }
+
+      expect(subject).to receive(:dirty?).and_return(true)
+      expect(subject).to receive(:valid?).and_return(true)
+      expect(subject).to receive(:full_state).and_return(data_sample)
+
+      expect(PatronusFati.event_handler)
+        .to receive(:event).with(:client, :changed, data_sample, anything)
+      subject.announce_changes
+    end
+
+    it 'should announce a minimal state of the client with offline syncs' do
+      subject.presence.mark_visible
+      subject.mark_synced
+
+      expect(subject).to receive(:valid?).and_return(true)
+      expect(subject).to receive(:active?).and_return(false).exactly(3).times
+
+      expect(subject.presence).to receive(:visible_time).and_return(1234)
+      min_data = {
+        'bssid' => subject.local_attributes[:mac],
+        'uptime' => 1234
+      }
+
+      expect(PatronusFati.event_handler)
+        .to receive(:event).with(:client, :offline, min_data, anything)
+      subject.announce_changes
+    end
+
+    it 'should announce the diagnostic data of the client' do
+      sample_data = { content: 'diagnostic' }
+
+      expect(subject).to receive(:dirty?).and_return(true)
+      expect(subject).to receive(:valid?).and_return(true)
+      expect(subject).to receive(:diagnostic_data).and_return(sample_data)
+
+      expect(PatronusFati.event_handler)
+        .to receive(:event).with(:client, :offline, anything, sample_data)
+      subject.announce_changes
+    end
+  end
+
+  context '#cleanup_probes' do
+    let(:probe) { PatronusFati::Presence.new }
+
+    it 'should not modify the children flag when there are no probes' do
+      expect(subject.probes).to be_empty
+      expect { subject.cleanup_probes }.to_not change { subject.sync_status }
+    end
+
+    it 'should not modify the children flag when there is only active probes' do
+      probe.mark_visible
+      subject.probes = { 'probe key' => probe }
+      expect { subject.cleanup_probes }.to_not change { subject.sync_status }
+    end
+
+    it 'should modify the children flag when there is a dead probe' do
+      expect(probe).to be_dead
+      subject.probes = { 'NETGEAR32' => probe }
+      expect { subject.cleanup_probes }
+        .to change { subject.sync_flag?(:dirtyChildren) }.from(false).to(true)
+    end
+
+    it 'should remove all dead probes from the list' do
+      expect(probe).to be_dead
+      subject.probes = { 'linksys' => probe }
+      expect { subject.cleanup_probes }.to change { subject.probes }.to({})
+    end
+  end
+
+  context '#full_state' do
+    it 'should return a hash' do
+      expect(subject.full_state).to be_kind_of(Hash)
+    end
+
+    it 'should include the keys expected by pulse' do
+      [:active, :bssid, :channel, :connected_access_points, :probes, :vendor].each do |k|
+        expect(subject.full_state.key?(k)).to be_truthy
+      end
+    end
+  end
+
+  context '#initialize' do
+    it 'should initialize probes to an empty hash' do
+      expect(subject.probes).to eql({})
+    end
+
+    it 'should initialize the local attributes with the client\'s mac' do
+      expect(subject.local_attributes.keys).to eql([:mac])
+      expect(subject.local_attributes[:mac]).to_not be_nil
+    end
+
+    it 'should initialize the APs it\'s connected to, to an empty array' do
+      expect(subject.access_point_bssids).to eql([])
+    end
+  end
+
+  context '#remove_access_point' do
+    it 'should make no change if the the bssid isn\'t present' do
+      subject.access_point_bssids = [ '78:2b:11:ae:00:12' ]
+      expect { subject.remove_access_point('00:11:22:33:44:55') }
+        .to_not change { subject.access_point_bssids }
+    end
+
+    it 'should remove just the bssid provided when it is present' do
+      test_mac = '00:11:22:33:44:55'
+      subject.access_point_bssids = [ '78:2b:11:ae:00:12', test_mac ]
+
+      expect { subject.remove_access_point(test_mac) }
+        .to change { subject.access_point_bssids }
+      expect(subject.access_point_bssids).to_not include(test_mac)
+    end
+  end
+
+  context '#track_probe' do
+    it 'should not change anything when provided a nil value' do
+      expect { subject.track_probe(nil) }.to_not change { subject.probes }
+    end
+
+    it 'should not change anything when provided an empty string' do
+      expect { subject.track_probe('') }.to_not change { subject.probes }
+    end
+
+    it 'should track new probes as a new presence instance' do
+      subject.track_probe('test')
+      expect(subject.probes['test']).to be_instance_of(PatronusFati::Presence)
+      expect(subject.probes['test']).to_not be_dead
+    end
+
+    it 'should mark existing probes as visisble' do
+      dbl = double(PatronusFati::Presence)
+      subject.probes['pineapple'] = dbl
+      expect(dbl).to receive(:mark_visible)
+      subject.track_probe('pineapple')
+    end
+  end
+
+  context '#update' do
+    it 'should not set invalid keys' do
+      expect { subject.update(bad: 'key') }
+        .to_not change { subject.local_attributes }
+    end
+
+    it 'shouldn\'t modify the sync flags on invalid keys' do
+      expect { subject.update(other: 'key') }
+        .to_not change { subject.sync_status }
+    end
+
+    it 'shouldn\'t modify the sync flags if the values haven\'t changed' do
+      expect { subject.update(subject.local_attributes) }
+        .to_not change { subject.sync_status }
+    end
+
+    it 'should set the dirty attribute flag when a value has changed' do
+      expect { subject.update(channel: 5) }
+        .to change { subject.sync_status }
+      expect(subject.sync_flag?(:dirtyAttributes)).to be_truthy
+    end
+  end
+
+  context '#valid?' do
+    it 'should be true when all required attributes are set' do
+      subject.local_attributes = { mac: 'testing' }
+      expect(subject).to be_valid
+    end
+
+    it 'should be false when missing a required attribute' do
+      subject.local_attributes.delete(:mac)
+      expect(subject).to_not be_valid
+    end
+  end
+
+  context '#vendor' do
+    it 'should short circuit if no MAC is available' do
+      expect(Louis).to_not receive(:lookup)
+
+      subject.update(mac: nil)
+      subject.vendor
+    end
+
+    it 'should use the Louis gem to perform it\'s lookup' do
+      inst = 'test string'
+      subject.update(mac: inst)
+
+      expect(Louis).to receive(:lookup).with(inst).and_return({})
+      subject.vendor
+    end
+
+    it 'should default the long vendor name if it\'s available' do
+      result = { 'long_vendor' => 'correct', 'short_vendor' => 'bad' }
+      expect(Louis).to receive(:lookup).and_return(result)
+      expect(subject.vendor).to eql('correct')
+    end
+
+    it 'should fallback on the short vendor name if long isn\'t available' do
+      result = { 'short_vendor' => 'short' }
+      expect(Louis).to receive(:lookup).and_return(result)
+      expect(subject.vendor).to eql('short')
+    end
+  end
+end

data/spec/patronus_fati/data_models/connection_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+RSpec.describe(PatronusFati::DataModels::Connection) do
+  subject { described_class.new('00:00:00:00:00:00', '34:34:34:34:34:34') }
+
+  it_behaves_like 'a common stateful model'
+end

data/spec/patronus_fati/data_models/ssid_spec.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+
+RSpec.describe(PatronusFati::DataModels::Ssid) do
+  subject { described_class.new('BillWiTheScienceFi') }
+
+  it_behaves_like 'a common stateful model'
+
+  context '#initialize' do
+    it 'should initialize the local attributes with the essid' do
+      expect(subject.local_attributes.keys).to include(:essid)
+      expect(subject.local_attributes[:essid]).to_not be_nil
+    end
+
+    it 'should initialize the local attributes with cloaked' do
+      expect(subject.local_attributes.keys).to include(:cloaked)
+    end
+
+    it 'should initialize the cloaked attribute to false if an essid is provided' do
+      expect(subject.local_attributes[:essid]).to_not be_nil
+      expect(subject.local_attributes[:essid].size).to be > 0
+      expect(subject.local_attributes[:cloaked]).to be_falsey
+    end
+
+    it 'should initialize the cloaked attribute to true if a nil essid is provided' do
+      subject = described_class.new(nil)
+      expect(subject.local_attributes[:cloaked]).to be_truthy
+    end
+
+    it 'should initialize the cloaked attribute to true if an empty essid is provided' do
+      subject = described_class.new('')
+      expect(subject.local_attributes[:cloaked]).to be_truthy
+    end
+  end
+
+  context '#update' do
+    it 'should not set invalid keys' do
+      expect { subject.update(bad: 'key') }
+        .to_not change { subject.local_attributes }
+    end
+
+    it 'shouldn\'t modify the sync flags on invalid keys' do
+      expect { subject.update(other: 'key') }
+        .to_not change { subject.sync_status }
+    end
+
+    it 'shouldn\'t modify the sync flags if the values haven\'t changed' do
+      expect { subject.update(subject.local_attributes) }
+        .to_not change { subject.sync_status }
+    end
+
+    it 'should set the dirty attribute flag when a value has changed' do
+      expect { subject.update(max_rate: 5) }
+        .to change { subject.sync_status }
+      expect(subject.sync_flag?(:dirtyAttributes)).to be_truthy
+    end
+  end
+end

data/spec/shared_examples/common_model_state.rb

@@ -0,0 +1,269 @@
+RSpec.shared_examples_for('a common stateful model') do
+  context 'class methods' do
+    # Helper to ensure tests don't interfere with each other
+    before(:each) do
+      described_class.instance_variable_set(:@instances, nil)
+    end
+
+    context '#[]' do
+      it 'should create a new instance when the key doesn\'t exist' do
+        expect { described_class['test'] }.to change { described_class.instances.count }.from(0).to(1)
+        expect(described_class['test']).to be_instance_of(described_class)
+      end
+
+      it 'should return an existing instance when the key already exists' do
+        dbl = double(described_class)
+        described_class.instances['just^keyed'] = dbl
+        expect(described_class['just^keyed']).to eq(dbl)
+      end
+    end
+
+    context '#exists?' do
+      it 'should be true when an instance matching the key exists' do
+        described_class.instances['test'] = double(described_class)
+        expect(described_class.exists?('test')).to be_truthy
+      end
+
+      it 'should be false when there is no instance matching the key' do
+        expect(described_class.exists?('other')).to be_falsey
+      end
+    end
+
+    context '#instances' do
+      it 'should default to an empty hash' do
+        expect(described_class.instances).to be_kind_of(Hash)
+        expect(described_class.instances).to be_empty
+      end
+    end
+  end
+
+  context '#active?' do
+    it 'should use it\'s expiration time against the presence instance' do
+      expect(described_class).to receive(:current_expiration_threshold).and_return(137)
+      expect(subject.presence).to receive(:visible_since?).with(137)
+
+      subject.active?
+    end
+
+    it 'should pass the presence result back' do
+      expect(subject.presence).to receive(:visible_since?).and_return(false)
+      expect(subject.active?).to be_falsey
+
+      expect(subject.presence).to receive(:visible_since?).and_return(true)
+      expect(subject.active?).to be_truthy
+    end
+
+    it 'should have an expiration time' do
+      expect(described_class).to respond_to(:current_expiration_threshold)
+      expect(described_class.current_expiration_threshold).to be_kind_of(Numeric)
+    end
+
+    it 'should have an expiration in the past' do
+      expect(described_class.current_expiration_threshold).to be <= Time.now.to_i
+    end
+  end
+
+  context '#data_dirty?' do
+    it 'should be false when no status flags have been set' do
+      subject.sync_status = PatronusFati::SYNC_FLAGS[:unsynced]
+      expect(subject.data_dirty?).to be_falsey
+    end
+
+    it 'should be false when only sync status flags are set' do
+      subject.sync_status = PatronusFati::SYNC_FLAGS[:syncedOffline]
+      expect(subject.data_dirty?).to be_falsey
+
+      subject.sync_status = PatronusFati::SYNC_FLAGS[:syncedOnline]
+      expect(subject.data_dirty?).to be_falsey
+    end
+
+    it 'should be true when the attributes have been marked dirty' do
+      subject.sync_status = PatronusFati::SYNC_FLAGS[:dirtyAttributes]
+      expect(subject.data_dirty?).to be_truthy
+    end
+
+    it 'should be true when a child has been marked dirty' do
+      subject.sync_status = PatronusFati::SYNC_FLAGS[:dirtyChildren]
+      expect(subject.data_dirty?).to be_truthy
+    end
+  end
+
+  context '#diagnostic_data' do
+    it 'should be a hash' do
+      expect(subject.diagnostic_data).to be_kind_of(Hash)
+    end
+
+    it 'should include the raw sync_status value' do
+      data = subject.diagnostic_data
+      expect(data.keys).to include(:sync_status)
+      expect(data[:sync_status]).to eql(subject.sync_status)
+    end
+
+    it 'should include the raw presence information' do
+      data = subject.diagnostic_data
+      expect(data.keys).to include(:current_presence)
+      expect(data.keys).to include(:last_presence)
+    end
+  end
+
+  context '#dirty?' do
+    it 'should be dirty when it\'s new' do
+      expect(subject).to receive(:new?).and_return(true)
+
+      expect(subject.dirty?).to be_truthy
+    end
+
+    it 'should be dirty if data has changed' do
+      expect(subject).to receive(:new?).and_return(false)
+      expect(subject).to receive(:data_dirty?).and_return(true)
+
+      expect(subject.dirty?).to be_truthy
+    end
+
+    it 'should be dirty if the sync status doesn\'t match or current status' do
+      expect(subject).to receive(:new?).and_return(false)
+      expect(subject).to receive(:data_dirty?).and_return(false)
+      expect(subject).to receive(:status_dirty?).and_return(true)
+
+      expect(subject.dirty?).to be_truthy
+    end
+
+    it 'should not be dirty when nothing has changed' do
+      expect(subject).to receive(:new?).and_return(false)
+      expect(subject).to receive(:data_dirty?).and_return(false)
+      expect(subject).to receive(:status_dirty?).and_return(false)
+
+      expect(subject.dirty?).to be_falsey
+    end
+  end
+
+  context '#initialize' do
+    it 'should initialize sync_status to zero' do
+      expect(subject.sync_status).to eql(0)
+    end
+
+    it 'should initialize a new presence instance' do
+      expect(subject.presence).to be_kind_of(PatronusFati::Presence)
+    end
+  end
+
+  context '#mark_synced' do
+    it 'should set the sync status to syncedOnline when active' do
+      expect(subject).to receive(:active?).and_return(true)
+      expect { subject.mark_synced }
+        .to change { subject.sync_flag?(:syncedOnline) }.from(false).to(true)
+    end
+
+    it 'should set the sync status to syncedOffline when not active' do
+      expect(subject).to receive(:active?).and_return(false)
+      expect { subject.mark_synced }
+        .to change { subject.sync_flag?(:syncedOffline) }.from(false).to(true)
+    end
+
+    it 'should clear the dirty attribute flags' do
+      subject.set_sync_flag(:dirtyAttributes)
+      expect { subject.mark_synced }
+        .to change { subject.sync_flag?(:dirtyAttributes) }.from(true).to(false)
+
+      subject.set_sync_flag(:dirtyChildren)
+      expect { subject.mark_synced }
+        .to change { subject.sync_flag?(:dirtyChildren) }.from(true).to(false)
+    end
+  end
+
+  context 'new?' do
+    it 'should be true when unsynced' do
+      expect(subject.sync_status).to eql(PatronusFati::SYNC_FLAGS[:unsynced])
+      expect(subject.new?).to be_truthy
+    end
+
+    it 'should be false when syncedOnline is set' do
+      subject.set_sync_flag(:syncedOnline)
+      expect(subject.new?).to be_falsey
+    end
+
+    it 'should be false when syncedOffline is set' do
+      subject.set_sync_flag(:syncedOffline)
+      expect(subject.new?).to be_falsey
+    end
+
+    it 'should be true when just the dirty data attributes are set' do
+      expect(subject.sync_status).to eql(PatronusFati::SYNC_FLAGS[:unsynced])
+
+      subject.set_sync_flag(:dirtyAttributes)
+      subject.set_sync_flag(:dirtyChildren)
+
+      expect(subject.new?).to be_truthy
+    end
+  end
+
+  context '#presence' do
+    it { expect(subject).to respond_to(:presence) }
+    it { expect(subject.presence).to be_instance_of(PatronusFati::Presence) }
+  end
+
+  context '#set_sync_flag' do
+    it 'should not change the value when it\'s already set' do
+      subject.set_sync_flag(:syncedOnline)
+      expect { subject.set_sync_flag(:syncedOnline) }
+        .to_not change { subject.sync_status }
+    end
+
+    it 'should set the flag if it\'s not already set' do
+      expect(subject.sync_flag?(:dirtyAttributes)).to be_falsey
+      subject.set_sync_flag(:dirtyAttributes)
+      expect(subject.sync_flag?(:dirtyAttributes)).to be_truthy
+    end
+
+    it 'should not change other flags when being set' do
+      subject.set_sync_flag(:dirtyChildren)
+      subject.set_sync_flag(:syncedOnline)
+
+      expect(subject.sync_flag?(:dirtyChildren)).to be_truthy
+    end
+  end
+
+  context '#status_dirty?' do
+    it 'should be true when inactive and marked as active' do
+      expect(subject).to receive(:active?).and_return(false)
+      subject.set_sync_flag(:syncedOnline)
+      expect(subject.status_dirty?).to be_truthy
+    end
+
+    it 'should be true when active and marked as inactive' do
+      expect(subject).to receive(:active?).and_return(true)
+      subject.set_sync_flag(:syncedOffline)
+      expect(subject.status_dirty?).to be_truthy
+    end
+
+    it 'should be false when status and marking are active' do
+      expect(subject).to receive(:active?).and_return(true)
+      subject.set_sync_flag(:syncedOnline)
+      expect(subject.status_dirty?).to be_falsey
+    end
+
+    it 'should be false when status and marking are inactive' do
+      expect(subject).to receive(:active?).and_return(false)
+      subject.set_sync_flag(:syncedOffline)
+      expect(subject.status_dirty?).to be_falsey
+    end
+  end
+
+  context '#sync_flag?' do
+    it 'should be true when the provided flag is set' do
+      expect { subject.set_sync_flag(:dirtyAttributes) }
+        .to change { subject.sync_flag?(:dirtyAttributes) }.from(false).to(true)
+    end
+
+    it 'should be false when the provided flag isn\'t set' do
+      subject.sync_status = 0
+      expect(subject.sync_flag?(:dirtyChildren)).to be_falsey
+    end
+
+    it 'should be false when just another flag is set' do
+      subject.sync_status = 0
+      subject.set_sync_flag(:dirtyAttributes)
+      expect(subject.sync_flag?(:syncedOffline)).to be_falsey
+    end
+  end
+end