motel 0.3 → 0.3.1

data/spec/callbacks_spec.rb

@@ -0,0 +1,156 @@
+# callbacks module tests
+#
+# Copyright (C) 2010 Mohammed Morsi <movitto@yahoo.com>
+# Licensed under the AGPLv3+ http://www.gnu.org/licenses/agpl.txt
+
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe Motel::Callbacks::Movement do
+  it "should invoke handler w/out restriction by default" do
+    invoked = false
+    loc = Location.new :x => 0, :y => 0, :z => 0
+    Motel::Callbacks::Movement.new(:handler => lambda { |loc, d, dx, dy, dz|
+      invoked = true
+      loc.should == loc
+      d.should == 0
+      dx.should == 0
+      dy.should == 0
+      dz.should == 0
+    }).invoke(loc, 0, 0, 0)
+    invoked.should be_true
+  end
+
+  it "should invoke handler only when location moves min distance" do
+    invoked = false
+    loc = Location.new :x => 0, :y => 0, :z => 0
+    cb = Motel::Callbacks::Movement.new :min_distance => 10, 
+                                           :handler => lambda { |loc, d, dx, dy, dz|
+      invoked = true
+    }
+    cb.invoke(loc, 0, 0, 0)
+    invoked.should be_false
+    cb.instance_variable_set(:@orig_x, nil) # XXX ugly hack need to reset orig_x so that new 'old coordinates' get accepted
+
+    cb.invoke(loc, -5, 0, 0)
+    invoked.should be_false
+    cb.instance_variable_set(:@orig_x, nil)
+
+    cb.invoke(loc, 0.5, 1.2, 0.23)
+    invoked.should be_false
+    cb.instance_variable_set(:@orig_x, nil)
+
+    cb.invoke(loc, 0, 10, 0)
+    invoked.should be_true
+    invoked = false
+    cb.instance_variable_set(:@orig_x, nil)
+
+    cb.invoke(loc, 0, 10, -10)
+    invoked.should be_true
+    invoked = false
+    cb.instance_variable_set(:@orig_x, nil)
+
+    cb.invoke(loc, -10, 0, 0)
+    invoked.should be_true
+    invoked = false
+    cb.instance_variable_set(:@orig_x, nil)
+
+    cb.invoke(loc, 10, 0, 0)
+    invoked.should be_true
+    invoked = false
+    cb.instance_variable_set(:@orig_x, nil)
+
+    loc.x = -5 ; loc.y = 5 ; loc.z = 12
+    cb.invoke(loc, 0, 0, 0)
+    invoked.should be_true
+  end
+
+  it "should invoke handler only when location moves min axis distance" do
+    invoked = false
+    loc = Location.new :x => 0, :y => 0, :z => 0
+    cb = Motel::Callbacks::Movement.new :min_y => 10, 
+                                           :handler => lambda { |loc, d, dx, dy, dz|
+      invoked = true
+    }
+    cb.invoke(loc, 0, 0, 0)
+    invoked.should be_false
+    cb.instance_variable_set(:@orig_x, nil) # XXX ugly hack need to reset orig_x so that new 'old coordinates' get accepted
+
+    cb.invoke(loc, 0, -6, 0)
+    invoked.should be_false
+    cb.instance_variable_set(:@orig_x, nil)
+
+    cb.invoke(loc, 10, 0, 0)
+    invoked.should be_false
+    cb.instance_variable_set(:@orig_x, nil)
+
+    cb.invoke(loc, 10, -5, 20)
+    invoked.should be_false
+    cb.instance_variable_set(:@orig_x, nil)
+
+    cb.invoke(loc, 0, -10, 0)
+    invoked.should be_true
+    invoked = false
+    cb.instance_variable_set(:@orig_x, nil)
+
+    cb.invoke(loc, 0, 10, 0)
+    invoked.should be_true
+    invoked = false
+  end
+end
+
+describe Motel::Callbacks::Proximity do
+  it "should only invoke handler if locations share coordinates by default" do
+    invoked = false
+    loc1 = Location.new :x => 0, :y => 0, :z => 0
+    loc2 = Location.new :x => 10, :y => 0, :z => 0
+
+    callback = Motel::Callbacks::Proximity.new :to_location => loc1, :handler => lambda { |loc1, loc2|
+      invoked = true
+    }
+    callback.invoke(loc2)
+    invoked.should be_false
+
+    loc2.x = 0
+    callback.invoke(loc2)
+    invoked.should be_true
+  end
+
+  it "should invoke handler only when locations are within max distance of each other" do
+    invoked = false
+    loc1 = Location.new :x => 0, :y => 0, :z => 0
+    loc2 = Location.new :x => 20, :y => 0, :z => 0
+    cb = Motel::Callbacks::Proximity.new :to_location => loc2, :max_distance => 10, 
+                                           :handler => lambda { |loc1, loc2|
+      invoked = true
+    }
+    cb.invoke(loc1)
+    invoked.should be_false
+
+    loc1.y = 1.5
+    loc1.z = 0.75
+    loc2.x = 2.5
+    loc2.y = 2.5
+    cb = Motel::Callbacks::Proximity.new :to_location => loc2, :max_distance => 10, 
+                                           :handler => lambda { |loc1, loc2|
+      invoked = true
+    }
+    cb.invoke(loc1)
+    invoked.should be_true
+  end
+
+  it "should invoke handler only when locations are within max axis distance of each other" do
+    invoked = false
+    loc1 = Location.new :x => 0, :y => 0, :z => 0
+    loc2 = Location.new :x => 0, :y => 0, :z => 20
+    cb = Motel::Callbacks::Proximity.new :max_z => 10, :to_location => loc1,
+                                           :handler => lambda { |loc1, loc2|
+      invoked = true
+    }
+    cb.invoke(loc2)
+    invoked.should be_false
+
+    loc2.z = 7
+    cb.invoke(loc2)
+    invoked.should be_true
+  end
+end

