redcar-dev 0.12.17dev

data/plugins/core/spec/core/gui_spec.rb

@@ -0,0 +1,27 @@
+require File.join(File.dirname(__FILE__), "..", "spec_helper")
+
+describe Redcar::Gui do
+  before do
+    Redcar::Gui.all.clear
+    @gui = Redcar::Gui.new("test gui")
+  end
+  
+  it "has a name" do
+    @gui.name.should == "test gui"
+  end
+  
+  it "registers itself" do
+    Redcar::Gui.all.map {|g| g.name} .should == ["test gui"]
+  end
+  
+  it "delegates start and stop to the event loop" do
+    event_loop = mock("Event Loop")
+    event_loop.should_receive(:start)
+    event_loop.should_receive(:stop)
+    
+    @gui.register_event_loop(event_loop)
+    
+    @gui.start
+    @gui.stop
+  end
+end

data/plugins/core/spec/core/observable_spec.rb

@@ -0,0 +1,104 @@
+require File.join(File.dirname(__FILE__), "..", "spec_helper")
+
+describe Redcar::Observable do
+  class SeeMe
+    include Redcar::Observable
+    
+    def trigger_event(event, *args, &block)
+      notify_listeners(event, *args, &block)
+    end
+  end
+  
+  before do
+    @obj = SeeMe.new
+    @value = nil
+  end
+  
+  describe "without any listeners" do
+    it "attaches and triggers an event" do
+      @obj.add_listener(:christmas) do
+        @value = 101
+      end
+      @obj.trigger_event(:christmas)
+      @value.should == 101
+    end
+  
+    it "triggers an event with a block" do
+      @obj.trigger_event(:christmas) do
+        @value = 10
+      end
+      @value.should == 10
+    end
+  
+    it "attaches and triggers to multiple events" do
+      @obj.add_listener :HookTestHook, :HookTestHook2 do
+        @value = 34
+      end
+      @value.should be_nil
+      @obj.trigger_event :HookTestHook
+      @value.should == 34
+      @value = nil
+      @obj.trigger_event :HookTestHook2
+      @value.should == 34
+    end
+  
+    it "calls a before block first" do
+      @value = 1
+      @obj.add_listener :before => :HookTestHook do 
+        @value = 10
+      end
+      @obj.trigger_event :HookTestHook do
+        @value *= 5
+      end
+      @value.should == 50
+    end
+
+    it "calls an after block after" do
+      @value = nil
+      @obj.add_listener :after => :HookTestHook do 
+        @value *= 5
+      end
+      @obj.trigger_event :HookTestHook do
+        @value = 10
+      end
+      @value.should == 50
+    end
+  
+    it "passes an object through to the block" do
+      @obj.add_listener :HookTestHook do |str|
+        str.reverse!
+      end
+      str = "Hello!"
+      @obj.trigger_event :HookTestHook, str
+      str.should == "!olleH"
+    end
+
+    it "passes multiple objects through to the block" do
+      @obj.add_listener :HookTestHook do |str1, str2|
+        str1.replace(str1 + str2)
+      end
+      str1 = "Hel"
+      str2 = "lo!"
+      @obj.trigger_event :HookTestHook, str1, str2
+      str1.should == "Hello!"
+    end
+  end
+  
+  describe "with a listener" do
+    before do
+      @handler = @obj.add_listener(:christmas) do
+        @value = 101
+      end
+    end
+    
+    it "attaches and triggers an event" do
+      @obj.remove_listener(@handler)
+      @obj.trigger_event(:christmas)
+      @value.should be_nil
+    end
+  end
+end
+
+
+
+

data/plugins/core/spec/core/persistent_cache_spec.rb

