mvcli 0.0.16 → 0.1.0

data/spec/mvcli/middleware/exception_logger_spec.rb

@@ -4,10 +4,10 @@ require "mvcli/middleware/exception_logger"
 describe "MVCLI::Middleware::ExceptionLogger" do
   use_natural_assertions
 
-  Given(:command) {mock(:Command, :log => "")}
-  Given(:logger) {MVCLI::Middleware::ExceptionLogger.new}
+  Given(:command) { double(:Command, :log => "") }
+  Given(:logger) { MVCLI::Middleware::ExceptionLogger.new }
   context "with a cleanly running application" do
-    When(:result) {logger.call(command) {0}}
+    When(:result) { logger.call(command) {0} }
     Then {result == 0}
   end
   context "with an app that raises an exception" do

data/spec/mvcli/middleware/exit_status_spec.rb

@@ -3,24 +3,24 @@ require "mvcli/middleware/exit_status"
 
 describe MVCLI::Middleware::ExitStatus do
   use_natural_assertions
-  Given(:command) {mock(:Command)}
-  Given(:middleware) {MVCLI::Middleware::ExitStatus.new}
+  Given(:command) { double(:Command) }
+  Given(:middleware) { MVCLI::Middleware::ExitStatus.new }
   context "when called with code that succeeds" do
-    When(:status) {middleware.call(command) {0}}
-    Then {status == 0}
+    When(:status) { middleware.call(command) {0} }
+    Then { status == 0 }
   end
   context "when called with an app that fails with an exit status of 99" do
-    When(:status) {middleware.call(command) {99}}
-    Then{ status == 99}
+    When(:status) { middleware.call(command) {99} }
+    Then { status == 99 }
   end
 
   context "when the upstream app yields a non-integer" do
-    When(:status) {middleware.call(command) {"whoopeee!"}}
-    Then {status == 0}
+    When(:status) { middleware.call(command) {"whoopeee!"} }
+    Then { status == 0 }
   end
 
   context "when the upstream app raises an exception" do
-    When(:status) {middleware.call(command) {fail "boom!"}}
-    Then {status == 70}
+    When(:status) { middleware.call(command) {fail "boom!"} }
+    Then { status == 70 }
   end
 end

data/spec/mvcli/middleware_spec.rb

@@ -2,73 +2,56 @@ require "spec_helper"
 require "mvcli/middleware"
 
 describe "MVCLI::Middleware" do
-  before do
-    @middleware = MVCLI::Middleware.new
-    @command = mock(:Command)
-  end
+  use_natural_assertions
+  Given(:middleware) { MVCLI::Middleware.new }
+  Given(:command) { double :Command }
+
+  When { @result = middleware.call command }
 
-  it "runs perfectly fine without any apps" do
-    @middleware.call(@command).should eql 0
+  context "without any apps" do
+    Then { @result == 0 }
   end
 
-  describe "with a single app" do
-    before do
-      @app = proc do |command|
+  context "with a single app" do
+    Given do
+      middleware << proc do |command|
         @called = command
       end
-      @middleware << @app
-      @middleware.call @command
-    end
-    it "calls it" do
-      @called.should eql @command
     end
+    Then { @called == command }
   end
 
-  describe "with a couple apps" do
-    before do
+  context "with a couple of apps" do
+    Given do
       @sequence = []
       @commands = []
-      @middleware << proc do |command, &block|
+      middleware << proc do |command, &block|
         @commands << command
         @sequence << "first.before"
         block.call
         @sequence << "first.after"
       end
-      @middleware << proc do |command, &block|
+      middleware << proc do |command, &block|
         @commands << command
         @sequence << "second"
       end
-      @middleware.call @command
-    end
-    it "passes the command to all the apps" do
-      @commands.should eql [@command, @command]
-    end
-    it "calls the first app *around* the second app" do
-      @sequence.should eql ["first.before", "second", "first.after"]
     end
+    Then { @commands == [command, command] }
+    Then { @sequence == ["first.before", "second", "first.after"] }
 
-    describe "if the first app does not yield" do
-      before do
-        @sequence.clear
-        @middleware[0] = Proc.new {}
-        @middleware.call @command
-      end
-      it "never calls the second app" do
-        @sequence.should eql []
-      end
+    context "when the first does not yield to the second" do
+      Given { middleware[0] = Proc.new {} }
+      Then { @sequence == [] }
     end
   end
 
