playful 0.1.0.alpha.1

data/spec/unit/playful/control_point/device_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+require 'playful/control_point/device'
+
+
+describe Playful::ControlPoint::Device do
+  pending
+end

data/spec/unit/playful/control_point_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+require 'playful/control_point'
+
+
+describe Playful::ControlPoint do
+  subject do
+    Playful::ControlPoint.new(1)
+  end
+
+  describe '#ssdp_search_and_listen' do
+    let(:notification) do
+      double 'notification'
+    end
+
+    let(:searcher) do
+      s = double 'Playful::SSDP::Searcher'
+      s.stub_chain(:discovery_responses, :subscribe).and_yield notification
+
+      s
+    end
+
+    before do
+      expect(Playful::SSDP).to receive(:search).with('ssdp:all', {}).and_return searcher
+      EM.stub(:add_periodic_timer)
+    end
+
+    after do
+      EM.unstub(:add_periodic_timer)
+    end
+
+    it 'creates a ControlPoint::Device for every discovery response' do
+      EM.stub(:add_timer)
+      subject.should_receive(:create_device).with(notification)
+      subject.ssdp_search_and_listen('ssdp:all')
+    end
+
+    it 'shuts down the searcher and starts the listener after the given response wait time' do
+      EM.stub(:add_timer).and_yield
+      subject.stub(:create_device)
+      searcher.should_receive(:close_connection)
+      subject.should_receive(:listen)
+      subject.ssdp_search_and_listen('ssdp:all')
+    end
+  end
+end

data/spec/unit/playful/ssdp/listener_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+require 'playful/ssdp/listener'
+
+
+describe Playful::SSDP::Listener do
+  around(:each) do |example|
+    EM.synchrony do
+      example.run
+      EM.stop
+    end
+  end
+
+  before do
+    allow_any_instance_of(Playful::SSDP::Listener).to receive(:setup_multicast_socket)
+  end
+
+  subject { Playful::SSDP::Listener.new(1) }
+
+  describe '#receive_data' do
+    it 'logs the IP and port from which the request came from' do
+      expect(subject).to receive(:peer_info).and_return %w[ip port]
+      expect(subject).to receive(:log).
+        with("Response from ip:port:\nmessage\n")
+      allow(subject).to receive(:parse).and_return({})
+
+      subject.receive_data('message')
+    end
+  end
+end

data/spec/unit/playful/ssdp/multicast_connection_spec.rb

