Salut 0.3.1 → 0.4.0

data/spec/Service_spec.rb

@@ -7,11 +7,11 @@ describe Salut::Service do
 
   describe '#advertising?' do
     before do
-      @service = Salut::Service.new({
-        port:3000,
-        instance_name:'Test',
-        service_type:'_http._tcp.'
-      })
+      @service = Salut::Service.new(
+                                    port:3000,
+                           instance_name:'Test',
+                            service_type:'_http._tcp.'
+                                    )
     end
 
     it 'should be initialized to false' do
@@ -25,24 +25,22 @@ describe Salut::Service do
 
     it 'should be false after I stop advertising' do
       @service.start_advertising
-      NSRunLoop.currentRunLoop.runUntilDate Time.now + 2
+      run_run_loop
       @service.stop_advertising
-      NSRunLoop.currentRunLoop.runUntilDate Time.now + 2
+      run_run_loop
       @service.advertising?.should.be.equal false
     end
 
     it 'should be false if advertising fails' do
-      @other_service = @service.dup
+      @service.service_type = 'badname'
       @service.start_advertising
-      NSRunLoop.currentRunLoop.runUntilDate Time.now + 2
-      @other_service.start_advertising
-      NSRunLoop.currentRunLoop.runUntilDate Time.now + 2
-      @other_service.advertising?.should.be.equal false
+      run_run_loop
+      @service.advertising?.should.be.equal false
     end
 
     it 'should be true when advertising is successful' do
       @service.start_advertising
-      NSRunLoop.currentRunLoop.runUntilDate Time.now + 2
+      run_run_loop
       @service.advertising?.should.be.equal true
     end
   end
@@ -50,11 +48,11 @@ describe Salut::Service do
 
   describe '#service' do
     before do
-      @service = Salut::Service.new({
-        port:3000,
-        instance_name:'Test',
-        service_type:'_http._tcp.'
-      })
+      @service = Salut::Service.new(
+                                    port:3000,
+                           instance_name:'Test',
+                            service_type:'_http._tcp.'
+                                    )
     end
 
     it 'is an NSNetService instance when not nil' do
@@ -67,7 +65,7 @@ describe Salut::Service do
                                                  type:'_http._tcp.',
                                                  name:'TEST',
                                                  port:4000
-      @service = Salut::Service.new({ service:new_service })
+      @service = Salut::Service.new service:new_service
       @service.service.should.be.equal new_service
     end
 
@@ -80,7 +78,7 @@ describe Salut::Service do
     it 'will be set to nil when advertising stops' do
       @service.service.should.be.equal nil
       @service.start_advertising
-      NSRunLoop.currentRunLoop.runUntilDate (Time.now + 5)
+      run_run_loop 5
       @service.stop_advertising
       @service.service.should.be.equal nil
     end
@@ -89,15 +87,15 @@ describe Salut::Service do
 
   describe '#initialize' do
     it 'will let you initialize the port number' do
-      Salut::Service.new({ port:4000 }).port.should.be.equal 4000
+      Salut::Service.new( port:4000 ).port.should.be.equal 4000
     end
 
     it 'will let you initialize the instance name' do
-      Salut::Service.new({ instance_name:'TEST' }).instance_name.should.be.equal 'TEST'
+      Salut::Service.new( instance_name:'TEST' ).instance_name.should.be.equal 'TEST'
     end
 
     it 'will let you initialize the service type' do
-      Salut::Service.new({ service_type:'_http._tcp.' }).service_type.should.be.equal '_http._tcp.'
+      Salut::Service.new( service_type:'_http._tcp.' ).service_type.should.be.equal '_http._tcp.'
     end
 
     it 'will let you initialize with a service' do
@@ -105,14 +103,10 @@ describe Salut::Service do
                                                  type:'_http._tcp.',
                                                  name:'TEST',
                                                  port:4000
-      @service = Salut::Service.new({ service:new_service })
+      @service = Salut::Service.new service:new_service
       @service.service.should.be.equal new_service
     end
 
-    it 'will initialize delegates to an empty hash' do
-      Salut::Service.new.delegates.should.be.equal Hash.new
-    end
-
     it 'will initialize @advertising to false' do
       Salut::Service.new.advertising?.should.be.equal false
     end
@@ -124,44 +118,31 @@ describe Salut::Service do
   end
 
 
