sprout 0.7.246 → 1.0.0.pre

data/test/unit/remote_file_loader_test.rb

@@ -0,0 +1,34 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class RemoteFileLoaderTest <  Test::Unit::TestCase
+  include SproutTestCase
+
+  context "The remote file loader" do
+
+    setup do
+      @uri  = 'http://github.com/downloads/lukebayes/project-sprouts/echochamber-test.zip'
+      @file = File.join fixtures, 'remote_file_loader', 'md5', 'echochamber-test.zip'
+      @md5  = 'd6939117f1df58e216f365a12fec64f9'
+
+      # Don't reach out to the network for these tests:
+      Sprout::RemoteFileLoader.stubs(:fetch).returns File.read @file
+    end
+
+    should "attempt to load a requested file" do
+      bytes = Sprout::RemoteFileLoader.load @uri, @md5
+      assert_equal 310, bytes.size
+    end
+
+    should "fail if md5 doesn't match" do
+      Sprout::RemoteFileLoader.expects(:prompt_for_md5_failure)
+      Sprout::RemoteFileLoader.load @uri, 'abcd'
+    end
+
+    should "pass if md5 isn't provided" do
+      Sprout::RemoteFileLoader.expects(:prompt_for_md5_failure).never
+      Sprout::RemoteFileLoader.load @uri
+    end
+  end
+
+end
+

data/test/unit/remote_file_target_test.rb

@@ -0,0 +1,105 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class RemoteFileTargetTest < Test::Unit::TestCase
+  include SproutTestCase
+
+  context "an improperly configured remote file target" do
+
+    setup do
+      Sprout::RemoteFileTarget.any_instance.stubs(:load_archive).returns true
+    end
+
+    should "throw validation error on archive_type" do
+      assert_raises Sprout::Errors::ValidationError do
+        t = Sprout::RemoteFileTarget.new
+        #t.archive_type = :zip # This causes the validation error
+        t.md5          = 'abcd'
+        t.url          = 'http://google.com'
+        t.pkg_name     = 'google'
+        t.pkg_version  = '1.0.0'
+
+        t.resolve
+      end
+    end
+
+    should "throw validation error on md5" do
+      assert_raises Sprout::Errors::ValidationError do
+        t = Sprout::RemoteFileTarget.new
+        t.archive_type = :zip
+        #t.md5          = 'abcd' # This causes the validation error
+        t.url          = 'http://google.com'
+        t.pkg_name     = 'google'
+        t.pkg_version  = '1.0.0'
+
+        t.resolve
+      end
+    end
+
+    should "throw validation error on url" do
+      assert_raises Sprout::Errors::ValidationError do
+        t = Sprout::RemoteFileTarget.new
+        t.archive_type = :zip
+        t.md5          = 'abcd'
+        #t.url          = 'http://google.com' # This causes the validation error
+        t.pkg_name     = 'google'
+        t.pkg_version  = '1.0.0'
+
+        t.resolve
+      end
+    end
+  end
+
+  context "a correctly configured remote file target" do
+
+    setup do
+      @target = Sprout::RemoteFileTarget.new do |t|
+        t.archive_type = :zip
+        t.md5          = 'd6939117f1df58e216f365a12fec64f9'
+        t.url          = 'http://github.com/downloads/lukebayes/project-sprouts/echochamber-test.zip'
+        t.pkg_name     = 'echochamber'
+        t.pkg_version  = '1.0.pre'
+        t.add_executable :echochamber, 'bin/echochamber.sh'
+      end
+
+      @unpacked_file = File.join(temp_cache, 'unpacked')
+      @target.stubs(:unpacked_file).returns @unpacked_file
+
+      @downloaded_file = File.join(temp_cache, 'downloaded.zip')
+      @target.stubs(:downloaded_file).returns @downloaded_file
+
+      @archive_bytes = File.read(File.join(fixtures, 'remote_file_target', 'echochamber-test.zip'))
+    end
+
+    context "that has already been UNPACKED" do
+      should "not be DOWNLOADED or unpacked" do
+        create_file @unpacked_file
+        @target.expects(:download_archive).never
+        @target.expects(:unpack_archive).never
+        @target.resolve
+      end
+    end
+
+    context "that has been DOWNLOADED, but not UNPACKED" do
+      should "unpack but not download" do
+        create_file @downloaded_file
+        @target.expects(:download_archive).never
+        @target.expects(:unpack_archive)
+        @target.resolve
+      end
+    end
+
+    context "that has not yet been DOWNLOADED, or UNPACKED" do
+      should "download and unpack the remote archive" do
+        @target.expects(:download_archive).returns @archive_bytes
+        #@target.expects(:unpack_archive)
+
+        @target.resolve
+        assert_file @downloaded_file
+        assert_file @unpacked_file
+        #assert_not_empty @unpacked_file
+      end
+    end
+
+  end
+end
+

