boson-more 0.1.0

data/test/argument_inspector_test.rb

@@ -0,0 +1,40 @@
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+describe "scrape_with_eval" do
+  def args_from(string)
+    # methods need options to have their args parsed with ArgumentInspector
+    string.gsub!(/(def blah)/, 'options :a=>1; \1')
+    Inspector.enable
+    ::Boson::Commands::Aaa.module_eval(string)
+    Inspector.disable
+    MethodInspector.store[:args]['blah']
+  end
+
+  before_all { eval "module ::Boson::Commands::Aaa; end"; }
+  before { MethodInspector.mod_store[::Boson::Commands::Aaa] = {} }
+
+  it "determines arguments with literal defaults" do
+    args_from("def blah(arg1,arg2='val2'); end").should == [['arg1'], ['arg2','val2']]
+  end
+
+  it "determines splat arguments" do
+    args_from("def blah(arg1, *args); end").should == [['arg1'], ["*args"]]
+  end
+
+  it "determines arguments with local values before a method" do
+    body = "AWESOME='awesome'; def sweet; 'ok'; end; def blah(arg1=AWESOME, arg2=sweet); end"
+    args_from(body).should == [['arg1', 'awesome'], ['arg2', 'ok']]
+  end
+
+  it "doesn't get arguments with local values after a method" do
+    args_from("def blah(arg1=nope) end; def nope; 'nope'; end").should == nil
+  end
+
+  it "doesn't determine arguments of a private method" do
+    args_from("private; def blah(arg1,arg2); end").should == nil
+  end
+
+  it "doesn't determine arguments if an error occurs" do
+    args_from("def blah(arg1,arg2=raise); end").should == nil
+  end
+end

data/test/command_test.rb

@@ -0,0 +1,22 @@
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+describe "Command" do
+  describe ".find" do
+    before_all {
+      reset_boson
+      Boson.libraries << Library.new(:name=>'bling', :namespace=>true)
+      @namespace_command = Command.new(:name=>'blah', :lib=>'bling', :namespace=>'bling')
+      @top_level_command = Command.new(:name=>'blah', :lib=>'bling')
+      Boson.commands << @namespace_command
+      Boson.commands << @top_level_command
+    }
+
+    it 'finds correct command when a subcommand of the same name exists' do
+      Command.find('blah').should == @top_level_command
+    end
+
+    it 'finds correct command when a top level command of the same name exists' do
+      Command.find('bling.blah').should == @namespace_command
+    end
+  end
+end

data/test/commands_test.rb

@@ -0,0 +1,53 @@
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+module Boson
+  class CommandsTest < Test::Unit::TestCase
+    before(:all) {
+        @higgs = Boson.main_object
+        if Boson.libraries.size.zero?
+          reset_boson
+          ancestors = class <<Boson.main_object; self end.ancestors
+          # allows running just this test file
+          Manager.load Runner.default_libraries unless ancestors.include?(Boson::Commands::Core)
+        end
+    }
+
+    def render_expects(&block)
+      View.expects(:render).with(&block)
+    end
+
+    context "libraries" do
+      before(:all) {
+        Boson.libraries << Boson::Library.new(:name=>'blah')
+        Boson.libraries << Boson::Library.new(:name=>'another', :module=>"Cool")
+      }
+
+      test "lists all when given no argument" do
+        render_expects {|*args| args[0].size == Boson.libraries.size }
+        @higgs.libraries
+      end
+
+      test "searches with a given search field" do
+        render_expects {|*args| args[0] == [Boson.library('another')]}
+        @higgs.libraries('Cool', :query_fields=>[:module])
+      end
+    end
+
+    context "commands" do
+      before(:all) {
+        Boson.commands << Command.create('some', Library.new(:name=>'thing'))
+        Boson.commands << Command.create('and', Library.new(:name=>'this'))
+      }
+
+      test "lists all when given no argument" do
+        render_expects {|*args| args[0].size == Boson.commands.size }
+        @higgs.commands
+      end
+
+      test "searches with a given search field" do
+        render_expects {|*args| args[0] == [Command.find('and')]}
+        @higgs.commands('this', :query_fields=>[:lib])
+      end
+    end
+  end
+end

data/test/comment_inspector_test.rb

