offroad 0.0.1

data/test/unit/group_data_test.rb

@@ -0,0 +1,435 @@
+require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
+
+# This is a unit test on the ability of model_extensions to handle group data models
+
+class GroupDataTest < Test::Unit::TestCase
+  def setup
+    @guest = Guest.new if HOBO_TEST_MODE
+    super
+  end
+
+  online_test "a new group is online by default" do
+    g = Group.create(:name => "This Should Be Online")
+    assert g.group_online?
+  end
+  
+  online_test "online group data has expected offline status" do
+    assert @online_group.group_online?, "Groups which are in online mode should return true to group_online?"
+    assert_equal false, @online_group.group_offline?, "Groups in online mode should return false to group_offline?"
+    assert @online_group_data.group_online?, "Data belonging to groups which are in online mode should return true to group_online?"
+    assert_equal false, @online_group_data.group_offline?, "Data belonging to groups in online mode should return false to group_offline?"
+  end
+  
+  double_test "offline group data has expected offline status" do
+    assert @offline_group.group_offline?, "Groups which have been set offline should return true to group_offline?"
+    assert_equal false, @offline_group.group_online?, "Groups which have been set offline should return false to group_online?"
+    assert @offline_group_data.group_offline?, "Data belonging to groups which have been set offline should return true to group_offline?"
+    assert_equal false, @offline_group_data.group_online?, "Data belonging to groups which have been set offline should return false to group_online?"
+  end
+  
+  double_test "group data models report being group data" do
+    assert Group.offroad_group_data?, "Group model should return true to offroad_group_data?"
+    assert_equal false, Group.offroad_global_data?, "Group model should return false to offroad_global_data?"
+    
+    assert GroupOwnedRecord.offroad_group_data?, "Group-owned model should return true to offroad_group_data?"
+    assert_equal false, GroupOwnedRecord.offroad_global_data?, "Group-owned model should return false to offroad_global_data?"
+  end
+  
+  double_test "group base reports being owned by itself" do
+    assert_equal @offline_group.id, @offline_group.owning_group.id, "Can get offline group id thru owning_group dot id"
+  end
+  
+  double_test "group-owned data reports proper ownership" do
+    assert_equal @offline_group.id, @offline_group_data.owning_group.id, "Can get owner id thru owning_group dot id"
+  end
+
+  double_test "indirectly group-owned data reports proper ownership" do
+    assert_equal @offline_group.id, @offline_indirect_data.owning_group.id, "Can get owner id through owning_group dot id"
+  end
+  
+  online_test "only offline groups locked and unsaveable" do
+    assert @offline_group.locked_by_offroad?, "Offline groups should be locked"
+    assert_raise ActiveRecord::ReadOnlyRecord do
+      @offline_group.save!
+    end
+    
+    assert_equal false, @online_group.locked_by_offroad?, "Online groups should not be locked"
+    assert_nothing_raised do
+      @online_group.save!
+    end
+
+    if HOBO_TEST_MODE
+      @offline_group.permissive = true
+      @online_group.permissive = true
+      assert !@offline_group.updatable_by?(@guest)
+      assert @online_group.updatable_by?(@guest)
+    end
+  end
+  
+  online_test "only offline group owned data locked and unsaveable" do
+    assert @offline_group_data.locked_by_offroad?, "Offline group data should be locked"
+    assert_raise ActiveRecord::ReadOnlyRecord do
+      @offline_group_data.save!
+    end
+    
+    assert_equal false, @online_group_data.locked_by_offroad?, "Online group data should not be locked"
+    assert_nothing_raised do
+      @online_group_data.save!
+    end
+    
+    if HOBO_TEST_MODE
+      @offline_group_data.permissive = true
+      @online_group_data.permissive = true
+      assert !@offline_group_data.updatable_by?(@guest)
+      assert @online_group_data.updatable_by?(@guest)
+    end
+  end
+  
+  online_test "only offline group indirect data locked and unsaveable" do
+    assert @offline_indirect_data.locked_by_offroad?, "Offline indirect data should be locked"
+    assert_raise ActiveRecord::ReadOnlyRecord do
+      @offline_indirect_data.save!
+    end
+    
+    assert_equal false, @online_indirect_data.locked_by_offroad?, "Online indirect data should not be locked"
+    assert_nothing_raised do
+      @online_indirect_data.save!
+    end
+
+    if HOBO_TEST_MODE
+      @offline_indirect_data.permissive = true
+      @online_indirect_data.permissive = true
+      assert !@offline_indirect_data.updatable_by?(@guest)
+      assert @online_indirect_data.updatable_by?(@guest)
+    end
+  end
+
+  online_test "can find online and offline groups through scope" do
+    another = Group.create(:name => "Another Online Group")
+
+    offline_groups = Group.offline_groups.all
+    online_groups = Group.online_groups.all
+
+    assert_equal 2, offline_groups.size
+    assert_equal 1, offline_groups.select{|r| r.id == @offline_group.id}.size
+    offline_groups.each do |g|
+      assert g.group_offline?
+    end
+
+    assert_equal 3, online_groups.size
+    assert_equal 1, online_groups.select{|r| r.id == another.id}.size
+    assert_equal 1, online_groups.select{|r| r.id == @online_group.id}.size
+    online_groups.each do |g|
+      assert g.group_online?
+    end
+  end
+  
+  online_test "offline and online groups can both be destroyed" do
+    assert_nothing_raised do
+      @offline_group.destroy
+    end
+    
+    assert_nothing_raised do
+      @online_group.destroy
+    end
+
+    if HOBO_TEST_MODE
+      @offline_group.permissive = true
+      @online_group.permissive = true
+      assert @offline_group.destroyable_by?(@guest)
+      assert @online_group.destroyable_by?(@guest)
+    end
+  end
+  
+  online_test "only offline group owned data cannot be destroyed" do
+    assert_raise ActiveRecord::ReadOnlyRecord do
+      @offline_group_data.destroy
+    end
+    
+    assert_nothing_raised do
+      @online_group_data.destroy
+    end
+
+    if HOBO_TEST_MODE
+      @offline_group_data.permissive = true
+      @online_group_data.permissive = true
+      assert !@offline_group_data.destroyable_by?(@guest)
+      assert @online_group_data.destroyable_by?(@guest)
+    end
+  end
+  
+  online_test "only offline indirect owned data cannot be destroyed" do
+    assert_raise ActiveRecord::ReadOnlyRecord do
+      @offline_indirect_data.destroy
+    end
+    
+    assert_nothing_raised do
+      @online_indirect_data.destroy
+    end
+
+    if HOBO_TEST_MODE
+      @offline_indirect_data.permissive = true
+      @online_indirect_data.permissive = true
+      assert !@offline_indirect_data.destroyable_by?(@guest)
+      assert @online_indirect_data.destroyable_by?(@guest)
+    end
+  end
+  
+  offline_test "offline groups unlocked and writable" do
+    assert_equal false, @offline_group.locked_by_offroad?
+    assert_nothing_raised do
+      @offline_group.save!
+    end
+
+    if HOBO_TEST_MODE
+      @offline_group.permissive = true
+      assert @offline_group.updatable_by?(@guest)
+    end
+  end
+  
+  offline_test "offline group owned data unlocked and writable" do
+    assert_equal false, @offline_group_data.locked_by_offroad?
+    assert_nothing_raised do
+      @offline_group_data.save!
+    end
+
+    if HOBO_TEST_MODE
+      @offline_group_data.permissive = true
+      assert @offline_group_data.updatable_by?(@guest)
+    end
+  end
+  
+  offline_test "offline indirectly owned data unlocked and writable" do
+    assert_equal false, @offline_indirect_data.locked_by_offroad?
+    assert_nothing_raised do
+      @offline_indirect_data.save!
+    end
+
+    if HOBO_TEST_MODE
+      @offline_indirect_data.permissive = true
+      assert @offline_indirect_data.updatable_by?(@guest)
+    end
+  end
+  
+  offline_test "offline group owned data destroyable" do
+    assert_nothing_raised do
+      @offline_group_data.destroy
+    end
+    
+    if HOBO_TEST_MODE
+      @offline_group_data.permissive = true
+      assert @offline_group_data.destroyable_by?(@guest)
+    end
+  end
+  
+  offline_test "offline indirectly owned data destroyable" do
+    assert_nothing_raised do
+      @offline_indirect_data.destroy
+    end
+    
+    if HOBO_TEST_MODE
+      @offline_indirect_data.permissive = true
+      assert @offline_indirect_data.destroyable_by?(@guest)
+    end
+  end
+  
+  offline_test "cannot create another group" do
+    new_group = Group.new(:name => "Another Offline Group?")
+    assert_raise Offroad::DataError do
+      new_group.save
+    end
+
+    if HOBO_TEST_MODE
+      new_group.permissive = true
+      assert !new_group.creatable_by?(@guest)
+    end
+  end
+  
+  offline_test "cannot destroy the group" do
+    assert_raise ActiveRecord::ReadOnlyRecord do
+      @offline_group.destroy
+    end
+
+    if HOBO_TEST_MODE
+      @offline_group.permissive = true
+      assert !@offline_group.destroyable_by?(@guest)
+    end
+  end
+  
+  offline_test "cannot change id of offline group data" do
+    assert_raise Offroad::DataError do
+      @offline_group.id += 1
+      @offline_group.save!
+    end
+    
+    assert_raise Offroad::DataError do
+      @offline_group_data.id += 1
+      @offline_group_data.save!
+    end
+    
+    assert_raise Offroad::DataError do
+      @offline_indirect_data.id += 1
+      @offline_indirect_data.save!
+    end
+  end
+  
+  online_test "cannot change id of online group data" do
+    assert_raise Offroad::DataError do
+      @online_group.id += 1
+      @online_group.save!
+    end
+    
+    assert_raise Offroad::DataError do
+      @online_group_data.id += 1
+      @online_group_data.save!
+    end
+    
+    assert_raise Offroad::DataError do
+      @online_indirect_data.id += 1
+      @online_indirect_data.save!
+    end
+  end
+  
+  offline_test "cannot set offline group to online" do
+    assert_raise Offroad::DataError do
+      @offline_group.group_offline = false
+    end
+  end
+  
+  online_test "group data cannot hold a foreign key to a record owned by another group" do
+    # This is an online test because the concept of "another group" doesn't fly in offline mode
+    @another_group = Group.create(:name => "Another Group")
+    @another_group_data = GroupOwnedRecord.create(:description => "Another Piece of Data", :group => @another_group)
+    @another_indirect_data = SubRecord.create(:description => "Yet Another Data Thingie", :group_owned_record => @another_group_data)
+    assert_raise Offroad::DataError, "Expect exception when putting bad foreign key in group base data" do
+      @online_group.favorite = @another_group_data
+      @online_group.save!
+    end
+    assert_raise Offroad::DataError, "Expect exception when putting bad foreign key in group owned data" do
+      @online_group_data.parent = @another_group_data
+      @online_group_data.save!
+    end
+    assert_raise Offroad::DataError, "Expect exception when putting bad foreign key in indirectly group owned data" do
+      @online_indirect_data.buddy = @another_indirect_data
+      @online_indirect_data.save!
+    end
+  end
+  
+  double_test "group data can hold a foreign key to data owned by the same group" do
+    more_data = GroupOwnedRecord.create(:description => "More Data", :group => @editable_group, :parent => @editable_group_data)
+    more_indirect_data = SubRecord.create(:description => "Yet More", :group_owned_record => more_data)
+    assert_nothing_raised do
+      @editable_group.favorite = more_data
+      @editable_group.save!
+      @editable_indirect_data.buddy = more_indirect_data
+      @editable_indirect_data.save!
+    end
+  end
+  
+  online_test "group data can hold a foreign key to global data" do
+    # This is an online test because an offline app cannot create global records
+    global_data = GlobalRecord.create(:title => "Some Global Data")
+    assert_nothing_raised "No exception when putting global data key in group base data" do
+      @editable_group.global_record = global_data
+      @editable_group.save!
+    end
+    assert_nothing_raised "No exception when putting global data key in group owned data" do
+      @editable_group_data.global_record = global_data
+      @editable_group_data.save!
+    end
+  end
+  
+  double_test "group data cannot hold a foreign key to unmirrored data" do
+    unmirrored_data = UnmirroredRecord.create(:content => "Some Unmirrored Data")
+    assert_raise Offroad::DataError, "Expect exception when putting bad foreign key in group base data" do
+      @editable_group.unmirrored_record = unmirrored_data
+      @editable_group.save!
+    end
+    assert_raise Offroad::DataError, "Expect exception when putting bad foreign key in group owned data" do
+      @editable_group_data.unmirrored_record = unmirrored_data
+      @editable_group_data.save!
+    end
+    assert_raise Offroad::DataError, "Expect exception when putting bad foreign key in indirectly owned data" do
+      @editable_indirect_data.unmirrored_record = unmirrored_data
+      @editable_indirect_data.save!
+    end
+  end
+  
+  online_test "last_known_status is not available for online groups" do
+    assert_raise Offroad::DataError do
+      status = @online_group.last_known_status
+    end
+  end
+  
+  double_test "last_known_status is available for offline groups" do
+    status = @offline_group.last_known_status
+    assert status
+  end
+  
+  double_test "group data models return true to acts_as_offroadable?" do
+    assert Group.acts_as_offroadable?, "Group reports mirrored offline"
+    assert GroupOwnedRecord.acts_as_offroadable?, "GroupOwnedRecord reports mirrored offline"
+  end
+  
+  online_test "cannot save :group_owned data with an invalid group id" do
+    assert_raise Offroad::DataError do
+      @offline_group_data.group_id = Group.maximum(:id)+1
+      @offline_group_data.save(false) # Have to disable validations or it'll catch this error first
+    end
+  end
+  
+  online_test "cannot move :group_owned data from one group to another" do
+    assert_raise Offroad::DataError do
+      @offline_group_data.group = @online_group
+      @offline_group_data.save!
+    end
+  end
+
+  online_test "cannot move indirectly owned data from one group to another" do
+    assert_raise Offroad::DataError do
+      @offline_indirect_data.group_owned_record = @online_group_data
+      @offline_indirect_data.save!
+    end
+  end
+
+  online_test "can move indirectly owned data between parents in the same group" do
+    another = GroupOwnedRecord.create(:description => "Another", :group => @online_group)
+    assert another
+    assert_nothing_raised do
+      @online_indirect_data.group_owned_record = another
+      @online_indirect_data.save!
+    end
+  end
+
+  online_test "cannot create :group_owned data in an offline group" do
+    assert_raise ActiveRecord::ReadOnlyRecord do
+      GroupOwnedRecord.create(:description => "Test", :group => @offline_group)
+    end
+  end
+
+  online_test "cannot create indirectly group owned data in an offline group" do
+    assert_raise ActiveRecord::ReadOnlyRecord do
+      SubRecord.create(:description => "Test", :group_owned_record => @offline_group_data)
+    end
+  end
+
+  offline_test "offline app can lock its group to prevent any further changes" do
+    @offline_group.offroad_group_lock!
+    assert_raise ActiveRecord::ReadOnlyRecord do
+      GroupOwnedRecord.create(:description => "Test", :group => @offline_group)
+    end
+    assert_raise ActiveRecord::ReadOnlyRecord do
+      @offline_group_data.description = "Wev"
+      @offline_group_data.save!
+    end
+    assert_raise ActiveRecord::ReadOnlyRecord do
+      @offline_group_data.destroy
+    end
+  end
+
+  online_test "online app cannot lock groups" do
+    assert_raise Offroad::DataError do
+      @offline_group.offroad_group_lock!
+    end
+  end
+end

