revolt 0.5.1

data/test/fixtures/rv/levels/test lEveL/readme.txt

@@ -0,0 +1 @@
+

data/test/fixtures/rv/levels/test lEveL/reversed/TEst level.inf

@@ -0,0 +1 @@
+

data/test/fixtures/rv/levels/test lEveL/reversed/TeST level.w

@@ -0,0 +1 @@
+

data/test/fixtures/rv/levels/test lEveL/reversed/readme.txt

@@ -0,0 +1 @@
+

data/test/fixtures/rv/levels/test lEveL/reversed/test LEVELa.bmp

@@ -0,0 +1 @@
+

data/test/fixtures/rv/levels/test lEveL/test LEVELa.bmp

@@ -0,0 +1 @@
+

data/test/tc_archive_analyzer.rb

@@ -0,0 +1,185 @@
+#!/usr/bin/ruby -w
+
+require File.join(File.dirname(__FILE__), '../lib/revolt')
+require File.join(File.dirname(__FILE__), 'common')
+require 'test/unit'
+
+class ArchiveAnalyzer < Test::Unit::TestCase
+  include ReVolt::Test
+
+  def open_browser(file, &block)
+    ReVolt::Package::Archive::open(file, &block)
+  end
+
+  def track_analysis_of(browser)
+    analyzer = ReVolt::Package::Archive::Analyzer::for_track(browser)
+    analyzer.track_files(browser)
+  end
+
+  def test_standard_zip
+    open_browser(get_test_file(ZIPS[:standard])) do |browser|
+      result = track_analysis_of(browser)
+      expect = {
+        :level => { 
+          'levid' => [
+            'levels/levid/levid.inf',
+            'levels/levid/levida.bmp',
+            'levels/levid/levid.w',
+            'levels/levid/readme.txt'
+          ],
+        },
+        :inf => {
+          'levid' => 'levels/levid/levid.inf'
+        },
+        :gfx => {
+          'levid' => ['gfx/levid.bmp', 'gfx/levid.bmq']
+        }
+      }
+
+      assert_equal(stringify_and_order_structure(expect), 
+                   stringify_and_order_structure(result))
+    end    
+  end
+
+  def test_standard_rev_zip
+    open_browser(get_test_file(ZIPS[:standard_rev])) do |browser|
+      result = track_analysis_of(browser)
+      expect = {
+        :level => { 
+          'levidrev' => [
+            'levels/levidrev/levidrev.inf',
+            'levels/levidrev/levidreva.bmp',
+            'levels/levidrev/levidrev.w',
+            'levels/levidrev/readme.txt',
+          ],
+        },
+        :reversed => {
+          'levidrev' => [
+            'levels/levidrev/reversed/levidrev.cam',
+            'levels/levidrev/reversed/levidrev.fan',
+            'levels/levidrev/reversed/levidrev.fin'
+          ],
+        },
+        :inf => {
+          'levidrev' => 'levels/levidrev/levidrev.inf'
+        },
+        :gfx => {
+          'levidrev' => ['gfx/levidrev.bmp', 'gfx/levidrev.bmq']
+        }
+      }
+      
+      assert_equal(stringify_and_order_structure(expect), 
+                   stringify_and_order_structure(result))
+    end
+  end
+
+  def test_standard_multi_zip
+    open_browser(get_test_file(ZIPS[:standard_multi])) do |browser|
+      result = track_analysis_of(browser)
+      expect = {
+        :level => { 
+          'levidrev' => [
+            'levels/levidrev/levidrev.inf',
+            'levels/levidrev/levidreva.bmp',
+            'levels/levidrev/levidrev.w',
+            'levels/levidrev/readme.txt',
+          ],
+          'levid' => [
+            'levels/levid/levid.inf',
+            'levels/levid/levida.bmp',
+            'levels/levid/levid.w',
+            'levels/levid/readme.txt'
+          ],
+        },
+        :reversed => {
+          'levidrev' => [
+            'levels/levidrev/reversed/levidrev.cam',
+            'levels/levidrev/reversed/levidrev.fan',
+            'levels/levidrev/reversed/levidrev.fin'
+          ],
+        },
+        :inf => {
+          'levidrev' => 'levels/levidrev/levidrev.inf',
+          'levid' => 'levels/levid/levid.inf'
+        },
+        :gfx => {
+          'levidrev' => ['gfx/levidrev.bmp', 'gfx/levidrev.bmq'],
+          'levid' => ['gfx/levid.bmp', 'gfx/levid.bmq']
+        }
+      }
+      
+      assert_equal(stringify_and_order_structure(expect), 
+                   stringify_and_order_structure(result))
+    end
+  end
+
+  def test_rickyd_zip
+    open_browser(get_test_file(ZIPS[:rickyd_style])) do |browser|
+      result = track_analysis_of(browser)
+      expect = {
+        :level => { 
+          'levidrev' => [
+            'levidrev/levidreva.bmp',
+            'levidrev/levidrev.inf',
+            'levidrev/levidrev.w',
+            'levidrev/readme.txt'
+          ],
+        },
+        :reversed => {
+          'levidrev' => [
+            'levidrev/reversed/levidrev.cam',
+            'levidrev/reversed/levidrev.fan',
+            'levidrev/reversed/levidrev.fin'
+          ],
+        },
+        :inf => {
+          'levidrev' => 'levidrev/levidrev.inf'
+        },
+        :gfx => {
+          'levidrev' => ['levidrev/gfx/levidrev.bmp', 'levidrev/gfx/levidrev.bmq']
+        }
+      }
+      
+      assert_equal(stringify_and_order_structure(expect), 
+                     stringify_and_order_structure(result))
+    end
+  end
+
+  def test_nodirs_zip
+    open_browser(get_test_file(ZIPS[:nodirs_style])) do |browser|
+      result = track_analysis_of(browser)
+      expect = {
+        :level => { 
+          'levid' => [
+            'levid.inf',
+            'levida.bmp',
+            'levid.w',
+            'readme.txt'
+          ],
+        },
+        :inf => {
+          'levid' => 'levid.inf'
+        },
+        :gfx => {
+          'levid' => ['levid.bmp', 'levid.bmq']
+        }
+      }
+      
+      assert_equal(stringify_and_order_structure(expect), 
+                   stringify_and_order_structure(result))
+    end
+  end
+
+  def test_zips_inside_package
+    open_browser(get_test_file(ZIPS[:zips_inside])) do |browser|
+      result = track_analysis_of(browser)
+      expect = {
+        :possible => ['standard_track.zip', 'standard_rev_track.zip']
+      }
+        
+      assert_equal(stringify_and_order_structure(expect), 
+                   stringify_and_order_structure(result))
+    end    
+  end
+
+end