@@ -0,0 +1,126 @@
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+describe "CommentInspector" do
+  before_all { eval "module ::Optional; def self.bling; {:a=>'bling'}; end; end" }
+  describe "scrapes description" do
+    before {
+      @lines = ["module Foo", "  # some comments yay", "  def foo", "  end", "end"]
+    }
+    def description(options={})
+      CommentInspector.scrape(@lines.join("\n"), options[:line] || 3, Optional)[:desc]
+    end
+
+    it "directly above method returns desc" do
+      description.should == "some comments yay"
+    end
+
+    it "with explicit @desc returns desc" do
+      @lines[1] = '#@desc   some comments yay'
+      description.should == "some comments yay"
+    end
+
+    it "of multiple lines returns desc" do
+      @lines.delete_at(1)
+      @lines.insert(1, '#@options :b=>1', '#@desc here be', '# comments')
+      description(:line=>5).should == "here be comments"
+    end
+
+    it "that is empty returns nil" do
+      @lines[1] = ""
+      description.should == nil
+    end
+
+    it "that is empty with options keyword returns nil" do
+      @lines[1] = '#@options {:a=>1}'
+      description.should == nil
+    end
+
+    it "not directly above returns nil" do
+      @lines.insert(2, "   ")
+      description(:line=>4).should == nil
+    end
+  end
+
+  describe "scrapes options" do
+    before {
+      @lines = ["module Foo", '  #@options {:a=>true}', "  def foo", "  end", "end"]
+    }
+    def options(opts={})
+      @lines[1] = opts[:value] if opts[:value]
+      args = [@lines.join("\n"), opts[:line] || 3, Optional]
+      CommentInspector.scrape(*args)[:options]
+    end
+
+    it "that are basic" do
+      options.should == {:a=>true}
+    end
+
+    it "that are hash-like" do
+      options(:value=>'#@options :a => 2').should == {:a=>2}
+    end
+
+    it "that are whitespaced" do
+      options(:value=>"\t"+ '#    @options {:a=>1}').should == {:a=>1}
+    end
+
+    it "that have a local value" do
+      options(:value=>'#@options bling').should == {:a=>'bling'}
+    end
+
+    it "that are multi-line" do
+      @lines.delete_at(1)
+      @lines.insert(1, '#@options {:a =>', " # 1}", "# some comments")
+      options(:line=>5).should == {:a=>1}
+    end
+
+    it "with failed eval and returns nil" do
+      options(:value=>'#@options !--').should == nil
+    end
+
+    it "that are empty and returns nil" do
+      options(:value=>"# nada").should == nil
+    end
+
+    it "when @option overwrites @options" do
+      @lines.insert(1, '  #@option :a, :boolean')
+      options(:line=>4).should == {:a=>:boolean}
+    end
+
+    it "when set by @option and @options" do
+      @lines.insert(1, '  #@option :b, :boolean')
+      options(:line=>4).should == {:b=>:boolean, :a=>true}
+    end
+
+    it "when set by @option" do
+      @lines.delete_at(1)
+      @lines.insert(1, ' #@option :b, :string', '  #@option :a, 4')
+      options(:line=>4).should == {:b=>:string, :a=>4}
+    end
+
+    it "when set by multi-line @option" do
+      @lines.delete_at(1)
+      @lines.insert(1, ' #@option :b, :type=>:string,', '  # :values=>%w{one two}', '# some comments')
+      options(:line=>5).should == {:b=>{:type=>:string, :values=>%w{one two}}}
+    end
+
+    it "and ignores invalid @option's" do
+      @lines.delete_at(1)
+      @lines.insert(1, '  #@option :b=>:string', '  #@option :a, :string')
+      options(:line=>4).should == {:a=>:string}
+    end
+  end
+
+  it "scrapes all comment types with implicit desc" do
+    @lines = ["module Foo", '# @config :a=>true', '  # @options {:a=>true}',
+      '#blah', "  def foo", "  end", "end"]
+    expected = {:desc=>"blah", :options=>{:a=>true}, :config=>{:a=>true}}
+    CommentInspector.scrape(@lines.join("\n"), 5, Optional).should == expected
+  end
+
+  it "scrapes all comment types with explicit desc" do
+    @lines = ["module Foo",  '#@desc blah', '  # @options {:a=>true}',
+      '  # @config :a=>true', "  def foo", "  end", "end"]
+    expected = {:desc=>"blah", :options=>{:a=>true}, :config=>{:a=>true}}
+    CommentInspector.scrape(@lines.join("\n"), 5, Optional).should == expected
+  end
+end