@@ -0,0 +1,100 @@
+
+require File.join(File.dirname(__FILE__), *%w".. .. lib core persistent_cache")
+
+PersistentCache = Redcar::PersistentCache
+
+describe PersistentCache do
+  before do
+    PersistentCache.storage_dir = storage_dir
+    FileUtils.rm_rf(storage_dir)
+    @shouldnt_calculate = false
+    @calculation = false
+  end
+  
+  after do
+    FileUtils.rm_rf(storage_dir)
+  end
+
+  def storage_dir
+    File.expand_path(File.join(File.dirname(__FILE__), "scratch"))
+  end
+  
+  def cache_file_exists?(name)
+    File.exist?(File.join(File.dirname(__FILE__), "scratch", name)).should be_true
+  end
+
+  def expect_no_calculation
+    @shouldnt_calculate = true
+  end
+  
+  def it_should_have_calculated
+    @calculation.should be_true
+  end
+  
+  def reset_calculation
+    @calculation = false
+  end
+  
+  def test_block
+    lambda do
+      if @shouldnt_calculate
+        raise "shouldn't be calculating here"
+      end
+      @calculation = true
+      [1, 2, 3]
+    end  
+  end
+  
+  def spec_glob
+    File.expand_path(File.dirname(__FILE__)) + "/*"
+  end
+  
+  def expected_result
+    [1, 2, 3]
+  end
+
+  it "should create a cache file" do
+    cache = PersistentCache.new("test1")
+    cache.cache(&test_block).should == expected_result
+    it_should_have_calculated
+    cache_file_exists?("test1.cache")
+  end
+
+  it "should not calculate a second time" do
+    cache = PersistentCache.new("test1")
+    cache.cache(&test_block).should == expected_result
+
+    cache = PersistentCache.new("test1")
+    expect_no_calculation
+    cache.cache(&test_block).should == expected_result
+    cache_file_exists?("test1.cache")
+  end
+  
+  it "should let you get a list of all defined caches" do
+    PersistentCache.all.should == []
+    cache = PersistentCache.new("test1")
+    cache.cache(&test_block)
+    PersistentCache.all.map(&:name).should == ["test1"]
+  end
+  
+  it "should let you clear a cache" do
+    PersistentCache.all.should == []
+    cache = PersistentCache.new("test1")
+    cache.cache(&test_block)
+    it_should_have_calculated
+    PersistentCache.all.map(&:name).should == ["test1"]
+    cache.clear
+    PersistentCache.all.should == []
+    cache = PersistentCache.new("test1")
+    cache.cache(&test_block)
+    it_should_have_calculated
+    PersistentCache.all.map(&:name).should == ["test1"]
+  end
+end
+
+
+
+
+
+
+

data/plugins/core/spec/core/resource_spec.rb

