offroad 0.0.1

data/test/unit/cargo_streamer_test.rb

@@ -0,0 +1,332 @@
+require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
+
+class CargoStreamerTest < Test::Unit::TestCase
+  # Based on the pattern found here: http://stackoverflow.com/questions/315850/rails-model-without-database
+  class TestModel < ActiveRecord::Base
+    self.abstract_class = true
+    
+    def self.columns
+      @columns ||= []
+    end
+    
+    columns << ActiveRecord::ConnectionAdapters::Column.new("id", nil, "integer", true)
+    columns << ActiveRecord::ConnectionAdapters::Column.new("data", "", "string", false)
+    
+    has_one(:fake_association)
+    attr_accessor :fake_association
+    
+    validates_presence_of :data
+    
+    @@safety_switch = true
+    
+    def self.safe_to_load_from_cargo_stream?
+      @@safety_switch
+    end
+    
+    def self.set_safe
+      @@safety_switch = true
+    end
+    
+    def self.set_unsafe
+      @@safety_switch = false
+    end
+  end
+  
+  def generate_cargo_string(hash, skip_validation = false)
+    return StringIO.open do |sio|
+      writer = Offroad::CargoStreamer.new(sio, "w")
+      hash.each do |key, arr|
+        arr.each do |elem|
+          writer.write_cargo_section(key, elem, :skip_validation => skip_validation)
+        end
+      end
+      
+      sio.string
+    end
+  end
+  
+  def retrieve_cargo_from_string(str)
+    hash = {}
+    
+    reader = Offroad::CargoStreamer.new(str, "r")
+    reader.cargo_section_names.each do |key|
+      hash[key] = []
+      reader.each_cargo_section(key) do |elem|
+        hash[key] << elem
+      end
+    end
+    
+    return hash
+  end
+  
+  def round_trip(hash = {})
+    retrieve_cargo_from_string(generate_cargo_string(hash))
+  end
+  
+  # Asserts content equality between two hashes of arrays of arrays of records ("haar"s)
+  # Cannot just do new_hash == hash, because ActiveRecord#== always false when comparing two unsaved records.
+  def assert_haar_equality(first_hash, second_hash)
+    assert_nothing_raised do
+      # Assert that they are subsets of each other
+      [[first_hash, second_hash], [second_hash, first_hash]].each do |hash_a, hash_b|
+        hash_a.each do |key, arr|
+          arr.each_with_index do |subarr, i|
+            subarr.each_with_index do |rec, j|
+              rec.attributes.each_pair do |attr_key, attr_value|
+                raise "Mismatch" unless attr_value == hash_b[key][i][j].attributes[attr_key]
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+  
+  def assert_round_trip_equality(hash = {})
+    assert_haar_equality(hash, round_trip(hash))
+  end
+  
+  def test_rec(str)
+    TestModel.new(:data => str)
+  end
+  
+  agnostic_test "can encode and retrieve a model instances in an array" do
+    assert_round_trip_equality "test" => [[test_rec("A"), test_rec("B")]]
+  end
+  
+  agnostic_test "can encode and retrieve model instances with first-level association data" do
+    r1 = test_rec("A")
+    r1.fake_association = test_rec("B")
+    r2 = test_rec("XYZ") # Making sure we can also encode a model instance that doesn't have the assoc data
+    
+    str = StringIO.open do |sio|
+      writer = Offroad::CargoStreamer.new(sio, "w")
+      writer.write_cargo_section("abc", [r1, r2], :include => [:fake_association])
+      sio.string
+    end
+    
+    decoded_rec = StringIO.open(str) do |sio|
+      cs = Offroad::CargoStreamer.new(sio, "r")
+      cs.first_cargo_section("abc")[0]
+    end
+    
+    assert_equal "B", decoded_rec.fake_association.data
+  end
+  
+  agnostic_test "encoded models do not lose their id" do
+    rec = test_rec("ABC")
+    rec.id = 45
+    decoded = round_trip "test" => [[rec]]
+    assert_equal 45, decoded["test"][0][0].id
+  end
+  
+  agnostic_test "cannot encode and retrieve non-model data" do
+    assert_raise Offroad::CargoStreamerError do
+      generate_cargo_string "a" => [[1]]
+    end
+  end
+  
+  agnostic_test "cannot encode a model that is not in an array" do
+    assert_raise Offroad::CargoStreamerError do
+      # This is not "in an array" for CargoStreamer; look at how generate_cargo_string is implemented
+      generate_cargo_string "a" => [test_rec("Test")]
+    end
+  end
+  
+  agnostic_test "can decode cargo data even if there is other stuff around it" do
+    test_hash = {"foo bar narf bork" => [[test_rec("Test")]]}
+    str = "BLAH BLAH BLAH" + generate_cargo_string(test_hash) + "BAR BAR BAR"
+    assert_haar_equality test_hash, retrieve_cargo_from_string(str)
+  end
+  
+  agnostic_test "can correctly identify the names of the cargo sections" do
+    test_hash = {"abc" => [[test_rec("A")]], "xyz" => [[test_rec("X")]]}
+    cs = Offroad::CargoStreamer.new(generate_cargo_string(test_hash), "r")
+    assert_equal test_hash.keys, cs.cargo_section_names
+    assert cs.has_cargo_named?("abc")
+    assert_equal false, cs.has_cargo_named?("foobar")
+  end
+  
+  agnostic_test "can create and retrieve multiple ordered cargo sections with the same name" do
+    test_data = [[test_rec("a"), test_rec("b")], [test_rec("c"), test_rec("d")], [test_rec("e"), test_rec("f")]]
+   
+    str = StringIO.open do |sio|
+      cs = Offroad::CargoStreamer.new(sio, "w")
+      test_data.each do |dat|
+        cs.write_cargo_section("xyz", dat)
+      end
+      sio.string
+    end
+    
+    result_data = []
+    cs = Offroad::CargoStreamer.new(str, "r")
+    cs.each_cargo_section "xyz" do |dat|
+      result_data << dat
+    end
+    
+    assert_haar_equality({"test" => test_data}, {"test" => result_data})
+  end
+  
+  agnostic_test "can use first_cargo_section to get only the first section with a given name" do
+    result = StringIO.open do |sio|
+      cs = Offroad::CargoStreamer.new(sio, "w")
+      for i in 1..3 do
+        cs.write_cargo_section("testing", [test_rec("item number #{i}")])
+      end
+      sio.string
+    end
+    
+    cs = Offroad::CargoStreamer.new(result, "r")
+    assert_equal test_rec("item number 1").attributes, cs.first_cargo_section("testing")[0].attributes
+    assert_equal nil, cs.first_cargo_section("no-such-section")
+  end
+  
+  agnostic_test "can use first_cargo_element to get the first element of the first section with a given name" do
+    result = StringIO.open do |sio|
+      cs = Offroad::CargoStreamer.new(sio, "w")
+      [10, 20, 30].each do |i|
+        cs.write_cargo_section("testing", [test_rec("item number #{i}"), test_rec("item number #{i+1}")])
+      end
+      sio.string
+    end
+    
+    cs = Offroad::CargoStreamer.new(result, "r")
+    assert_equal test_rec("item number 10").attributes, cs.first_cargo_element("testing").attributes
+    assert_equal nil, cs.first_cargo_element("no-such-section")
+  end
+  
+  agnostic_test "can use :human_readable to include a string version of a record" do
+    test_str = "ABCD\n123"
+    rec = test_rec(test_str)
+    
+    result = StringIO.open do |sio|
+      cs = Offroad::CargoStreamer.new(sio, "w")
+      cs.write_cargo_section("test", [rec], :human_readable => false)
+      sio.string
+    end
+    assert_equal false, result.include?(test_str)
+    
+    result = StringIO.open do |sio|
+      cs = Offroad::CargoStreamer.new(sio, "w")
+      cs.write_cargo_section("test", [rec], :human_readable => true)
+      sio.string
+    end
+    assert result.include?(test_str)
+  end
+  
+  agnostic_test "uses an md5 fingerprint to detect corruption" do
+    str = generate_cargo_string "test" => [[test_rec("abc")]]
+    
+    md5sum = nil
+    if str =~ /\b([0-9a-f]{32})\b/
+      md5sum = $1
+    else
+      flunk "Unable to find an md5sum in the generated string"
+    end
+    assert_raise Offroad::CargoStreamerError, "Changing fingerprint causes exception to be raised" do
+      retrieve_cargo_from_string(str.gsub md5sum, "a"*md5sum.size)
+    end
+    
+    assert_raise Offroad::CargoStreamerError, "Changing base64 content causes exception to be raised" do
+      # This is somewhat of an implementation-dependent test; I checked manually that the data has these strings.
+      # It's safe, though, as changing the implementation should cause false neg, not false pos.
+      retrieve_cargo_from_string(str.sub("X", "x"))
+    end
+  end
+  
+  agnostic_test "modes r and w work, other modes do not" do
+    assert_nothing_raised "Mode r works" do
+      Offroad::CargoStreamer.new(StringIO.new(), "r")
+    end
+    
+    assert_nothing_raised "Mode w works" do
+      Offroad::CargoStreamer.new(StringIO.new(), "w")
+    end
+    
+    assert_raise Offroad::CargoStreamerError, "Mode a doesn't work" do
+      Offroad::CargoStreamer.new(StringIO.new(), "a")
+    end
+  end
+  
+  agnostic_test "cannot write cargo in read mode" do
+    assert_raise Offroad::CargoStreamerError do
+      cs = Offroad::CargoStreamer.new(StringIO.new, "r")
+      cs.write_cargo_section("test", [test_rec("test")])
+    end
+  end
+  
+  agnostic_test "cannot use invalid cargo section names" do
+    cs = Offroad::CargoStreamer.new(StringIO.new, "w")
+    
+    assert_raise Offroad::CargoStreamerError, "Expect exception for symbol cargo name" do
+      cs.write_cargo_section(:test, [test_rec("test")])
+    end
+    
+    assert_raise Offroad::CargoStreamerError, "Expect exception for cargo name that's bad in HTML comments" do
+      cs.write_cargo_section("whatever--foobar", [test_rec("test")])
+    end
+    
+    assert_raise Offroad::CargoStreamerError, "Expect exception for cargo name that's multiline" do
+      cs.write_cargo_section("whatever\nfoobar", [test_rec("test")])
+    end
+  end
+  
+  agnostic_test "cannot encode invalid records except with :skip_validation option" do
+    rec = TestModel.new() # Nothing set to the required "data" field
+    assert_equal false, rec.valid?
+    assert_raise Offroad::CargoStreamerError do
+      generate_cargo_string "foo" => [[rec]]
+    end
+    assert_nothing_raised Offroad::CargoStreamerError do
+      generate_cargo_string({"foo" => [[rec]]}, true)
+    end
+    rec.data = "Something"
+    assert_nothing_raised do
+      generate_cargo_string "foo" => [[rec]]
+    end
+  end
+
+  agnostic_test "cannot encode a non-safe model class" do
+    begin
+      TestModel.set_safe
+      assert_nothing_raised do
+        str = generate_cargo_string "test" => [[test_rec("ABC")]]
+      end
+      TestModel.set_unsafe
+      assert_raise Offroad::CargoStreamerError do
+        str = generate_cargo_string "test" => [[test_rec("ABC")]]
+      end
+    ensure
+      TestModel.set_safe
+    end
+  end
+  
+  agnostic_test "cannot trick cargo streamer into decoding a non-safe model class" do
+    begin
+      TestModel.set_safe
+      str = generate_cargo_string "test" => [[test_rec("Stuff")]]
+      
+      assert_nothing_raised do
+        retrieve_cargo_from_string(str)
+      end
+      TestModel.set_unsafe
+      assert_raise Offroad::CargoStreamerError do
+        retrieve_cargo_from_string(str)
+      end
+    ensure
+      TestModel.set_safe
+    end
+  end
+  
+  agnostic_test "cargo streamer can read directly from a passed in string" do
+    str = generate_cargo_string("test" => [[test_rec("abc")]])
+    cs = Offroad::CargoStreamer.new(str, "r")
+    assert cs.has_cargo_named?("test")
+  end
+  
+  agnostic_test "cannot have cargo streamer write to a passed in string" do
+    assert_raise Offroad::CargoStreamerError do
+      Offroad::CargoStreamer.new("", "w")
+    end
+  end
+end