data/spec/dsl_spec.rb

@@ -16,11 +16,11 @@ describe "Motel::dsl" do
 
     # use dsl to connect to server and issue a few requests
     connect :schema_file => SIMRPC_SPEC do |client|
-       location_id = 100
-       client.create_location(location_id).should be(true)
-       loc = client.get_location(location_id)
-       loc.should_not be_nil
-       loc.id.should be(location_id)
+       loc = Location.new :id => 500
+       client.create_location(loc).id.should == loc.id
+       loc2 = client.get_location(loc.id)
+       loc2.should_not be_nil
+       loc2.id.should be(loc.id)
     end
   end
 

data/spec/location_spec.rb

@@ -25,13 +25,6 @@ describe Location do
      location.movement_strategy.should == ms
   end
 
-  it "should default to origin coordinates" do
-     loc = Location.new
-     loc.x.should == 0
-     loc.y.should == 0
-     loc.z.should == 0
-  end
-
   it "should be updatable given another location to copy" do
      p1 = Location.new
      p2 = Location.new
@@ -40,8 +33,8 @@ describe Location do
      new  = Location.new :x => 5, :movement_strategy => 'foomoney', :parent_id => 10, :parent => p2
      orig.update(new)
      orig.x.should be(5)
-     orig.y.should be(0)
-     orig.y.should be(0)
+     orig.y.should == 2
+     orig.z.should be_nil
      orig.movement_strategy.should == "foomoney"
      orig.parent_id.should be(10)
      orig.parent.should be(p2)
@@ -52,7 +45,13 @@ describe Location do
      orig.y.should be(6)
   end
 
-  it "retrieve root location" do
+  it "should retrieve a location's coordinates" do
+    loc = Location.new :x => 10, :y => 20, :z => -30
+    coords = loc.coordinates
+    coords.should == [10, 20, -30]
+  end
+
+  it "should retrieve root location" do
     ggp = Location.new
     gp  = Location.new :parent => ggp
     p   = Location.new :parent => gp
@@ -106,4 +105,10 @@ describe Location do
     child.total_z.should == 42 - 93
   end
 
+  it "should calculate the distance between two locations" do
+    loc1 = Location.new :x => 10, :y => 10, :z => 10
+    loc2 = Location.new :x => -5, :y => -7, :z => 30
+    ((loc1 - loc2 - 30.2324329156619) < 0.000001).should be_true
+  end
+
 end

data/spec/runner_spec.rb

@@ -8,29 +8,29 @@ require File.dirname(__FILE__) + '/spec_helper'
 describe Runner do
 
   it "manage array of locations to be run" do
-    loc = Location.new
-    Runner.instance.locations.clear
+    loc = Location.new :id => 50
+    Runner.instance.clear
     Runner.instance.locations.should == []
     Runner.instance.run loc
     Runner.instance.locations.should == [loc]
-    Runner.instance.locations.clear
+    Runner.instance.clear
   end
 
   it "should run managed locations" do