data/test/unit/group_single_test.rb

@@ -0,0 +1,136 @@
+require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
+
+# This is a unit test on the ability of model_extensions to handle models in group_single mode
+
+class GroupSingleTest < Test::Unit::TestCase
+  def setup
+    super
+    self.class.const_set("GroupSingleRecord", Class.new(ActiveRecord::Base))
+    GroupSingleRecord.send(:acts_as_offroadable, :group_single)
+  end
+
+  def teardown
+    # Manually remove the group_single model after the test is done.
+    # Otherwise no other tests will be able to work with multiple groups
+    Offroad.send(:class_variable_set, :@@group_single_models, {})
+    self.class.send(:remove_const, "GroupSingleRecord")
+    super
+  end
+
+  empty_online_test "can create, alter, and destroy group single records if there are no offline groups" do
+    assert_nothing_raised do
+      rec = GroupSingleRecord.create(:description => "Foo")
+      rec.description = "Bar"
+      rec.save!
+      rec.destroy
+    end
+  end
+
+  empty_online_test "cannot create, alter, or destroy group single records if there are any offline groups" do
+    rec = GroupSingleRecord.create(:description => "Foo")
+    group = Group.create(:name => "Test Group")
+    group.group_offline = true
+
+    assert_raise ActiveRecord::ReadOnlyRecord do
+      GroupSingleRecord.create(:description => "Bar")
+    end
+
+    assert_raise ActiveRecord::ReadOnlyRecord do
+      rec.description = "Bar"
+      rec.save!
+    end
+
+    assert_raise ActiveRecord::ReadOnlyRecord do
+      rec.destroy
+    end
+  end
+
+  empty_online_test "group single models are offroad_group_data" do
+    GroupSingleRecord.offroad_group_data?
+  end
+
+  empty_online_test "group single records belong to nil if no groups are offline" do
+    rec = GroupSingleRecord.create(:description => "Foo")
+    group_a = Group.create(:name => "A")
+    group_b = Group.create(:name => "B")
+    assert_equal nil, rec.owning_group
+    assert_equal 0, GroupSingleRecord.owned_by_offroad_group(group_a).count
+    assert_equal 0, GroupSingleRecord.owned_by_offroad_group(group_b).count
+  end
+
+  empty_online_test "group single records belong to first offline group" do
+    rec = GroupSingleRecord.create(:description => "Foo")
+    group_a = Group.create(:name => "A")
+    group_b = Group.create(:name => "B")
+
+    group_a.group_offline = true
+    assert_equal group_a, rec.owning_group
+    assert_equal 1, GroupSingleRecord.owned_by_offroad_group(group_a).count
+    assert_equal 0, GroupSingleRecord.owned_by_offroad_group(group_b).count
+
+    group_a.group_offline = false
+    group_b.group_offline = true
+    assert_equal group_b, rec.owning_group
+    assert_equal 0, GroupSingleRecord.owned_by_offroad_group(group_a).count
+    assert_equal 1, GroupSingleRecord.owned_by_offroad_group(group_b).count
+  end
+
+  empty_online_test "cannot set more than one group offline if any group single models exist" do
+    group_a = Group.create(:name => "A")
+    group_b = Group.create(:name => "B")
+
+    group_a.group_offline = true
+    assert_raise Offroad::DataError do
+      group_b.group_offline = true
+    end
+    group_a.group_offline = false
+    group_b.group_offline = true
+    assert_raise Offroad::DataError do
+      group_a.group_offline = true
+    end
+  end
+  
+  cross_test "can insert and update and delete group single data using mirror files" do
+    mirror_data = nil
+
+    in_online_app(false, true) do
+      GroupSingleRecord.create(:description => "Foo")
+      GroupSingleRecord.create(:description => "Bar")
+      group_a = Group.create(:name => "A")
+      group_a.group_offline = true
+      mirror_data = Offroad::MirrorData.new(group_a, :initial_mode => true).write_downwards_data
+    end
+
+    in_offline_app(false, true) do
+      assert_equal 0, GroupSingleRecord.count
+      Offroad::MirrorData.new(nil, :initial_mode => true).load_downwards_data(mirror_data)
+      assert_equal 2, GroupSingleRecord.count
+
+      foo_rec = GroupSingleRecord.find_by_description("Foo")
+      assert foo_rec
+      foo_rec.description = "Fu"
+      foo_rec.save!
+
+      bar_rec = GroupSingleRecord.find_by_description("Bar")
+      assert bar_rec
+      bar_rec.destroy
+
+      GroupSingleRecord.create(:description => "One more for the road")
+      GroupSingleRecord.create(:description => "Yet another for the road")
+
+      mirror_data = Offroad::MirrorData.new(Group.first).write_upwards_data
+    end
+
+    in_online_app do
+      assert_equal 2, GroupSingleRecord.count
+      Offroad::MirrorData.new(Group.first).load_upwards_data(mirror_data)
+      assert_equal 3, GroupSingleRecord.count # One record destroyed, two created
+
+      assert_equal nil, GroupSingleRecord.find_by_description("Foo")
+      assert GroupSingleRecord.find_by_description("Fu")
+      assert_equal nil, GroupSingleRecord.find_by_description("Bar")
+      assert GroupSingleRecord.find_by_description("One more for the road")
+      assert GroupSingleRecord.find_by_description("Yet another for the road")
+    end
+  end
+end

