manifests-vmc-plugin 0.5.0 → 0.6.0

data/lib/manifests-vmc-plugin/loader/normalizer.rb

@@ -10,7 +10,7 @@ module VMCManifests
 
       default_paths_to_keys!(apps)
 
-      apps = convert_from_array(apps) 
+      apps = convert_to_array(apps)
 
       merge_toplevel!(toplevel, manifest, apps)
       normalize_apps!(apps)
@@ -28,20 +28,43 @@ module VMCManifests
     private
 
     def normalize_paths!(apps)
-      apps.each do |_, app|
+      apps.each do |app|
         app["path"] = from_manifest(app["path"])
       end
     end
 
-    def convert_from_array(apps)
-      return apps unless apps.is_a?(Array)
+    def convert_to_array(apps)
+      return apps if apps.is_a?(Array)
 
-      apps_hash = {}
-      apps.each.with_index do |a, i|
-        apps_hash[i.to_s] = a
+      ordered_by_deps(apps)
+    end
+
+    # sort applications in dependency order
+    # e.g. if A depends on B, B will be listed before A
+    def ordered_by_deps(apps, processed = Set[])
+      ordered = []
+      apps.each do |tag, info|
+        next if processed.include?(tag)
+
+        if deps = Array(info["depends-on"])
+          dep_apps = {}
+          deps.each do |dep|
+            dep_apps[dep] = apps[dep]
+          end
+
+          processed.add(tag)
+
+          ordered += ordered_by_deps(dep_apps, processed)
+          ordered << info
+        else
+          ordered << info
+          processed.add(tag)
+        end
       end
 
-      apps_hash
+      ordered.each { |app| app.delete("depends-on") }
+
+      ordered
     end
 
     def default_paths_to_keys!(apps)
@@ -53,7 +76,7 @@ module VMCManifests
     end
 
     def normalize_apps!(apps)
-      apps.each_value do |app|
+      apps.each do |app|
         normalize_app!(app)
       end
     end
@@ -61,8 +84,8 @@ module VMCManifests
     def merge_toplevel!(toplevel, manifest, apps)
       return if toplevel.empty?
 
-      apps.each do |t, a|
-        apps[t] = toplevel.merge(a)
+      apps.collect! do |a|
+        toplevel.merge(a)
       end
 
       toplevel.each do |k, _|

data/lib/manifests-vmc-plugin/plugin.rb

@@ -4,55 +4,63 @@ require "vmc/plugin"
 require "manifests-vmc-plugin"
 
 
-class Manifests < VMC::App::Base
+class ManifestsPlugin < VMC::App::Base
   include VMCManifests
+  include VMC::App::Sync
 
   option :manifest, :aliases => "-m", :value => :file,
     :desc => "Path to manifest file to use"
 
 
+  def wrap_with_optional_name(name_made_optional, cmd, input)
+    return cmd.call if input[:all]
+
+    unless manifest
+      # if the command knows how to handle this
+      if input.has?(:app) || !name_made_optional
+        return cmd.call
+      else
+        return no_apps
+      end
+    end
+
+    internal, external = apps_in_manifest(input)
+
+    return cmd.call if internal.empty? && !external.empty?
+
+    show_manifest_usage
+
+    apps = internal + external
+
+    if apps.empty?
+      apps = current_apps if apps.empty?
+      apps = all_apps if apps.empty?
+      apps = apps.collect { |app| app[:name] }
+    end
+
+    return no_apps if apps.empty?
+
+    apps.each.with_index do |app, num|
+      line unless quiet? || num == 0
+      cmd.call(input.without(:apps).merge_given(:app => app))
+    end
+  end
+
   # basic commands that, when given no name, act on the
   # app(s) described by the manifest, in dependency-order
   [ :start, :restart, :instances, :logs, :env,
     :health, :stats, :scale, :app
   ].each do |wrap|
-    optional_name = change_argument(wrap, :app, :optional)
+    name_made_optional = change_argument(wrap, :app, :optional)
 
     around(wrap) do |cmd, input|