data/test/tc_args.rb

@@ -0,0 +1,55 @@
+#!/usr/bin/ruby -w
+
+require File.join(File.dirname(__FILE__), '../lib/revolt')
+require File.join(File.dirname(__FILE__), 'common')
+require 'test/unit'
+
+class ArgsTest < Test::Unit::TestCase
+  include ReVolt::Test
+
+  def setup
+    super
+    ReVolt::global_args = nil
+  end
+    
+  def test_global_args
+    ReVolt::global_args = { :test1 => 'test1', :test2 => 'test2' }
+    assert_equal(ReVolt::global_args[:test1], 'test1')
+    assert_equal(ReVolt::global_args[:test2], 'test2')
+    assert_equal(ReVolt::global_args[:test3], nil)
+    assert_equal(ReVolt::arg(:test1), 'test1')
+    assert_equal(ReVolt::arg(:test2), 'test2')
+    assert_equal(ReVolt::arg(:test3), nil)
+  end
+
+  def test_local_args
+    a = { :test1 => 'test1', :test2 => 'test2' }
+    assert_equal(ReVolt::arg(:test1, a), 'test1')
+    assert_equal(ReVolt::arg(:test2, a), 'test2')
+    assert_equal(ReVolt::arg(:test3, a), nil)
+  end
+
+  def test_local_global_args
+    ReVolt::global_args = { :test1 => 'test1', :test2 => 'test2' }
+    a = { :test1 => 'ltest1' }
+    assert_equal(ReVolt::arg(:test1, a), 'ltest1')
+    assert_equal(ReVolt::arg(:test2, a), 'test2')
+    assert_equal(ReVolt::arg(:test3, a), nil)
+  end
+    
+  def test_arg_install_url
+    testurl = 'http://www.test.com/dohdah.zip'
+    levels = ReVolt::Levels.at(get_test_output_dir('rvtmp'))
+    called = false
+    a = {
+      ReVolt::ARG_INSTALL_URL => lambda {|url|
+        called = true
+        assert_equal(testurl, url)
+        nil
+      }
+    }
+    ReVolt::global_args = a
+    levels.install_urls(testurl, a)
+    assert(called)
+  end
+end