data/test/console_runner_test.rb

@@ -0,0 +1,58 @@
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+describe "repl_runner" do
+  def start(hash={})
+    Hirb.stubs(:enable)
+    Boson.start(hash.merge(:verbose=>false))
+  end
+
+  before_all { reset }
+  before { ConsoleRunner.instance_eval("@initialized = false") }
+
+  it "loads default libraries and libraries in :console_defaults config" do
+    defaults = BareRunner.default_libraries + ['yo']
+    with_config(:console_defaults=>['yo']) do
+      Manager.expects(:load).with {|*args| args[0] == defaults }
+      start
+    end
+  end
+
+  it "doesn't call init twice" do
+    capture_stderr { start }
+    ConsoleRunner.expects(:init).never
+    start
+  end
+
+  it "loads multiple libraries with :libraries option" do
+    ConsoleRunner.expects(:init)
+    Manager.expects(:load).with([:lib1,:lib2], anything)
+    start(:libraries=>[:lib1, :lib2])
+  end
+
+  it "autoloader autoloads libraries" do
+    start(:autoload_libraries=>true)
+    Index.expects(:read)
+    Index.expects(:find_library).with('blah').returns('blah')
+    Manager.expects(:load).with('blah', anything)
+    Boson.main_object.blah
+  end
+  after_all { FileUtils.rm_r File.dirname(__FILE__)+'/config', :force=>true }
+end
+
+describe "console options" do
+  before_all { reset }
+
+  it "console option starts irb" do
+    ConsoleRunner.expects(:start)
+    Util.expects(:which).returns("/usr/bin/irb")
+    ConsoleRunner.expects(:load_repl).with("/usr/bin/irb")
+    start("--console")
+  end
+
+  it "console option but no irb found prints error" do
+    ConsoleRunner.expects(:start)
+    Util.expects(:which).returns(nil)
+    ConsoleRunner.expects(:abort).with {|arg| arg[/Console not found/] }
+    start '--console'
+  end
+end

data/test/deps.rip

@@ -0,0 +1,4 @@
+mocha >=0
+bacon >=1.1.0
+mocha-on-bacon >=0
+bacon-bits >=0

data/test/file_library_test.rb

@@ -0,0 +1,41 @@
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+describe "file library" do
+  before { reset; FileLibrary.reset_file_cache }
+  before { Gem.stubs(:loaded_specs).returns({}) }
+
+  it "loads" do
+    load :blah, :file_string=>"module Blah; def blah; end; end"
+    library_has_module('blah', 'Boson::Commands::Blah')
+    command_exists?('blah')
+  end
+
+  it "in a subdirectory loads" do
+    load 'site/delicious', :file_string=>"module Delicious; def blah; end; end"
+    library_has_module('site/delicious', "Boson::Commands::Site::Delicious")
+    command_exists?('blah')
+  end
+
+  it "in a sub subdirectory loads" do
+    load 'web/site/delicious', :file_string=>"module Delicious; def blah; end; end"
+    library_has_module('web/site/delicious', "Boson::Commands::Web::Site::Delicious")
+    command_exists?('blah')
+  end
+
+  it "loads by basename" do
+    Dir.stubs(:[]).returns([File.expand_path('./test/commands/site/github.rb')])
+    load 'github', :file_string=>"module Github; def blah; end; end", :exists=>false
+    library_has_module('site/github', "Boson::Commands::Site::Github")
+    command_exists?('blah')
+  end
+
+  it "loads a plugin library by creating its module" do
+    load(:blah, :file_string=>"def blah; end")
+    library_has_module('blah', "Boson::Commands::Blah")
+    command_exists?('blah', false)
+  end
+
+  it "prints error for file library with multiple modules" do
+    capture_stderr { load(:blah, :file_string=>"module Doo; end; module Daa; end") }.should =~ /Can't.*config/
+  end
+end

data/test/gem_library_test.rb

