bubble-wrap 1.7.1 → 1.8.0

data/spec/motion/motion/core_motion_spec.rb

@@ -0,0 +1,231 @@
+describe BubbleWrap::Motion do
+
+  it 'should be able to instantiate all the things' do
+    mgr = CMMotionManager.alloc.init
+    mgr.should.be.kind_of(CMMotionManager)
+
+    accelerometer = BubbleWrap::Motion::Accelerometer.new(mgr)
+    accelerometer.should.be.kind_of(BubbleWrap::Motion::Accelerometer)
+
+    gyroscope = BubbleWrap::Motion::Gyroscope.new(mgr)
+    gyroscope.should.be.kind_of(BubbleWrap::Motion::Gyroscope)
+
+    magnetometer = BubbleWrap::Motion::Magnetometer.new(mgr)
+    magnetometer.should.be.kind_of(BubbleWrap::Motion::Magnetometer)
+
+    devicemotion = BubbleWrap::Motion::DeviceMotion.new(mgr)
+    devicemotion.should.be.kind_of(BubbleWrap::Motion::DeviceMotion)
+  end
+
+  describe 'BubbleWrap::Motion.manager' do
+    it 'should return a CMMotionManager' do
+      BubbleWrap::Motion.manager.should.be.kind_of(CMMotionManager)
+    end
+    it 'should be a shared instance' do
+      mgr1 = BubbleWrap::Motion.manager
+      mgr2 = BubbleWrap::Motion.manager
+      mgr1.should.equal? mgr2
+    end
+  end
+
+  describe 'BubbleWrap::Motion.accelerometer' do
+    it 'should be a BubbleWrap::Motion::Accelerometer' do
+      BubbleWrap::Motion.accelerometer.should.be.kind_of(BubbleWrap::Motion::Accelerometer)
+    end
+    it 'should be shared instanceAccelerometer' do
+      obj1 = BubbleWrap::Motion.accelerometer
+      obj2 = BubbleWrap::Motion.accelerometer
+      obj1.should.equal? obj2
+    end
+    it 'should not be available in the simulator' do
+      BubbleWrap::Motion.accelerometer.available?.should == false
+    end
+    it 'should not be active in the simulator' do
+      BubbleWrap::Motion.accelerometer.active?.should == false
+    end
+    it 'should not have data' do
+      BubbleWrap::Motion.accelerometer.data.should == nil
+    end
+    it 'should be able to start with a block' do
+      -> do
+        BubbleWrap::Motion.accelerometer.start {}
+        BubbleWrap::Motion.accelerometer.stop
+      end.should.not.raise
+    end
+    it 'should be able to start without a block' do
+      -> do
+        BubbleWrap::Motion.accelerometer.start
+        BubbleWrap::Motion.accelerometer.stop
+      end.should.not.raise
+    end
+    it 'should be able to repeat' do
+      -> do
+        BubbleWrap::Motion.accelerometer.repeat {}
+        BubbleWrap::Motion.accelerometer.stop
+      end.should.not.raise
+    end
+    it 'should be able to repeat via every' do
+      -> do
+        BubbleWrap::Motion.accelerometer.every(5) {}
+        BubbleWrap::Motion.accelerometer.stop
+      end.should.not.raise
+    end
+    it 'should be able to run once' do
+      -> do
+        BubbleWrap::Motion.accelerometer.once {}
+        BubbleWrap::Motion.accelerometer.stop
+      end.should.not.raise
+    end
+  end
+
+  describe 'BubbleWrap::Motion.gyroscope' do
+    it 'should be a BubbleWrap::Motion::Gyroscope' do
+      BubbleWrap::Motion.gyroscope.should.be.kind_of(BubbleWrap::Motion::Gyroscope)
+    end
+    it 'should be a shared instance' do
+      obj1 = BubbleWrap::Motion.gyroscope
+      obj2 = BubbleWrap::Motion.gyroscope
+      obj1.should.equal? obj2
+    end
+    it 'should not be available in the simulator' do
+      BubbleWrap::Motion.gyroscope.available?.should == false
+    end
+    it 'should not be active in the simulator' do
+      BubbleWrap::Motion.gyroscope.active?.should == false
+    end
+    it 'should not have data' do
+      BubbleWrap::Motion.gyroscope.data.should == nil
+    end
+    it 'should be able to start with a block' do
+      -> do
+        BubbleWrap::Motion.gyroscope.start {}
+        BubbleWrap::Motion.gyroscope.stop
+      end.should.not.raise
+    end
+    it 'should be able to start without a block' do
+      -> do
+        BubbleWrap::Motion.gyroscope.start
+        BubbleWrap::Motion.gyroscope.stop
+      end.should.not.raise
+    end
+    it 'should be able to repeat' do
+      -> do
+        BubbleWrap::Motion.gyroscope.repeat {}
+        BubbleWrap::Motion.gyroscope.stop
+      end.should.not.raise
+    end
+    it 'should be able to repeat via every' do
+      -> do
+        BubbleWrap::Motion.gyroscope.every(5) {}
+        BubbleWrap::Motion.gyroscope.stop
+      end.should.not.raise
+    end
+    it 'should be able to run once' do
+      -> do
+        BubbleWrap::Motion.gyroscope.once {}
+        BubbleWrap::Motion.gyroscope.stop
+      end.should.not.raise
+    end
+  end
+
+  describe 'BubbleWrap::Motion.magnetometer' do
+    it 'should be a BubbleWrap::Motion::Magnetometer' do
+      BubbleWrap::Motion.magnetometer.should.be.kind_of(BubbleWrap::Motion::Magnetometer)
+    end
+    it 'should be a shared instance' do
+      obj1 = BubbleWrap::Motion.magnetometer
+      obj2 = BubbleWrap::Motion.magnetometer
+      obj1.should.equal? obj2
+    end
+    it 'should not be available in the simulator' do
+      BubbleWrap::Motion.magnetometer.available?.should == false
+    end
+    it 'should not be active in the simulator' do
+      BubbleWrap::Motion.magnetometer.active?.should == false
+    end
+    it 'should not have data' do
+      BubbleWrap::Motion.magnetometer.data.should == nil
+    end
+    it 'should be able to start with a block' do
+      -> do
+        BubbleWrap::Motion.magnetometer.start {}
+        BubbleWrap::Motion.magnetometer.stop
+      end.should.not.raise
+    end
+    it 'should be able to start without a block' do
+      -> do
+        BubbleWrap::Motion.magnetometer.start
+        BubbleWrap::Motion.magnetometer.stop
+      end.should.not.raise
+    end
+    it 'should be able to repeat' do
+      -> do
+        BubbleWrap::Motion.magnetometer.repeat {}
+        BubbleWrap::Motion.magnetometer.stop
+      end.should.not.raise
+    end
+    it 'should be able to repeat via every' do
+      -> do
+        BubbleWrap::Motion.magnetometer.every(5) {}
+        BubbleWrap::Motion.magnetometer.stop
+      end.should.not.raise
+    end
+    it 'should be able to run once' do
+      -> do
+        BubbleWrap::Motion.magnetometer.once {}
+        BubbleWrap::Motion.magnetometer.stop
+      end.should.not.raise
+    end
+  end
+
+  describe 'BubbleWrap::Motion.device' do
+    it 'should be a BubbleWrap::Motion::DeviceMotion' do
+      BubbleWrap::Motion.device.should.be.kind_of(BubbleWrap::Motion::DeviceMotion)
+    end
+    it 'should be a shared instance' do
+      obj1 = BubbleWrap::Motion.device
+      obj2 = BubbleWrap::Motion.device
+      obj1.should.equal? obj2
+    end
+    it 'should not be available in the simulator' do
+      BubbleWrap::Motion.device.available?.should == false
+    end
+    it 'should not be active in the simulator' do
+      BubbleWrap::Motion.device.active?.should == false
+    end
+    it 'should not have data' do
+      BubbleWrap::Motion.device.data.should == nil
+    end
+    it 'should be able to start with a block' do
+      -> do
+        BubbleWrap::Motion.device.start {}
+        BubbleWrap::Motion.device.stop
+      end.should.not.raise
+    end
+    it 'should be able to start without a block' do
+      -> do
+        BubbleWrap::Motion.device.start
+        BubbleWrap::Motion.device.stop
+      end.should.not.raise
+    end
+    it 'should be able to repeat' do
+      -> do
+        BubbleWrap::Motion.device.repeat {}
+        BubbleWrap::Motion.device.stop
+      end.should.not.raise
+    end
+    it 'should be able to repeat via every' do
+      -> do
+        BubbleWrap::Motion.device.every(5) {}
+        BubbleWrap::Motion.device.stop
+      end.should.not.raise
+    end
+    it 'should be able to run once' do
+      -> do
+        BubbleWrap::Motion.device.once {}
+        BubbleWrap::Motion.device.stop
+      end.should.not.raise
+    end
+  end
+
+end