@@ -0,0 +1,157 @@
+require 'spec_helper'
+require 'playful/ssdp/multicast_connection'
+
+
+describe Playful::SSDP::MulticastConnection do
+  around(:each) do |example|
+    EM.synchrony do
+      example.run
+      EM.stop
+    end
+  end
+
+  subject { Playful::SSDP::MulticastConnection.new(1) }
+
+  before do
+    Playful.log = false
+  end
+
+  describe '#peer_info' do
+    before do
+      allow_any_instance_of(Playful::SSDP::MulticastConnection).to receive(:setup_multicast_socket)
+      subject.stub_chain(:get_peername, :[], :unpack).
+          and_return(%w[1234 1 2 3 4])
+    end
+
+    it 'returns an Array with IP and port' do
+      expect(subject.peer_info).to eq ['1.2.3.4', 1234]
+    end
+
+    it 'returns IP as a String' do
+      expect(subject.peer_info.first).to be_a String
+    end
+
+    it 'returns port as a Fixnum' do
+      expect(subject.peer_info.last).to be_a Fixnum
+    end
+  end
+
+  describe '#parse' do
+    before do
+      allow_any_instance_of(Playful::SSDP::MulticastConnection).to receive(:setup_multicast_socket)
+    end
+
+    it 'turns headers into Hash keys' do
+      result = subject.parse ROOT_DEVICE1
+      expect(result).to have_key :cache_control
+      expect(result).to have_key :date
+      expect(result).to have_key :location
+      expect(result).to have_key :server
+      expect(result).to have_key :st
+      expect(result).to have_key :ext
+      expect(result).to have_key :usn
+      expect(result).to have_key :content_length
+    end
+
+    it 'turns header values into Hash values' do
+      result = subject.parse ROOT_DEVICE1
+      expect(result[:cache_control]).to eq 'max-age=1200'
+      expect(result[:date]).to eq 'Mon, 26 Sep 2011 06:40:19 GMT'
+      expect(result[:location]).to eq 'http://1.2.3.4:5678/description/fetch'
+      expect(result[:server]).to eq 'Linux-i386-2.6.38-10-generic-pae, UPnP/1.0, PMS/1.25.1'
+      expect(result[:st]).to eq 'upnp:rootdevice'
+      expect(result[:ext]).to be_empty
+      expect(result[:usn]).to eq 'uuid:3c202906-992d-3f0f-b94c-90e1902a136d::upnp:rootdevice'
+      expect(result[:content_length]).to eq '0'
+    end
+
+    context 'single line String as response data' do
+      before { @data = ROOT_DEVICE1.gsub("\n", ' ') }
+
+      it 'returns an empty Hash' do
+        expect(subject.parse(@data)).to eq({ })
+      end
+
+      it "logs the 'bad' response" do
+        subject.should_receive(:log).twice
+        subject.parse @data
+      end
+    end
+  end
+
+  describe '#setup_multicast_socket' do
+    before do
+      allow_any_instance_of(Playful::SSDP::MulticastConnection).to receive(:set_membership)
+      allow_any_instance_of(Playful::SSDP::MulticastConnection).to receive(:switch_multicast_loop)
+      allow_any_instance_of(Playful::SSDP::MulticastConnection).to receive(:set_multicast_ttl)
+      allow_any_instance_of(Playful::SSDP::MulticastConnection).to receive(:set_ttl)
+    end
+
+    it 'adds 0.0.0.0 and 239.255.255.250 to the membership group' do
+      expect(subject).to receive(:set_membership).with(
+        IPAddr.new('239.255.255.250').hton + IPAddr.new('0.0.0.0').hton
+      )
+      subject.setup_multicast_socket
+    end
+
+    it 'sets multicast TTL to 4' do
+      expect(subject).to receive(:set_multicast_ttl).with(4)
+      subject.setup_multicast_socket
+    end
+
+    it 'sets TTL to 4' do
+      expect(subject).to receive(:set_ttl).with(4)
+      subject.setup_multicast_socket
+    end
+
+    context "ENV['RUBY_UPNP_ENV'] != testing" do
+      after { ENV['RUBY_UPNP_ENV'] = 'testing' }
+
+      it 'turns multicast loop off' do
+        ENV['RUBY_UPNP_ENV'] = 'development'
+        expect(subject).to receive(:switch_multicast_loop).with(:off)
+        subject.setup_multicast_socket
+      end
+    end
+  end
+
+  describe '#switch_multicast_loop' do
+    before do
+      allow_any_instance_of(Playful::SSDP::MulticastConnection).to receive(:setup_multicast_socket)
+    end
+
+    it "passes '\\001' to the socket option call when param == :on" do
+      expect(subject).to receive(:set_sock_opt).with(
+        Socket::IPPROTO_IP, Socket::IP_MULTICAST_LOOP, "\001"
+      )
+      subject.switch_multicast_loop :on
+    end
+
+    it "passes '\\001' to the socket option call when param == '\\001'" do
+      expect(subject).to receive(:set_sock_opt).with(
+       Socket::IPPROTO_IP, Socket::IP_MULTICAST_LOOP, "\001"
+      )
+      subject.switch_multicast_loop "\001"
+    end
+
+    it "passes '\\000' to the socket option call when param == :off" do
+      expect(subject).to receive(:set_sock_opt).with(
+        Socket::IPPROTO_IP, Socket::IP_MULTICAST_LOOP, "\000"
+      )
+      subject.switch_multicast_loop :off
+    end
+
+    it "passes '\\000' to the socket option call when param == '\\000'" do
+      expect(subject).to receive(:set_sock_opt).with(
+        Socket::IPPROTO_IP, Socket::IP_MULTICAST_LOOP, "\000"
+      )
+      subject.switch_multicast_loop "\000"
+    end
+
+    it "raises when not :on, :off, '\\000', or '\\001'" do
+      expect { subject.switch_multicast_loop 12312312 }.
+        to raise_error(Playful::SSDP::Error)
+    end
+  end
+end
+

data/spec/unit/playful/ssdp/notifier_spec.rb

