torquebox-configure 2.0.0.beta1-java

data/spec/global_spec.rb

@@ -0,0 +1,482 @@
+require 'options_macros'
+require 'torquebox/configuration/global'
+
+include TorqueBox::Configuration
+
+describe "TorqueBox.configure using the GlobalConfiguration" do
+  before(:each) do
+    Thread.current[:torquebox_config] = TorqueBox::Configuration::GlobalConfiguration.new
+    Thread.current[:torquebox_config_entry_map] = TorqueBox::Configuration::GlobalConfiguration::ENTRY_MAP
+  end
+
+  shared_examples_for "options" do
+    before(:each) do
+      validator = mock('Validator')
+      validator.stub(:valid?).and_return(true)
+      TorqueBox::Configuration::Validator.stub(:new).and_return(validator)
+    end
+
+    it "should parse a hash" do
+      config = TorqueBox.configure do |cfg|
+        cfg.send( @method, {'foo' => 'bar'} )
+      end
+
+      config['<root>'][@method].should == {'foo' => 'bar'}
+    end
+
+    it "should parse a block" do
+      config = TorqueBox.configure do |cfg|
+        cfg.send( @method ) { foo 'bar'}
+      end
+      config['<root>'][@method].should == { :foo => 'bar' }
+    end
+  end
+
+  shared_examples_for "a thing with options" do
+    before(:each) do
+      validator = mock('Validator')
+      validator.stub(:valid?).and_return(true)
+      TorqueBox::Configuration::Validator.stub(:new).and_return(validator)
+    end
+
+    def assert_options(config, key, options)
+      if @discrete
+        config['<root>'][@method].should == [[key, options]]
+      else
+        config['<root>'][@method][key].should == options
+      end
+
+    end
+
+    it "should parse a string and a hash" do
+      config = TorqueBox.configure do |cfg|
+        cfg.send( @method, 'a string', {'foo' => 'bar'} )
+      end
+
+      assert_options( config, 'a string', {'foo' => 'bar'} )
+    end
+
+    it "should parse a symbol and a hash" do
+      config = TorqueBox.configure do |cfg|
+        cfg.send( @method, :a_sym, {'foo' => 'bar'} )
+      end
+
+      assert_options( config, 'a_sym', {'foo' => 'bar'} )
+    end
+
+    it "should parse a constant and a hash" do
+      config = TorqueBox.configure do |cfg|
+        cfg.instance_eval "#{@method} AConstant, {'foo' => 'bar'}"
+      end
+      assert_options( config, 'AConstant', {'foo' => 'bar'} )
+    end
+
+    it "should parse a thing and a block" do
+      config = TorqueBox.configure do |cfg|
+        cfg.send( @method, 'a thing' ) { foo 'bar' }
+      end
+
+      assert_options( config, 'a thing', { :foo => 'bar' } )
+    end
+
+  end
+
+  describe '#authentication' do
+    before(:each) { @method = 'authentication' }
+    it_should_behave_like 'a thing with options'
+
+    it_should_not_allow_invalid_options { authentication 'a-name', :foo => :bar }
+    it_should_allow_valid_options { authentication 'a-name', :domain => :pizza }
+  end
+
+  describe "#credential" do
+    it "should only be valid inside authentication" do
+      lambda {
+        TorqueBox.configure { credential 'ham', 'biscuit' }
+      }.should raise_error(TorqueBox::Configuration::ConfigurationError)
+
+      lambda {
+        TorqueBox.configure do
+          authentication :default, :domain => 'ham' do
+            credential 'ham', 'biscuit'
+          end
+        end
+      }.should_not raise_error(TorqueBox::Configuration::ConfigurationError)
+    end
+
+    it "should nest under its parent" do
+      config = TorqueBox.configure do
+        authentication :default, :domain => 'ham' do
+          credential 'ham', 'biscuit'
+        end
+      end
+      config['<root>']['authentication']['default']['credential'].should == [['ham', 'biscuit']]
+    end
+
+    it "should nest under its parent properly when called more than once" do
+      config = TorqueBox.configure do
+        authentication :default, :domain => 'ham' do
+          credential 'ham', 'biscuit'
+          credential 'biscuit', 'gravy'
+        end
+      end
+      config['<root>']['authentication']['default']['credential'].should == [['ham', 'biscuit'], ['biscuit', 'gravy']]
+    end
+  end
+
+  describe '#environment' do
+    before(:each) { @method = 'environment' }
+    it_should_behave_like 'options'
+
+    it "should be additive" do
+      config = TorqueBox.configure do
+        environment 'foo' => 'bar'
+        environment 'bar' => 'baz'
+      end
+
+      config['<root>']['environment'].should == { 'foo' => 'bar', 'bar' => 'baz' }
+    end
+  end
+
+  describe '#ruby' do
+    before(:each) { @method = 'ruby' }
+    it_should_behave_like 'options'
+
+    it_should_not_allow_invalid_options { ruby :foo => :bar }
+    it_should_allow_valid_options { ruby :version => '1.9', :compile_mode => :jit, :debug => true, :interactive => true }
+
+    it_should_not_allow_invalid_option_values { ruby :version => '2' }
+    it_should_not_allow_invalid_option_values { ruby :compile_mode => :bacon }
+    it_should_not_allow_invalid_option_values { ruby :debug => :sure }
+    it_should_not_allow_invalid_option_values { ruby :interactive => :sure }
+    it_should_allow_valid_option_values { ruby :version => '1.8', :compile_mode => :jit }
+  end
+
+  describe '#web' do
+    before(:each) { @method = 'web' }
+    it_should_behave_like 'options'
+
+    it_should_not_allow_invalid_options { web :foo => :bar }
+    it_should_allow_valid_options { web :context => '', :host => '', :rackup => '', :static => '' }
+  end
+
+  describe '#pool' do
+    before(:each) { @method = 'pool' }
+    it_should_behave_like 'a thing with options'
+
+    it_should_not_allow_invalid_options { pool 'a-name', :foo => :bar }
+    it_should_allow_valid_options { pool 'a-name', :type => :shared, :min => '', :max => '' }
+
+    it_should_not_allow_invalid_option_values { pool 'a-name', :type => :bacon }
+    it_should_allow_valid_option_values { pool 'a-name', :type => :shared }
+  end
+
+  %w{ queue topic }.each do |method|
+    describe "##{method}" do
+      before(:each) { @method = method }
+      it_should_behave_like 'a thing with options'
+
+      it_should_not_allow_invalid_options {send(method, 'a-name', :foo => :bar) }
+      it_should_allow_valid_options { send(method, 'a-name', :create => false, :durable => true, :remote_host => '') }
+
+      it_should_not_allow_invalid_option_values { send(method, 'a-name', :create => :yep) }
+      it_should_allow_valid_option_values { send(method, 'a-name', :create => true) }
+    end
+  end
+
+  describe "#processor" do
+    it "should only be valid inside a queue or topic" do
+      lambda {
+        TorqueBox.configure { processor 'Foo' }
+      }.should raise_error(TorqueBox::Configuration::ConfigurationError)
+
+      lambda {
+        TorqueBox.configure do
+          queue 'a-queue' do
+            processor 'Foo'
+          end
+        end
+      }.should_not raise_error(TorqueBox::Configuration::ConfigurationError)
+
+      lambda {
+        TorqueBox.configure do
+          topic 'a-topic' do
+            processor 'Foo'
+          end
+        end
+      }.should_not raise_error(TorqueBox::Configuration::ConfigurationError)
+
+    end
+
+    it "should nest under its parent" do
+      config = TorqueBox.configure do
+        topic 'a-topic' do
+          processor 'Foo'
+        end
+      end
+      config['<root>']['topic']['a-topic']['processor'].should == [['Foo', {}]]
+    end
+
+
+    it_should_not_allow_invalid_options do
+      topic 'a-topic' do
+        processor 'AClass', :foo => :bar
+      end
+    end
+
+    it_should_allow_valid_options  do
+      topic 'a-topic' do
+        processor 'AClass', :concurrency => 1, :config => '', :filter => '', :name => '', :singleton=>true
+      end
+    end
+
+  end
+
+  describe "#options_for" do
+    before(:each) { @method = 'options_for' }
+
+    it_should_behave_like 'a thing with options'
+
+    it_should_not_allow_invalid_options { options_for 'a-name', :foo => :bar }
+    it_should_allow_valid_options { options_for 'a-name', :concurrency => 1, :disabled => true }
+
+    it_should_not_allow_invalid_option_values { options_for 'a-name', :disabled => :bacon }
+    it_should_allow_valid_option_values { options_for 'a-name', :disabled => false }
+  end
+
+  describe "#service" do
+    before(:each) do
+      @method = 'service'
+      @discrete = true
+    end
+
+    it_should_behave_like 'a thing with options'
+
+    it_should_not_allow_invalid_options { service 'AClass', :foo => :bar }
+    it_should_allow_valid_options { service 'AClass', :config => '', :singleton => true, :name => '' }
+
+    it_should_not_allow_invalid_option_values { service 'AClass', :singleton => :bacon }
+    it_should_allow_valid_option_values { service 'AClass', :singleton => false }
+
+    it "should allow multiple services using the same class" do
+      config = TorqueBox.configure do
+        service 'AService'
+        service 'AService'
+      end
+
+      config['<root>']['service'].should == [['AService', { }], ['AService', { }]]
+    end
+  end
+
+  describe '#stomp' do
+    before(:each) { @method = 'stomp' }
+    it_should_behave_like 'options'
+
+    it_should_not_allow_invalid_options { stomp :foo => :bar }
+    it_should_allow_valid_options { stomp :host => 'example.com' }
+  end
+
+
+  describe "#stomplet" do
+    before(:each) do
+      @method = 'stomplet'
+      @discrete = true
+    end
+
+    it_should_behave_like 'a thing with options'
+
+    it_should_not_allow_invalid_options { stomplet 'AClass', :route => '/foo', :foo => :bar }
+    it_should_allow_valid_options { stomplet 'AClass', :config => '',  :route => '/foo', :name => '' }
+
+    it "should allow multiple stomplets using the same class" do
+      config = TorqueBox.configure do
+        stomplet 'AStomplet', :route => '/x'
+        stomplet 'AStomplet', :route => '/y'
+      end
+
+      config['<root>']['stomplet'].should == [['AStomplet', {:route => '/x' }], ['AStomplet', { :route => '/y' }]]
+    end
+  end
+
+  describe "#job" do
+    before(:each) do
+      @method = 'job'
+      @discrete = true
+    end
+
+    it_should_behave_like 'a thing with options'
+
+    it_should_not_allow_invalid_options { job 'AClass', :foo => :bar }
+    it_should_allow_valid_options { job 'AClass', :config => '', :singleton => true, :name => '' , :cron => '234'}
+
+    it_should_not_allow_invalid_option_values { job 'AClass', :singleton => :bacon }
+    it_should_allow_valid_option_values { job 'AClass', :singleton => false, :cron => '234' }
+
+    it "should allow multiple jobs using the same class" do
+      config = TorqueBox.configure do
+        job 'AJob', :cron => '1234'
+        job 'AJob', :cron => '1234'
+      end
+
+      config['<root>']['job'].should == [['AJob', { :cron => '1234' }], ['AJob', { :cron => '1234' }]]
+    end
+
+    it "should allow cron to be set in a block" do
+      lambda {
+        TorqueBox.configure do
+          job 'AJob' do
+            cron '123'
+          end
+        end
+      }.should_not raise_error(TorqueBox::Configuration::ConfigurationError)
+    end
+
+    it "should raise if cron doesn't get set in a block" do
+      lambda {
+        TorqueBox.configure do
+          job 'AJob' do
+          end
+        end
+      }.should raise_error(TorqueBox::Configuration::ConfigurationError)
+    end
+
+  end
+
+  describe "#to_metadata_hash" do
+    before(:each) do
+      @config = GlobalConfiguration.new
+      @config['<root>'] = {
+        'authentication' => {
+          'ham' => {
+            :domain => :gravy,
+            'credential' => [['ham', 'biscuit'], ['biscuit', 'gravy']]
+          }
+        },
+        'environment' => { :ham => 'biscuit' },
+        'job' => [ [ FakeConstant.new( 'AJob' ), {
+                       :cron => 'cronspec',
+                       :name => 'a-job',
+                       :config => { :foo => :bar }
+                     } ],
+                   [ FakeConstant.new( 'AnotherJob' ), {
+                       :cron => 'cronspec',
+                       :config => { :foo => :bar }
+                     } ],
+                   [ FakeConstant.new( 'AnotherJob' ), {
+                       :cron => 'cronspec',
+                       :config => { :foo => :bar }
+                     } ] ],
+        'options_for' => {
+          FakeConstant.new( 'Backgroundable' ) => { :concurrency => 42 },
+          'messaging' => { :default_message_encoding => :biscuit }
+        },
+        'pool' => {
+          'web' => { :type => :shared },
+          'foo' => { :type => :bounded, :min => 1, :max => 2 } },
+        'queue' => {
+          'a-queue' => {
+            :create => false,
+            'processor' => [ [ FakeConstant.new( 'AProcessor' ),
+                               {
+                                 :name => 'a-proc',
+                                 :config => { :foo => :bar } } ] ]
+          },
+          'another-queue' => {},
+        },
+        'ruby' => { :version => '1.9' },
+        'service' => [ [ FakeConstant.new( 'AService' ), {
+                           :name => 'a-service',
+                           :config => { :foo => :bar } } ],
+                       [ FakeConstant.new( 'AnotherService' ), {
+                           :config => { :foo => :bar } } ] ],
+        'stomp' => { :host => 'hambiscuit.com' },
+        'stomplet' => [ [ FakeConstant.new( 'AStomplet' ), {
+                            :route => '/a',
+                            :name => 'a-stomplet',
+                            :config => { :foo => :bar } } ],
+                        [ FakeConstant.new( 'AnotherStomplet' ), {
+                            :route => '/b',
+                            :config => { :foo => :bar } } ] ],
+        'topic' => { 'a-topic' => { :durable => true } },
+        'web' => { :context => '/bacon' }
+      }
+
+      @metadata = @config.to_metadata_hash
+    end
+
+    it "should properly setup authentication" do
+      @metadata['auth']['ham'].should == { 'domain' => :gravy, 'credentials' => { 'ham' => 'biscuit', 'biscuit' => 'gravy' } }
+    end
+
+    it "should properly set the environment" do
+      @metadata['environment'].should == { 'ham' => 'biscuit' }
+    end
+
+    it "should properly set a job" do
+      job = @metadata['jobs']['a-job']
+      job.should_not be_nil
+      job['job'].should == 'AJob'
+      job['cron'].should == 'cronspec'
+    end
+
+    it "should properly handle jobs for the same class without names" do
+      @metadata['jobs']['AnotherJob'].should_not be_nil
+      @metadata['jobs']['AnotherJob-1'].should_not be_nil
+    end
+
+
+    it "should properly set messaging options from options_for" do
+      @metadata['messaging']['default_message_encoding'].should == 'biscuit'
+    end
+    
+    it "should properly set task options from options_for" do
+      @metadata['tasks']['Backgroundable']['concurrency'].should == 42
+    end
+
+    it "should properly set pooling" do
+      @metadata['pooling']['web'].should == 'shared'
+      foo = @metadata['pooling']['foo']
+      foo.should_not be_nil
+      foo['min'].should == 1
+      foo['max'].should == 2
+    end
+
+    it "should properly set a processor" do
+      @metadata['messaging']['a-queue']['AProcessor'].should == { "name" => 'a-proc', "config" => { 'foo' => :bar } }
+    end
+
+    it "should properly set a queue" do
+      @metadata['queues']['another-queue'].should == { }
+    end
+
+    it "should not set a queue marked as create => false" do
+      @metadata['queues']['a-queue'].should be_nil
+    end
+
+    it "should properly set ruby runtime options" do
+      @metadata['ruby']['version'].should == '1.9'
+    end
+
+    it "should properly set stomp options" do
+      @metadata['stomp']['host'].should == 'hambiscuit.com'
+    end
+
+    it "should properly set a service" do
+      @metadata['services']['a-service'].should == { 'service' => 'AService', 'config' => { 'foo' => :bar } }
+    end
+
+    it "should properly set a stomplet" do
+      @metadata['stomp']['stomplets']['a-stomplet'].should == { 'class' => 'AStomplet', 'route' => '/a', 'config' => { 'foo' => :bar } }
+    end
+
+    it "should properly set a topic" do
+      @metadata['topics']['a-topic'].should == { 'durable' => true }
+    end
+
+    it "should properly set web" do
+      @metadata['web']['context'].should == '/bacon'
+    end
+  end
+end
+
+