data/test/tc_args_external.rb

@@ -0,0 +1,55 @@
+#!/usr/bin/ruby -w
+
+require File.join(File.dirname(__FILE__), '../lib/revolt')
+require File.join(File.dirname(__FILE__), 'common')
+require 'test/unit'
+
+class ArgsTest < Test::Unit::TestCase
+  include ReVolt::Test
+
+  def setup
+    super
+    ReVolt::global_args = nil
+  end
+    
+  def test_global_args
+    ReVolt::global_args = { :test1 => 'test1', :test2 => 'test2' }
+    assert_equal(ReVolt::global_args[:test1], 'test1')
+    assert_equal(ReVolt::global_args[:test2], 'test2')
+    assert_equal(ReVolt::global_args[:test3], nil)
+    assert_equal(ReVolt::arg(:test1), 'test1')
+    assert_equal(ReVolt::arg(:test2), 'test2')
+    assert_equal(ReVolt::arg(:test3), nil)
+  end
+
+  def test_local_args
+    a = { :test1 => 'test1', :test2 => 'test2' }
+    assert_equal(ReVolt::arg(:test1, a), 'test1')
+    assert_equal(ReVolt::arg(:test2, a), 'test2')
+    assert_equal(ReVolt::arg(:test3, a), nil)
+  end
+
+  def test_local_global_args
+    ReVolt::global_args = { :test1 => 'test1', :test2 => 'test2' }
+    a = { :test1 => 'ltest1' }
+    assert_equal(ReVolt::arg(:test1, a), 'ltest1')
+    assert_equal(ReVolt::arg(:test2, a), 'test2')
+    assert_equal(ReVolt::arg(:test3, a), nil)
+  end
+  
+  def test_arg_install_url
+    testurl = 'http://www.test.com/dohdah.zip'
+    levels = ReVolt::Levels.at(get_test_output_dir('rvtmp'))
+    called = false
+    a = {
+      ReVolt::ARG_INSTALL_URL => lambda {|url|
+        called = true
+        assert_equal(testurl, url)
+        nil
+      }
+    }
+    ReVolt::global_args = a
+    levels.install_urls(testurl, a)
+    assert(called)
+  end
+end

data/test/tc_file_system_fetcher.rb

@@ -0,0 +1,26 @@
+#!/usr/bin/ruby -w
+
+require File.join(File.dirname(__FILE__), '../lib/revolt')
+require File.join(File.dirname(__FILE__), 'common')
+require 'test/unit'
+
+class FileSystemFetcher < Test::Unit::TestCase
+  include ReVolt::Package
+  include ReVolt::Test
+
+  def test_fetcher_success
+    source = get_test_file(ZIPS[:standard])
+    STDERR.puts("Source: #{source}")
+    f = ReVolt::Fetcher.for(source)
+    f.run
+    assert_equal(source, f.target.to_s)
+  end
+
+  def test_fetcher_non_exists
+    source = get_test_file('this_one_doesnt_exist.zip')
+    f = ReVolt::Fetcher.for(source)
+    assert_raise(ReVolt::FileNotFoundError) do
+      f.run
+    end
+  end
+end

data/test/tc_info.rb

@@ -0,0 +1,23 @@
+#!/usr/bin/ruby -w
+
+require File.join(File.dirname(__FILE__), '../lib/revolt')
+require File.join(File.dirname(__FILE__), 'common')
+require 'test/unit'
+
+class InfoTest < Test::Unit::TestCase
+  include ReVolt::Test
+  
+  def test_exe_path
+    path = ReVolt::Info::exe_path
+    
+    assert_not_nil(path, 'Could not get Re-Volt exe path!')
+    assert(path.file?, "Re-Volt not found from returned path #{path}")
+  end
+
+  def test_path
+    path = ReVolt::Info::path
+    
+    assert_not_nil(path, 'Could not get Re-Volt exe path!')
+    assert(path.directory?, "Re-Volt directory from returned path #{path}")
+  end
+end

data/test/tc_level.rb