@@ -0,0 +1,76 @@
+require 'spec_helper'
+require 'playful/ssdp/notifier'
+
+
+describe Playful::SSDP::Notifier do
+  around(:each) do |example|
+    EM.synchrony do
+      example.run
+      EM.stop
+    end
+  end
+
+  let(:nt) { 'en tee' }
+  let(:usn) { 'you ess en' }
+  let(:ddf_url) { 'ddf url' }
+  let(:duration) { 567 }
+
+  subject do
+    Playful::SSDP::Notifier.new(1, nt, usn, ddf_url, duration)
+  end
+
+  describe '#initialize' do
+    it 'creates a notification' do
+      expect_any_instance_of(Playful::SSDP::Notifier).to receive(:notification).
+        with(nt, usn, ddf_url, duration)
+
+      subject
+    end
+  end
+
+  describe '#post_init' do
+    context 'send_datagram returns positive value' do
+      before do
+        expect(subject).to receive(:send_datagram).and_return 1
+      end
+
+      it 'logs what was sent' do
+        expect(subject).to receive(:log).with /Sent notification/
+
+        subject.post_init
+      end
+    end
+
+    context 'send_datagram returns 0' do
+      before do
+        expect(subject).to receive(:send_datagram).and_return 0
+      end
+
+      it 'does not log what was sent' do
+        expect(subject).to_not receive(:log)
+
+        subject.post_init
+      end
+    end
+  end
+
+  describe '#notification' do
+    before do
+      subject.instance_variable_set(:@os, 'my OS')
+    end
+
+    it 'builds the notification message' do
+      expect(subject.notification(nt, usn, ddf_url, duration)).to eq <<-NOTE
+NOTIFY * HTTP/1.1\r
+HOST: 239.255.255.250:1900\r
+CACHE-CONTROL: max-age=567\r
+LOCATION: ddf url\r
+NT: en tee\r
+NTS: ssdp:alive\r
+SERVER: my OS UPnP/1.0 Playful/#{Playful::VERSION}\r
+USN: you ess en\r
+\r
+      NOTE
+    end
+  end
+end

data/spec/unit/playful/ssdp/searcher_spec.rb

@@ -0,0 +1,110 @@
+require 'spec_helper'
+require 'playful/ssdp/searcher'
+
+
+describe Playful::SSDP::Searcher do
+  around(:each) do |example|
+    EM.synchrony do
+      example.run
+      EM.stop
+    end
+  end
+
+  before do
+    Playful.log = false
+    allow_any_instance_of(Playful::SSDP::MulticastConnection).to receive(:setup_multicast_socket)
+  end
+
+  subject do
+    Playful::SSDP::Searcher.new(1, 'ssdp:all', {})
+  end
+
+  it 'lets you read its responses' do
+    responses = double 'responses'
+    subject.instance_variable_set(:@discovery_responses, responses)
+    expect(subject.discovery_responses).to eq responses
+  end
+
+  describe '#initialize' do
+    it 'does an #m_search' do
+      expect_any_instance_of(Playful::SSDP::Searcher).to receive(:m_search).and_return(<<-MSEARCH
+M-SEARCH * HTTP/1.1\r
+HOST: 239.255.255.250:1900\r
+MAN: "ssdp:discover"\r
+MX: 5\r
+ST: ssdp:all\r
+\r
+      MSEARCH
+      )
+      subject
+    end
+  end
+
+  describe '#receive_data' do
+    let(:parsed_response) do
+      parsed_response = double 'parsed response'
+      expect(parsed_response).to receive(:has_key?).with(:nts).and_return false
+      expect(parsed_response).to receive(:[]).and_return false
+
+      parsed_response
+    end
+
+    it 'takes a response and adds it to the list of responses' do
+      response = double 'response'
+      allow(subject).to receive(:peer_info).and_return(['0.0.0.0', 4567])
+
+      expect(subject).to receive(:parse).with(response).exactly(1).times.
+        and_return(parsed_response)
+      expect(subject.instance_variable_get(:@discovery_responses)).to receive(:<<).
+        with(parsed_response)
+
+      subject.receive_data(response)
+    end
+  end
+
+  describe '#post_init' do
+    before { allow_any_instance_of(Playful::SSDP::Searcher).to receive(:m_search).and_return('hi') }
+
+    it 'sends an M-SEARCH as a datagram over 239.255.255.250:1900' do
+      m_search_count_times = subject.instance_variable_get(:@m_search_count)
+      expect(subject).to receive(:send_datagram).
+        with('hi', '239.255.255.250', 1900).
+        exactly(m_search_count_times).times.
+        and_return 0
+      subject.post_init
+    end
+  end
+
+  describe '#m_search' do
+    it 'builds the MSEARCH string using the given parameters' do
+      expect(subject.m_search('ssdp:all', 10)).to eq <<-MSEARCH
+M-SEARCH * HTTP/1.1\r
+HOST: 239.255.255.250:1900\r
+MAN: "ssdp:discover"\r
+MX: 10\r
+ST: ssdp:all\r
+\r
+      MSEARCH
+    end
+
+    it 'uses 239.255.255.250 as the HOST IP' do
+      expect(subject.m_search('ssdp:all', 10)).to match(/HOST: 239.255.255.250/m)
+    end
+
+    it 'uses 1900 as the HOST port' do
+      expect(subject.m_search('ssdp:all', 10)).to match(/HOST:.*1900/m)
+    end
+
+    it 'lets you search for undefined search target types' do
+      expect(subject.m_search('spaceship', 10)).to eq <<-MSEARCH
+M-SEARCH * HTTP/1.1\r
+HOST: 239.255.255.250:1900\r
+MAN: "ssdp:discover"\r
+MX: 10\r
+ST: spaceship\r
+\r
+      MSEARCH
+    end
+  end
+end
+