-      next cmd.call if input[:all]
-
-      unless manifest
-        if optional_name && !input.has?(:app)
-          no_apps
-        else
-          next cmd.call
-        end
-      end
-
-      show_manifest_usage
-
-      num = 0
-      rest =
-        specific_apps_or_all(input) do |info|
-          puts "" unless quiet? || num == 0
-          cmd.call(input.without(:apps).merge_given(:app => info[:name]))
-          num += 1
-        end
-
-      if rest
-        rest.each do |name|
-          cmd.call(input.without(:apps).merge(:app => name))
-        end
-
-      # fail manually for commands whose name we made optional
-      elsif optional_name
-        no_apps
-      end
+      wrap_with_optional_name(name_made_optional, cmd, input)
     end
   end
 
 
   # same as above but in reverse dependency-order
+  # TODO: do we care about this?
   [:stop, :delete].each do |wrap|
     around(wrap) do |cmd, input|
       next cmd.call if input[:all] || !manifest
@@ -76,6 +84,10 @@ class Manifests < VMC::App::Base
   end
 
 
+  def wrap_push(cmd, input)
+
+  end
+
   # push and sync meta changes in the manifest
   # also sets env data on creation if present in manifest
   #
@@ -127,10 +139,13 @@ class Manifests < VMC::App::Base
                 a
               }
             }) do
+          existing_app = client.app_by_name(app[:name])
+
           # only set inputs if creating app or updating with --reset
-          if input[:reset] || !client.app_by_name(app[:name])
+          if input[:reset] || !existing_app
             app_input = input.rebase_given(app)
           else
+            # assign manifest values to detect differences
             app_input = input.merge(:path => from_manifest(app[:path]))
           end
 

data/lib/manifests-vmc-plugin/version.rb

@@ -1,3 +1,3 @@
 module VMCManifests
-  VERSION = "0.5.0".freeze
+  VERSION = "0.6.0".freeze
 end

data/lib/manifests-vmc-plugin.rb

@@ -71,19 +71,10 @@ module VMCManifests
     end
   end
 
-  # find an app by its unique tag
-  def app_by_tag(tag)
-    manifest[:applications][tag]
-  end
-
   # find apps by an identifier, which may be either a tag, a name, or a path
   def find_apps(identifier)
     return [] unless manifest
 
-    if app = app_by_tag(identifier)
-      return [app]
-    end
-
     apps = apps_by(:name, identifier)
 
     if apps.empty?
@@ -93,78 +84,58 @@ module VMCManifests
     apps
   end
 
-  # call a block for each app in a manifest (in dependency order), setting
-  # inputs for each app
-  def each_app(&blk)
-    return unless manifest
-
-    ordered_by_deps(manifest[:applications]).each(&blk)
-  end
-
-  # return all the apps described by the manifest, in dependency order
+  # return all the apps described by the manifest
   def all_apps
-    apps = []
+    manifest[:applications]
+  end
 
-    each_app do |app|
-      apps << app
+  def current_apps
+    manifest[:applications].select do |app|
+      next unless app[:path]
+      from_manifest(app[:path]) == Dir.pwd
     end
-
-    apps
   end
 
-  # like each_app, but only acts on apps specified as paths instead of names
-  #
-  # returns the names that were not paths
-  def specific_apps_or_all(input = nil, use_name = true, &blk)
+  # splits the user's input, resolving paths with the manifest,
+  # into internal/external apps
+  def apps_in_manifest(input = nil, use_name = true, &blk)
     names_or_paths =
       if input.has?(:apps)
         # names may be given but be [], which will still cause
         # interaction, so use #direct instead of #[] here
         input.direct(:apps)
       elsif input.has?(:app)
-        [input[:app]]
+        [input.direct(:app)]
       else
         []
       end
 
-    input = input.without(:app, :apps)
-    in_manifest = []
-
-    if names_or_paths.empty?
-      apps = find_apps(Dir.pwd)
-
-      if !apps.empty?
-        in_manifest += apps
-      else
-        each_app(&blk)
-        return []
-      end
-    end
-
+    internal = []
     external = []
+
     names_or_paths.each do |x|
       if x.is_a?(String)
-        path = File.expand_path(x)
+        if x =~ %r([/\\])
+          apps = find_apps(File.expand_path(x))
 
-        apps = find_apps(File.exists?(path) ? path : x)
+          if apps.empty?
+            fail("Path #{b(x)} is not present in manifest #{b(relative_manifest_file)}.")
+          end
+        else
+          apps = find_apps(x)
+        end
 
         if !apps.empty?
-          in_manifest += apps
-        elsif app = client.app_by_name(x)
-          external << app
+          internal += apps.collect { |app| app[:name] }
         else