-  describe '#delegates' do
-    it 'should be initialized to an empty hash' do
-      Salut::Service.new.delegates.should.be.equal Hash.new
-    end
+  describe '#delegate' do
+    before do @service = Salut::Service.new end
 
     it 'should be writable' do
-      @service = Salut::Service.new
-      @service.delegates[:test] = Proc.new { true }
-      @service.delegates[:test].should.not.be.equal nil
-    end
-  end
+      @service.delegate :test do true end
+      @service.delegate( :test ).call.should.not.be.equal nil
 
-
-  describe '#[]' do
-    it 'should be equivalent to #delegates[]' do
-      @service = Salut::Service.new
-      @service.delegates[:test] = 'HEY'
-      @service[:test].should.be.equal 'HEY'
+      @service.delegate :test do 'HEY' end
+      @service.delegate( :test ).call.should.be.equal 'HEY'
     end
-  end
 
-
-  describe '#[]=' do
-    it 'should be equivalent to #delegates[]=' do
-      @service = Salut::Service.new
-      @service[:test] = 'HEY'
-      @service.delegates[:test].should.be.equal 'HEY'
+    it 'should be readable' do
+      @service.delegate :test do 'HEY' end
+      @service.delegate( :test ).call.should.be.equal 'HEY'
     end
   end
 
 
   describe '#start_advertising' do
     before do
-      @service = Salut::Service.new({
-        instance_name:'TEST',
-        service_type:'_test._tcp.',
-        port:9001
-      })
+      @service = Salut::Service.new(
+                                    instance_name:'TEST',
+                                     service_type:'_test._tcp.',
+                                             port:9001
+                                    )
     end
 
     it 'should create a new @service object' do
@@ -171,18 +152,17 @@ describe Salut::Service do
     end
 
     it 'should set the delegate for @service to self' do
-      @service.delegates[:'netServiceWillPublish:'] = Proc.new { |sender|
-        @service.service.should.be.equal sender
-      }
+      @service.delegate :'netServiceWillPublish:' do |sender|
+        @service.should.be.equal sender
+      end
       @service.start_advertising
     end
 
-    # a fragile test since it depends on one of the callbacks
-    # being called
+    # a fragile test since it depends on one of the callbacks being called
     it 'should call #publish on @service' do
-      @service.delegates[:'netServiceWillPublish:'] = Proc.new { |sender|
-        @service.service.should.be.equal sender
-      }
+      @service.delegate :'netServiceWillPublish:' do |sender|
+        @service.should.be.equal sender
+      end
       @service.start_advertising
     end
 
@@ -198,36 +178,35 @@ describe Salut::Service do
 
     it 'should fail if service type, instance name, or port are not set' do
       @service.service_type = nil
-      should.raise(NoMethodError) { @service.start_advertising }
+      should.raise NoMethodError do @service.start_advertising end
     end
   end
 
 
   describe '#stop_advertising' do
     before do
-      @service = Salut::Service.new({
-        instance_name:'TEST',
-        service_type:'_test._tcp.',
-        port:9001
-      })
+      @service = Salut::Service.new(
+                                    instance_name:'TEST',
+                                     service_type:'_test._tcp.',
+                                             port:9001
+                                    )
       @service.start_advertising
-      NSRunLoop.currentRunLoop.runUntilDate Time.now + 3
+      run_run_loop
     end
 
-    # a fragile test since it depends on one of the callbacks
-    # being called
+    # a fragile test since it depends on one of the callbacks being called
     it 'should call #stop on @service' do
-      @service.delegates[:'netServiceDidStop:'] = Proc.new { |sender|
+      @service.delegate :'netServiceDidStop:' do |sender|
         true.should.be.equal true
-      }
+      end
       @service.stop_advertising
-      NSRunLoop.currentRunLoop.runUntilDate Time.now + 3
+      run_run_loop
     end
 
     it 'should set @service to nil' do
       @service.service.should.not.be.equal nil
       @service.stop_advertising
-      NSRunLoop.currentRunLoop.runUntilDate Time.now + 3
+      run_run_loop
       @service.service.should.be.equal nil
     end
   end
@@ -235,188 +214,350 @@ describe Salut::Service do
 
   describe '#resolve' do
     before do
-      @service = Salut::Service.new({
-        instance_name:'TEST',
-        service_type:'_test._tcp.',
-        port:9001
-      })
+      @service = Salut::Service.new(
+                                    instance_name:'TEST',
+                                     service_type:'_test._tcp.',
+                                             port:9001
+                                    )
       @service.start_advertising
       @browser = Salut::Browser.new