@@ -0,0 +1,125 @@
+
+#require 'java'
+#
+#require File.join(File.dirname(__FILE__), *%w".. spec_helper")
+#
+#TaskQueue = Redcar::TaskQueue
+#Task      = Redcar::Task
+#Resource  = Redcar::Resource
+#
+#describe Resource do
+#  before do
+#    $started_tasks = []
+#    @block_runs = 0
+#    @started_flag = false
+#    @finish_flag  = false
+#    $wait_task_finish = false
+#    @q = TaskQueue.new
+#    Resource.stub!(:task_queue).and_return(@q)
+#  end
+#  
+#  after do
+#    @q.stop
+#  end
+#  
+#  describe "synchronous get" do
+#    it "should let you synchronously get the value" do
+#      resource = Resource.new { 101 }
+#      resource.value.should == 101
+#    end
+#    
+#    it "should cache the value across multiple calls" do
+#      resource = Resource.new { @block_runs += 1; 101 }
+#      resource.value
+#      resource.value
+#      resource.value.should == 101
+#      @block_runs.should == 1
+#    end
+#      
+#    it "should wait for a background job to finish if one is already in progress" do
+#      resource = Resource.new do
+#        @block_runs += 1
+#        1 until @finish_flag
+#      end
+#      resource.compute
+#      Thread.new do
+#        resource.value
+#      end
+#      sleep 0.1
+#      @finish_flag = true
+#      @block_runs.should == 1
+#    end
+#    
+#    it "should not wait for a background job if it pending, because it may have a long wait" do
+#      @q.submit(BlockingTask.new)
+#      resource = Resource.new do
+#        @block_runs += 1
+#        911
+#      end
+#      resource.compute
+#      Thread.new do
+#        resource.value
+#      end
+#      sleep 0.1
+#      resource.value.should == 911
+#      @block_runs.should == 1
+#    end
+#    
+#    it "should cancel background jobs that it overtakes" do
+#      @q.submit(BlockingTask.new)
+#      resource = Resource.new do
+#        @block_runs += 1
+#        911
+#      end
+#      resource.compute
+#      task = resource.task
+#      Thread.new do
+#        resource.value
+#      end
+#      sleep 0.1
+#      task.should be_cancelled
+#    end
+#  end
+#  
+#  it "should let you compute the resource in the background" do
+#    resource = Resource.new do
+#      1 until @started_flag
+#      @block_runs += 1
+#      @finish_flag = true
+#    end
+#    resource.compute
+#    @block_runs.should == 0
+#    @started_flag = true
+#    1 until @finish_flag
+#    @block_runs.should == 1
+#  end
+#  
+#  it "should have the background computed value" do
+#    resource = Resource.new do
+#      @block_runs += 1
+#      @started_flag = true
+#      999
+#    end
+#    resource.compute
+#    1 until @started_flag
+#    sleep 0.1
+#    resource.value.should == 999
+#    @block_runs.should == 1
+#  end
+#  
+#  it "should not compute lots of times" do
+#    resource = Resource.new do
+#      @block_runs += 1
+#      1 until @finish_flag
+#      999
+#    end
+#    20.times { resource.compute }
+#    @finish_flag = true
+#    resource.value.should == 999
+#    1 until @block_runs == 2
+#    @block_runs.should == 2
+#  end
+#end
+#
+#
+#

data/plugins/core/spec/core/shared_storage_spec.rb

@@ -0,0 +1,49 @@
+
+require File.join(File.dirname(__FILE__), "..", "spec_helper")
+
+describe Redcar::Plugin::SharedStorage do
+  
+  before do
+    remove_test_files
+  end
+  
+  after do
+    remove_test_files
+  end
+  
+  def remove_test_files
+    FileUtils.rm_rf(Redcar::Plugin::SharedStorage.new('test_shared_storage').send(:path))
+  end
+  
+  it "should set the default when it is not already set and the value is an Array" do
+    storage = Redcar::Plugin::SharedStorage.new("test_shared_storage")
+    storage.set_or_update_default('a', ['b', 'c'])
+    storage['a'].should == ['b', 'c']
+    storage = Redcar::Plugin::SharedStorage.new("test_shared_storage")
+    storage['a'].should == ['b', 'c']
+  end
+  
+  it "should set the default when it is not already and the value is not an Array" do
+    storage = Redcar::Plugin::SharedStorage.new("test_shared_storage")
+    storage.set_or_update_default('a', 'b')
+    storage['a'].should == ['b']
+    storage = Redcar::Plugin::SharedStorage.new("test_shared_storage")
+    storage['a'].should == ['b']
+  end
+  
+  it "should update the default when it is already set and the value is an Array" do
+    storage = Redcar::Plugin::SharedStorage.new("test_shared_storage")
+    storage.set_or_update_default('a', 'b')
+    storage = Redcar::Plugin::SharedStorage.new("test_shared_storage")
+    storage.set_or_update_default('a', 'c')
+    storage['a'].should == ['b', 'c']
+  end
+  
+  it "should update the default when it is already set and the value is not an Array" do
+    storage = Redcar::Plugin::SharedStorage.new("test_shared_storage")
+    storage.set_or_update_default('a', 'b')
+    storage = Redcar::Plugin::SharedStorage.new("test_shared_storage")
+    storage.set_or_update_default('a', ['c', 'd'])
+    storage['a'].should == ['b', 'c', 'd']
+  end
+end