-    loc1 = Location.new :movement_strategy => TestMovementStrategy.new
-    loc2 = Location.new :movement_strategy => TestMovementStrategy.new
-    Runner.instance.locations.clear
+    loc1 = Location.new :id => 100, :movement_strategy => TestMovementStrategy.new
+    loc2 = Location.new :id => 200, :movement_strategy => TestMovementStrategy.new
+    Runner.instance.clear
     Runner.instance.run loc1
     Runner.instance.run loc2
     Runner.instance.locations.size.should == 2
 
     Runner.instance.start :async => true, :num_threads => 10
-    Runner.instance.thread_pool.should_not == nil
-    Runner.instance.thread_pool.max_size.should == 10
+    #Runner.instance.thread_pool.should_not == nil
+    #Runner.instance.thread_pool.max_size.should == 10
     Runner.instance.terminate.should == false
 
-    # TODO should we sleep here for a fixed time, to allow 
-    # move to be called multiple times ?
+    # sleep here to allow move to be called
+    sleep 2
 
     Runner.instance.stop
     Runner.instance.terminate.should == true
@@ -42,4 +42,18 @@ describe Runner do
     loc2.movement_strategy.times_moved.should be > 0
   end
 
+  it "should set id on managed location to be run if missing" do
+    loc1 = Location.new :id => 1, :movement_strategy => TestMovementStrategy.new
+    loc3 = Location.new :id => 3, :movement_strategy => TestMovementStrategy.new
+    Runner.instance.clear
+    Runner.instance.run loc1
+    Runner.instance.run loc3
+    Runner.instance.locations.size.should == 2
+
+    loc2 = Location.new :movement_strategy => TestMovementStrategy.new
+    loc2a = Runner.instance.run loc2
+    loc2.id.should == 2
+    Runner.instance.locations.size.should == 3
+  end
+
 end

data/spec/simrpc_spec.rb

@@ -3,7 +3,7 @@
 # Copyright (C) 2010 Mohammed Morsi <movitto@yahoo.com>
 # Licensed under the AGPLv3+ http://www.gnu.org/licenses/agpl.txt
 
-dir = File.dirname(__FILE__) 
+dir = File.dirname(__FILE__)
 require dir + '/spec_helper'
 
 describe "Motel::Simrpc" do
@@ -20,63 +20,184 @@ describe "Motel::Simrpc" do
 
   it "should permit location creation and retrieval" do
     locations = Runner.instance.locations.size
-    location_id = 10
-    @client.create_location(location_id).should be(true)
+    clocation = Location.new :id => 10, :x => 100, :y => -200, :z => 500
+    tloc = @client.create_location(clocation)
+    tloc.id.should == clocation.id
+    tloc.x.should == 100
+    tloc.y.should == -200
+    tloc.z.should == 500
     Runner.instance.locations.size.should == locations + 1
 
-    loc = @client.get_location(location_id)
+    # FIXME test setting / retrieving movement strategy
+
+    loc = @client.get_location(clocation.id)
+    loc.should_not be_nil
+    loc.id.should be(clocation.id)
+    loc.x.should == 100
+    loc.y.should == -200
+    loc.z.should == 500
+  end
+
+  it "should autogenerate location id and coordinates on creation if not specified" do
+    Runner.instance.clear
+    loc1 = Location.new :id => 1
+    loc2 = Location.new :id => 2
+    loc4 = Location.new :id => 4
+    @client.create_location(loc1)
+    @client.create_location(loc2)
+    @client.create_location(loc4)
+
+    loc3 = @client.create_location(Location.new)
+    loc3.id.should == 3
+    loc3.x.should == 0
+    loc3.y.should == 0
+    loc3.z.should == 0
+
+    Runner.instance.locations.size.should == 4
+
+    loc3a = @client.get_location(3)
+    loc3a.should_not be_nil
+  end
+
+  it "should autogenerate location if none is specified on creation" do
+    Runner.instance.clear
+    loc = @client.create_location
+    loc.id.should == 1
+    loc.x.should == 0
+    loc.y.should == 0
+    loc.z.should == 0
+
+    Runner.instance.locations.size.should == 1
+
+    loc = @client.get_location(1)
     loc.should_not be_nil
-    loc.id.should be(location_id)
   end
 
   it "should permit updating a location" do
-    location_id = 20
-    @client.create_location(location_id).should be(true)
-    @client.update_location(Location.new(:id => location_id, :x => 150, :y => 300, :z => -600)).should be(true)
+    clocation = Location.new :id => 20
+    @client.create_location(clocation).id.should == clocation.id
+    @client.update_location(Location.new(:id => clocation.id, :x => 150, :y => 300, :z => -600)).should be(true)
 
