dnssd 2.0.1 → 3.0.0

data/lib/dnssd/text_record.rb

@@ -4,6 +4,31 @@ require 'delegate'
 # DNSSD::TextRecord is a Hash delegate that can encode its contents for DNSSD.
 
 class DNSSD::TextRecord < DelegateClass(Hash)
+  def self.decode text_record
+    record = {}
+
+    tr = text_record.unpack 'C*'
+
+    until tr.empty? do
+      size  = tr.shift
+
+      next if size.zero?
+
+      raise ArgumentError, 'ran out of data in text record' if tr.length < size
+
+      entry = tr.shift(size).pack('C*')
+
+      raise ArgumentError, 'key not found' unless entry =~ /^[^=]/
+
+      key, value = entry.split '=', 2
+
+      next unless key
+
+      record[key] = value
+    end
+
+    new record
+  end
 
   ##
   # Creates a new TextRecord decoding an encoded +text_record+ if given or
@@ -30,29 +55,7 @@ class DNSSD::TextRecord < DelegateClass(Hash)
   # Decodes +text_record+ and returns a Hash
 
   def decode(text_record)
-    record = {}
-
-    tr = text_record.unpack 'C*'
-
-    until tr.empty? do
-      size  = tr.shift
-
-      next if size.zero?
-
-      raise ArgumentError, 'ran out of data in text record' if tr.length < size
-
-      entry = tr.shift(size).pack('C*')
-
-      raise ArgumentError, 'key not found' unless entry =~ /^[^=]/
-
-      key, value = entry.split '=', 2
-
-      next unless key
-
-      record[key] = value
-    end
-
-    record
+    self.class.decode text_record
   end
 
   ##

data/test/test_dnssd.rb

@@ -1,60 +1,101 @@
-require 'minitest/autorun'
-require 'dnssd'
-require 'socket'
-
-class TestDNSSD < MiniTest::Unit::TestCase
+require 'helper'
 
+class TestDNSSD < DNSSD::Test
   def setup
     @abort = Thread.abort_on_exception
     Thread.abort_on_exception = true
 
-    @port = Socket.getservbyname 'blackjack'
+    begin
+      @port = Socket.getservbyname 'blackjack'
+    rescue
+      @port = 1025
+    end
   end
 
   def teardown
     Thread.abort_on_exception = @abort
   end
 
+  def test_synchronous_register
+    reply = DNSSD.register! name, "_http._tcp", nil, 8080 do |r|
+      break r
+    end
+    assert reply
+  end
+
+  def test_synchronous_enumerate
+    Timeout.timeout(2, Minitest::Skip) do
+      reply = DNSSD.enumerate_domains! do |r|
+        break r
+      end
+      assert reply
+    end
+  end
+
+  def test_asynchronous_enumerate
+    latch = Latch.new
+    reply = DNSSD.enumerate_domains do |r|
+      latch.await
+    end
+    latch.release
+    assert reply
+  end
+
+  def test_synchronous_browse
+    register = DNSSD::Service.register name, "_http._tcp", nil, 8080
+    thing = nil
+    DNSSD.browse!('_http._tcp') do |r|
+      thing = true
+      break
+    end
+    assert thing
+    register.stop
+  end
+
   def test_class_announce_tcp_server
-    t = Thread.current
-    DNSSD.browse '_blackjack._tcp' do |reply|
+    t = nil
+    latch = Latch.new
+
+    browse = DNSSD.browse '_blackjack._tcp' do |reply|
       next unless 'blackjack tcp server' == reply.name
-      t[:reply] = reply
+      t = reply
+      latch.release
     end
 
     s = TCPServer.new 'localhost', @port
 
-    DNSSD.announce s, 'blackjack tcp server'
+    stub Socket, :getservbyport, 'blackjack' do
+      DNSSD.announce s, 'blackjack tcp server'
+    end
 
-    sleep 1
+    latch.await
 
-    assert_equal 'blackjack tcp server', t[:reply].name
+    assert_equal 'blackjack tcp server', t.name
   ensure