-          fail("Unknown app '#{x}'")
+          external << x
         end
       else
         external << x
       end
     end
 
-    in_manifest.each do |app|
-      blk.call app
-    end
-
-    external
+    [internal, external]
   end
 
   def create_manifest_for(app, path)
@@ -213,10 +184,14 @@ module VMCManifests
 
   private
 
+  def relative_manifest_file
+    Pathname.new(manifest_file).relative_path_from(Pathname.pwd)
+  end
+
   def show_manifest_usage
     return if @@showed_manifest_usage
 
-    path = Pathname.new(manifest_file).relative_path_from(Pathname.pwd)
+    path = relative_manifest_file
     line "Using manifest file #{c(path, :name)}"
     line
 
@@ -228,14 +203,9 @@ module VMCManifests
   end
 
   def apps_by(attr, val)
-    found = []
-    manifest[:applications].each do |tag, info|
-      if info[attr] == val
-        found << info
-      end
+    manifest[:applications].select do |info|
+      info[attr] == val
     end
-
-    found
   end
 
   # expand a path relative to the manifest file's directory
@@ -243,33 +213,6 @@ module VMCManifests
     File.expand_path(path, File.dirname(manifest_file))
   end
 
-  # sort applications in dependency order
-  # e.g. if A depends on B, B will be listed before A
-  def ordered_by_deps(apps, processed = Set[])
-    ordered = []
-    apps.each do |tag, info|
-      next if processed.include?(tag)
-
-      if deps = Array(info[:"depends-on"])
-        dep_apps = {}
-        deps.each do |dep|
-          dep = dep.to_sym
-          fail "Circular dependency detected." if processed.include? dep
-          dep_apps[dep] = apps[dep]
-        end
-
-        processed.add(tag)
-
-        ordered += ordered_by_deps(dep_apps, processed)
-        ordered << info
-      else
-        ordered << info
-        processed.add(tag)
-      end
-    end
-
-    ordered
-  end
 
   def ask_to_save(input, app)
     return if manifest_file
@@ -344,6 +287,8 @@ module VMCManifests
     end
 
     to_bind.each do |s|
+      next if app.binds?(s)
+
       # TODO: splat
       invoke :bind_service, :app => app, :service => s
     end

data/spec/{loader → manifests-vmc-plugin/loader}/normalizer_spec.rb

@@ -18,7 +18,7 @@ describe VMCManifests::Normalizer do
 
       it "sets the path to their tag, assuming it's a path" do
         expect(subject).to eq(
-          :applications => { :"." => { :name => "foo", :path => "." } })
+          :applications => [{ :name => "foo", :path => "." }])
       end
     end
 
@@ -27,9 +27,7 @@ describe VMCManifests::Normalizer do
 
       it "sets it to none" do
         expect(subject).to eq(
-          :applications => {
-            :"." => { :path => ".", :url => "none" }
-          })
+          :applications => [{ :path => ".", :url => "none" }])
       end
     end
 
@@ -41,7 +39,7 @@ describe VMCManifests::Normalizer do
 
         it 'keeps the properties at the toplevel' do
           expect(subject).to eq(
-            :applications => { :"0" => { :name => "foo", :path => "." } },
+            :applications => [{ :name => "foo", :path => "." }],
             :properties => { :fizz => "buzz" })
         end
       end
@@ -52,7 +50,7 @@ describe VMCManifests::Normalizer do
 
           it 'adds it as an application with path .' do
             expect(subject).to eq(
-              :applications => { :"0" => { :name => "foo", :path => "." } })
+              :applications => [{ :name => "foo", :path => "." }])
           end
         end
 
@@ -61,9 +59,7 @@ describe VMCManifests::Normalizer do
 
           it 'adds it as an application with the proper tag and path' do
             expect(subject).to eq(
-              :applications => {
-                :"0" => { :name => "foo", :path => "./foo" }
-              })
+              :applications => [{ :name => "foo", :path => "./foo" }])
           end
         end
       end
@@ -80,27 +76,50 @@ describe VMCManifests::Normalizer do
         }
 
         it "merges the toplevel attributes into the applications" do
