lifx-lan 0.1.0

data/spec/integration/tags_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+module LIFX
+  module LAN
+    describe 'tags', integration: true do
+      let(:color) { Color.hsb(rand(360), 0.3, 0.3) }
+
+      specify 'Clearing, setting and using tags' do
+        light.add_tag('Foo')
+        expect(light.tags).to include('Foo')
+
+        test_tag = lights.with_tag('Foo')
+        test_tag.turn_on
+        test_tag.set_color(color, duration: 0)
+        flush
+        sleep 1 # Set messages are scheduled 250ms if no at_time is set
+                # It also returns the current light state rather than the
+                # final state
+        light.refresh
+        wait { expect(light.color).to be_similar_to(color) }
+
+        light.remove_tag('Foo')
+        wait { expect(light.tags).not_to include('Foo') }
+      end
+
+      it 'deletes tags when no longer assigned to a light' do
+        light.add_tag('TempTag')
+        light.remove_tag('TempTag')
+        expect(lifx.unused_tags).to include('TempTag')
+        lifx.purge_unused_tags!
+        expect(lifx.unused_tags).to be_empty
+      end
+
+      it 'handles non-ascii tags' do
+        light.add_tag('_tést')
+        expect(light.tags).to include('_tést')
+        light.remove_tag('_tést')
+        lifx.purge_unused_tags!
+      end
+    end
+  end
+end

data/spec/light_collection_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+module LIFX
+  module LAN
+    describe LightCollection do
+      subject(:collection) { LightCollection.new(context: double) }
+
+      describe '#with_id' do
+        let(:light) { double(Light, id: 'id') }
+        before { allow(collection).to receive(:lights).and_return([light]) }
+
+        it 'returns a Light with matching id' do
+          expect(collection.with_id('id')).to eq light
+        end
+
+        it 'returns nil when none matches' do
+          ret = collection.with_id('wrong id')
+          expect(ret).to eq nil
+        end
+      end
+
+      describe '#with_label' do
+        let(:light) { double(Light, label: 'label') }
+        before { allow(collection).to receive(:lights).and_return([light]) }
+
+        it 'returns a Light with matching label' do
+          expect(collection.with_label('label')).to eq light
+        end
+
+        it 'returns nil' do
+          ret = collection.with_label('wrong label')
+          expect(ret).to eq nil
+        end
+      end
+    end
+  end
+end

data/spec/message_spec.rb