+    browse.stop
     s.close
   end
 
   def test_class_announce_tcp_server_service
-    t = Thread.current
+    t = nil
+    latch = Latch.new
 
-    DNSSD.resolve 'blackjack resolve', '_blackjack._tcp', 'local.' do |reply|
-      t[:reply] = reply
+    rs = DNSSD.resolve 'blackjack resolve', '_blackjack._tcp', 'local.' do |reply|
+      t = reply
+      latch.release
     end
 
     s = TCPServer.new 'localhost', @port + 1
 
     DNSSD.announce s, 'blackjack resolve', 'blackjack'
 
-    sleep 1
+    latch.await
 
-    assert_equal 'blackjack resolve', t[:reply].name
-    assert_equal @port + 1, t[:reply].port
+    assert_equal 'blackjack resolve', t.name
+    assert_equal @port + 1, t.port
   ensure
-    s.close
-  end
-
-  def test_class_getservbyport
-    assert_equal 'blackjack', DNSSD.getservbyport(1025),
-                 "Your /etc/services is out of date, sorry!"
+    rs.stop
+    s.close if s
   end
 
   def test_class_interface_index
@@ -69,6 +110,4 @@ class TestDNSSD < MiniTest::Unit::TestCase
 
     assert_match %r%^lo0?$%, DNSSD.interface_name(index)
   end
-
 end
-

data/test/test_dnssd_flags.rb

@@ -1,7 +1,6 @@
-require 'minitest/autorun'
-require 'dnssd'
+require 'helper'
 
-class TestDNSSDFlags < MiniTest::Unit::TestCase
+class TestDNSSDFlags < DNSSD::Test
 
   def setup
     @flags = DNSSD::Flags.new

data/test/test_dnssd_record.rb

@@ -1,14 +1,13 @@
-require 'minitest/autorun'
-require 'dnssd'
+require 'helper'
 
-class TestDNSSDRecord < MiniTest::Unit::TestCase
+class TestDNSSDRecord < DNSSD::Test
 
   def setup
     @fullname = 'blackjack._blackjack._tcp.test.'
     @IN = DNSSD::Record::IN
-    @ipv4 = "\300\000\002\001"
-    @ipv6 = " \001\r\270\000\000\000\000\000\000\000\000\000\000\000\001"
-    @nowhere = "\007nowhere\007example\000"
+    @ipv4 = "\300\000\002\001".force_encoding("ascii-8bit")
+    @ipv6 = " \001\r\270\000\000\000\000\000\000\000\000\000\000\000\001".force_encoding("ascii-8bit")
+    @nowhere = "\007nowhere\007example\000".force_encoding("ascii-8bit")
 
     @R = DNSSD::Record
   end
@@ -28,6 +27,11 @@ class TestDNSSDRecord < MiniTest::Unit::TestCase
     end
   end
 
+  def test_idk
+    a_variable = IPAddr.new '2001:db8::1'
+    assert_equal @ipv6, a_variable.hton
+  end
+
   def test_class_to_data_AAAA
     assert_equal @ipv6, @R.to_data(DNSSD::Record::AAAA, '2001:db8::1')
     assert_equal @ipv6,

data/test/test_dnssd_reply.rb

@@ -1,7 +1,6 @@
-require 'minitest/autorun'
-require 'dnssd'
+require 'helper'
 
-class TestDNSSDReply < MiniTest::Unit::TestCase
+class TestDNSSDReply < DNSSD::Test
 
   def setup
     @reply = DNSSD::Reply.new nil, 0, 0

data/test/test_dnssd_reply_browse.rb

@@ -1,17 +1,21 @@
-require 'minitest/autorun'
-require 'dnssd'
+require 'helper'
 
-class TestDNSSDReplyBrowse < MiniTest::Unit::TestCase
+class TestDNSSDReplyBrowse < DNSSD::Test
 
   def test_connect
     reply = DNSSD::Reply::Browse.new nil, 0, 0, 'blackjack no port',
                                      '_blackjack._tcp', 'local'
 