-          expect(subject).to eq(
-            :applications => {
-              :"./foo" =>
-                { :name => "foo", :path => "./foo", :runtime => "ruby19" },
-
-              :"./bar" =>
-                { :name => "bar", :path => "./bar", :runtime => "ruby19" },
-
-              :"./baz" =>
-                { :name => "baz", :path => "./baz", :runtime => "ruby18" }
-            })
+          expect(subject[:applications]).to match_array [
+            { :name => "foo", :path => "./foo", :runtime => "ruby19" },
+            { :name => "bar", :path => "./bar", :runtime => "ruby19" },
+            { :name => "baz", :path => "./baz", :runtime => "ruby18" }
+          ]
         end
       end
     end
 
-    context 'with a manifest where applications is an array' do
-      let(:manifest) { { "applications" => [{ "name" => "foo" }] } }
+    context 'with a manifest where applications is a hash' do
+      let(:manifest) { { "applications" => { "foo" => { "name" => "foo" } } } }
 
-      it 'converts the array to a hash, with the path as .' do
+      it 'converts the array to a hash, with the path as the key' do
         expect(subject).to eq(
-          :applications => { :"0" => { :name => "foo", :path => "." } })
+          :applications => [{ :name => "foo", :path => "foo" }])
+      end
+
+      context "and the applications had dependencies" do
+        let(:manifest) do
+          { "applications" => {
+              "bar" => { "name" => "bar", "depends-on" => "foo" },
+              "foo" => { "name" => "foo" }
+            }
+          }
+        end
+
+        it "converts using dependency order" do
+          expect(subject).to eq(
+            :applications => [{ :name => "foo", :path => "foo" }, { :name => "bar", :path => "bar" }])
+        end
+
+        context "and there's a circular dependency" do
+          let(:manifest) do
+            { "applications" => {
+               "bar" => { "name" => "bar", "depends-on" => "foo" },
+               "foo" => { "name" => "foo", "depends-on" => "bar" }
+              }
+            }
+          end
+
+          it "doesn't blow up" do
+            expect(subject).to be_true
+          end
+        end
       end
     end
   end

data/spec/manifests-vmc-plugin/loader/plugin_spec.rb

