cf 0.6.1.rc9 → 0.6.1.rc10

data/spec/manifests/manifests_spec.rb

@@ -0,0 +1,309 @@
+require 'spec_helper'
+
+describe CFManifests 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 = CF::App::Push.new(nil, inputs)
+    manifest.extend CFManifests
+    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).manifest { manifest }
+    stub(cmd).manifest_file { manifest_file }
+  end
+
+  describe '#find_apps' do
+    subject { cmd.find_apps(nil) }
+
+    context 'when there is no manifest file' do
+      before { stub(cmd).manifest { nil } }
+      it { should eq [] }
+    end
+  end
+
+  describe '#create_manifest_for' do
+    let(:app) {
+      fake :app,
+        :memory => 2048,
+        :total_instances => 2,
+        :command => "ruby main.rb",
+        :buildpack => "git://example.com/foo.git",
+        :routes => [
+          fake(:route,
+               :host => "some-app-name",
+               :domain => fake(:domain, :name => target_base))
+        ],
+        :service_bindings => [
+          fake(
+            :service_binding,
+            :service_instance =>
+              fake(
+                :service_instance,
+                :name => "service-1",
+                :service_plan =>
+                  fake(
+                    :service_plan,
+                    :name => "P200",
+                    :service => fake(:service))))
+        ]
+    }
+
+    subject { cmd.create_manifest_for(app, "some-path") }
+
+    its(["name"]) { should eq app.name }
+    its(["memory"]) { should eq "2G" }
+    its(["instances"]) { should eq 2 }
+    its(["path"]) { should eq "some-path" }
+    its(["url"]) { should eq "some-app-name.${target-base}" }
+    its(["command"]) { should eq "ruby main.rb" }
+    its(["buildpack"]) { should eq "git://example.com/foo.git" }
+
+    it "contains the service information" do
+      expect(subject["services"]).to be_a Hash
+
+      services = subject["services"]
+      app.service_bindings.each do |b|
+        service = b.service_instance
+
+        expect(services).to include service.name
+
+        info = services[service.name]
+
+        plan = service.service_plan
+        offering = plan.service
+
+        { "plan" => plan.name,
+          "label" => offering.label,
+          "provider" => offering.provider,
+          "version" => offering.version
+        }.each do |attr, val|
+          expect(info).to include attr
+          expect(info[attr]).to eq val
+        end
+      end
+    end
+
+    context 'when there is no url' do
+      let(:app) {
+        fake :app,
+          :memory => 2048,
+          :total_instances => 2
+      }
+
+      its(["url"]) { should eq "none" }
+    end
+
+    context 'when there is no command' do
+      let(:app) {
+        fake :app,
+          :memory => 2048,
+          :total_instances => 2
+      }
+
+      it { should_not include "command" }
+    end
+
+    context 'when there are no service bindings' do
+      let(:app) {
+        fake :app,
+          :memory => 2048,
+          :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(:foo_hash) { { :name => "foo", :path => "/abc/foo" } }
+    let(:bar_hash) { { :name => "bar", :path => "/abc/bar" } }
+    let(:baz_hash) { { :name => "baz", :path => "/abc/baz" } }
+
+    let(:manifest) { { :applications => [foo_hash, bar_hash, baz_hash] } }
+
+    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_hash, bar_hash] }
+        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_hash] }
+        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_hash] }
+        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(CF::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/manifests/plugin_spec.rb

@@ -0,0 +1,362 @@
+require "spec_helper"
+
+describe ManifestsPlugin do
+  let(:manifest) { {} }
+  let(:manifest_file) { nil }
+  let(:inputs_hash) { {} }
+  let(:given_hash) { {} }
+  let(:global_hash) { { :quiet => true } }
+  let(:command) { nil }
+  let(:inputs) { Mothership::Inputs.new(Mothership.commands[:push], nil, inputs_hash, given_hash, global_hash) }
+  let(:plugin) { ManifestsPlugin.new(command, inputs) }
+
+  let(:client) { fake_client }
+
+  before do
+    stub(plugin).manifest { manifest }
+    stub(plugin).manifest_file { manifest_file } if manifest_file
+    stub(plugin).client { client }
+  end
+
+  describe "#wrap_with_optional_name" do
+    let(:name_made_optional) { true }
+    let(:wrapped) { mock! }
+
+    subject { plugin.send(:wrap_with_optional_name, name_made_optional, wrapped, inputs) }
+
+    context "when --all is given" do
+      let(:inputs_hash) { { :all => true } }
+
+      it "skips all manifest-related logic, and invokes the command" do
+        mock(wrapped).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(wrapped).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(wrapped).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(wrapped).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(wrapped).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(wrapped).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(wrapped).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(wrapped).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(wrapped).call(anything) do |inputs|
+            expect(inputs.given[:app]).to eq "foo"
+          end
+
+          subject
+        end
+      end
+    end
+  end
+
+  describe "#wrap_push" do
+    let(:wrapped) { mock! }
+    let(:command) { Mothership.commands[:push] }
+
+    subject { plugin.send(:wrap_push, wrapped, inputs) }
+
+    before do
+      stub(plugin).show_manifest_usage
+    end
+
+    context "with a manifest" do
+      let(:manifest_file) { "/abc/manifest.yml" }
+
+      let(:manifest) do
+        { :applications => [
+          { :name => "a",
+            :path => "/abc/a",
+            :instances => "200",
+            :memory => "128M"
+          }
+        ]
+        }
+      end
+
+      # cf push foo
+      context "and a name is given" do
+        context "and the name is present in the manifest" do
+          let(:given_hash) { { :name => "a" } }
+
+          context "and the app exists" do
+            let(:app) { fake :app, :name => "a" }
+            let(:client) { fake_client :apps => [app] }
+
+            context "and --reset was given" do
+              let(:inputs_hash) { { :reset => true } }
+              let(:given_hash) { { :name => "a", :instances => "100" } }
+
+              it "rebases their inputs on the manifest's values" do
+                mock(wrapped).call(anything) do |inputs|
+                  expect(inputs.given).to eq(
+                    :name => "a", :path => "/abc/a", :instances => "100", :memory => "128M")
+                end
+
+                subject
+              end
+            end
+          end
+
+          context "and the app does NOT exist" do
+            it "pushes a new app with the inputs from the manifest" do
+              mock(wrapped).call(anything) do |inputs|
+                expect(inputs.given).to eq(
+                  :name => "a", :path => "/abc/a", :instances => "200", :memory => "128M")
+              end
+
+              subject
+            end
+          end
+        end
+
+        context "and the name is NOT present in the manifest" do
+          let(:given_hash) { { :name => "x" } }
+
+          it "fails, saying that name was not found in the manifest" do
+            expect { subject }.to raise_error(CF::UserError, /Could not find .+ in the manifest./)
+          end
+        end
+      end
+
+      # cf push ./abc
+      context "and a path is given" do
+        context "and there are apps matching that path in the manifest" do
+          let(:manifest) do
+            { :applications => [
+              { :name => "a",
+                :path => "/abc/a",
+                :instances => "200",
+                :memory => "128M"
+              },
+              { :name => "b",
+                :path => "/abc/a",
+                :instances => "200",
+                :memory => "128M"
+              }
+            ]
+            }
+          end
+
+          let(:given_hash) { { :name => "/abc/a" } }
+
+          it "pushes the found apps" do
+            pushed_apps = []
+            mock(wrapped).call(anything).twice do |inputs|
+              pushed_apps << inputs[:name]
+            end
+
+            subject
+
+            expect(pushed_apps).to eq(["a", "b"])
+          end
+        end
+
+        context "and there are NOT apps matching that path in the manifest" do
+          let(:given_hash) { { :name => "/abc/x" } }
+
+          it "fails, saying that the path was not found in the manifest" do
+            expect { subject }.to raise_error(CF::UserError, /Path .+ is not present in manifest/)
+          end
+        end
+      end
+    end
+
+    context "without a manifest" do
+      let(:app) { mock! }
+      let(:manifest) { nil }
+
+      it "asks to save the manifest when uploading the application" do
+        mock_ask("Save configuration?", :default => false)
+        stub(wrapped).call { plugin.filter(:push_app, app) }
+        subject
+      end
+    end
+  end
+
+  describe "#push_input_for" do
+    context "with an existing app" do
+      before do
+        stub(plugin).from_manifest { "PATH" }
+        app.changes.clear
+      end
+
+      let(:client) { fake_client(:apps => [app]) }
+      let(:manifest_memory) { "256M" }
+      let(:app) { fake :app, :name => "a", :memory => 256 }
+      let(:manifest) { { :name => "a", :memory => manifest_memory } }
+
+      subject { plugin.send(:push_input_for, manifest, inputs) }
+
+      context "with --reset" do
+        let(:inputs_hash) { { :reset => true } }
+
+        context "with changes" do
+          let(:manifest_memory) { "128M" }
+
+          it "applies the changes" do
+            subject[:memory].should == "128M"
+          end
+
+          it "does not ask to set --reset" do
+            dont_allow(plugin).warn_reset_changes
+            subject
+          end
+        end
+
+        context "without changes" do
+          it "does not ask to set --reset" do
+            dont_allow(plugin).warn_reset_changes
+            subject
+          end
+        end
+      end
+
+      context "without --reset" do
+        let(:inputs_hash) { {} }
+
+        context "with changes" do
+          let(:manifest_memory) { "128M" }
+
+          it "asks user to provide --reset" do
+            mock(plugin).warn_reset_changes
+            subject
+          end
+
+          it "does not apply changes" do
+            stub(plugin).warn_reset_changes
+            subject[:memory].should == nil
+          end
+        end
+
+        context "without changes" do
+          it "does not ask to set --reset" do
+            dont_allow(plugin).warn_reset_changes
+            subject
+          end
+        end
+      end
+    end
+  end
+end