@@ -0,0 +1,183 @@
+require 'spec_helper'
+
+describe LIFX::LAN::Message do
+  context 'unpacking' do
+    let(:data) do
+      "\x39\x00\x00\x34\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x31" \
+      "\x6c\x69\x66\x78\x31\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x67\x00" \
+      "\x00\x00\x00\x01\x00\x00\xff\xff\xff\xff\xac\x0d\xc8\x00\x00\x00\x00" \
+      "\x00\x80\x3f\x00\x00\x00".b
+    end
+    let(:msg) { LIFX::LAN::Message.unpack(data) }
+
+    it 'unpacks without errors' do
+      expect(msg).not_to be_nil
+    end
+
+    it 'returns the correct frame data' do
+      expect(msg.msg_size).to eq 57
+      expect(msg.protocol).to eq 1024
+      expect(msg).to be_addressable
+    end
+
+    it 'returns the correct address data' do
+      expect(msg.raw_site).to eq '1lifx1'
+      expect(msg.raw_target).to eq "\x00" * 8
+    end
+
+    it 'has correct ProtocolPath data' do
+      expect(msg.path).to be_a(LIFX::LAN::ProtocolPath)
+      expect(msg.path.site_id).to eq '316c69667831'
+      expect(msg.path.tag_ids).to eq []
+      expect(msg.path.device_id).to be_nil
+    end
+
+    it 'returns the correct metadata' do
+      expect(msg.at_time).to eq 0
+      expect(msg.type_).to eq 103
+    end
+
+    let(:payload) { msg.payload }
+    it 'returns the payload' do
+      expect(payload.class).to eq LIFX::LAN::Protocol::Light::SetWaveform
+      expect(payload.stream).to eq 0
+      expect(payload.transient).to eq(true)
+      expect(payload.color.hue).to eq 0
+      expect(payload.color.saturation).to eq 65_535
+      expect(payload.color.brightness).to eq 65_535
+      expect(payload.color.kelvin).to eq 3_500
+      expect(payload.period).to eq 200
+      expect(payload.cycles).to eq 1.0
+      expect(payload.skew_ratio).to eq 0
+      expect(payload.waveform).to eq 0
+    end
+
+    it 'repacks to the same data' do
+      expect(msg.pack).to eq data
+    end
+  end
+
+  context 'packing' do
+    context 'no attributes' do
+      let(:msg) { LIFX::LAN::Message.new }
+
+      it 'throws an exception' do
+        expect { msg.pack }.to raise_error(LIFX::LAN::Message::NoPayload)
+      end
+    end
+
+    context 'no path' do
+      let(:msg) { LIFX::LAN::Message.new(payload: LIFX::LAN::Protocol::Device::SetPower.new) }
+
+      it 'defaults to null site and target' do
+        unpacked = LIFX::LAN::Message.unpack(msg.pack)
+        expect(unpacked.path.site_id).to eq('000000000000')
+        expect(unpacked.path.device_id).to eq('000000000000')
+      end
+    end
+
+    context 'passed in via hash' do
+      let(:msg) do
+        LIFX::LAN::Message.new({
+          path: LIFX::LAN::ProtocolPath.new(tagged: false, raw_target: 'abcdefgh'),
+          at_time: 9001,
+          payload: LIFX::LAN::Protocol::Wifi::SetAccessPoint.new(
+            interface: 1,
+            ssid: 'who let the dogs out',
+            pass: 'woof, woof, woof woof!',
+            security: 1
+          )
+        })
+      end
+      # let(:unpacked) { LIFX::Message.unpack(msg.pack) }
+
+      it 'sets the size' do
+        expect(msg.msg_size).to eq 134
+      end
+
+      it 'packs correctly' do
+        expect(msg.pack).to eq "\x86\x00\x00\x14\x00\x00\x00\x00abcdefgh\x00" \
+                               "\x00\x00\x00\x00\x00\x00\x00)#\x00\x00\x00"   \
+                               "\x00\x00\x001\x01\x00\x00\x01who let the "    \
+                               "dogs out\x00\x00\x00\x00\x00\x00\x00\x00\x00" \
+                               "\x00\x00\x00woof, woof, woof woof!\x00\x00"   \
+                               "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" \
+                               "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" \
+                               "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" \
+                               "\x00\x00\x00\x00\x00\x00\x00\x01".b
+        expect(msg.protocol).to eq 1024
+        expect(msg.path).not_to be_tagged
+        expect(msg).to be_addressable
+        expect(msg.path.raw_target).to eq 'abcdefgh'
+        expect(msg.at_time).to eq 9001
+        expect(msg.type_).to eq 305
+        expect(msg.payload.class).to eq LIFX::LAN::Protocol::Wifi::SetAccessPoint
+        expect(msg.payload.interface).to eq 1
+        expect(msg.payload.ssid).to eq 'who let the dogs out'
+        expect(msg.payload.pass).to eq 'woof, woof, woof woof!'
+        expect(msg.payload.security).to eq 1
+      end
+    end
+
+    context 'packing with tags' do
+      let(:msg) do
+        LIFX::LAN::Message.new({
+          path: LIFX::LAN::ProtocolPath.new(tag_ids: [0, 1]),
+          at_time: 9001,
+          payload: LIFX::LAN::Protocol::Device::GetTime.new
+        })
+      end
+
+      let(:unpacked) { LIFX::LAN::Message.unpack(msg.pack) }
+
+      it 'packs the tag correctly' do
+        expect(msg.pack).to eq "$\x00\x004\x00\x00\x00\x00\x03\x00\x00\x00"   \
+                               "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" \
+                               "\x00)#\x00\x00\x00\x00\x00\x00\x04\x00\x00"   \
+                               "\x00".b
+      end
+
+      it 'sets tagged' do
+        expect(unpacked.path).to be_tagged
+      end
+
+      it 'sets tags' do
+        expect(unpacked.path.tag_ids).to eq [0, 1]
+      end
+
+      it 'device should be nil' do
+        expect(unpacked.path.device_id).to be_nil
+      end
+    end
+
+    context 'packing with device' do
+      let(:msg) do
+        LIFX::LAN::Message.new({
+          path: LIFX::LAN::ProtocolPath.new(device_id: '0123456789ab', site_id: '0' * 12),
+          at_time: 9001,
+          payload: LIFX::LAN::Protocol::Device::GetTime.new
+        })
+      end
+
+      let(:unpacked) { LIFX::LAN::Message.unpack(msg.pack) }
+
+      it 'packs the tag correctly' do
+        expect(msg.pack).to eq "$\x00\x00\x14\x00\x00\x00\x00\x01#Eg\x89\xAB" \
+                               "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00)#"   \
+                               "\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00".b
+      end
+
+      it 'sets tagged to false' do
+        expect(unpacked.path).not_to be_tagged
+      end
+
+      it 'sets device' do
+        expect(unpacked.path.device_id).to eq '0123456789ab'
+      end
+
+      it 'tags should be nil' do
+        expect(unpacked.path.tag_ids).to be_nil
+      end
+    end
+  end
+end