data/test/unit/ruby_feature_test.rb

@@ -0,0 +1,108 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class RubyFeatureTest < Test::Unit::TestCase
+  include SproutTestCase
+
+  context "a new ruby feature" do
+
+    teardown do
+      FakePlugin.clear_entities!
+    end
+
+    should "allow register" do
+      # Shouldn't require the package since it's already
+      # registered and available...
+      FakePlugin.expects(:require_ruby_package).never
+      plugin = create_item
+      FakePlugin.register plugin
+      assert_equal plugin, FakePlugin.load(:foo, 'sprout/base')
+    end
+
+    should "return nil if nothing is registered" do
+      FakePlugin.expects :require_ruby_package
+      assert_raises Sprout::Errors::LoadError do
+        FakePlugin.load(:foo, 'sprout/base')
+      end
+    end
+
+    should "find the correct registered plugin" do
+      foo = create_item
+      bar = create_item :name => :bar
+      FakePlugin.register foo
+      FakePlugin.register bar
+      assert_equal bar, FakePlugin.load(:bar)
+    end
+
+    should "not share registrations among includers" do
+      foo = create_item
+      FakePlugin.register foo
+      assert_raises Sprout::Errors::LoadError do
+        OtherFakePlugin.load :foo
+      end
+    end
+
+    should "allow registration and load without ruby package or version" do
+      FakePlugin.register OpenStruct.new({:name => :foo2})
+      assert_not_nil FakePlugin.load :foo2
+    end
+
+    should "allow registration and match with nil pkg_name" do
+      FakePlugin.register(create_item(:pkg_name => nil))
+      assert_not_nil FakePlugin.load :foo
+    end
+
+    should "allow registration and match with nil pkg_version" do
+      FakePlugin.register(create_item(:pkg_version => nil))
+      assert_not_nil FakePlugin.load :foo
+    end
+
+    should "allow registration and match with nil platform" do
+      FakePlugin.register(create_item(:platform => nil))
+      assert_not_nil FakePlugin.load :foo
+    end
+
+    should "not allow registration with nil name" do
+      assert_raises Sprout::Errors::UsageError do
+        FakePlugin.register(create_item(:name => nil))
+      end
+    end
+
+    should "load when request is a string" do
+      FakePlugin.register(OpenStruct.new({:name => :foo3}))
+      assert_not_nil FakePlugin.load 'foo3'
+    end
+
+    should "load when registration is a string" do
+      FakePlugin.register(OpenStruct.new({:name => :swc, :pkg_name => 'asunit4'}))
+      assert_not_nil FakePlugin.load nil, :asunit4
+    end
+
+    should "raise on failure to find from collection" do
+      FakePlugin.register(create_item)
+      assert_raises Sprout::Errors::LoadError do
+        FakePlugin.load [:bar, :baz]
+      end
+    end
+
+    should "allow load with collection of names" do
+      FakePlugin.register(create_item)
+      assert_not_nil FakePlugin.load [:bar, :baz, :foo]
+    end
+  end
+
+  private
+
+  def create_item options={}
+    OpenStruct.new({:name => :foo, :pkg_name => 'sprout/base', :pkg_version => '1.0.pre', :platform => :universal}.merge(options))
+  end
+
+  class FakePlugin
+    include Sprout::RubyFeature
+  end
+
+  class OtherFakePlugin
+    include Sprout::RubyFeature
+  end
+end 
+
+

data/test/unit/ruby_generator_test.rb