data/test/unit/global_data_test.rb

@@ -0,0 +1,102 @@
+require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
+
+# This is a unit test on the ability of model_extensions to handle global models
+
+class GlobalDataTest < Test::Unit::TestCase
+  online_test "can create new global records" do
+    assert_nothing_raised do
+      GlobalRecord.create(:title => "Something or other")
+    end
+  end
+  
+  offline_test "cannot create new global records" do
+    assert_raise ActiveRecord::ReadOnlyRecord do
+      GlobalRecord.create(:title => "Foo bar baz bork")
+    end
+  end
+  
+  double_test "global data models report being global data" do
+    assert GlobalRecord.offroad_global_data?, "Global model should return true to offroad_global_data?"
+    assert_equal false, GlobalRecord.offroad_group_data?, "Global model should return false to offroad_group_data?"
+  end
+  
+  online_test "global data is writable and destroyable" do
+    global_record = GlobalRecord.create(:title => "Something or other")
+    assert !global_record.locked_by_offroad?
+    assert_nothing_raised do
+      global_record.title = "Something else"
+      global_record.save!
+      global_record.destroy
+    end
+
+    if HOBO_TEST_MODE
+      guest = Guest.new
+      global_record.permissive = true
+      assert global_record.creatable_by?(guest)
+      assert global_record.updatable_by?(guest)
+      assert global_record.destroyable_by?(guest)
+    end
+  end
+  
+  offline_test "global data is not writable or destroyable" do
+    global_record = GlobalRecord.new(:title => "Something or other")
+    force_save_and_reload(global_record)
+    assert global_record.locked_by_offroad?
+    
+    assert_raise ActiveRecord::ReadOnlyRecord, "expect exception on title change" do
+      global_record.title = "Something else"
+      global_record.save!
+    end
+    
+    assert_raise ActiveRecord::ReadOnlyRecord, "expect exception on destroy" do
+      global_record.destroy
+    end
+
+    if HOBO_TEST_MODE
+      guest = Guest.new
+      global_record.permissive = true
+      assert !global_record.creatable_by?(guest)
+      assert !global_record.updatable_by?(guest)
+      assert !global_record.destroyable_by?(guest)
+    end
+  end
+  
+  online_test "cannot change id of global data" do
+    global_record = GlobalRecord.create(:title => "Something or other")
+    assert_raise Offroad::DataError do
+      global_record.id += 1
+      global_record.save!
+    end
+  end
+  
+  online_test "global data can hold a foreign key to other global data" do
+    global_record = GlobalRecord.create(:title => "Something or other")
+    another_global_record = GlobalRecord.create(:title => "Yet Another")
+    
+    assert_nothing_raised do
+      global_record.friend = another_global_record
+      global_record.save!
+    end
+  end
+  
+  online_test "global data cannot hold a foreign key to group data" do
+    global_record = GlobalRecord.create(:title => "Something or other")
+    assert_raise Offroad::DataError do
+      global_record.some_group = @offline_group
+      global_record.save!
+    end
+  end
+  
+  online_test "global data cannot hold a foreign key to unmirrored data" do
+    global_record = GlobalRecord.create(:title => "Something or other")
+    unmirrored_data = UnmirroredRecord.create(:content => "Some Unmirrored Data")
+    assert_raise Offroad::DataError do
+      global_record.unmirrored_record = unmirrored_data
+      global_record.save!
+    end
+  end
+  
+  double_test "global data models return true to acts_as_offroadable?" do
+    assert GlobalRecord.acts_as_offroadable?
+  end
+end