-  describe "with an app that yields even though there is no next app" do
-    before do
-      app = Object.new
-      def app.call(command)
-        yield
-      end
-      @middleware << @app
-    end
-    it "runs successfully" do
-      @middleware.call(@command).should eql 0
-    end
+  context "with a single app that yields even though there is no next app" do
+    Given { middleware << proc {|c, &block| block.call } }
+    Then { @result == 0 }
+  end
+
+  context "when invoked with a 'follow-on' app" do
+    When(:result) { middleware.call(command) {|c| c} }
+    Then { result == command }
   end
 end

data/spec/mvcli/path_spec.rb

@@ -0,0 +1,13 @@
+require "spec_helper"
+require "mvcli/path"
+
+describe "MVCLI::Path" do
+  use_natural_assertions
+  Given(:path) { MVCLI::Path.new(Pathname(__FILE__).dirname.join(File.basename __FILE__, '.rb')) }
+
+  Then { path.exists? 'does/exist' }
+  Then { not path.exists? 'does/not/exist' }
+  Then { path.read('does/exist') == "Hello World"}
+  Then { path.to_s('flim flam')  =~ %r{mvcli/spec/mvcli/path_spec/flim flam} }
+  Then { path.nearest('spec_helper.rb') == Pathname(__FILE__).parent.parent.join('spec_helper.rb') }
+end

data/spec/mvcli/path_spec/does/exist

@@ -0,0 +1 @@
+Hello World

data/spec/mvcli/plugins/providers/bundle_provider_spec.rb

@@ -0,0 +1,23 @@
+require "spec_helper"
+require "mvcli/plugins/providers/bundle_provider"
+require "bundler/ui"
+
+
+
+describe "Bundle Provider" do
+  # Given(:bundle) { MVCLI::BundleProvider.new }
+  # Given(:dir) { Pathname(__FILE__).dirname.join('tmp/plugins') }
+  # Given do
+  #   bundle.stub(:dir) { dir }
+  #   FileUtils.rm_rf dir.to_s
+  #   FileUtils.mkdir_p dir.to_s
+  # end
+  # describe "replacing a gem in the bundle" do
+  #   When { bundle.replace "trivium-timing", require: 'trivium-timing', path: File.expand_path('../../../../fixtures/plugins/timing-plugin', __FILE__) }
+  #   When { bundle.replace "ref" }
+  #   describe "activating the bundle" do
+  #     When { bundle.activate! }
+  #     Then { "it's in the classpath now" }
+  #   end
+  # end
+end

data/spec/mvcli/provisioning_spec.rb

@@ -3,54 +3,56 @@ require "mvcli/provisioning"
 
 describe "Provisioning" do
   use_natural_assertions
+
   describe "Scope" do
-    Given(:provisioner) {{}}
-    Given(:mod) {Module.new {include MVCLI::Provisioning}}
-    Given(:cls) {m = mod; Class.new {include m}}
-    Given(:obj) {cls.new}
-    Given(:command) {mock(:Command)}
-    Given(:scope) {MVCLI::Provisioning::Scope.new command, provisioner}
+    Given(:scope) { MVCLI::Provisioning::Scope.new options }
+    Given(:command) { double :Command }
+    Given(:cortex) { double :Cortex }
+    Given(:mod) { Module.new {include MVCLI::Provisioning} }
+    Given(:cls) { m = mod; Class.new {include m} }
+    Given(:obj) { cls.new }
+
     context "when the command is required" do
-      Given {mod.requires :command}
-      When(:result) {scope.evaluate {obj.command}}
-      Then {result == command}
+      Given { mod.requires :command }
+      Given(:options) { {command: command} }
+      When(:result) { scope.evaluate { obj.command } }
+      Then { result == command }
+    end
+    context "when the cortex is required" do
+      Given { mod.requires :cortex }
+      Given(:options) { {cortex: cortex} }
+      Then { scope.evaluate { obj.cortex } == cortex }
     end
     context "with a requirement is specified on the module" do
-      Given {mod.requires :foo}
-      context "when accessing it but it is not present" do
-        When(:result) {scope.evaluate {obj.foo}}
-        Then {result.should have_failed MVCLI::Provisioning::UnsatisfiedRequirement, /foo/}
+      Given(:options) { {cortex: cortex} }
+      Given { mod.requires :foo }
+      context "when reading it but it is not present" do
+        Given { cortex.stub(:read) { fail "no such provider" } }
+        When(:result) { scope.evaluate { obj.foo } }
+        Then { result.should have_failed StandardError, /no such/ }
+        And { cortex.should have_received(:read).with(:provider, :foo)}
+        context "but it is manually specified in an enclosing block" do
+          When(:result) { scope.evaluate(foo: 'bar') { obj.foo} }
+          Then { result == 'bar' }
+          context "and then not" do
+            When(:result) { scope.evaluate { obj.foo } }
+            Then { result.should have_failed }
+          end
+        end
       end
       context "and there is a scope which satisfies the requirement" do