-    port = Socket.getservbyname 'blackjack'
+    port = stub Socket, :getservbyname, 1025 do
+      Socket.getservbyname('blackjack')
+    end
+
     server = TCPServer.new nil, port
     Thread.start do server.accept end
 
-    DNSSD.announce server, 'blackjack no port'
+    stub Socket, :getservbyport, "blackjack" do
+      DNSSD.announce server, 'blackjack no port'
+    end
 
     socket = reply.connect
 
@@ -29,14 +33,18 @@ class TestDNSSDReplyBrowse < MiniTest::Unit::TestCase
                                      '_blackjack._tcp', 'local'
 
 
-    port = Socket.getservbyname 'blackjack'
+    port = stub Socket, :getservbyname, 1025 do
+      Socket.getservbyname 'blackjack'
+    end
     server = TCPServer.new nil, port
     Thread.start do server.accept end
 
     name = "\u00E9"
     name.encode! Encoding::ISO_8859_1
 
-    DNSSD.announce server, name
+    stub Socket, :getservbyport, 'blackjack' do
+      DNSSD.announce server, name
+    end
 
     socket = reply.connect
 
@@ -46,6 +54,4 @@ class TestDNSSDReplyBrowse < MiniTest::Unit::TestCase
     socket.close if socket
     server.close if server
   end
-
 end
-

data/test/test_dnssd_reply_query_record.rb

@@ -1,7 +1,6 @@
-require 'minitest/autorun'
-require 'dnssd'
+require 'helper'
 
-class TestDNSSDReplyQueryRecord < MiniTest::Unit::TestCase
+class TestDNSSDReplyQueryRecord < DNSSD::Test
 
   def setup
     @fullname = 'blackjack._blackjack._tcp.test.'

data/test/test_dnssd_reply_resolve.rb

@@ -1,11 +1,13 @@
-require 'minitest/autorun'
-require 'dnssd'
+require 'helper'
 
-class TestDNSSDReplyResolve < MiniTest::Unit::TestCase
+class TestDNSSDReplyResolve < DNSSD::Test
 
   def setup
-    @port = Socket.getservbyname 'blackjack'
+    @port = stub Socket, :getservbyname, 1025 do
+      Socket.getservbyname 'blackjack'
+    end
     @interface = DNSSD::InterfaceAny
+    super
   end
 
   def test_connect_tcp

data/test/test_dnssd_service.rb

@@ -1,7 +1,6 @@
-require 'minitest/autorun'
-require 'dnssd'
+require 'helper'
 
-class TestDNSSDService < MiniTest::Unit::TestCase
+class TestDNSSDService < DNSSD::Test
 
   def test_class_get_property
     skip 'DNSSD::Service::get_property not defined' unless
@@ -12,11 +11,10 @@ class TestDNSSDService < MiniTest::Unit::TestCase
   end
 
   def test_class_getaddrinfo
-    service = DNSSD::Service.new
-
     addresses = []
+    service = DNSSD::Service.getaddrinfo 'localhost'
 
-    service.getaddrinfo 'localhost' do |addrinfo|
+    service.each do |addrinfo|
       addresses << addrinfo.address
       break unless addrinfo.flags.more_coming?
     end
@@ -24,5 +22,175 @@ class TestDNSSDService < MiniTest::Unit::TestCase
     assert addresses.index('127.0.0.1')
   end
 
