trucker-cli 0.0.1

data/spec/manifests/manifests_spec.rb

@@ -0,0 +1,335 @@
+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
+    manifest.stub(:client) { client }
+    manifest
+  end
+
+  let(:target_base) { "some-cloud.com" }
+
+  let(:foo) { build(:app, :name => "foo") }
+  let(:bar) { build(:app, :name => "bar") }
+  let(:baz) { build(:app, :name => "baz") }
+  let(:xxx) { build(:app, :name => "xxx") }
+  let(:yyy) { build(:app, :name => "yyy") }
+
+  let(:client) do
+    build(:client).tap { |client| client.stub(:apps => [foo, bar, baz, xxx, yyy]) }
+  end
+
+  let(:manifest_file) { "/abc/manifest.yml" }
+
+  before do
+    cmd.stub(:manifest) { manifest }
+    cmd.stub(:manifest_file) { manifest_file }
+  end
+
+  describe "#resolve_symbol" do
+    it "resolves target-base for old manifest files" do
+      cmd.stub(:target_base) { 'the_really_great_target_base' }
+      cmd.resolve_symbol("target-base").should == 'the_really_great_target_base'
+    end
+  end
+
+  describe "#find_apps" do
+    subject { cmd.find_apps(nil) }
+
+    context "when there is no manifest file" do
+      before { cmd.stub(:manifest).and_return(nil) }
+      it { should eq [] }
+    end
+  end
+
+  describe "#create_manifest_for" do
+    let(:app) do
+      build :app,
+        :memory => 2048,
+        :total_instances => 2,
+        :command => "ruby main.rb",
+        :buildpack => "git://example.com/foo.git",
+        :routes => [
+          build(:route,
+            :host => "some-app-name",
+            :domain => build(:domain, :name => target_base))
+        ],
+        :service_bindings => [
+          build(
+            :service_binding,
+            :service_instance =>
+              build(
+                :managed_service_instance,
+                :name => "service-1",
+                :service_plan =>
+                  build(
+                    :service_plan,
+                    :name => "P200",
+                    :service => build(:service,
+                      label: "managed",
+                      provider: "hamazon",
+                      version: "v3"
+                    )
+                  )
+              )
+          ),
+          build(
+            :service_binding,
+            :service_instance =>
+              build(
+                :user_provided_service_instance,
+                :name => "service-2",
+                :credentials => { uri: "mysql://example.com" }
+              )
+          )
+        ]
+    end
+
+    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(["host"]) { should eq "some-app-name" }
+    its(["domain"]) { should eq app.domain }
+    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 eq(
+        "service-1" => {
+          "plan" => "P200",
+          "label" => "managed",
+          "provider" => "hamazon",
+          "version" => "v3",
+        },
+        "service-2" => {
+          "credentials" => {"uri" => "mysql://example.com"},
+          "label" => "user-provided"
+        },
+      )
+    end
+
+    context "with only minimum configuration" do
+      let(:app) {
+        build :app,
+          :memory => 2048,
+          :total_instances => 2,
+          :routes => [],
+          :service_bindings => []
+      }
+
+      its(["host"]) { should eq "none" }
+      its(["domain"]) { should eq "none" }
+      it { should_not include "command" }
+      it { should_not include "services" }
+    end
+  end
+
+  describe "#setup_services" do
+    let(:service_bindings) { [] }
+    let(:app) { build :app, :service_bindings => service_bindings }
+
+    before do
+      dont_allow_ask(anything, anything)
+    end
+
+    context "when user-provided services are defined in the manifest" do
+      let(:client) do
+        build(:client).tap { |client| client.stub(:services => [], :service_instances => []) }
+      end
+
+      let(:info) { {:services => {'moracle' => {:label => "user-provided", :credentials =>{"k" => "v"}}}}}
+
+      it "creates the service with label user-provided" do
+        cmd.should_receive(:invoke).with(:create_service,
+          :name => 'moracle', :offering => has_label("user-provided"), :app => app, :credentials => {"k" => "v"}
+        )
+        cmd.send("setup_services", app, info)
+      end
+    end
+
+    context "when services are defined in the manifest" do
+      let(:info) do
+        {:services => {"service-1" => {:label => "mysql", :plan => "100"}}}
+      end
+
+      let(:service_1) { build(:managed_service_instance, :name => "service-1") }
+      let(:plan_100) { build :service_plan, :name => "100" }
+
+      let(:mysql) do
+        build(
+          :service,
+          :label => "mysql",
+          :provider => "core",
+          :service_plans => [plan_100])
+      end
+
+      let(:service_instances) { [] }
+
+      let(:client) do
+        build(:client).tap { |client| client.stub(:services => [mysql], :service_instances => service_instances) }
+      end
+
+      context "and the services exist" do
+        let(:service_instances) { [service_1] }
+
+        context "and are already bound" do
+          let(:service_bindings) { [build(:service_binding, :service_instance => service_1)] }
+
+          it "does neither create nor bind the service again" do
+            cmd.should_not_receive(:invoke).with(:create_service, anything)
+            cmd.should_not_receive(:invoke).with(:bind_service, anything)
+            cmd.send(:setup_services, app, info)
+          end
+        end
+
+        context "but are not bound" do
+          it "does not create the services" do
+            cmd.should_not_receive(:invoke).with(:create_service, anything)
+            cmd.stub(:invoke).with(:bind_service, anything)
+            cmd.send(:setup_services, app, info)
+          end
+
+          it "binds the service" do
+            cmd.should_receive(:invoke).with(: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
+          cmd.should_receive(:invoke).with(:create_service, :app => app,
+            :name => service_1.name, :offering => mysql, :plan => plan_100)
+          cmd.should_not_receive(:invoke).with(: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
+      Dir.stub(:pwd) { "/abc" }
+      expect(subject).to eq [{:name => "foo", :path => "/abc"}, {:name => "bar", :path => "/abc"}]
+    end
+  end
+
+  describe "#check_manifest!" do
+
+    it "prints a warning if there is some unknown attribute" do
+      wrong_manifest_hash = {:applications => [{:bad_attr => 'boom'}]}
+      output = double('output')
+
+      msg = "\033[31mWarning: bad_attr is not a valid manifest attribute. "+
+        "Please remove this attribute from your manifest to get rid of this"+
+        " warning\033[0m"
+
+      output.should_receive(:puts).with(msg)
+      cmd.check_manifest!(wrong_manifest_hash, output)
+    end
+  end
+end

data/spec/manifests/plugin_spec.rb

@@ -0,0 +1,410 @@
+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) { build(:client) }
+
+  before do
+    plugin.stub(:manifest) { manifest }
+    plugin.stub(:manifest_file) { manifest_file } if manifest_file
+    plugin.stub(:client) { client }
+  end
+
+  describe ".use_manifest_for_app_input" do
+    it "makes the app argument optional and wraps it in an around that gets the app from the manifest" do
+      command = described_class.commands[:app]
+      command.instance_variable_set(:@arguments, [{:name => :app, :type => :required, :value => nil}])
+
+      expect(command.arguments).to eq [{:name => :app, :type => :required, :value => nil}]
+      expect(command.around.size).to eq 1
+
+      described_class.default_to_app_from_manifest :app, false
+
+      expect(command.arguments).to eq [{:name => :app, :type => :optional, :value => nil}]
+      expect(command.around.size).to eq 2
+    end
+  end
+
+  describe "#wrap_with_optional_name" do
+    let(:name_made_optional) { true }
+    let(:fail_without_app) { true }
+    let(:wrapped) { double(:wrapped).as_null_object }
+
+    subject { plugin.send(:wrap_with_optional_name, name_made_optional, wrapped, inputs, fail_without_app) }
+
+    context "when --all is given" do
+      let(:inputs_hash) { { :all => true } }
+
+      it "skips all manifest-related logic, and invokes the command" do
+        wrapped.should_receive(:call)
+        plugin.should_not_receive(: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
+          wrapped.should_receive(:call)
+          plugin.should_not_receive(: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
+            plugin.should_receive(:no_apps)
+            subject
+          end
+
+          context "when it is not supposed to fail" do
+            let(:fail_without_app) { false }
+            it "doesnt fail" do
+              plugin.should_not_receive(:no_apps)
+              subject
+            end
+          end
+        end
+
+        context "and we did NOT make it optional" do
+          let(:name_made_optional) { false }
+
+          it "passes through to the command" do
+            wrapped.should_receive(:call)
+            plugin.should_not_receive(:show_manifest_usage)
+            subject
+          end
+        end
+      end
+    end
+
+    context "when there is a manifest" do
+      let(:manifest_file) { "/abc/manifest.yml" }
+
+      before do
+        plugin.stub(: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
+            wrapped.should_receive(:call).with(anything) do |inputs|
+              expect(inputs.given[:app]).to eq "foo"
+            end
+
+            Dir.stub(: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"]
+            wrapped.should_receive(:call).with(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
+            plugin.should_receive(:show_manifest_usage)
+
+            uncalled_apps = ["a", "x"]
+            wrapped.should_receive(:call).with(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
+            wrapped.should_receive(:call)
+            plugin.should_not_receive(:show_manifest_usage)
+            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
+          wrapped.should_receive(:call).with(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
+          wrapped.should_receive(:call).with(anything) do |inputs|
+            expect(inputs.given[:app]).to eq "foo"
+          end
+
+          subject
+        end
+      end
+    end
+  end
+
+  describe "#wrap_push" do
+    let(:wrapped) { double(:wrapped).as_null_object }
+    let(:command) { Mothership.commands[:push] }
+
+    subject { plugin.send(:wrap_push, wrapped, inputs) }
+
+    before do
+      plugin.stub(: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" } }
+          let(:app) { build :app, :name => "a" }
+
+          before do
+            client.stub(:apps => [app])
+            client.stub(:app_by_name).with("a").and_return(app)
+          end
+
+          context "and the app exists" do
+
+            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
+                wrapped.should_receive(:call).with(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
+            let(:app) { nil }
+
+            it "pushes a new app with the inputs from the manifest" do
+              wrapped.should_receive(:call).with(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
+          before do
+            client.stub(:apps => [build(:app), build(:app)])
+            client.stub(:app_by_name)
+          end
+
+          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 = []
+            wrapped.should_receive(:call).with(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
+
+      context "and --path is specified too" do
+        let(:given_hash) { { :path => "/somewhere/else" } }
+
+        it "warns the user that --path will be ignored" do
+          plugin.stub(:line)
+          plugin.stub(:push_with_manifest)
+
+          subject
+
+          expect(plugin).to have_received(:line).with("--path is ignored when using a manifest. Please specify the path in the manifest.")
+        end
+      end
+    end
+
+    context "without a manifest" do
+      let(:app) { double(:app).as_null_object }
+      let(:manifest) { nil }
+
+      it "asks to save the manifest when uploading the application" do
+        should_ask("Save configuration?", :default => false)
+        wrapped.stub(:call) { plugin.filter(:push_app, app) }
+        subject
+      end
+    end
+  end
+
+  describe "#push_input_for" do
+    context "with an existing app" do
+      before do
+        plugin.stub(:from_manifest) { "PATH" }
+        app.changes.clear
+        client.stub(:apps => [app])
+      end
+
+      let(:manifest_memory) { "256M" }
+      let(:app) { build(: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
+            plugin.should_not_receive(:warn_reset_changes)
+            subject
+          end
+        end
+
+        context "without changes" do
+          it "does not ask to set --reset" do
+            plugin.should_not_receive(: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
+            plugin.should_receive(:warn_reset_changes)
+            subject
+          end
+
+          it "does not apply changes" do
+            plugin.stub(:warn_reset_changes)
+            subject[:memory].should == nil
+          end
+        end
+
+        context "without changes" do
+          it "does not ask to set --reset" do
+            plugin.should_not_receive(:warn_reset_changes)
+            subject
+          end
+        end
+      end
+    end
+  end
+end