-        Given(:foo) {Object.new}
-        Given {provisioner[:foo] = foo}
+        Given(:foo) { Object.new }
+        Given { cortex.stub(:read) { double(:Provider, value: foo)}}
 
-        context "when a dependency is accessed in the context of the scope" do
-          When(:result) {scope.evaluate {obj.foo}}
-          Then {result == foo}
+        context "when a dependency is read in the context of the scope" do
+          When(:result) { scope.evaluate { obj.foo } }
+          Then { result == foo }
         end
       end
       context "accessing requirements with no scope" do
-        When(:result) {obj.foo}
-        Then {result.should have_failed MVCLI::Provisioning::MissingScope}
+        When(:result) { obj.foo }
+        Then { result.should have_failed MVCLI::Provisioning::MissingScope }
       end
     end
   end
-
-  describe "Provisioner" do
-    Given do
-      ActiveSupport::Dependencies.clear
-      ActiveSupport::Dependencies.autoload_paths.clear
-      ActiveSupport::Dependencies.autoload_paths << File.expand_path('../dummy/app/providers', __FILE__)
-    end
-    Given(:provisioner) {MVCLI::Provisioning::Provisioner.new}
-    context "when no provider exists for a value" do
-      When(:result) {provisioner[:does_not_exist]}
-      Then {result.should have_failed}
-    end
-    context "when a provider exists" do
-      When(:result) {provisioner[:test]}
-      Then {result == "here is a free value just for you!!"}
-    end
-  end
 end

data/spec/mvcli/router_spec.rb

@@ -4,57 +4,51 @@ require "mvcli/router"
 describe "MVCLI::Router" do
   use_natural_assertions
 
-  Given(:Router) {MVCLI::Router}
-  Given(:actions) {mock(:Actions)}
-  Given(:router) {self.Router.new actions}
-  Given do
-    actions.stub(:[]) do |action|
-      @action = action
-      ->(command, bindings) {@command = command; @bindings = bindings}
-    end
-  end
+  Given(:Router) { MVCLI::Router}
+  Given(:routes) { self.Router::DSL.new }
+  Given(:router) { routes.router }
+  Given(:actions) { double(:Actions) }
+  Given { actions.stub(:new) { |match, mapping| Map match: match, mapping: mapping } }
+  Given { router.stub(:actions) { actions } }
 
   def invoke(route = '')
-    router.call mock(:Command, :argv => route.split(/\s+/))
+    router.call double(:Command, :argv => route.split(/\s+/))
   end
 
   context "without any routes" do
-    When(:result) {invoke}
-    Then {result.should have_failed self.Router::RoutingError}
+    When(:result) { invoke }
+    Then { result.should have_failed self.Router::RoutingError }
   end
 
   context "with a route matched to an action" do
-    Given {router.match 'login' => 'logins#create'}
-    When {invoke 'login'}
-    Then { @action == 'logins#create' }
-    And { not @command.nil? }
-    Then { @command.argv == ['login'] }
+    Given { routes.match 'login' => 'logins#create' }
+    When(:action) { invoke 'login' }
+    Then { action.mapping == 'logins#create' }
   end
 
   context "when there are command line options, it does not interfere" do
-    Given { router.match 'login' => 'logins#create' }
-    When { invoke 'login --then --go-away -f 6 -p' }
-    Then { not @command.nil? }
+    Given { routes.match 'login' => 'logins#create' }
+    When(:action) { invoke 'login --then --go-away -f 6 -p' }
+    Then { action.mapping == 'logins#create' }
   end
 
   context "with a route matched to a block" do
-    Given { router.match bam: ->(command) {@command = command} }
-    When { invoke 'bam' }
-    Then { @command.argv == ['bam'] }
+    Given { routes.match bam: ->(command) { command } }
+    When(:action) { invoke 'bam' }
+    Then { action.mapping.call('foo') == 'foo' }
   end
 
   context "with a route with captures" do