data/test/unit/hobo_permissions_test.rb

@@ -0,0 +1,57 @@
+require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
+
+# This is a unit test on the ability of model_extensions to override regular Hobo model permissions
+
+class HoboPermissionsTest < Test::Unit::TestCase
+  if HOBO_TEST_MODE
+    def setup
+      @guest = Guest.new
+      super
+    end
+
+    class HoboPermissionsTestModel < ActiveRecord::Base
+      hobo_model
+      set_table_name "broken_records"
+
+      def create_permitted?
+        true
+      end
+
+      def update_permitted?
+        true
+      end
+
+      def destroy_permitted?
+        true
+      end
+
+      acts_as_offroadable :global
+    end
+  end
+
+  offline_test "can override hobo permissions" do
+    if HOBO_TEST_MODE
+      rec = HoboPermissionsTestModel.new
+      force_save_and_reload(rec)
+
+      # We are in offline mode and rec is offroad as global
+      # Therefore we should not be able to edit it
+      assert !rec.creatable_by?(@guest)
+      assert !rec.updatable_by?(@guest)
+      assert !rec.destroyable_by?(@guest)
+    end
+  end
+
+  online_test "overriding hobo permissions does not block off user specified permissions" do
+    if HOBO_TEST_MODE
+      rec = HoboPermissionsTestModel.new
+      force_save_and_reload(rec)
+
+      # We are in offline mode and rec is offroad as global
+      # Therefore we should be able to edit it
+      assert rec.creatable_by?(@guest)
+      assert rec.updatable_by?(@guest)
+      assert rec.destroyable_by?(@guest)
+    end
+  end
+end