@@ -0,0 +1,182 @@
+require "spec_helper"
+
+require "manifests-vmc-plugin/plugin"
+
+
+describe ManifestsPlugin do
+  let(:manifest) { {} }
+  let(:manifest_file) { nil }
+  let(:inputs_hash) { {} }
+  let(:given_hash) { {} }
+  let(:global_hash) { { :quiet => true } }
+  let(:inputs) { Mothership::Inputs.new(nil, nil, inputs_hash, given_hash, global_hash) }
+  let(:plugin) { ManifestsPlugin.new(nil, inputs) }
+
+  before do
+    stub(plugin).manifest { manifest }
+    stub(plugin).manifest_file { manifest_file } if manifest_file
+  end
+
+  describe "#wrap_with_optional_name" do
+    let(:name_made_optional) { true }
+    let(:command) { mock! }
+
+    subject { plugin.wrap_with_optional_name(name_made_optional, command, inputs) }
+
+    context "when --all is given" do
+      let(:inputs_hash) { { :all => true } }
+
+      it "skips all manifest-related logic, and invokes the command" do
+        mock(command).call
+        dont_allow(plugin).show_manifest_usage
+        subject
+      end
+    end
+
+    context "when there is no manifest" do
+      let(:manifest) { nil }
+
+      context "and an app is given" do
+        let(:given_hash) { { :app => "foo" } }
+
+        it "passes through to the command" do
+          mock(command).call
+          dont_allow(plugin).show_manifest_usage
+          subject
+        end
+      end
+
+      context "and an app is NOT given" do
+        let(:inputs_hash) { {} }
+
+        context "and we made it optional" do
+          it "fails manually" do
+            mock(plugin).no_apps
+            subject
+          end
+        end
+
+        context "and we did NOT make it optional" do
+          let(:name_made_optional) { false }
+
+          it "passes through to the command" do
+            mock(command).call
+            dont_allow(plugin).show_manifest_usage
+            subject
+          end
+        end
+      end
+    end
+
+    context "when there is a manifest" do
+      let(:manifest_file) { "/abc/manifest.yml" }
+
+      before do
+        stub(plugin).show_manifest_usage
+      end
+
+      context "when no apps are given" do
+        context "and the user's working directory matches a particular app in the manifest" do
+          let(:manifest) { { :applications => [{ :name => "foo", :path => "/abc/foo" }] } }
+
+          it "calls the command for only that app" do
+            mock(command).call(anything) do |inputs|
+              expect(inputs.given[:app]).to eq "foo"
+            end
+
+            stub(Dir).pwd { "/abc/foo" }
+
+            subject
+          end
+        end
+
+        context "and the user's working directory isn't in the manifest" do
+          let(:manifest) { { :applications => [{ :name => "foo" }, { :name => "bar" }] } }
+
+          it "calls the command for all apps in the manifest" do
+            uncalled_apps = ["foo", "bar"]
+            mock(command).call(anything).twice do |inputs|
+              uncalled_apps.delete inputs.given[:app]
+            end
+
+            subject
+
+            expect(uncalled_apps).to be_empty
+          end
+        end
+      end
+
+      context "when any of the given apps are not in the manifest" do
+        let(:manifest) { { :applications => [{ :name => "a" }, { :name => "b" }] } }
+
+        context "and --apps is given" do
+          let(:given_hash) { { :apps => ["x", "a"] } }
+
+          it "passes through to the original command" do
+            mock(plugin).show_manifest_usage
+
+            uncalled_apps = ["a", "x"]
+            mock(command).call(anything).twice do |inputs|
+              uncalled_apps.delete inputs.given[:app]
+            end
+
+            subject
+
+            expect(uncalled_apps).to be_empty
+            subject
+          end
+        end
+      end
+
+      context "when none of the given apps are in the manifest" do
+        let(:manifest) { { :applications => [{ :name => "a" }, { :name => "b" }] } }
+
+        context "and --apps is given" do
+          let(:given_hash) { { :apps => ["x", "y"] } }
+
+          it "passes through to the original command" do
+            dont_allow(plugin).show_manifest_usage
+            mock(command).call
+            subject
+          end
+        end
+      end
+
+      context "when an app name that's in the manifest is given" do
+        let(:manifest) { { :applications => [{ :name => "foo" }] } }
+        let(:given_hash) { { :app => "foo" } }
+
+        it "calls the command with that app" do
+          mock(command).call(anything) do |inputs|
+            expect(inputs.given[:app]).to eq "foo"
+          end
+
+          subject
+        end
+      end
+
+      context "when a path to an app that's in the manifest is given" do
+        let(:manifest) { { :applications => [{ :name => "foo", :path => "/abc/foo" }] } }
+        let(:given_hash) { { :app => "/abc/foo" } }
+
+        it "calls the command with that app" do
+          mock(command).call(anything) do |inputs|
+            expect(inputs.given[:app]).to eq "foo"
+          end
+
+          subject
+        end
+      end
+    end
+  end
+
+  describe "#wrap_push" do
+    context "with a manifest" do
+
+    end
+
+    context "without a manifest" do
+      
+    end
+  end
+end

data/spec/manifests-vmc-plugin_spec.rb

@@ -1,20 +1,39 @@
 require 'spec_helper'
 require 'manifests-vmc-plugin'
 
-require 'cfoundry/test_support'
-
 describe VMCManifests do
+  let(:inputs_hash) { {} }
+  let(:given_hash) { {} }
+  let(:global_hash) { {} }
+  let(:inputs) { Mothership::Inputs.new(nil, nil, inputs_hash, given_hash, global_hash) }
+
   let(:cmd) do
-    manifest = VMC::App::Push.new
+    manifest = VMC::App::Push.new(nil, inputs)
     manifest.extend VMCManifests
+    stub(manifest).client { client }
     manifest
   end
 
   let(:target_base) { "some-cloud.com" }
 
+  let(:foo) { fake(:app, :name => "foo") }
+  let(:bar) { fake(:app, :name => "bar") }
+  let(:baz) { fake(:app, :name => "baz") }
+  let(:xxx) { fake(:app, :name => "xxx") }
+  let(:yyy) { fake(:app, :name => "yyy") }
+
+  let(:client) do
+    fake_client :apps => [foo, bar, baz, xxx, yyy]
+  end
+
+  let(:manifest_file) { "/abc/manifest.yml" }
+
   before do
     stub(cmd).target_base { target_base }
     stub(cmd).v2? { true }
+
+    stub(cmd).manifest { manifest }
+    stub(cmd).manifest_file { manifest_file }
   end
 
   describe '#find_apps' do
@@ -32,7 +51,7 @@ describe VMCManifests do
         :framework => fake(:framework),
         :runtime => fake(:runtime),
         :memory => 2048,