@@ -0,0 +1,70 @@
+require File.join(File.dirname(__FILE__), "test_helper")
+
+require 'sprout/generators/ruby/ruby_generator'
+
+class RubyGeneratorTest < Test::Unit::TestCase
+  include SproutTestCase
+
+  context "A generated ruby application" do
+
+    setup do
+      @temp = File.join(fixtures, 'generators', 'ruby')
+      FileUtils.mkdir_p @temp
+      @generator = Sprout::RubyGenerator.new
+      @generator.path = @temp
+      @generator.logger = StringIO.new
+    end
+
+    teardown do
+      remove_file @temp
+    end
+
+    should "generate a new ruby application" do
+      @generator.input = 'SomeProject'
+      @generator.version = '4.2.pre'
+      @generator.lib = 'libs'
+      @generator.execute
+
+      project_dir = File.join @temp, 'some_project'
+      assert_file project_dir
+
+      gem_file = File.join project_dir, 'Gemfile'
+      assert_file gem_file
+
+      lib_dir = File.join project_dir, 'libs'
+      assert_file lib_dir
+
+      module_file = File.join lib_dir, 'some_project.rb'
+      assert_file module_file do |content|
+        assert_matches /VERSION/, content
+        assert_matches /4.2.pre/, content
+      end
+
+      classes_dir = File.join lib_dir, 'some_project'
+      assert_file classes_dir
+
+      main_file = File.join classes_dir, 'base.rb'
+      assert_file main_file
+
+      test_dir = File.join project_dir, 'test'
+      assert_file test_dir
+
+      unit_dir = File.join test_dir, 'unit'
+      assert_file unit_dir
+
+      fixtures_dir = File.join test_dir, 'fixtures'
+      assert_file fixtures_dir
+
+      bin_dir = File.join project_dir, 'bin'
+      assert_file bin_dir
+
+      exe_file = File.join bin_dir, 'some-project'
+      assert_file exe_file do |content|
+        assert_matches /some_project/, content
+        assert_matches /SomeProject::Base.new/, content
+      end
+
+    end
+  end
+end
+

data/test/unit/specification_test.rb

@@ -0,0 +1,73 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class SpecificationTest < Test::Unit::TestCase
+  include SproutTestCase
+
+  context "a newly defined specification" do
+    setup do
+      @spec = Sprout::Specification.new do |s|
+        s.version = '1.0.pre'
+      end
+    end
+
+    should "have a default name" do
+      assert_equal 'specification_test', @spec.name
+    end
+
+    should "accept the version" do
+      assert_equal '1.0.pre', @spec.version
+    end
+
+    context "with a new name" do
+      setup do
+        @spec.name    = 'foo_sdk'
+        @spec.version = '1.0.pre'
+      end
+
+      should "register executables" do
+        @spec.add_file_target do |t|
+          t.add_executable :foo, 'bin/foo'
+        end
+
+        Sprout::Executable.stubs :require_ruby_package
+        assert_not_nil Sprout::Executable.load :foo, 'foo_sdk', '1.0.pre'
+      end
+
+      should "load returns libraries in expected order" do
+        @spec.add_file_target do |t|
+          t.add_library :swc, 'bin/foo'
+          t.add_library :src, 'bin/bar'
+        end
+
+        # Without specifying the :swc/:src decision:
+        library = Sprout::Library.load nil, 'foo_sdk'
+        assert_equal 'foo', File.basename(library.path)
+      end
+
+     
+    end
+  end
+
+  context "a newly included executable" do
+    setup do
+      @echo_chamber = File.join fixtures, 'executable', 'echochamber_gem', 'echo_chamber'
+      $:.unshift File.dirname(@echo_chamber)
+    end
+
+    teardown do
+      $:.shift
+    end
+
+    should "require the sproutspec" do
+      path = Sprout::Executable.load(:echos, 'echo_chamber').path
+      assert_matches /fixtures\/.*echochamber/, path
+      assert_file path
+
+      # TODO: We should be able to execute
+      # the provided executable!
+      #response = Sprout::System.create.execute path
+      #assert_equal 'ECHO ECHO ECHO', response
+    end
+  end
+end
+

data/test/unit/sprout_test.rb