data/spec/unit/playful/ssdp_spec.rb

@@ -0,0 +1,214 @@
+require 'spec_helper'
+require 'playful/ssdp'
+
+
+describe Playful::SSDP do
+  subject { Playful::SSDP }
+
+  describe '.listen' do
+    let(:listener) do
+      searcher = double 'Playful::SSDP::Listener'
+      searcher.stub_chain(:alive_notifications, :pop).and_yield(%w[one two])
+      searcher.stub_chain(:byebye_notifications, :pop).and_yield(%w[three four])
+
+      searcher
+    end
+
+    before do
+      allow(EM).to receive(:run).and_yield
+      allow(EM).to receive(:add_timer)
+      allow(EM).to receive(:open_datagram_socket).and_return listener
+    end
+
+    context 'reactor is already running' do
+      it 'returns a Playful::SSDP::Listener' do
+        allow(EM).to receive(:reactor_running?).and_return true
+        expect(subject.listen).to eq listener
+      end
+    end
+
+    context 'reactor is not already running' do
+      it 'returns a Hash of available and byebye responses' do
+        allow(EM).to receive(:add_shutdown_hook).and_yield
+        expect(subject.listen).to eq({
+          alive_notifications: %w[one two],
+          byebye_notifications: %w[three four]
+        })
+      end
+
+      it 'opens a UDP socket on 239.255.255.250, port 1900' do
+        allow(EM).to receive(:add_shutdown_hook)
+        expect(EM).to receive(:open_datagram_socket).with('239.255.255.250', 1900,
+          Playful::SSDP::Listener, 4)
+        subject.listen
+      end
+    end
+  end
+
+  describe '.search' do
+    let(:multicast_searcher) do
+      searcher = double 'Playful::SSDP::Searcher'
+      searcher.stub_chain(:discovery_responses, :subscribe).and_yield(%w[one two])
+
+      searcher
+    end
+
+    let(:broadcast_searcher) do
+      searcher = double 'Playful::SSDP::BroadcastSearcher'
+      searcher.stub_chain(:discovery_responses, :subscribe).and_yield(%w[three four])
+
+      searcher
+    end
+
+    before do
+      allow(EM).to receive(:run).and_yield
+      allow(EM).to receive(:add_timer)
+      allow(EM).to receive(:open_datagram_socket).and_return multicast_searcher
+    end
+
+    context 'when search_target is not a String' do
+      it 'calls #to_upnp_s on search_target' do
+        search_target = double('search_target')
+        expect(search_target).to receive(:to_upnp_s)
+        subject.search(search_target)
+      end
+    end
+
+    context 'when search_target is a String' do
+      it 'calls #to_upnp_s on search_target but does not alter it' do
+        search_target = "I'm a string"
+        expect(search_target).to receive(:to_upnp_s).and_call_original
+
+        expect(EM).to receive(:open_datagram_socket).with('0.0.0.0', 0,
+          Playful::SSDP::Searcher, "I'm a string", {})
+        subject.search(search_target)
+      end
+    end
+
+    context 'reactor is already running' do
+      it 'returns a Playful::SSDP::Searcher' do
+        allow(EM).to receive(:reactor_running?).and_return true
+        expect(subject.search).to eq multicast_searcher
+      end
+    end
+
+    context 'reactor is not already running' do
+      context 'options hash includes do_broadcast_search' do
+        before do
+          allow(EM).to receive(:open_datagram_socket).
+            and_return(multicast_searcher, broadcast_searcher)
+        end
+
+        it 'returns an Array of responses' do
+          allow(EM).to receive(:add_shutdown_hook).and_yield
+          expect(subject.search(:all, do_broadcast_search: true)).to eq %w[one two three four]
+        end
+
+        it 'opens 2 UDP sockets on 0.0.0.0, port 0' do
+          allow(EM).to receive(:add_shutdown_hook)
+          expect(EM).to receive(:open_datagram_socket).with('0.0.0.0', 0, Playful::SSDP::Searcher,
+            'ssdp:all', {})
+          expect(EM).to receive(:open_datagram_socket).with('0.0.0.0', 0, Playful::SSDP::BroadcastSearcher,
+            'ssdp:all', 5, 4)
+          subject.search(:all, do_broadcast_search: true)
+        end
+      end
+
+      context 'options hash does not include do_broadcast_search' do
+        it 'returns an Array of responses' do
+          allow(EM).to receive(:add_shutdown_hook).and_yield
+          expect(subject.search).to eq %w[one two]
+        end
+
+        it 'opens a UDP socket on 0.0.0.0, port 0' do
+          allow(EM).to receive(:add_shutdown_hook)
+          expect(EM).to receive(:open_datagram_socket).with('0.0.0.0', 0, Playful::SSDP::Searcher,
+            'ssdp:all', {})
+          subject.search
+        end
+      end
+    end
+  end
+
+  describe '.notify' do
+    pending 'Implementation of UPnP Devices'
+  end
+
+  describe '.send_notification' do
+    pending 'Implementation of UPnP Devices'
+  end
+
+=begin
+    context 'by default' do
+      it "searches for 'ssdp:all'" do
+        pending
+      end
+
+      it 'waits for 5 seconds for responses' do
+        before = Time.now
+
+        SSDP.search
+
+        after = Time.now
+        (after - before).should < 5.1
+        (after - before).should > 5.0
+      end
+    end
+
+    context "finds 'upnp:rootdevice's" do
+      it "by using the spec's string 'upnp:rootdevice'" do
+        SSDP.search('upnp:rootdevice').should == [
+          {
+            :cache_control=>'max-age=1200',
+            :date=>'Mon, 26 Sep 2011 06:40:19 GMT',
+            :location=>'http://192.168.10.3:5001/description/fetch',
+            :server=>'Linux-i386-2.6.38-10-generic-pae, UPnP/1.0, PMS/1.25.1',
+            :st=>'upnp:rootdevice',
+            :ext=>'',
+            :usn=>'uuid:3c202906-992d-3f0f-b94c-90e1902a136d::upnp:rootdevice',
+            :content_length=>'0'
+          }
+        ]
+      end
+
+      it 'by using :root' do
+        pending
+      end
+    end
+
+    it 'can wait for user-defined seconds for responses' do
+      before = Time.now
+
+      SSDP.search(:all, 1)
+
+      after = Time.now
+      (after - before).should < 1.1
+      (after - before).should > 1.0
+    end
+
+    it 'finds a device by its URN' do
+      pending
+    end
+
+    it 'finds a device by its UUID' do
+      pending
+    end
+
+    it 'finds a device by its UPnP device type' do
+      pending
+    end
+
+    it 'finds a device by its UPnP device type using a non-standard domain name' do
+      pending
+    end
+
+    it 'finds a service by its UPnP service type' do
+      pending
+    end
+
+    it 'find a service by its UPnP service type using a non-standard domain name' do
+      pending
+    end
+=end
+end
+