-        :instances => 2,
+        :total_instances => 2,
         :command => "ruby main.rb",
         :routes => [
           fake(:route,
@@ -66,10 +85,9 @@ describe VMCManifests do
     its(["command"]) { should eq "ruby main.rb" }
 
     it "contains the service information" do
-      manifest = subject
-      expect(manifest["services"]).to be_a Hash
+      expect(subject["services"]).to be_a Hash
 
-      services = manifest["services"]
+      services = subject["services"]
       app.service_bindings.each do |b|
         service = b.service_instance
 
@@ -97,7 +115,7 @@ describe VMCManifests do
           :framework => fake(:framework),
           :runtime => fake(:runtime),
           :memory => 2048,
-          :instances => 2
+          :total_instances => 2
       }
 
       its(["url"]) { should eq "none" }
@@ -109,7 +127,7 @@ describe VMCManifests do
           :framework => fake(:framework),
           :runtime => fake(:runtime),
           :memory => 2048,
-          :instances => 2
+          :total_instances => 2
       }
 
       it { should_not include "command" }
@@ -121,10 +139,183 @@ describe VMCManifests do
           :framework => fake(:framework),
           :runtime => fake(:runtime),
           :memory => 2048,
-          :instances => 2
+          :total_instances => 2
       }
 
       it { should_not include "services" }
     end
   end
+
+  describe "#setup_services" do
+    let(:service_bindings) { [] }
+    let(:app) { fake :app, :service_bindings => service_bindings }
+
+    before do
+      dont_allow_ask(anything, anything)
+    end
+
+    context "when services are defined in the manifest" do
+      let(:info) {
+        { :services => { "service-1" => { :label => "mysql", :plan => "100" } } }
+      }
+
+      let(:service_1) { fake(:service_instance, :name => "service-1") }
+
+      let(:plan_100) { fake :service_plan, :name => "100" }
+
+      let(:mysql) {
+        fake(
+          :service,
+          :label => "mysql",
+          :provider => "core",
+          :service_plans => [plan_100])
+      }
+
+      let(:service_instances) { [] }
+
+      let(:client) {
+        fake_client :services => [mysql], :service_instances => service_instances
+      }
+
+      context "and the services exist" do
+        let(:service_instances) { [service_1] }
+
+        context "and are already bound" do
+          let(:service_bindings) { [fake(:service_binding, :service_instance => service_1)] }
+
+          it "does neither create nor bind the service again" do
+            dont_allow(cmd).invoke :create_service, anything
+            dont_allow(cmd).invoke :bind_service, anything
+            cmd.send(:setup_services, app, info)
+          end
+        end
+
+        context "but are not bound" do
+          it "does not create the services" do
+            dont_allow(cmd).invoke :create_service, anything
+            stub(cmd).invoke :bind_service, anything
+            cmd.send(:setup_services, app, info)
+          end
+
+          it "binds the service" do
+            mock(cmd).invoke :bind_service, :app => app, :service => service_1
+            cmd.send(:setup_services, app, info)
+          end
+        end
+      end
+
+      context "and the services do not exist" do
+        it "creates the services" do
+          mock(cmd).invoke :create_service, :app => app,
+            :name => service_1.name, :offering => mysql, :plan => plan_100
+          dont_allow(cmd).invoke :bind_service, anything
+          cmd.send(:setup_services, app, info)
+        end
+      end
+    end
+
+    context "when there are no services defined" do
+      let(:info) { {} }
+
+      it "does not ask anything" do
+        cmd.send(:setup_services, app, info)
+      end
+    end
+  end
+
+  describe "#apps_in_manifest" do
+    let(:manifest) do
+      {:applications => [
+        {:name => "foo", :path => "/abc/foo"},
+        {:name => "bar", :path => "/abc/bar"},
+        {:name => "baz", :path => "/abc/baz"}
+      ]}
+    end
+
+    subject { cmd.apps_in_manifest(inputs) }
+
+    context "when no apps are passed" do
+      let(:given_hash) { {} }
+
+      its(:first) { should eq [] }
+      its(:last) { should eq [] }
+    end
+
+    context "when app names are passed" do
+      context "and all of them are in the manifest" do
+        let(:given_hash) { { :apps => ["foo", "bar"] } }
+
+        its(:first) { should eq ["foo", "bar"] }
+        its(:last) { should eq [] }
+      end
+
+      context "and one of them is in the manifest" do
+        let(:given_hash) { { :apps => ["foo", "xxx"] } }
+
+        its(:first) { should eq ["foo"] }
+        its(:last) { should eq ["xxx"] }
+      end
+
+      context "and none of them are in the manifest" do
+        let(:given_hash) { { :apps => ["xxx", "yyy"] } }
+
+        its(:first) { should eq [] }
+        its(:last) { should eq ["xxx", "yyy"] }
+      end
+    end
+
+    context "when apps are passed as paths" do
+      context "and the paths are in the manifest" do
+        let(:given_hash) { { :apps => ["/abc/foo"] } }
+
+        its(:first) { should eq ["foo"] }
+        its(:last) { should eq [] }
+      end
+
+      context "and any path is not in the manifest" do
+        let(:given_hash) { { :apps => ["/abc/xxx"] } }
+
+        it "fails with a manifest-specific method (i.e. path not in manifest)" do
+          expect { subject }.to raise_error(VMC::UserError, /Path .+ is not present in manifest/)
+        end
+      end
+    end
+  end
+
+  describe "#all_apps" do
+    let(:applications) do
+      [
+        {:name => "foo", :path => "/abc"},
+        {:name => "bar", :path => "/abc"},
+        {:name => "baz", :path => "/abc/baz"}
+      ]
+    end
+
+    let(:manifest) do
+      { :applications => applications }
+    end
+
+    subject { cmd.all_apps }
+
+    it "returns all of the apps described in the manifest, as hashes" do
+      expect(subject).to eq applications
+    end
+  end
+
+  describe "#current_apps" do
+    let(:manifest) do
+      {:applications => [
+        {:name => "foo", :path => "/abc"},
+        {:name => "bar", :path => "/abc"},
+        {:name => "baz", :path => "/abc/baz"}
+      ]}
+    end
+
+    subject { cmd.current_apps }
+
+    it "returns the applications with the cwd as their path" do
+      stub(Dir).pwd { "/abc" }
+      expect(subject).to eq [{ :name => "foo", :path => "/abc"}, { :name => "bar", :path => "/abc" }]
+    end
+  end
 end