@@ -0,0 +1,40 @@
+describe "Loader" do
+  describe "load" do
+    before { reset }
+    describe "gem library" do
+      def mock_library(lib, options={})
+        options[:file_string] ||= ''
+        File.stubs(:exists?).returns(false)
+        GemLibrary.expects(:is_a_gem?).returns(true)
+        Util.expects(:safe_require).with { eval options.delete(:file_string) || ''; true}.returns(true)
+      end
+
+      it "loads" do
+        with_config(:libraries=>{"dude"=>{:module=>'Dude'}}) do
+          load "dude", :file_string=>"module ::Dude; def blah; end; end"
+          library_has_module('dude', "Dude")
+          command_exists?("blah")
+        end
+      end
+
+      it "with kernel methods loads" do
+        load "dude", :file_string=>"module ::Kernel; def dude; end; end"
+        library_loaded? 'dude'
+        library('dude').module.should == nil
+        command_exists?("dude")
+      end
+
+      it "prints error when nonexistent" do
+        capture_stderr { load('blah') }.should =~ /Library blah did not/
+      end
+
+      it "with invalid module prints error" do
+        with_config(:libraries=>{"coolio"=>{:module=>"Cool"}}) do
+          capture_stderr {
+            load('coolio', :file_string=>"module ::Coolio; def coolio; end; end")
+          }.should =~ /Unable.*coolio.*No module/
+        end
+      end
+    end
+  end
+end

data/test/libraries_test.rb

@@ -0,0 +1,55 @@
+
+describe "Loader" do
+  before { Gem.stubs(:loaded_specs).returns({}) }
+  describe "config" do
+    before { reset }
+
+    # if this test fails, other exists? using methods fail
+    it "from callback recursively merges with user's config" do
+      with_config(:libraries=>{'blah'=>{:commands=>{'bling'=>{:desc=>'bling', :options=>{:num=>3}}}}}) do
+        File.stubs(:exists?).returns(true)
+        load :blah, :file_string=> "module Blah; def self.config; {:commands=>{'blang'=>{:alias=>'ba'}, " +
+          "'bling'=>{:options=>{:verbose=>:boolean}}}}; end; end"
+        library('blah').command_object('bling').options.should == {:verbose=>:boolean, :num=>3}
+        library('blah').command_object('bling').desc.should == 'bling'
+        library('blah').command_object('blang').alias.should == 'ba'
+      end
+    end
+
+    it "non-hash from inspector overridden by user's config" do
+      with_config(:libraries=>{'blah'=>{:commands=>{'bling'=>{:desc=>'already'}}}}) do
+        load :blah, :file_string=>"module Blah; #from file\ndef bling; end; end"
+        library('blah').command_object('bling').desc.should == 'already'
+      end
+    end
+
+    it "from inspector attribute config sets command's config" do
+      load :blah, :file_string=>"module Blah; config :alias=>'ok'\n; def bling; end; end"
+      library('blah').command_object('bling').alias.should == 'ok'
+    end
+  end
+
+  describe "load" do
+    before { reset }
+    it "calls included callback" do
+      capture_stdout {
+        load :blah, :file_string=>"module Blah; def self.included(mod); puts 'included blah'; end; def blah; end; end"
+      }.should =~ /included blah/
+    end
+
+    it "calls after_included callback" do
+      capture_stdout {
+        load :blah, :file_string=>"module Blah; def self.after_included; puts 'yo'; end; end"
+      }.should == "yo\n"
+    end
+
+    it "prints error if library module conflicts with top level constant/module" do
+      capture_stderr {
+        load :blah, :file_string=>"module Object; def self.blah; end; end"
+      }.should =~ /conflict.*'Object'/
+      library_loaded?('blah')
+    end
+  end
+
+  after_all { FileUtils.rm_r File.dirname(__FILE__)+'/commands/', :force=>true }
+end

data/test/loader_test.rb