data/test/unit/group_controller_test.rb

@@ -0,0 +1,152 @@
+require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
+
+# This just tests the controller's ability to properly access the functionality of the MirrorData class
+# Tests for the actual generation and processing of mirror files are in mirror_data_test.rb
+
+class GroupControllerTest < ActionController::TestCase
+  online_test "can retrieve a down mirror file for the offline group" do
+    get :download_down_mirror, "id" => @offline_group.id
+    assert_response :success
+    assert @response.headers["Content-Disposition"].include?("attachment")
+    content = @response.binary_content
+    assert content.include?("downloaded from the Test App online system"), "testapp's down mirror view file used"
+    
+    StringIO.open(content) do |sio|
+      cs = Offroad::CargoStreamer.new(sio, "r")
+      mirror_info = cs.first_cargo_element("mirror_info")
+      assert mirror_info.app_mode.downcase.include?("online")
+      assert_equal false, mirror_info.initial_file
+    end
+  end
+  
+  online_test "can retrieve an initial down mirror file for the offline group" do
+    get :download_initial_down_mirror, "id" => @offline_group.id
+    assert_response :success
+    assert @response.headers["Content-Disposition"].include?("attachment")
+    content = @response.binary_content
+    assert content.include?("downloaded from the Test App online system"), "testapp's down mirror view file used"
+    
+    StringIO.open(content) do |sio|
+      cs = Offroad::CargoStreamer.new(sio, "r")
+      mirror_info = cs.first_cargo_element("mirror_info")
+      assert mirror_info.app_mode.downcase.include?("online")
+      assert mirror_info.initial_file
+    end
+  end
+  
+  offline_test "can retrieve an up mirror file for the offline group" do
+    get :download_up_mirror, "id" => @offline_group.id
+    assert_response :success
+    assert @response.headers["Content-Disposition"].include?("attachment")
+    content = @response.binary_content
+    assert content.include?("to the Test App online system"), "testapp's up mirror view file was used"
+    
+    # This tests ViewHelper::link_to_online_app, used from the testapp's up mirror view
+    assert content.include?(">" + Offroad::online_url + "</a>")
+    assert content.include?("href=\"" + Offroad::online_url + "\"")
+    
+    StringIO.open(content) do |sio|
+      cs = Offroad::CargoStreamer.new(sio, "r")
+      assert cs.first_cargo_element("mirror_info").app_mode.downcase.include?("offline")
+    end
+  end
+  
+  online_test "cannot retrieve up mirror files" do
+    assert_raise Offroad::PluginError do
+      get :download_up_mirror, "id" => @offline_group.id
+    end
+  end
+  
+  online_test "cannot retrieve down mirror files for online groups" do
+    assert_raise Offroad::PluginError do
+      get :download_down_mirror, "id" => @online_group.id
+    end
+  end
+  
+  cross_test "can upload up mirror files" do
+    mirror_data = ""
+    in_offline_app do
+      @offline_group.name = "ABC"
+      @offline_group.save!
+      get :download_up_mirror, "id" => @offline_group.id
+      mirror_data = @response.binary_content
+    end
+    
+    in_online_app do
+      post :upload_up_mirror, "id" => @offline_group.id, "mirror_data" => mirror_data
+      assert_response :success
+      @offline_group.reload
+      assert_equal "ABC", @offline_group.name
+    end
+  end
+  
+  offline_test "can upload down mirror files" do
+    mirror_data = ""
+    in_online_app do
+      GlobalRecord.create!(:title => "123")
+      get :download_down_mirror, "id" => @offline_group.id
+      mirror_data = @response.binary_content
+    end
+    
+    in_offline_app do
+      assert_equal 0, GlobalRecord.count
+      post :upload_down_mirror, "id" => @offline_group.id, "mirror_data" => mirror_data
+      assert_response :success
+      assert_equal 1, GlobalRecord.count
+      assert_equal "123", GlobalRecord.first.title
+    end
+  end
+    
+  cross_test "can upload initial down mirror files" do
+    mirror_data = ""
+    in_online_app do
+      get :download_initial_down_mirror, "id" => @offline_group.id
+      mirror_data = @response.binary_content
+    end
+    
+    in_offline_app(false, true) do
+      assert_equal 0, Group.count
+      post :upload_initial_down_mirror, "mirror_data" => mirror_data
+      assert_equal 1, Group.count
+    end
+  end
+  
+  offline_test "cannot retrieve down mirror files" do
+    assert_raise Offroad::PluginError do
+      get :download_down_mirror, {"id" => @offline_group.id}
+    end
+  end
+  
+  offline_test "cannot upload up mirror files" do
+    get :download_up_mirror, "id" => @offline_group.id
+    mirror_data = @response.binary_content
+    
+    assert_raise Offroad::PluginError do
+      post :upload_up_mirror, "id" => @offline_group.id, "mirror_data" => mirror_data
+    end
+  end
+  
+  online_test "cannot upload down mirror files" do
+    get :download_down_mirror, "id" => @offline_group.id
+    mirror_data = @response.binary_content
+    
+    assert_raise Offroad::PluginError do
+      post :upload_down_mirror, "id" => @offline_group.id, "mirror_data" => mirror_data
+    end
+  end
+  
+  cross_test "cannot upload a mirror file for an online group" do
+    mirror_data = ""
+    in_offline_app do
+      get :download_up_mirror, "id" => @offline_group.id
+      mirror_data = @response.binary_content
+    end
+    
+    in_online_app do
+      @offline_group.group_offline = false
+      assert_raise Offroad::PluginError do
+        post :upload_up_mirror, "id" => @online_group.id, "mirror_data" => mirror_data
+      end
+    end
+  end
+end