data/spec/motion/reactor/deferrable_spec.rb

@@ -0,0 +1,81 @@
+describe BubbleWrap::Reactor::Deferrable do
+
+  before do
+    @subject = Class.new do
+      include BubbleWrap::Reactor::Deferrable
+    end
+    @object = @subject.new
+  end
+
+  describe '.callback' do
+
+    it "calls the callback block with arguments after .succeed" do
+      args = [1, 2]
+      @object.callback do |*passed_args|
+        passed_args.should.equal args
+      end
+      @object.succeed *args
+    end
+
+    it "calls the callback if even if the deferrable already suceeded" do
+      @object.succeed :succeeded
+      @object.callback do |*args|
+        args[0].should.equal :succeeded
+      end
+    end
+
+  end
+
+  describe '.errback' do
+    it "calls the errback block after the deferrable fails" do
+      args = [1, 2]
+      @object.errback do |*passed_args|
+        passed_args.should.equal args
+      end
+      @object.fail *args
+    end
+
+    it "calls the errback block even if the deferrable failed first" do
+      @object.fail :err
+      @object.errback do |err|
+        err.should.equal :err
+      end
+    end
+  end
+
+  describe '.delegate' do
+    it "passes the delegate to both .errback_delegate and .callback_delegate" do
+      @object.define_singleton_method(:callback_delegate) { |d| @callback_delegated = true }
+      @object.define_singleton_method(:errback_delegate) { |d| @errback_delegated = true }
+
+      @object.delegate(@subject.new)
+      @object.instance_variable_get("@callback_delegated").should.equal true
+      @object.instance_variable_get("@errback_delegated").should.equal true
+    end
+  end
+
+  describe '.errback_delegate' do
+    it "calls the delegate errback method when the deferrable fails" do
+      delegate = @subject.new
+      @object.errback_delegate delegate
+
+      delegate.errback do |*args|
+        args[0].should.equal :err
+      end
+      @object.fail :err
+    end
+  end
+
+  describe '.callback_delegate' do
+    it "calls the delegate callback when the deferrable suceeds" do
+      delegate = @subject.new
+      @object.callback_delegate delegate
+
+      delegate.callback do |*args|
+        args[0].should.equal :passed
+      end
+      @object.succeed :passed
+    end
+  end
+
+end