-    loc = @client.get_location(location_id)
+    loc = @client.get_location(clocation.id)
     loc.should_not be_nil
     loc.x.should be(150)
     loc.y.should be(300)
     loc.z.should be(-600)
 
-    loc = @client.request :get_location, location_id
+    loc = @client.request :get_location, clocation.id
     loc.should_not be_nil
     loc.x.should be(150)
   end
 
-  it "should permit receiving location updates" do
+  #it "should invoke callbacks when updating a location" do
+  #  Runner.instance.clear
+  #  clocation = Location.new :id => 250
+  #  @client.create_location(clocation).id.should == clocation.id
+
+  #  # handle and subscribe to location movement
+  #  times_moved = 0
+  #  @client.on_location_moved = lambda { |location, d, dx, dy, dz|
+  #    times_moved += 1
+  #  }
+  #  @client.subscribe_to_location_movement(clocation.id).should be(true)
+
+  #  res = @client.update_location(Location.new(:id => clocation.id, :x => 150, :y => 300, :z => -600))
+  #  res.should be(true)
+
+  #  loc = @client.get_location(clocation.id)
+  #  loc.should_not be_nil
+  #  loc.x.should be(150)
+  #  loc.y.should be(300)
+  #  loc.z.should be(-600)
+  #  times_moved.should be(1)
+  #end
+
+  it "should permit receiving location movement updates" do
     # start the runner here, to actual move location / process callbacks
+    Runner.instance.clear
     Runner.instance.start :async => true
 
     # create the location
-    location_id = 30
-    @client.create_location(location_id).should be(true)
+    clocation = Location.new :id => 30
+    @client.create_location(clocation).id.should == clocation.id
 
     ## set a linear movement strategy
     location = Location.new
-    location.id = location_id
+    location.id = clocation.id
     location.movement_strategy = Linear.new(:step_delay => 1,
-                                            :speed      => 15, 
+                                            :speed      => 15,
                                             :direction_vector_x => 1,
                                             :direction_vector_y => 0,
                                             :direction_vector_z => 0)
     @client.update_location(location).should be(true)
 
-    times_moved = 0 
+    times_moved = 0
 
     # handle location_moved method
-    @client.on_location_received = lambda { |location|
+    @client.on_location_moved = lambda { |location, d, dx, dy, dz|
       times_moved += 1
-    }   
+    }
+
+    ## subscribe to updates
+    @client.subscribe_to_location_movement(clocation.id).should be(true)
+    Runner.instance.locations.first.movement_callbacks.size.should == 1
+    Runner.instance.locations.first.movement_callbacks[0].class.should == Callbacks::Movement
+
+    ## delay briefly allowing for updates
+    sleep 2
+
+    times_moved.should be > 0
+
+    # stop the runner
+    Runner.instance.stop
+  end
+
+  it "should permit receiving location proximity events" do
+    # start the runner here, to actual move location / process callbacks
+    Runner.instance.clear
+    Runner.instance.start :async => true
+
+    # create the locations
+    clocation1 = Location.new :id => 300
+    clocation2 = Location.new :id => 600
+    @client.create_location(clocation1).id.should == clocation1.id
+    @client.create_location(clocation2).id.should == clocation2.id
+
+    # update
+    location1 = Location.new :id => clocation1.id, :x => 0, :y => 0, :z => 0
+    location2 = Location.new :id => clocation2.id, :x => 0, :y => 0, :z => 100
+    @client.update_location(location1).should be(true)
+    @client.update_location(location2).should be(true)
+
+    proximity_triggered = false
+
+    # handle location_moved method
+    @client.on_locations_proximity = lambda { |loc1, loc2|
+      location1.id.should == clocation1.id
+      location2.id.should == clocation2.id
+      proximity_triggered = true
+    }
 
     ## subscribe to updates
-    @client.subscribe_to_location(location_id).should be(true)
+    @client.subscribe_to_locations_proximity(clocation1.id, clocation2.id, "proximity", 10).should be(true)
+    Runner.instance.locations.first.proximity_callbacks.size.should == 1
+    Runner.instance.locations.first.proximity_callbacks[0].class.should == Callbacks::Proximity
+
+    # FIXME test all proximity events: proximity, entered_proximity, left_proximity
+
+    ## delay briefly allowing for updates
+    sleep 2
+
+    proximity_triggered.should be_false
+
+    # update location to satisfy proximity criteria
+    location2.z = 5
+    @client.update_location(location2).should be(true)
 
     ## delay briefly allowing for updates
-    sleep 5
+    sleep 2
 
-    times_moved.should be > 0 
+    proximity_triggered.should be_true
 
     # stop the runner
     Runner.instance.stop