data/spec/protocol_path_spec.rb

@@ -0,0 +1,109 @@
+require 'spec_helper'
+
+module LIFX
+  module LAN
+    describe ProtocolPath do
+      describe 'initializing from raw data' do
+        subject do
+          ProtocolPath.new(raw_site: '1lifx1', raw_target: target, tagged: tagged)
+        end
+
+        context 'device target' do
+          let(:target) { "\xAB\xCD\xEF\x12\x34\x56\x00\x00" }
+          let(:tagged) { false }
+
+          it 'returns site_id in hex' do
+            expect(subject.site_id).to eq '316c69667831'
+          end
+
+          it 'returns device_id in hex' do
+            expect(subject.device_id).to eq 'abcdef123456'
+          end
+
+          it 'returns tagged as false' do
+            expect(subject).not_to be_tagged
+          end
+
+          it 'returns nil for tag_ids' do
+            expect(subject.tag_ids).to be_nil
+          end
+        end
+
+        context 'tagged target' do
+          let(:target) { "\x03\x00\x00\x00\x00\x00\x00\x00" }
+          let(:tagged) { true }
+
+          it 'returns site_id in hex' do
+            expect(subject.site_id).to eq '316c69667831'
+          end
+
+          it 'returns device_id as nil' do
+            expect(subject.device_id).to be_nil
+          end
+
+          it 'returns tagged as true' do
+            expect(subject).to be_tagged
+          end
+
+          it 'returns the tag_ids' do
+            expect(subject.tag_ids).to eq [0, 1]
+          end
+        end
+      end
+
+      describe 'initializing from strings' do
+        context 'device target' do
+          subject do
+            ProtocolPath.new(site_id: '316c69667831', device_id: 'abcdef123456')
+          end
+
+          it 'sets raw_site correctly' do
+            expect(subject.raw_site).to eq '1lifx1'
+          end
+
+          it 'sets raw_target correctly' do
+            expect(subject.raw_target).to eq "\xAB\xCD\xEF\x12\x34\x56\x00\x00".b
+          end
+
+          it 'sets tagged to false' do
+            expect(subject).to_not be_tagged
+          end
+        end
+
+        context 'tagged target' do
+          subject do
+            ProtocolPath.new(site_id: '316c69667831', tag_ids: [0, 1])
+          end
+
+          it 'sets raw_site properly' do
+            expect(subject.raw_site).to eq '1lifx1'
+          end
+
+          it 'sets raw_target correctly' do
+            expect(subject.raw_target).to eq "\x03\x00\x00\x00\x00\x00\x00\x00".b
+          end
+
+          it 'returns tagged as true' do
+            expect(subject).to be_tagged
+          end
+        end
+
+        context 'tagged target with no site' do
+          subject { ProtocolPath.new(tagged: true) }
+
+          it 'raw_site should be null string' do
+            expect(subject.raw_site).to eq "\x00\x00\x00\x00\x00\x00".b
+          end
+
+          it 'sets raw_target correctly' do
+            expect(subject.raw_target).to eq "\x00\x00\x00\x00\x00\x00\x00\x00".b
+          end
+
+          it 'returns tagged as true' do
+            expect(subject).to be_tagged
+          end
+        end
+      end
+    end
+  end
+end