-      NSRunLoop.currentRunLoop.runUntilDate Time.now + 2
+      run_run_loop
     end
 
     # a fragile test since it depends on callbacks of callbacks being called
     it 'should cause the resolve callback to be called' do
-      @browser.delegates[:'netServiceBrowser:didFindService:moreComing:'] = Proc.new {
+      @browser.delegate :'netServiceBrowser:didFindService:moreComing:' do
         |sender, service, more|
-        service.delegates[:'netServiceWillResolve:'] = Proc.new { |sender|
+        service.delegate :'netServiceWillResolve:' do |sender|
           true.should.be.equal true
-        }
+        end
         service.resolve
-      }
-      @browser.find_services '_test._tcp.', in_domain:''
-      NSRunLoop.currentRunLoop.runUntilDate (Time.now + 5)
+      end
+      @browser.find_services '_test._tcp.'
+      run_run_loop
     end
 
     it 'should allow me to override the timeout' do
-      @browser.delegates[:'netServiceBrowser:didFindService:moreComing:'] = Proc.new {
+      @browser.delegate :'netServiceBrowser:didFindService:moreComing:' do
         |sender, service, more|
-        service.delegates[:'netServiceWillResolve:'] = Proc.new { |sender|
+        service.delegate :'netServiceWillResolve:' do |sender|
           true.should.be.equal true
-        }
+        end
         service.resolve 2.0
-      }
-      @browser.find_services '_test._tcp.', in_domain:''
-      NSRunLoop.currentRunLoop.runUntilDate (Time.now + 5)
+      end
+      @browser.find_services '_test._tcp.'
+      run_run_loop
     end
   end
 
 
-  # describe 'callback skeletons' do
-
-  #   before do
-  #     # set the logger to log INFO and log to a stringIO object
-  #   end
-
-
-  #   describe '#netServiceWillPublish' do
-  #     it 'should call its proc if exists' do
-  #     end
-
-  #     it 'should not explode if the proc does not exist' do
-  #     end
-
-  #     it 'should log a message at the INFO level' do
-  #     end
-
-  #     it 'should pass self to the proc' do
-  #     end
-  #   end
-
-
-  #   describe '#netService:didNotPublish:' do
-  #     it 'should call its proc if exists' do
-  #     end
-
-  #     it 'should not explode if the proc does not exist' do
-  #     end
-
-  #     it 'should log a message at the INFO level' do
-  #     end
-
-  #     it 'should set @advertising to false' do
-  #     end
-
-  #     it 'should pass self to the proc' do
-  #     end
-
-  #     it 'should pass the error dict to the proc' do
-  #     end
-  #   end
-
+  describe 'callback skeletons' do
 
-  #   describe '#netServiceDidPublish' do
-  #     it 'should call its proc if exists' do
-  #     end
-
-  #     it 'should not explode if the proc does not exist' do
-  #     end
-
-  #     it 'should log a message at the INFO level' do
-  #     end
-
-  #     it 'should set @advertising to true' do
-  #     end
-
-  #     it 'should pass self to the proc' do
-  #     end
-  #   end
-
-
-  #   describe '#netServiceWillResolve' do
-  #     it 'should call its proc if exists' do
-  #     end
+    before do
+      @output         = StringIO.new
+      Salut.log       = Logger.new @output
+      Salut.log.level = Logger::INFO
 
-  #     it 'should not explode if the proc does not exist' do
-  #     end
+      @service = Salut::Service.new(
+                                     service_type:'_test._tcp.',
+                                    instance_name:'TEST',
+                                             port:9001
+                                    )
+    end
 
-  #     it 'should log a message at the INFO level' do
-  #     end
 
-  #     it 'should pass self to the proc' do
-  #     end
-  #   end
+    describe '#netServiceWillPublish' do
+      it 'should call its proc if exists' do
+        @service.delegate :'netServiceWillPublish:' do |sender|
+          true.should.be.equal true
+        end
+        @service.start_advertising
+      end
 
+      it 'should not explode if the proc does not exist' do
+        @service.start_advertising
+        true.should.be.equal true #if we got here we didn't explode
+      end
 
-  #   describe '#netService:didNotResolve:' do
-  #     it 'should call its proc if exists' do
-  #     end
+      it 'should log a message at the INFO level' do
+        @service.start_advertising
+        @output.string.should.match /Starting to advertise/
+      end
 