@@ -0,0 +1,182 @@
+#!/usr/bin/ruby -w
+
+require File.join(File.dirname(__FILE__), '../lib/revolt')
+require File.join(File.dirname(__FILE__), 'common')
+require 'test/unit'
+
+class LevelTest < Test::Unit::TestCase
+  include ReVolt::Test
+  
+  ID, NAME = 'test level'.to_sym, 'Test Level'
+  RVPATH   = File.join(File.dirname(__FILE__), 'fixtures/rv')
+
+  STOCK_TRACKS = [
+    :nhood1,
+    :market2,
+    :muse2,
+    :garden1,
+    :toylite,
+    :wild_west1,
+    :toy2,
+    :ship1,
+    :nhood2,
+    :muse1,
+    :market1,
+    :wild_west2,
+    :ship2,
+  ]
+  
+  def setup
+    super
+    
+    @levels = ReVolt::Levels.new RVPATH
+    @level  = ReVolt::Level.new ID, { :name => NAME }
+    @level.parent = @levels
+  end
+
+  def test_name
+    @level.parent = nil # name should work even without parent levels
+    assert_equal NAME, @level.name
+  end
+
+  def test_id
+    @level.parent = nil # id should work even without parent levels
+    assert_equal ID, @level.id
+    assert_equal ID.to_s, @level.id.to_s
+    assert_equal ReVolt::Level.new(ID.to_s).id, @level.id
+  end
+
+  def test_load_level
+    @level  = ReVolt::Level.new('test level', :parent => @levels)
+    assert_equal false, @level.loaded?
+    assert_not_nil @level.inf
+    pp @level.inf
+    assert_equal 'Test Level', @level.inf[:name]
+    assert_equal 'Test Level', @level.name
+    assert_equal '3', @level.inf[:startgrid]
+    assert_equal true, @level.loaded?
+  end
+
+  def test_reversed
+    target = ReVolt::Levels.new(get_test_output_dir('revolt'))
+    target.create_dir_structure
+    @level.copy_to(target)
+    level = target[ID]
+    assert_not_nil(level)
+    assert(level.reverse?)
+    
+    rpath = level.path + 'reversed'
+    assert(rpath.exist?)
+    assert(Dir[rpath + '*'].size > 0)
+    
+    # Delete the reversed directory
+    rpath.rmtree
+    assert(level.reverse? == false)
+  end
+  
+  def test_dirs_and_files
+    (dirs, files) = @level.dirs_and_files
+    dirs_expect = ['levels/test level/emptydir',
+                   'levels/test level/reversed']
+    fils_expect = ['levels/test level/test level.inf',
+                   'levels/test level/test level.w',
+                   'levels/test level/test levela.bmp',
+                   'levels/test level/readme.txt',
+                   'levels/test level/reversed/test level.inf',
+                   'levels/test level/reversed/test level.w',
+                   'levels/test level/reversed/test levela.bmp',
+                   'levels/test level/reversed/readme.txt',
+                   'gfx/test level.bmp'
+                   ]
+    assert_equal(strdowncase_and_order_structure(fils_expect), 
+                 strdowncase_and_order_structure(files))
+    assert_equal(strdowncase_and_order_structure(dirs_expect), 
+                 strdowncase_and_order_structure(dirs))
+  end
+  
+  def test_copy_level
+    target = ReVolt::Levels.new(get_test_output_dir('revolt'))
+    target.create_dir_structure
+    STDERR.puts("Target dir: #{target.path}")
+    expect = @levels[@level].files
+    @level.copy_to(target)
+    result = target[@level.id].files
+    assert_not_nil(target[ID])
+    assert_not_nil(@levels[ID])
+    assert_equal(stringify_and_order_structure(expect), 
+                 stringify_and_order_structure(result))
+    assert_equal(stringify_and_order_structure(expect),
+                 stringify_and_order_structure(@levels[@level].files))
+  end
+
+  def test_move_level  
+    source = ReVolt::Levels.new(get_test_output_dir('revolt_from'))
+    target = ReVolt::Levels.new(get_test_output_dir('revolt_to'))
+    source.create_dir_structure
+    target.create_dir_structure
+    STDERR.puts("Target dir: #{target.path}")
+    expect = @levels[@level].files
+    @level.copy_to(source)
+    
+    assert(source.member?(@level) == true)    
+    source.move_level_to(source[@level], target)
+
+    assert(target.member?(@level) == true)    
+    assert(source.include?(@level) == false)    
+    assert((target.path + @level.id.to_s).exist? == true)
+    assert((source.path + @level.id.to_s).exist? == false)
+    result = target[@level.id].files
+    assert_equal(stringify_and_order_structure(expect), 
+                 stringify_and_order_structure(result))
+    assert_nil(source[@level])
+    assert_equal(stringify_and_order_structure(expect),
+                 stringify_and_order_structure(@levels[@level].files))
+  end
+
+  def test_delete_level
+    source = ReVolt::Levels.new(get_test_output_dir('revolt_delete'))
+    source.create_dir_structure
+
+    assert_nil(source[@level.id])
+    @level.copy_to(source)
+    tlevel       = source[@level.id]
+    tlevel_dir   = source.path + @level.id.to_s
+    tlevel_files = tlevel.files
+    assert(tlevel_dir.exist? == true)
+    
+    assert(tlevel.files != 0)
+    tlevel_files.each do |f|
+      fullpath = source.base_path + f
+      assert(fullpath.exist? == true, "Path don't exist: #{fullpath}")
+    end
+    tlevel.delete
+    assert(tlevel_dir.exist? == false)
+    assert_nil(tlevel.parent)
+    tlevel_files.each do |f|
+      fullpath = source.base_path + f
+      assert(fullpath.exist? == false, "Path exists: #{fullpath}")
+    end
+  end
+    
+  def test_inf_file_missing
+    @level  = ReVolt::Level.new 'inf_missing_level', :parent => @levels
+    assert_raise(ReVolt::InfFileNotFoundError) { @level.reload }
+  end
+
+  def test_load_level_no_parent
+    @level.parent = nil
+    assert_raise(RuntimeError) { @level.reload }
+  end
+  
+  def test_stock
+    STOCK_TRACKS.each do |stock_id|
+      level = ReVolt::Level.new stock_id
+      assert(level.stock?, 'level id #{stock_id} not stock')
+    end
+  end
+
+  def test_custom
+    assert(@level.custom?, 'level id #{@level.id} not custom')
+  end
+
+end