data/plugins/core/spec/core/storage_spec.rb

@@ -0,0 +1,27 @@
+
+require File.join(File.dirname(__FILE__), "..", "spec_helper")
+
+describe Redcar::Plugin::Storage do
+  
+  it "should be based on Redcar::Plugin::BaseStorage" do
+    Redcar::Plugin::Storage.ancestors.should include(Redcar::Plugin::BaseStorage)
+  end
+  
+  it "should have a default storage path" do
+    Redcar::Plugin::Storage.storage_dir.should == File.join(Redcar.user_dir, "storage")
+  end
+  
+  it "should have a configurable storage path" do
+    old_storage_dir = Redcar::Plugin::Storage.storage_dir
+    Redcar::Plugin::Storage.storage_dir = File.dirname(__FILE__)
+    Redcar::Plugin::Storage.storage_dir.should == File.dirname(__FILE__)
+    Redcar::Plugin::Storage.storage_dir = old_storage_dir
+  end
+  
+  it "should store files inside the directory specified by storage path" do
+    Redcar::Plugin::Storage.storage_dir = File.dirname(__FILE__)
+    storage = Redcar::Plugin::Storage.new('test_storage')
+    storage.send(:path).should == File.join(File.dirname(__FILE__), 'test_storage.yaml')
+  end
+    
+end

data/plugins/core/spec/core/task_queue_spec.rb