-    Given { router.match 'show loadbalancer :id' => 'loadbalancers#show' }
-    When { invoke 'show loadbalancer 6' }
-    Then {@action == 'loadbalancers#show'}
-    And { @command.argv == ['show', 'loadbalancer', '6'] }
-    And { @bindings[:id] == '6' }
+    Given { routes.match 'show loadbalancer :id' => 'loadbalancers#show' }
+    When(:action) { invoke 'show loadbalancer 6' }
+    Then { action.mapping == 'loadbalancers#show'}
+    Then { action.match.bindings[:id] == '6' }
   end
 
   context "with macros" do
-    Given { router.macro /(-h|--help) (.*)/ => "help \\2" }
-    Given { router.match "help me" => "help#me"}
-    When { invoke "--help me" }
-    Then { @action == 'help#me' }
+    Given { routes.macro /(-h|--help) (.*)/ => "help \\2" }
+    Given { routes.match "help me" => "help#me"}
+    When(:action) { invoke "--help me" }
+    Then { action.mapping == 'help#me' }
   end
 end

data/spec/mvcli/std/extensions/erb_extension_spec.rb

@@ -0,0 +1,34 @@
+require "spec_helper"
+require "mvcli/std/extensions/erb_extension"
+
+describe "The ERB Extension" do
+  Given(:extension) { MVCLI::ERBExtension.new }
+  Given(:name) { 'foo/bar' }
+
+  describe "to_path" do
+    When(:path) { extension.to_path name, extension_type }
+    context "when the extension_type is a string" do
+      Given(:extension_type) { "template" }
+      Then { path == "templates/foo/bar.txt.erb" }
+    end
+    context "when the extension_type is a symbol" do
+      Given(:extension_type) { :template }
+      Then { path == "templates/foo/bar.txt.erb" }
+    end
+    context "when the extension_type is not 'template'" do
+      Given(:extension_type) { :not_a_template }
+      Then { path.should have_failed ArgumentError }
+    end
+  end
+  describe "define" do
+    Given(:extension_type) { :template }
+    Given(:namespace) { Object }
+    When(:template) { extension.define(name, bytes, extension_type, namespace) }
+    context "with a valid ERB template" do
+      Given(:bytes) { "Hello <%= this.name %>" }
+      Given(:output) { StringIO.new }
+      When { template.call Map(name: 'Bob'), output }
+      Then { output.string == 'Hello Bob' }
+    end
+  end
+end

data/spec/mvcli/std/providers/middleware_provider_spec.rb

@@ -0,0 +1,10 @@
+require "spec_helper"
+require "mvcli/std/providers/middleware_provider"
+
+describe "building middleware" do
+  use_natural_assertions
+
+  When(:middleware) { MVCLI::MiddlewareProvider.new.value }
+  Then { middleware.should_not have_failed }
+  And { middleware.length == 2}
+end

data/spec/mvcli/validatable_spec.rb

@@ -3,27 +3,27 @@ require "mvcli/validatable"
 
 describe "a validator" do
   use_natural_assertions
-  Given(:object) {Object.new}
-  Given(:validator) {MVCLI::Validatable::Validator.new}
+  Given(:object) { Object.new }
+  Given(:validator) { MVCLI::Validatable::Validator.new }
   Given(:validation) { validator.validate object }
   Given(:violations) { validation.violations }
 
   context "when it validates a field that does not exist on the object" do
-    Given {validator.validates(:does_not_exist, "invalid") {}}
-    When(:validation) {validator.validate object}
-    Then {not validation.errors[:does_not_exist].empty?}
-    Then {not validation.valid?}
+    Given { validator.validates(:does_not_exist, "invalid") {} }
+    When(:validation) { validator.validate object }
+    Then { not validation.errors[:does_not_exist].empty? }
+    Then { not validation.valid? }
   end
   describe "validating a child" do
-    Given {validator.validates_child(:some_child)}
+    Given { validator.validates_child(:some_child) }
     context "when it is nil" do
-      When(:validation) {validator.validate(mock(:Object, :some_child => nil))}
-      Then {validation.valid?}
+      When(:validation) { validator.validate(double(:Object, :some_child => nil)) }
+      Then { validation.valid? }
     end
     context "when it does not exist" do
-      When(:validation) {validator.validate(Object.new)}
-      Then {not validation.errors[:some_child].nil?}
-      And {not validation.valid?}
+      When(:validation) { validator.validate(Object.new) }
+      Then { not validation.errors[:some_child].nil? }
+      And { not validation.valid? }
     end
   end