data/test/tc_level_installer.rb

@@ -0,0 +1,88 @@
+#!/usr/bin/ruby -w
+
+require File.join(File.dirname(__FILE__), '../lib/revolt')
+require File.join(File.dirname(__FILE__), 'common')
+
+require 'test/unit'
+require 'fileutils'
+
+class LevelInstaller < Test::Unit::TestCase
+  include ReVolt::Test
+  include ReVolt::Package
+
+  RVZT_URL = 'http://revolt.speedweek.net/main/dload.php?trackname=Rickyd%27s+Garden'
+
+  def setup
+    super
+    
+    @rv_base_dir = Pathname.new(get_test_output_dir('rv'))# @output_dir + 'rv';
+
+    # Create the levels structure so that levels can
+    # be installed
+    @levels = ReVolt::Levels.new(@rv_base_dir)
+    @levels.create_dir_structure
+  end
+
+  def teardown
+    # clean_working_dir
+  end
+
+  def installed_tracks
+    dir = ReVolt::Util::FsBrowser.new(@rv_base_dir)
+    dir.map {|f| Pathname.new(f).relative_path_from(@rv_base_dir).to_s}
+  end
+
+  def test_install_local_zip
+    zip_id = :standard
+    ids = @levels.install(get_test_file(ZIPS[zip_id]), @output_dir)
+    result = installed_tracks
+    expect = %w(
+      gfx
+      gfx/levid.bmp
+      gfx/levid.bmq
+      levels
+      levels/levid
+      levels/levid/levid.inf
+      levels/levid/levid.w
+      levels/levid/levida.bmp
+      levels/levid/readme.txt
+    )
+
+    assert_equal(stringify_and_order_structure(expect), 
+                 stringify_and_order_structure(result))
+    assert_equal(stringify_and_order_structure(ids), 
+                 stringify_and_order_structure(ZIPS_IDS[zip_id]))
+  end
+
+  def test_install_local_zip_overwrite
+    test_install_local_zip
+    test_install_local_zip
+  end
+  
+  def test_install_local_zip_nl
+    zip_id = :standard
+    f = get_test_file(ZIPS[zip_id])
+    # This tests that installing works easily even
+    # when the file name is read from for example STDIN.each
+    f = f.to_s + "\n"
+    ids = @levels.install(f, @output_dir)
+    result = installed_tracks
+    expect = %w(
+      gfx
+      gfx/levid.bmp
+      gfx/levid.bmq
+      levels
+      levels/levid
+      levels/levid/levid.inf
+      levels/levid/levid.w
+      levels/levid/levida.bmp
+      levels/levid/readme.txt
+    )
+
+    assert_equal(stringify_and_order_structure(expect), 
+                 stringify_and_order_structure(result))
+    assert_equal(stringify_and_order_structure(ids), 
+                 stringify_and_order_structure(ZIPS_IDS[zip_id]))
+  end
+
+end