-  #     it 'should not explode if the proc does not exist' do
-  #     end
+      it 'should pass self to the proc' do
+        @service.delegate :'netServiceWillPublish:' do |sender|
+          sender.should.be.equal @service
+        end
+        @service.start_advertising
+      end
+    end
 
-  #     it 'should log a message at the INFO level' do
-  #     end
 
-  #     it 'should pass self to the proc' do
-  #     end
+    describe '#netService:didNotPublish:' do
+      before do
+        @service.service_type = 'badname' # this is how we make publishing fail
+      end
 
-  #     it 'should pass the error dict to the proc' do
-  #     end
-  #   end
+      it 'should call its proc if exists' do
+        @service.delegate :'netService:didNotPublish:' do |sender, dict|
+          true.should.be.equal true
+        end
+        @service.start_advertising
+        run_run_loop
+      end
+
+      it 'should not explode if the proc does not exist' do
+        @service.start_advertising
+        run_run_loop
+        true.should.be.equal true
+      end
+
+      it 'should log a message at the INFO level' do
+        @service.start_advertising
+        run_run_loop
+        @output.string.should.match /ERROR: could not advertise/
+      end
+
+      it '@advertising will still be false' do
+        @service.start_advertising
+        run_run_loop
+        @service.advertising.should.be.equal false
+      end
+
+      it 'should pass self to the proc' do
+        @service.delegate :'netService:didNotPublish:' do |sender, dict|
+          sender.should.be.equal @service
+        end
+        @service.start_advertising
+        run_run_loop
+      end
+
+      it 'should pass the error dict to the proc' do
+        @service.delegate :'netService:didNotPublish:' do |sender, dict|
+          dict.class.should.be.equal Hash
+          dict['NSNetServicesErrorCode'].should.not.be.equal nil
+        end
+        @service.start_advertising
+        run_run_loop
+      end
+    end
+
+
+    describe '#netServiceDidPublish' do
+      it 'should call its proc if exists' do
+        @service.delegate :'netServiceDidPublish:' do |sender|
+          true.should.be.equal true
+        end
+        @service.start_advertising
+        run_run_loop
+      end
+
+      it 'should not explode if the proc does not exist' do
+        @service.start_advertising
+        run_run_loop
+        true.should.be.equal true
+      end
+
+      it 'should log a message at the INFO level' do
+        @service.start_advertising
+        run_run_loop
+        @output.string.should.match /Successfully advertising/
+      end
+
+      it 'should set @advertising to true' do
+        @service.start_advertising
+        run_run_loop
+        @service.advertising.should.be.equal true
+      end
+
+      it 'should pass self to the proc' do
+        @service.delegate :'netServiceDidPublish:' do |sender|
+          sender.should.be.equal @service
+        end
+        @service.start_advertising
+        run_run_loop
+      end
+    end
+
+
+    describe '#netServiceWillResolve' do
+      before do
+        @service.start_advertising
+        @browser = Salut::Browser.new
+        @browser.find_services '_test._tcp.'
+        run_run_loop
+        @found_service = @browser.services.first
+      end
+
+      it 'should call its proc if it exists' do
+        @found_service.delegate :'netServiceWillResolve:' do |sender|
+          true.should.be.equal true
+        end
+        @found_service.resolve
+      end
 
+      it 'should not explode if the proc does not exist' do
+        @found_service.resolve
+        true.should.be.equal true
+      end
 
-  #   describe '#netServiceDidResolveAddress' do
-  #     it 'should call its proc if exists' do
-  #     end
+      it 'should log a message at the INFO level' do
+        @found_service.resolve
+        @output.string.should.match /Resolving service/
+      end
 
-  #     it 'should not explode if the proc does not exist' do
-  #     end
+      it 'should pass self to the proc' do
+        @found_service.delegate :'netServiceWillResolve:' do |sender|
+          @found_service.should.be.equal sender
+        end
+        @found_service.resolve
+      end
+    end
 
-  #     it 'should log a message at the INFO level' do
-  #     end
 
-  #     it 'should pass self to the proc' do
-  #     end
-  #   end
+    # Spitting in the face of my own documentation. Why? Because I want the
+    # the code to fail and this is the easiest way to make it happen.
+    describe '#netService:didNotResolve:' do
+      before do @service.start_advertising end
 