data/spec/options_macros.rb

@@ -0,0 +1,39 @@
+module OptionsMacros
+  def it_should_allow_valid_options(&block)
+    it "should allow valid options" do
+      lambda {
+        TorqueBox.configure &block
+      }.should_not raise_error(TorqueBox::Configuration::ConfigurationError)
+    end
+  end
+
+  def it_should_not_allow_invalid_options(&block)
+    it "should not allow invalid options" do
+      lambda {
+        TorqueBox.configure &block
+      }.should raise_error(TorqueBox::Configuration::ConfigurationError)
+    end
+  end
+
+  def it_should_allow_valid_option_values(&block)
+    it "should allow valid option values" do
+      lambda {
+        TorqueBox.configure &block
+      }.should_not raise_error(TorqueBox::Configuration::ConfigurationError)
+    end
+  end
+
+  def it_should_not_allow_invalid_option_values(&block)
+    it "should not allow valid option values" do
+      lambda {
+        TorqueBox.configure &block
+      }.should raise_error(TorqueBox::Configuration::ConfigurationError)
+    end
+  end
+
+end
+
+RSpec.configure do |config|
+  config.extend(OptionsMacros)
+end
+

data/spec/validator_spec.rb

@@ -0,0 +1,36 @@
+require 'torquebox/configuration/validator'
+
+include TorqueBox::Configuration
+
+describe TorqueBox::Configuration::Validator do
+
+  context "required options" do
+    it "should be valid if all of the required options are there" do
+      Validator.new({ :required => [:foo, :bar]}, 'name', {:foo => :x, :bar => :y}).should be_valid
+    end
+
+    it "should not be valid if not all of the required options are there" do
+      Validator.new({ :required => [:foo, :bar]}, 'name', {:foo => :x}).should_not be_valid
+    end
+  end
+
+  context "allowed options" do
+    it "should be valid if no non-allowed options are there" do
+      Validator.new({ :optional => [:foo, :bar]}, 'name', {:foo => :x}).should be_valid
+    end
+
+    it "should not be valid if any non-allowed options are there" do
+      Validator.new({ :optional => [:foo, :bar]}, 'name', {:cheese => :x}).should_not be_valid
+    end
+  end
+
+  context "allowed values" do
+    it "should be valid if an allowed value is used" do
+      Validator.new({ :optional => [{ :foo => ['gouda', 'havarti']}, :bar]}, 'name', {:foo => 'gouda'}).should be_valid
+    end
+
+    it "should be invalid if an non-allowed value is used" do
+      Validator.new({ :optional => [{ :foo => ['gouda', 'havarti']}, :bar]}, 'name', {:foo => 'swiss'}).should_not be_valid
+    end
+  end
+end

