torquebox-core 3.2.0-java → 4.0.0.alpha1-java

data/spec/codecs_spec.rb

@@ -1,87 +0,0 @@
-require 'torquebox/codecs'
-require 'torquebox/codecs/json'
-
-def define_JSON
-  klass = Class.new {
-    def self.fast_generate(_)
-    end
-  }
-  Object.const_set(:JSON, klass)
-end
-
-describe TorqueBox::Codecs do
-
-  context "json" do
-    it "should decode an encoded array" do
-      TorqueBox::Codecs.decode(TorqueBox::Codecs.encode(['abc'], :json), :json).should eql(['abc'])
-    end
-    
-    if RUBY_VERSION >= '1.9'
-      it "should decode an encoded string" do
-        TorqueBox::Codecs.decode(TorqueBox::Codecs.encode('abc', :json), :json).should eql('abc')
-      end
-    end
-    
-    context "requiring json" do
-      before(:each) do
-        Object.send(:remove_const, :JSON) if defined?(JSON)
-      end
-
-      it "should raise if json isn't available" do
-        TorqueBox::Codecs::JSON.should_receive(:require).with('json').and_raise(LoadError.new)
-        lambda { TorqueBox::Codecs.encode('abc', :json) }.should raise_error( RuntimeError )
-      end
-
-      it "should not raise if json is available" do
-        TorqueBox::Codecs::JSON.should_receive(:require).with('json').and_return { define_JSON }
-        lambda { TorqueBox::Codecs.encode('abc', :json ) }.should_not raise_error
-      end
-
-      it "should only require json once" do
-        TorqueBox::Codecs::JSON.should_receive(:require).once.with('json').and_return { define_JSON }
-        TorqueBox::Codecs.encode('abc', :json)
-        TorqueBox::Codecs.encode('abc', :json)
-      end
-    end
-  end
-
-  context "edn" do
-    it "should decode what it encodes" do
-      TorqueBox::Codecs.decode(TorqueBox::Codecs.encode('abc', :edn), :edn).should eql('abc')
-    end
-  end
-
-  context "marshal" do
-    it "should decode what it encodes" do
-      TorqueBox::Codecs.decode(TorqueBox::Codecs.encode('abc', :marshal), :marshal).should eql('abc')
-    end
-
-    it "should decode and encode Time objects" do
-      now = Time.now
-      TorqueBox::Codecs.decode(TorqueBox::Codecs.encode(now, :marshal), :marshal).should eql(now)
-    end
-  end
-
-  context "marshal base64" do
-    it "should decode what it encodes" do
-      TorqueBox::Codecs.decode(TorqueBox::Codecs.encode('abc', :marshal_base64), :marshal_base64).should eql('abc')
-    end
-
-    it "should decode and encode Time objects" do
-      now = Time.now
-      TorqueBox::Codecs.decode(TorqueBox::Codecs.encode(now, :marshal_base64), :marshal_base64).should eql(now)
-    end
-  end
-
-  context "marshal_smart" do
-    it "should decode what it encodes" do
-      TorqueBox::Codecs.decode(TorqueBox::Codecs.encode('abc', :marshal_smart), :marshal_smart).should eql('abc')
-    end
-
-    it "should decode and encode Time objects" do
-      now = Time.now
-      TorqueBox::Codecs.decode(TorqueBox::Codecs.encode(now, :marshal_smart), :marshal_smart).should eql(now)
-    end
-  end
-
-end

data/spec/injectors_spec.rb

@@ -1,28 +0,0 @@
-
-require 'torquebox/injectors'
-
-describe TorqueBox::Injectors do
-
-  include TorqueBox::Injectors
-
-  it 'should return the same thing for all fetch types' do
-    TorqueBox::Registry.merge!('this' => :that)
-    TorqueBox::Registry['this'].should == :that
-    fetch('this').should == :that
-    fetch_msc('this').should == :that
-    fetch_service('this').should == :that
-    fetch_cdi(:this).should == :that
-    fetch_jndi('this').should == :that
-    fetch_queue('this').should == :that
-    fetch_topic('this').should == :that
-  end
-
-end
-
-describe 'TorqueBox::Injectors without include' do
-  it 'should work' do
-    TorqueBox::Registry.merge!('this' => :that)
-    TorqueBox::Registry['this'].should == :that
-    TorqueBox.fetch('this').should == :that
-  end
-end

data/spec/kernel_spec.rb