@@ -0,0 +1,199 @@
+
+require 'java'
+
+require File.join(File.dirname(__FILE__), *%w".. spec_helper")
+
+describe Redcar::TaskQueue do
+  before do
+    $started_tasks = []
+    @q = Redcar::TaskQueue.new
+  end
+  
+  after do
+    @q.stop
+  end
+  
+  describe "running tasks" do
+    it "should accept tasks and call them" do
+      @q.submit(QuickTask.new(101)).get
+      $started_tasks.should == [101]
+    end
+    
+    it "should call tasks in order" do
+      @q.submit(QuickTask.new(101))
+      @q.submit(QuickTask.new(102))
+      @q.submit(QuickTask.new(103)).get
+      $started_tasks.should == [101, 102, 103]
+    end
+    
+    it "should return the result of the Task execute method" do
+      @q.submit(QuickTask.new(103)).get.should == :hiho
+    end
+  end
+  
+  describe "cancelling tasks" do
+    before do
+      $wait_task_finish = false
+    end
+    
+    class WaitTask < QuickTask
+      def execute
+        super
+        1 until $wait_task_finish
+      end
+    end
+    
+    it "can be cancelled" do
+      @q.submit(QuickTask.new(101))
+      @q.submit(WaitTask.new(102))
+      @q.submit(task = QuickTask.new(103))
+      task.cancel
+      $wait_task_finish = true
+      sleep 0.1
+      $started_tasks.should == [101, 102]
+      @q.pending.should be_empty
+      task.should be_cancelled
+    end
+    
+    it "can cancel all pending tasks" do
+      @q.submit(WaitTask.new(102))
+      @q.submit(task1 = QuickTask.new(103))
+      @q.submit(task2 = QuickTask.new(104))
+      1 until $started_tasks.include?(102)
+      @q.cancel_all
+      $wait_task_finish = true
+      $started_tasks.should == [102]
+    end
+  end
+  
+  describe "information" do
+    describe "about pending tasks" do
+      it "should tell you about tasks that have not been started yet" do
+        @q.submit(t1 = BlockingTask.new(:a))
+        @q.submit(t2 = BlockingTask.new(:b))
+        @q.pending.include?(t2).should be_true
+      end
+      
+      it "should not include in process tasks" do
+        @q.submit(t1 = BlockingTask.new(:a))
+        @q.submit(t2 = BlockingTask.new(:b))
+        1 until $started_tasks.include?(:a)
+        @q.pending.include?(t1).should be_false
+      end
+      
+      it "should not include completed tasks" do
+        @q.submit(t1 = QuickTask.new(:a))
+        @q.submit(t2 = BlockingTask.new(:b))
+        1 until $started_tasks.include?(:b)
+        @q.pending.include?(t1).should be_false
+      end
+      
+      it "should tell you when it was enqueued" do
+        @q.submit(t1 = QuickTask.new(:a))
+        t1.enqueue_time.should be_an_instance_of(Time)
+      end
+      
+      it "should tell you it is pending" do
+        @q.submit(t1 = BlockingTask.new(:a))
+        @q.submit(t2 = BlockingTask.new(:b))
+        1 until $started_tasks.include?(:a)
+        t2.should be_pending
+        t2.should_not be_completed
+        t2.should_not be_in_process
+      end
+    end
+    
+    describe "in process tasks" do
+      it "should tell you which task is in process" do
+        @q.submit(t1 = BlockingTask.new(:a))
+        1 until $started_tasks.include?(:a)
+        @q.in_process.should == t1
+      end
+      
+      it "should tell you when it was started" do
+        @q.submit(t1 = BlockingTask.new(:a))
+        1 until $started_tasks.include?(:a)
+        t1.start_time.should be_an_instance_of(Time)
+      end
+      
+      it "should tell you they are in process" do
+        @q.submit(t1 = BlockingTask.new(:a))
+        1 until $started_tasks.include?(:a)
+        t1.should be_in_process
+        t1.should_not be_pending
+        t1.should_not be_completed
+      end
+    end
+    
+    describe "completed tasks" do
+      it "should tell you which tasks have completed" do
+        @q.submit(t1 = QuickTask.new(:a))
+        @q.submit(t2 = BlockingTask.new(:b))
+        1 until $started_tasks.include?(:b)
+        @q.completed.include?(t1).should be_true
+      end
+      
+      it "should not include in process tasks" do
+        @q.submit(t1 = QuickTask.new(:a))
+        @q.submit(t2 = BlockingTask.new(:b))
+        1 until $started_tasks.include?(:b)
+        @q.completed.include?(t2).should be_false
+      end
+      
+      it "should not include in pending tasks" do
+        @q.submit(t1 = QuickTask.new(:a))
+        @q.submit(t2 = BlockingTask.new(:b))
+        @q.submit(t3 = BlockingTask.new(:c))
+        1 until $started_tasks.include?(:b)
+        @q.completed.include?(t3).should be_false
+      end
+      
+      it "should tell you when it was completed" do
+        @q.submit(t1 = QuickTask.new(:a))
+        @q.submit(t2 = BlockingTask.new(:b))
+        1 until $started_tasks.include?(:b)
+        t1.completed_time.should be_an_instance_of(Time)
+      end
+      
+      it "should tell you they are completed" do
+        @q.submit(t1 = QuickTask.new(:a))
+        @q.submit(t2 = BlockingTask.new(:b))
+        1 until $started_tasks.include?(:b)
+        t1.should be_completed
+        t1.should_not be_pending
+        t1.should_not be_in_process
+      end
+    end
+  end
+  
+  describe "errored tasks" do
+    class ErrorTask < QuickTask
+      def execute
+        $started_tasks << @id
+        raise 'error'
+      end
+    end
+    
+    it "should be in completed task list" do
+      @q.submit(t1 = ErrorTask.new(:a))
+      @q.submit(t2 = BlockingTask.new(:b))
+      1 until $started_tasks.include?(:b)
+      @q.completed.should == [t1]
+    end
+    
+    it "should have the error" do
+      @q.submit(t1 = ErrorTask.new(:a))
+      @q.submit(t2 = BlockingTask.new(:b))
+      1 until $started_tasks.include?(:b)
+      @q.completed.first.error.should be_an_instance_of(RuntimeError)
+    end
+  end
+end
+
+
+
+
+
+
+
+