data/spec/spec_helper.rb

@@ -1,3 +1,16 @@
-require "cfoundry"
+SPEC_ROOT = File.dirname(__FILE__).freeze
+
+require "rspec"
 require "vmc"
-require "vmc/spec_helper"
+require "cfoundry"
+require "webmock"
+require "cfoundry/test_support"
+require "vmc/test_support"
+
+WebMock.disable_net_connect!
+
+RSpec.configure do |c|
+  c.include Fake::FakeMethods
+  c.include VMC::TestSupport::InteractHelper
+  c.mock_with :rr
+end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: manifests-vmc-plugin
 version: !ruby/object:Gem::Version 
-  hash: 11
+  hash: 7
   prerelease: 
   segments: 
   - 0
-  - 5
+  - 6
   - 0
-  version: 0.5.0
+  version: 0.6.0
 platform: ruby
 authors: 
 - Alex Suraci
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2013-01-15 00:00:00 Z
+date: 2013-02-06 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: cfoundry
@@ -25,12 +25,12 @@ dependencies:
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
-        hash: 15
+        hash: 11
         segments: 
         - 0
-        - 4
+        - 5
         - 0
-        version: 0.4.0
+        version: 0.5.0
   type: :runtime
   version_requirements: *id001
 - !ruby/object:Gem::Dependency 
@@ -112,7 +112,8 @@ files:
 - lib/manifests-vmc-plugin/plugin.rb
 - lib/manifests-vmc-plugin/version.rb
 - lib/manifests-vmc-plugin.rb
-- spec/loader/normalizer_spec.rb
+- spec/manifests-vmc-plugin/loader/normalizer_spec.rb
+- spec/manifests-vmc-plugin/loader/plugin_spec.rb
 - spec/manifests-vmc-plugin_spec.rb
 - spec/spec_helper.rb
 homepage: http://cloudfoundry.com/
@@ -149,6 +150,7 @@ signing_key:
 specification_version: 3
 summary: Cloud Foundry automation via manifest documents.
 test_files: 
-- spec/loader/normalizer_spec.rb
+- spec/manifests-vmc-plugin/loader/normalizer_spec.rb
+- spec/manifests-vmc-plugin/loader/plugin_spec.rb
 - spec/manifests-vmc-plugin_spec.rb
 - spec/spec_helper.rb