@@ -1,47 +0,0 @@
-
-require 'torquebox/kernel'
-
-describe TorqueBox::Kernel do
-
-  it "should return nil lookup if registry unavailable" do
-    TorqueBox::ServiceRegistry.service_registry = nil
-    TorqueBox::Kernel.lookup('foo').should be_nil
-  end
-
-  it "should return value from registry" do
-    @registry["foo"] = "bar"
-    TorqueBox::Kernel.lookup("foo").should eql("bar")
-  end
-
-  it "should yield value from from block when registry contains key" do
-    @registry["foo"] = "bar"
-    TorqueBox::Kernel.lookup("foo") {|x| "baz" }.should eql("baz")
-  end
-
-  it "should defer block execution if registry unavailable" do
-    TorqueBox::ServiceRegistry.service_registry = nil
-    @registry["foo"] = "bar"
-    TorqueBox::Kernel.lookup("foo") { |foo| @foo = foo }.should be_nil
-    TorqueBox::Kernel.blocks.should_not be_empty
-    @foo = nil
-    TorqueBox::ServiceRegistry.service_registry = @service_registry
-    TorqueBox::Kernel.blocks.should be_empty
-    @foo.should eql("bar")
-  end
-
-  # Mock a JBoss ServiceRegistry backed by a simple member Hash,
-  # @registry, that holds the fixtures for the tests.
-  before(:each) do
-    TorqueBox::ServiceRegistry.stub!(:service_name_for).and_return { |name| name }
-    TorqueBox::ServiceRegistry.service_registry = nil
-    @registry = {}
-    @service_registry = mock("service_registry")
-    @service_registry.stub!(:getService).and_return { |name|
-      service = mock("service")
-      service.stub!(:getValue).and_return(@registry[name])
-      service
-    }
-    TorqueBox::ServiceRegistry.service_registry = @service_registry
-  end
-
-end

data/spec/logger_spec.rb

@@ -1,103 +0,0 @@
-
-require 'torquebox/logger'
-require 'fileutils'
-require 'logger'
-
-shared_examples_for 'a torquebox logger' do
-  it "should look nice for class objects" do
-    require 'torquebox/service_registry'
-    logger = TorqueBox::Logger.new(TorqueBox::ServiceRegistry)
-    logger.error("JC: log for cache store")
-  end
-
-  it "should support the various boolean methods" do
-    logger.should respond_to(:debug?)
-    logger.should respond_to(:info?)
-    logger.should respond_to(:warn?)
-    logger.should respond_to(:error?)
-    logger.should respond_to(:fatal?)
-  end
-
-  it "should not barf on meaningless level setting" do
-    logger.level = Logger::WARN
-    logger.level.should == Logger::WARN
-  end
-
-  it "should deal with blocks correctly" do
-    logger.error "JC: message zero"
-    logger.error { "JC: message" }
-    logger.error "JC: message too"
-  end
-
-  it "should handle nil parameters" do
-    logger.info(nil)
-  end
-
-  it "should support the rack.errors interface" do
-    logger.should respond_to(:puts)
-    logger.should respond_to(:write)
-    logger.should respond_to(:flush)
-  end
-
-  it "should have a formatter" do
-    logger.should respond_to(:formatter)
-    logger.formatter.should_not be_nil
-  end
-end
-
-describe TorqueBox::Logger do
-
-  let(:logger) { TorqueBox::Logger.new }
-
-  it_should_behave_like 'a torquebox logger'
-
-  it "should support the trace boolean method" do
-    logger.should respond_to(:trace?)
-  end
-
-  it "should support the add method" do
-    fake_logger = mock('logger')
-    org.jboss.logging::Logger.stub!(:getLogger).and_return(fake_logger)
-    logger = TorqueBox::Logger.new
-
-    fake_logger.should_receive(:debug).with('debug')
-    logger.add(Logger::DEBUG, 'debug', nil)
-
-    fake_logger.should_receive(:info).with('info')
-    logger.add(Logger::INFO, 'info', nil)
-
-    fake_logger.should_receive(:warn).with('warning')
-    logger.add(Logger::WARN, 'warning', nil)
-
-    fake_logger.should_receive(:error).with('error')
-    logger.add(Logger::ERROR, 'error', nil)
-
-    fake_logger.should_receive(:warn).with('unknown')
-    logger.add(Logger::UNKNOWN, 'unknown', nil)
-
-    fake_logger.should_receive(:warn).with('block')
-    logger.add(Logger::WARN, nil, nil) { 'block' }
-  end
-end
-
-describe TorqueBox::FallbackLogger do
-  before(:each) do
-    @log_path = File.expand_path(File.join(File.dirname(__FILE__), '..',
-                                           'target',
-                                           'logger_spec_output.log'))
-    ENV['TORQUEBOX_FALLBACK_LOGFILE'] = @log_path
-  end
-
-  after(:each) do
-    FileUtils.rm_f(@log_path)
-  end
-
-  let(:logger) { TorqueBox::FallbackLogger.new }
-
-  it_should_behave_like 'a torquebox logger'
-
-  it "should let users override the fallback log file" do
-    logger.info('testing fallback log file')
-    File.read(@log_path).should include('testing fallback log file')
-  end
-end