data/spec/routing_manager_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+module LIFX
+  module LAN
+    describe RoutingManager do
+      describe '#tags_for_device_id' do
+        subject(:manager) { RoutingManager.new(context: double(timers: double(every: double))) }
+
+        before do
+          ['Some label', 'Another label', 'Much label'].each_with_index do |lbl, i|
+            manager.tag_table.update_table(device_id: 'device', tag_id: i, label: lbl)
+          end
+
+          manager.routing_table
+                 .update_table(site_id: 'site', device_id: 'device', tag_ids: [0, 2])
+        end
+
+        it 'resolves tags' do
+          tags = manager.tags_for_device_id('device')
+          expect(tags).to eq ['Some label', 'Much label']
+        end
+      end
+    end
+  end
+end

data/spec/routing_table_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+module LIFX
+  module LAN
+    describe RoutingTable do
+      describe '#clear_stale_entries' do
+        subject(:table) { RoutingTable.new }
+
+        before do
+          table.update_table(site_id: 'site', device_id: 'stale device', last_seen: Time.now - 305)
+          table.update_table(site_id: 'site', device_id: 'recent device', last_seen: Time.now)
+        end
+
+        it 'clears only entries older than 5 minutes' do
+          expect(table.entries.count).to eq(2)
+          table.clear_stale_entries
+          expect(table.entries.count).to eq(1)
+          expect(table.entries.first.device_id).to eq('recent device')
+        end
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,56 @@
+require 'bundler'
+Bundler.require
+begin
+  require 'pry'
+rescue LoadError
+end
+
+require 'lifx-lan'
+require 'lifx/lan/utilities'
+
+shared_context 'integration', integration: true do
+  def lifx
+    $lifx ||= begin
+      c = LIFX::LAN::Client.lan
+      begin
+        c.discover! do
+          c.tags.include?('_Test') && c.lights.with_tag('_Test').count > 0
+        end
+      rescue LIFX::Client::DiscoveryTimeout
+        raise "Could not find any lights with tag _Test in #{c.lights.inspect}"
+      end
+      c
+    end
+  end
+
+  def flush
+    lifx.flush
+  end
+
+  let(:lights) { lifx.lights.with_tag('_Test') }
+  let(:light) { lights.first }
+end
+
+module SpecHelpers
+  def wait(timeout: 5, retry_wait: 0.1, &block)
+    Timeout.timeout(timeout) do
+      begin
+        block.call
+      rescue RSpec::Expectations::ExpectationNotMetError
+        lights.refresh
+        sleep(retry_wait)
+        retry
+      end
+    end
+  rescue Timeout::Error
+    block.call
+  end
+end
+
+LIFX::LAN::Config.logger = Yell.new(STDERR) if ENV['DEBUG']
+
+RSpec.configure do |config|
+  config.include(SpecHelpers)
+  config.formatter = 'documentation'
+  config.color = true
+end