@@ -0,0 +1,170 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class SproutTest < Test::Unit::TestCase
+  include SproutTestCase
+
+  context "Errors" do
+    include Sprout::Errors
+
+    [
+      ArchiveUnpackerError,
+      DestinationExistsError,
+      ExecutionError, 
+      ExecutableRegistrationError,
+      MissingExecutableError,
+      ProcessRunnerError,
+      SproutError, 
+      ExecutableError,
+      UnknownArchiveType,
+      UsageError,
+      VersionRequirementNotMetError
+    ].each do |error|
+
+      should "be available to instiate a #{error.to_s}" do
+        error.new
+      end
+    end
+  end
+
+  context "cache" do
+    setup do
+      @library = File.join(fixtures, 'sprout')
+    end
+
+    should "find library from system" do
+      user = Sprout::System::OSXSystem.new
+      user.stubs(:library).returns @library
+      Sprout.stubs(:current_system).returns user
+
+      expected_cache = File.join(@library, 'Sprouts', Sprout::VERSION::MAJOR_MINOR, 'cache')
+      assert_equal expected_cache, Sprout.cache
+    end
+
+    should "find library for unix system" do
+      user = Sprout::System::UnixSystem.new
+      user.stubs(:library).returns @library
+      Sprout.stubs(:current_system).returns user
+
+      expected_cache = File.join(@library, '.sprouts', Sprout::VERSION::MAJOR_MINOR, 'cache')
+      assert_equal expected_cache, Sprout.cache
+    end
+  end
+
+  context "A new sprout test case" do
+
+    should "be able to work as a particular user but then revert when done" do
+      original_class = Sprout.current_system.class
+
+      block_called = false
+
+      systems = [
+                 Sprout::System::VistaSystem,
+                 Sprout::System::WinNixSystem,
+                 Sprout::System::WinSystem,
+                 Sprout::System::JavaSystem,
+                 Sprout::System::OSXSystem,
+                 Sprout::System::UnixSystem
+                ]
+      incr = 0
+
+      as_each_system do |sys|
+        block_called = true
+        assert_equal systems[incr], Sprout.current_system.class, "Requests for the current system should yield a UNIX system"
+        incr += 1
+      end
+
+      assert_equal original_class, Sprout.current_system.class
+      assert block_called, "Ensure the block was yielded to..."
+    end
+  end
+
+  context "Executables" do
+
+    context "with a sandboxed load path" do
+
+      setup do
+        path = File.join fixtures, "executable", "flex3sdk_gem"
+        $:.unshift path
+      end
+
+      teardown do
+        $:.shift
+      end
+
+      should "find requested executables" do
+        path = Sprout::Executable.load(:mxmlc, 'flex3sdk', '>= 3.0.0').path
+        assert_not_nil path
+      end
+    end
+    
+    context "with a stubbed load path" do
+
+      setup do
+        Sprout::Executable.stubs(:require_ruby_package).returns true
+        @path = 'test/fixtures/process_runner/chmod_script.sh'
+      end
+
+      should "work when registered with different gem names" do
+        register_executable :mxmlc, 'flex3sdk', '1.0.pre', @path
+        register_executable :mxmlc, 'flex4sdk', '1.0.pre', @path
+      end
+
+      should "work when registered with different exe names" do
+        register_executable :mxmlc, 'flex3sdk', '1.0.pre', @path
+        register_executable :compc, 'flex3sdk', '1.0.pre', @path
+      end
+
+      context "that are registered" do
+        should "work the first time" do
+          register_executable :mxmlc, 'flex3sdk', '1.0.pre', @path
+        end
+
+        context "and then requested" do
+          setup do
+            register_executable :mxmlc, 'flex3sdk', '1.0.pre', @path
+          end
+
+          should "succeed if the executable is available and no version specified" do
+            assert_equal @path, Sprout::Executable.load(:mxmlc, 'flex3sdk').path
+          end
+
+          should "succeed if version requirement is met" do
+            assert_equal @path, Sprout::Executable.load(:mxmlc, 'flex3sdk', '>= 1.0.pre').path
+          end
+
+          should "fail if version requirement is not met" do
+            assert_raises Sprout::Errors::LoadError do
+              Sprout::Executable.load :mxmlc, 'flex3sdk', '>= 1.1.0'
+            end
+          end
+
+        end
+      end
+
+      context "that are not registered" do
+        should "fail when requested" do
+          assert_raises Sprout::Errors::LoadError do
+            Sprout::Executable.load :mxmlc, 'flex3sdk'
+          end
+        end
+      end
+
+    end
+  end
+
+  private
+
+  def register_executable name, pkg_name, pkg_version, path, platform=:universal
+    exe = OpenStruct.new({
+      :name => name,
+      :path => path,
+      :pkg_name => pkg_name,
+      :pkg_version => pkg_version,
+      :platform => platform
+    })
+    Sprout::Executable.register exe
+  end
+
+end
+
+