@@ -0,0 +1,38 @@
+describe "Loader" do
+  it "loads a library and creates its class commands" do
+    with_config(:libraries=>{"blah"=>{:class_commands=>{"bling"=>"Blah.bling", "Blah"=>['hmm']}}}) do
+      load :blah, :file_string=>"module Blah; def self.bling; end; def self.hmm; end; end"
+      command_exists? 'bling'
+      command_exists? 'hmm'
+    end
+  end
+
+  it "loads a module library and all its class methods by default" do
+    eval %[module ::Harvey; def self.bird; end; def self.eagle; end; end]
+    load ::Harvey, :no_mock=>true
+    library_has_command('harvey', 'bird')
+    library_has_command('harvey', 'eagle')
+  end
+
+  it "prints error when nonexistent" do
+    capture_stderr { load('blah') }.should =~ /Library blah did not/
+  end
+
+  it "prints error if namespace conflicts with existing commands" do
+    eval "module ::Conflict; def self.bleng; end; end"
+    load Conflict, :no_mock=>true
+    with_config(:libraries=>{'bleng'=>{:namespace=>true}}) do
+      capture_stderr {
+        load 'bleng', :file_string=>"module Bleng; def bling; end; end"
+      }.should =~ /conflict.*bleng/
+    end
+  end
+
+  it "hash from inspector recursively merged with user's config" do
+    with_config(:libraries=>{'blah'=>{:commands=>{'blung'=>{:args=>[], :options=>{:sort=>'this'}}}}}) do
+      CommentInspector.expects(:scrape).returns({:options=>{:fields=>['this']}})
+      load :blah, :file_string=>"module Blah; def blung; end; end"
+      library('blah').command_object('blung').options.should == {:fields=>["this"], :sort=>"this"}
+    end
+  end
+end

data/test/module_library_test.rb

@@ -0,0 +1,30 @@
+describe "Loader" do
+  describe "load" do
+    before { reset }
+
+    describe "module library" do
+      def mock_library(*args); end
+
+      it "loads a module library and all its class methods by default" do
+        eval %[module ::Harvey; def self.bird; end; def self.eagle; end; end]
+        load ::Harvey, :no_mock=>true
+        library_has_command('harvey', 'bird')
+        library_has_command('harvey', 'eagle')
+      end
+
+      it "loads a module library with specified commands" do
+        eval %[module ::Peanut; def self.bird; end; def self.eagle; end; end]
+        load ::Peanut, :no_mock=>true, :commands=>%w{bird}
+        library('peanut').commands.size.should == 1
+        library_has_command('peanut', 'bird')
+      end
+
+      it "loads a module library as a class" do
+        eval %[class ::Mentok; def self.bird; end; def self.eagle; end; end]
+        load ::Mentok, :no_mock=>true, :commands=>%w{bird}
+        library('mentok').commands.size.should == 1
+        library_has_command('mentok', 'bird')
+      end
+    end
+  end
+end

data/test/more_manager_test.rb

@@ -0,0 +1,29 @@
+describe "Loader" do
+  before { Gem.stubs(:loaded_specs).returns({}) }
+  describe 'load' do
+    before { reset }
+
+    it "loads a library with dependencies" do
+      File.stubs(:exists?).returns(true)
+      File.stubs(:read).returns("module Water; def water; end; end", "module Oaks; def oaks; end; end")
+      with_config(:libraries=>{"water"=>{:dependencies=>"oaks"}}) do
+        load 'water', :no_mock=>true
+        library_has_module('water', "Boson::Commands::Water")
+        library_has_module('oaks', "Boson::Commands::Oaks")
+        command_exists?('water')
+        command_exists?('oaks')
+      end
+    end
+
+    it "prints error for library with invalid dependencies" do
+      GemLibrary.stubs(:is_a_gem?).returns(true) #mock all as gem libs
+      Util.stubs(:safe_require).returns(true)
+      with_config(:libraries=>{"water"=>{:dependencies=>"fire"}, "fire"=>{:dependencies=>"man"}}) do
+        capture_stderr {
+          load('water', :no_mock=>true)
+        }.should == "Unable to load library fire. Reason: Can't load dependency man\nUnable to load"+
+        " library water. Reason: Can't load dependency fire\n"
+      end
+    end
+  end
+end

data/test/more_method_inspector_test.rb