data/spec/motion/reactor/eventable_spec.rb

@@ -48,6 +48,17 @@ describe BubbleWrap::Reactor::Eventable do
       events[:foo].member?(proof).should == false
     end
 
+    it 'unregisters all events' do
+      def bar; end
+      proof = method(:bar)
+      @subject.on(:foo, proof)
+      proof_2 = proc { }
+      @subject.on(:foo, &proof_2)
+      events = @subject.instance_variable_get(:@__events__)
+      @subject.off(:foo)
+      events[:foo].should == []
+    end
+
     it 'unregisters method events after kvo' do
       observing_object = Class.new do
         include BubbleWrap::KVO

data/spec/motion/reactor/thread_aware_deferrable_spec.rb

@@ -0,0 +1,85 @@
+shared :queue_caching_deferrable_method do
+  it "stores the current queue that is being used when a callback is added" do
+    @subject.send(@method, &@blk)
+    cache = @subject.instance_variable_get("@queue_cache")
+    cache.should.not.be.nil
+    cache[@blk.object_id].to_s.should.equal Dispatch::Queue.main.to_s
+  end
+
+  it "stores the queue, even if its not the main" do
+    @queue.async do 
+      @subject.send(@method, &@blk)
+      Dispatch::Queue.main.async { resume }
+    end
+    wait do
+      cache = @subject.instance_variable_get("@queue_cache")
+      cache.should.not.be.nil
+      cache[@blk.object_id].to_s.should.equal @queue.to_s
+    end
+  end
+end
+
+shared :queue_block_execution do
+  it "calls the block on the right thread, with deferred argument once the deferrable is finished" do
+    @queue.async do 
+      @subject.send(@block_method) do |*args|
+        Dispatch::Queue.current.to_s.should.equal @queue.to_s
+        args.should.equal [true]
+        Dispatch::Queue.main.async { resume }
+      end
+    end
+    @subject.send(@status_method, true)
+
+    wait {}
+  end
+
+  it "removes the queue from internal cache once the deferrable is finished" do
+    @subject.send(@block_method) do |*args| 
+      Dispatch::Queue.main.async { resume }
+    end
+    @subject.send(@status_method, true)
+
+    wait do
+      @subject.instance_variable_get("@queue_cache").length.should.equal 0
+    end
+  end
+end
+
+describe BubbleWrap::Reactor::ThreadAwareDeferrable do
+
+  before do
+    @subject = BubbleWrap::Reactor::ThreadAwareDeferrable.new
+    @queue = Dispatch::Queue.new(:test_queue.to_s)
+    @blk = Proc.new {|*args| }
+  end
+
+  describe '.callback' do
+    before do
+      @method = :callback
+    end
+    behaves_like :queue_caching_deferrable_method
+  end
+
+  describe '.errback' do
+    before do
+      @method = :errback
+    end
+    behaves_like :queue_caching_deferrable_method
+  end
+
+  describe '.succeed' do
+    before do
+      @block_method = :callback
+      @status_method = :succeed
+    end
+    behaves_like :queue_block_execution
+  end
+
+  describe '.fail' do
+    before do
+      @block_method = :callback
+      @status_method = :succeed
+    end
+    behaves_like :queue_block_execution
+  end
+end