data/spec/scheduled_job_spec.rb

@@ -1,57 +0,0 @@
-require 'torquebox/scheduled_job'
-
-describe TorqueBox::ScheduledJob do
-  context "'at' jobs" do
-    it "should raise if no options are specified" do
-      lambda {
-        TorqueBox::ScheduledJob.at('Class', nil)
-      }.should raise_error("Invalid options for scheduling the job")
-    end
-
-    it "should raise if invalid options are specified" do
-      lambda {
-        TorqueBox::ScheduledJob.at('Class', "something")
-      }.should raise_error("Invalid options for scheduling the job")
-    end
-
-    it "should raise if :at and :in options are both specified" do
-      lambda {
-        TorqueBox::ScheduledJob.at('Class', :at => Time.now, :in => 2_000)
-      }.should raise_error("You can't specify both :at and :in")
-    end
-
-    it "should raise if :repeat is used without :every" do
-      lambda {
-        TorqueBox::ScheduledJob.at('Class', :at => Time.now, :repeat => 2_000)
-      }.should raise_error("You can't specify :repeat without :every")
-    end
-
-    it "should raise if :until is used without :every" do
-      lambda {
-        TorqueBox::ScheduledJob.at('Class', :at => Time.now, :until => Time.now + 2)
-      }.should raise_error("You can't specify :until without :every")
-    end
-
-    it "should raise if the :in parameter is not an Fixnum" do
-      lambda {
-        TorqueBox::ScheduledJob.at('Class', :in => Time.now)
-      }.should raise_error("Invalid type for :in, should be a Fixnum")
-
-    end
-  end
-
-  context "scheduled job" do
-    it "should raise if the job class is not provided" do
-      lambda {
-        TorqueBox::ScheduledJob.schedule(nil, '')
-      }.should raise_error("No job class name provided")
-    end
-
-    it "should raise if the cron expression is not provided" do
-      lambda {
-        TorqueBox::ScheduledJob.schedule('Class', nil)
-      }.should raise_error("No cron expression provided")
-    end
-  end
-end
-

data/spec/service_registry_spec.rb

@@ -1,52 +0,0 @@
-
-require 'torquebox/service_registry'
-
-describe TorqueBox::ServiceRegistry do
-
-  it "should return nil lookup if registry unavailable" do
-    TorqueBox::ServiceRegistry.lookup('foo').should be_nil
-  end
-
-  it "should return value from registry" do
-    @registry["foo"] = "bar"
-    TorqueBox::ServiceRegistry.service_registry = @service_registry
-    TorqueBox::ServiceRegistry.lookup("foo").should eql("bar")
-  end
-
-  it "should yield value from from block when registry contains key" do
-    @registry["foo"] = "bar"
-    TorqueBox::ServiceRegistry.service_registry = @service_registry
-    TorqueBox::ServiceRegistry.lookup("foo") {|x| "baz" }.should eql("baz")
-  end
-
-  it "should defer block execution if registry unavailable" do
-    @registry["foo"] = "bar"
-    TorqueBox::ServiceRegistry.lookup("foo") { |foo| @foo = foo }.should be_nil
-    TorqueBox::ServiceRegistry.blocks.should_not be_empty
-    @foo = nil
-    TorqueBox::ServiceRegistry.service_registry = @service_registry
-    TorqueBox::ServiceRegistry.blocks.should be_empty
-    @foo.should eql("bar")
-  end
-
-  it "should make the registry available" do
-    TorqueBox::ServiceRegistry.service_registry = @service_registry
-    TorqueBox::ServiceRegistry.registry.should == @service_registry
-  end
-
-  # Mock a JBoss ServiceRegistry backed by a simple member Hash,
-  # @registry, that holds the fixtures for the tests.
-  before(:each) do
-    TorqueBox::ServiceRegistry.stub!(:service_name_for).and_return { |name| name }
-    TorqueBox::ServiceRegistry.service_registry = nil
-    @registry = {}
-    @service_registry = mock("service_registry")
-    @service_registry.stub!(:getService).and_return { |name|
-      service = mock("service")
-      service.stub!(:getValue).and_return(@registry[name])
-      service
-    }
-  end
-  
-end
-