+      it 'should call its proc if it exists' do
+        @service.delegate :'netService:didNotResolve:' do |sender, dict|
+          true.should.be.equal true
+        end
+        @service.resolve 1
+        run_run_loop
+      end
+
+      it 'should not explode if the proc does not exist' do
+        @service.resolve 1
+        run_run_loop
+        true.should.be.equal true
+      end
+
+      it 'should log a message at the INFO level' do
+        @service.resolve 1
+        run_run_loop
+        @output.string.should.match /ERROR: could not resolve/
+      end
+
+      it 'should pass self to the proc' do
+        @service.delegate :'netService:didNotResolve:' do |sender, dict|
+          sender.should.be.equal @service
+        end
+        @service.resolve 1
+        run_run_loop
+      end
+
+      it 'should pass the error dict to the proc' do
+        @service.delegate :'netService:didNotResolve:' do |sender, dict|
+          dict.class.should.be.equal Hash
+        end
+        @service.resolve 1
+        run_run_loop
+      end
+    end
+
+
+    describe '#netServiceDidResolveAddress' do
+      before do
+        @service.start_advertising
+        @browser = Salut::Browser.new
+        @browser.find_services '_test._tcp.'
+        run_run_loop
+        @found_service = @browser.services.first
+      end
+
+      it 'should call its proc if it exists' do
+        @found_service.delegate :'netServiceDidResolveAddress:' do |sender|
+          true.should.be.equal true
+        end
+        @found_service.resolve
+        run_run_loop
+      end
+
+      it 'should not explode if the proc does not exist' do
+        @found_service.resolve
+        run_run_loop
+        true.should.be.equal true
+      end
 
-  #   describe '#netService:didUpdateTXTRecordData:' do
-  #     it 'should call its proc if exists' do
-  #     end
+      it 'should log a message at the INFO level' do
+        @found_service.resolve
+        run_run_loop
+        @output.string.should.match /Resolved address for service/
+      end
 
-  #     it 'should not explode if the proc does not exist' do
-  #     end
+      it 'should pass self to the proc' do
+        @found_service.delegate :'netServiceDidResolveAddress:' do |sender|
+          @found_service.should.be.equal sender
+        end
+        @found_service.resolve
+        run_run_loop
+      end
+    end
 
-  #     it 'should log a message at the INFO level' do
-  #     end
 
-  #     it 'should pass self to the proc' do
-  #     end
+    # describe '#netService:didUpdateTXTRecordData:' do
+    #   it 'should call its proc if exists' do
+    #   end
 
-  #     it 'should pass the TXT record data to the proc' do
-  #     end
-  #   end
+    #   it 'should not explode if the proc does not exist' do
+    #   end
 
+    #   it 'should log a message at the INFO level' do
+    #   end
 
-  #   describe '#netServiceDidStop' do
-  #     it 'should call its proc if exists' do
-  #     end
+    #   it 'should pass self to the proc' do
+    #   end
 
-  #     it 'should not explode if the proc does not exist' do
-  #     end
+    #   it 'should pass the TXT record data to the proc' do
+    #   end
+    # end
 
-  #     it 'should log a message at the INFO level' do
-  #     end
 
-  #     it 'should set @advertising to false' do
-  #     end
+    describe '#netServiceDidStop' do
+      before do
+        @service.start_advertising
+        run_run_loop 1
+      end
 
-  #     it 'should pass self to the proc' do
-  #     end
-  #   end
+      it 'should call its proc if exists' do
+        @service.delegate :'netServiceDidStop:' do |sender|
+          true.should.be.equal true
+        end
+        @service.stop_advertising
+        run_run_loop
+      end
+
+      it 'should not explode if the proc does not exist' do
+        @service.stop_advertising
+        run_run_loop
+        true.should.be.equal true
+      end
+
+      it 'should log a message at the INFO level' do
+        @service.stop_advertising
+        run_run_loop
+        @output.string.should.match /Stopped advertising/
+      end
+
+      it 'should set @advertising to false' do
+        @service.advertising?.should.be.equal true
+        @service.stop_advertising
+        run_run_loop
+        @service.advertising?.should.be.equal false
+      end
+
+      it 'should pass self to the proc' do
+        @service.delegate :'netServiceDidStop:' do |sender|
+          sender.should.be.equal @service
+        end
+        @service.stop_advertising
+        run_run_loop
+      end
+    end
 
-  # end
+  end
 
 
 end