data/spec/motion/rss_parser_spec.rb

@@ -1,4 +1,5 @@
 describe "RSSParser" do
+  extend WebStub::SpecHelpers
 
   before do
     @feed_url = 'https://raw.github.com/gist/2952427/9f1522cbe5d77a72c7c96c4fdb4b77bd58d7681e/atom.xml'
@@ -32,6 +33,11 @@ describe "RSSParser" do
     end
 
     it "parses url data" do
+      string = File.read(File.join(App.resources_path, 'atom.xml'))
+
+      stub_request(:get, @feed_url).
+        to_return(body: string, content_type: "application/xml")
+
       parser = BW::RSSParser.new(@feed_url)
       episodes = []
       parser.parse { |episode| episodes << episode }
@@ -40,28 +46,12 @@ describe "RSSParser" do
     end
 
     it "handles errors" do
-      parser = BW::RSSParser.new("http://doesnotexist.com")
-      parser.parse
-      parser.state.should.equal :errors
-    end
+      error_url = 'http://doesnotexist.com'
 
-    module BW
-      module HTTP
-        class << self
-          # To avoid interfering the http_spec's mocking, we only want to override HTTP.get if it's
-          # for the RSSParser spec.
-          alias_method :original_get, :get
-          def get(url, options = {}, &block)
-            if url == 'https://raw.github.com/gist/2952427/9f1522cbe5d77a72c7c96c4fdb4b77bd58d7681e/atom.xml'
-              string = File.read(File.join(App.resources_path, 'atom.xml'))
-              yield BW::HTTP::Response.new(body: string.to_data, status_code: 200)
-            elsif url == 'http://doesnotexist.com'
-              yield BW::HTTP::Response.new(status_code: nil)
-            else
-              original_get(url, options, &block)
-            end
-          end
-        end
+      parser = BW::RSSParser.new(error_url)
+      parser.parse
+      wait 0.1 do
+        parser.state.should.equal :errors
       end
     end
   end