metadata

@@ -0,0 +1,87 @@
+--- !ruby/object:Gem::Specification 
+name: torquebox-configure
+version: !ruby/object:Gem::Version 
+  prerelease: 6
+  version: 2.0.0.beta1
+platform: java
+authors: 
+  - The TorqueBox Team
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-12-02 00:00:00 Z
+dependencies: 
+  - !ruby/object:Gem::Dependency 
+    name: blankslate
+    prerelease: false
+    requirement: &id001 !ruby/object:Gem::Requirement 
+      none: false
+      requirements: 
+        - - "="
+          - !ruby/object:Gem::Version 
+            version: 2.1.2.4
+    type: :runtime
+    version_requirements: *id001
+  - !ruby/object:Gem::Dependency 
+    name: rspec
+    prerelease: false
+    requirement: &id002 !ruby/object:Gem::Requirement 
+      none: false
+      requirements: 
+        - - "="
+          - !ruby/object:Gem::Version 
+            version: 2.7.0
+    type: :development
+    version_requirements: *id002
+description: ""
+email: 
+  - torquebox-dev@torquebox.org
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+  - licenses/lgpl-2.1.txt
+  - lib/torquebox-configure.jar
+  - lib/torquebox-configure.rb
+  - lib/gem_hook.rb
+  - lib/torquebox/configuration.rb
+  - lib/torquebox/configure.rb
+  - lib/torquebox/configuration/global.rb
+  - lib/torquebox/configuration/validator.rb
+  - spec/global_spec.rb
+  - spec/options_macros.rb
+  - spec/validator_spec.rb
+homepage: http://www.torquebox.org/torquebox-gems-parent/torquebox-configure/
+licenses: 
+  - lgpl
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+  - lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+    - - ">"
+      - !ruby/object:Gem::Version 
+        version: 1.3.1
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.8.9
+signing_key: 
+specification_version: 3
+summary: TorqueBox Configure Gem
+test_files: 
+  - spec/global_spec.rb
+  - spec/validator_spec.rb