@@ -0,0 +1,42 @@
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+describe "MethodInspector" do
+  before_all { MethodInspector.mod_store = {} }
+  describe "commands module with" do
+    it "not all method attributes set causes method_locations to be set" do
+      MethodInspector.stubs(:find_method_locations).returns(["/some/path", 10])
+      parsed = parse "desc 'yo'; def yo; end; options :yep=>1; def yep; end; " +
+        "option :b, :boolean; config :a=>1; desc 'z'; options :a=>1; def az; end"
+      parsed[:method_locations].key?('yo').should == true
+      parsed[:method_locations].key?('yep').should == true
+      parsed[:method_locations].key?('az').should == false
+    end
+
+    it "no find_method_locations doesn't set method_locations" do
+      MethodInspector.stubs(:find_method_locations).returns(nil)
+      parse("def bluh; end")[:method_locations].key?('bluh').should == false
+    end
+  end
+
+  describe "scrape_arguments" do
+    def args_from(file_string)
+      MethodInspector.scrape_arguments(file_string, "blah")
+    end
+
+    it "parses arguments of class method" do
+      args_from("    def YAML.blah( filepath )\n").should == [['filepath']]
+    end
+
+    it "parses arguments with no spacing" do
+      args_from("def bong; end\ndef blah(arg1,arg2='val2')\nend").should == [["arg1"], ['arg2', "'val2'"]]
+    end
+
+    it "parses arguments with spacing" do
+      args_from("\t def blah(  arg1=val1, arg2 = val2)").should == [["arg1","val1"], ["arg2", "val2"]]
+    end
+
+    it "parses arguments without parenthesis" do
+      args_from(" def blah arg1, arg2, arg3={}").should == [['arg1'], ['arg2'], ['arg3','{}']]
+    end
+  end
+end

data/test/more_scientist_test.rb

@@ -0,0 +1,10 @@
+describe "Scientist" do
+  it "with debug option prints debug" do
+    capture_stdout { command_with_args("-v ok") }.should =~ /Arguments.*ok/
+  end
+
+  it "with pretend option prints arguments and returns early" do
+    Scientist.expects(:process_result).never
+    capture_stdout { command_with_args("-p ok") }.should =~ /Arguments.*ok/
+  end
+end

data/test/namespacer_test.rb

@@ -0,0 +1,61 @@
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+describe "Loader" do
+  def load_namespace_library
+    Manager.load([Boson::Commands::Namespace])
+  end
+
+  before { Gem.stubs(:loaded_specs).returns({}) }
+  describe "config" do
+    before { reset }
+    it "from callback overridden by user's config" do
+      with_config(:libraries=>{'blih'=>{:namespace=>false}}) do
+        load :blih, :file_string=>"module Blah; def self.config; {:namespace=>'bling'}; end; end"
+        library('blih').namespace.should == false
+      end
+    end
+  end
+
+  describe "load" do
+    before { reset }
+
+    it "namespaces a library that has a method conflict" do
+      load('blah', :file_string=>"module Blah; def chwhat; end; end")
+      capture_stderr {
+        load('chwhat2', :file_string=>"module Chwhat2; def chwhat; end; end")
+      }.should =~ /conflict.*chwhat.*chwhat2/
+      library_has_command('namespace', 'chwhat2')
+      library_has_command('chwhat2', 'chwhat')
+    end
+  end
+
+  describe "library with namespace" do
+    before_all { reset_main_object }
+    before { reset_boson }
+
+    it "loads and defaults to library name" do
+      with_config(:libraries=>{'blang'=>{:namespace=>true}}) do
+        load 'blang', :file_string=>"module Blang; def bling; end; end"
+        library_has_command('blang', 'bling')
+      end
+    end
+
+    it "loads with config namespace" do
+      with_config(:libraries=>{'blung'=>{:namespace=>'dope'}}) do
+        load 'blung', :file_string=>"module Blung; def bling; end; end"
+        library_has_command('blung', 'bling')
+        library('blung').commands.size.should == 1
+      end
+    end
+
+    it "prints error if namespace conflicts with existing commands" do
+      eval "module ::Conflict; def self.bleng; end; end"
+      load Conflict, :no_mock=>true
+      with_config(:libraries=>{'bleng'=>{:namespace=>true}}) do
+        capture_stderr {
+          load 'bleng', :file_string=>"module Bleng; def bling; end; end"
+        }.should =~ /conflict.*bleng/
+      end
+    end
+  end
+end