-end
+  def test_enumerate
+    service = DNSSD::Service.enumerate_domains
+
+    begin
+      Timeout.timeout(2) do
+        service.each do |reply|
+          # I *think* there will be a local. on every machine??
+          break if reply.domain == 'local.'
+        end
+        assert true
+      end
+    rescue Timeout::Error
+      skip "couldn't find any domains to enumerate"
+    end
+  ensure
+    service.stop
+  end
+
+  def test_async_register_browse
+    registered = Latch.new
+    found      = Latch.new
+    name       = SecureRandom.hex
+
+    register = DNSSD::Service.register name, "_http._tcp", nil, 8080
+    register.async_each do |reply|
+      if reply.domain == "local."
+        registered.release
+        found.await
+      end
+    end
+
+    registered.await
+
+    browse = DNSSD::Service.browse '_http._tcp'
+    browse.async_each do |r|
+      if r.name == name && r.domain == "local."
+        found.release
+        assert_equal name, r.name
+        assert_equal "_http._tcp", r.type
+      end
+    end
+
+    register.stop
+    browse.stop
+  end
+
+  def test_register_browse
+    registered = Latch.new
+    found      = Latch.new
+    name       = SecureRandom.hex
+
+    broadcast = Thread.new do
+      service = DNSSD::Service.register name, "_http._tcp", nil, 8080
+      service.each do |reply|
+        if reply.domain == "local."
+          registered.release
+          found.await
+          service.stop
+        end
+      end
+    end
+
+    find = Thread.new do
+      registered.await
+      service = DNSSD::Service.browse '_http._tcp'
+      service.each do |r|
+        if r.name == name && r.domain == "local."
+          found.release
+          service.stop
+          assert_equal name, r.name
+          assert_equal "_http._tcp", r.type
+        end
+      end
+    end
 
+    found.await
+    broadcast.join
+    find.join
+  end
+
+  def test_resolve
+    done = Latch.new
+    name = SecureRandom.hex
+
+    broadcast = Thread.new do
+      txt = DNSSD::TextRecord.new 'foo' => 'bar'
+      service = DNSSD::Service.register name, "_http._tcp", nil, 8080, nil, txt
+      done.await
+      service.stop
+    end
+
+    service = DNSSD::Service.browse '_http._tcp'
+    reply = service.each.find do |r|
+      r.name == name && r.domain == "local."
+    end
+
+    resolver = DNSSD::Service.resolve reply.name, reply.type, reply.domain
+    text = resolver.each.find(&:text_record).text_record
+    assert_equal 'bar', text['foo']
+
+    done.release
+    broadcast.join
+  end
+
+  def test_query_record
+    done = Latch.new
+    name = SecureRandom.hex
+
+    broadcast = Thread.new do
+      txt = DNSSD::TextRecord.new 'foo' => 'bar'
+      service = DNSSD::Service.register name, "_http._tcp", nil, 8080, nil, txt
+      done.await
+      service.stop
+    end
+
+    service = DNSSD::Service.browse '_http._tcp'
+    reply = service.each.find do |r|
+      r.name == name && r.domain == "local."
+    end
+    service.stop
+
+    service = DNSSD::Service.query_record reply.fullname, DNSSD::Record::SRV
+    assert service.each.first
+    service.stop
+
+    done.release
+    broadcast.join
+  end
+
+  def test_add_record
+    skip "not supported" if RbConfig::CONFIG['target_os'] =~ /linux/
+    done = Latch.new
+    registered = Latch.new
+    broadcast = Thread.new do
+      txt = DNSSD::TextRecord.new 'bar' => 'baz'
+      service = DNSSD::Service.register name, "_http._tcp", nil, 8080
+      service.add_record(DNSSD::Record::TXT, txt.encode)
+      registered.release
+      done.await
+    end
+
+    registered.await
+    service = DNSSD::Service.browse '_http._tcp'
+    reply = service.each.find { |r|
+      r.name == name && r.domain == "local."
+    }
+
+    query = DNSSD::Service.query_record reply.fullname, DNSSD::Record::TXT
+    r = query.each.find do |response|
+      !response.flags.more_coming?
+    end
+    record = DNSSD::TextRecord.decode r.record
+    done.release
+    assert_equal 'baz', record['bar']
+    broadcast.join
+  end
+
+  def test_stop
+    service = DNSSD::Service.browse '_http._tcp'
+    assert_predicate service, :started?
+    service.stop
+    refute_predicate service, :started?
+
+    assert_raises(DNSSD::Error) { service.each { } }
+  end
+
+  def test_stop_twice
+    service = DNSSD::Service.browse '_http._tcp'
+    service.stop
+    assert_raises(DNSSD::Error) { service.stop }
+  end
+end