trucker-cli 0.0.1

data/spec/features/services_spec.rb

@@ -0,0 +1,122 @@
+require "spec_helper"
+
+if ENV['CF_V2_RUN_INTEGRATION']
+  describe "Services" do
+    before do
+      login
+    end
+
+    describe "listing services" do
+      let(:service1) { "some-provided-instance-#{Time.now.to_i}" }
+      let(:service2) { "cf-managed-instance-#{Time.now.to_i}" }
+
+      it "shows all service instances in the space" do
+        create_service_instance("user-provided", service1, credentials: { hostname: "myservice.com"} )
+        create_service_instance("dummy-dev", service2, plan: "small")
+
+        BlueShell::Runner.run("#{cf_bin} services") do |runner|
+          expect(runner).to say /#{service1}\s+user-provided\s+n\/a\s+n\/a\s+n\/a\s+.*/
+        end
+      end
+
+      after do
+        delete_service(service1)
+        delete_service(service2)
+      end
+    end
+
+    describe "creating a service" do
+      describe "when the user leaves the line blank for a plan" do
+        it "re-prompts for the plan" do
+          BlueShell::Runner.run("#{cf_bin} create-service") do |runner|
+            expect(runner).to say "What kind?"
+            runner.send_keys "1"
+            expect(runner).to say "Name?"
+            runner.send_return
+            expect(runner).to say "Which plan?"
+            runner.send_return
+            expect(runner).to say "Which plan?"
+          end
+        end
+      end
+
+      describe "when the service is a user-provided instance" do
+        let(:service_name) { "my-private-db-#{Random.rand(1000) + 1000}"}
+
+        it "can create a service instance" do
+          BlueShell::Runner.run("#{cf_bin} create-service") do |runner|
+            expect(runner).to say "What kind?"
+            runner.send_keys "user-provided"
+
+            expect(runner).to say "Name?"
+            runner.send_keys service_name
+
+            expect(runner).to say "What credential parameters should applications use to connect to this service instance?\n(e.g. hostname, port, password)"
+            runner.send_keys "hostname"
+            expect(runner).to say "hostname"
+            runner.send_keys "myserviceinstance.com"
+
+            expect(runner).to say /Creating service #{service_name}.+ OK/
+          end
+        end
+
+        after do
+          delete_service(service_name)
+        end
+      end
+    end
+
+    describe "binding to a service" do
+      let(:app_folder) { "env" }
+      let(:app_name) { "services_env_test_app-#{Time.now.to_i}" }
+
+      let(:service_name) { "some-provided-instance-#{Time.now.to_i}" }
+
+      it "can bind and unbind user-provided services to apps" do
+        push_app(app_folder, app_name, start_command: "'bundle exec ruby env_test.rb -p $PORT'", timeout: 90)
+        create_service_instance("user-provided", service_name, credentials: { hostname: "myservice.com"} )
+
+        BlueShell::Runner.run("#{cf_bin} bind-service") do |runner|
+          expect(runner).to say "Which application?>"
+          runner.send_keys app_name
+
+          expect(runner).to say "Which service?>"
+          runner.send_keys service_name
+
+          expect(runner).to say "Binding #{service_name} to #{app_name}... OK"
+        end
+
+        BlueShell::Runner.run("#{cf_bin} unbind-service") do |runner|
+          expect(runner).to say "Which application?"
+          runner.send_keys app_name
+
+          expect(runner).to say "Which service?>"
+          runner.send_keys service_name
+
+          expect(runner).to say "Unbinding #{service_name} from #{app_name}... OK"
+        end
+      end
+
+      after do
+        delete_app(app_name)
+        delete_service(service_name)
+      end
+    end
+
+    def delete_service(service_name)
+      BlueShell::Runner.run("#{cf_bin} delete-service --service #{service_name} --force") do |runner|
+        expect(runner).to say "Deleting #{service_name}... OK"
+      end
+    end
+
+    def delete_app(app_name, routes=true)
+      delete_cmd = "#{cf_bin} delete #{app_name}"
+      delete_cmd + " --routes" if routes
+      BlueShell::Runner.run(delete_cmd) do |runner|
+        expect(runner).to say "Really delete #{app_name}?"
+        runner.send_keys "y"
+        expect(runner).to say "Deleting #{app_name}... OK"
+      end
+    end
+  end
+end

data/spec/features/space_spec.rb

@@ -0,0 +1,107 @@
+require "spec_helper"
+require "webmock/rspec"
+require "ffaker"
+
+if ENV['CF_V2_RUN_INTEGRATION']
+  describe 'A new user tries to use CF against v2 production', :ruby19 => true do
+    before(:all) do
+      WebMock.allow_net_connect!
+    end
+
+    after(:all) do
+      WebMock.disable_net_connect!
+    end
+
+    let(:organization) { ENV['CF_V2_TEST_ORGANIZATION'] }
+    let(:space) { ENV['CF_V2_TEST_SPACE'] }
+
+    before do
+      Interact::Progress::Dots.start!
+      login
+    end
+
+    after do
+      logout
+      Interact::Progress::Dots.stop!
+    end
+
+    it "can get space info" do
+      BlueShell::Runner.run("#{cf_bin} space #{space} --no-quiet") do |runner|
+        expect(runner).to say("#{space}:\n")
+        expect(runner).to say("organization: #{organization}")
+      end
+    end
+
+    describe "needs cleanup after specs" do
+      let(:run_id) { TRAVIS_BUILD_ID.to_s + Time.new.to_f.to_s.gsub(".", "_") }
+      let(:app) { "hello-sinatra-recursive-#{run_id}" }
+      let(:new_space) { "test-space-#{rand(10000)}" }
+      let(:new_space_two) { "test-space-renamed-#{rand(10000)}" }
+
+      after do
+        begin
+          BlueShell::Runner.run("#{cf_bin} delete-space #{new_space} -r -f")
+        rescue
+        end
+        begin
+          BlueShell::Runner.run("#{cf_bin} delete-space #{new_space_two} -r -f")
+        rescue
+        end
+      end
+
+      it "can create, switch, rename, and delete spaces" do
+        BlueShell::Runner.run("#{cf_bin} create-space #{new_space}") do |runner|
+          expect(runner).to say("Creating space #{new_space}... OK")
+        end
+
+        BlueShell::Runner.run("#{cf_bin} switch-space #{new_space}") do |runner|
+          expect(runner).to say("Switching to space #{new_space}... OK")
+        end
+
+        BlueShell::Runner.run("#{cf_bin} rename-space #{new_space} #{new_space_two}") do |runner|
+          expect(runner).to say("Renaming to #{new_space_two}... OK")
+        end
+
+        BlueShell::Runner.run("#{cf_bin} delete-space #{new_space_two}") do |runner|
+          expect(runner).to say("Really delete")
+          runner.send_keys "y"
+
+          expect(runner).to say("Deleting space #{new_space_two}... OK")
+        end
+      end
+
+      it "can create an app in a space, then delete it recursively" do
+        BlueShell::Runner.run("#{cf_bin} create-space #{new_space}") { |runner| runner.wait_for_exit(30) }
+        BlueShell::Runner.run("#{cf_bin} switch-space #{new_space}") { |runner| runner.wait_for_exit(30) }
+
+        push_app("hello-sinatra", app)
+
+        BlueShell::Runner.run("#{cf_bin} delete-space #{new_space} --force") do |runner|
+          expect(runner).to say("If you want to delete the space along with all dependent objects, rerun the command with the '--recursive' flag.")
+          runner.wait_for_exit(30)
+        end.should_not be_successful
+
+        BlueShell::Runner.run("#{cf_bin} spaces") do |runner|
+          expect(runner).to say(new_space)
+          expect(runner).to say(app)
+        end
+
+        BlueShell::Runner.run("#{cf_bin} delete-space #{new_space} --recursive --force") do |runner|
+          expect(runner).to say("Deleting space #{new_space}... OK")
+        end
+
+        BlueShell::Runner.run("#{cf_bin} spaces") do |runner|
+          expect(runner).to_not say(new_space)
+          expect(runner).to_not say(app)
+        end
+      end
+    end
+
+    it "shows all the spaces in the org" do
+      BlueShell::Runner.run("#{cf_bin} spaces") do |runner|
+        expect(runner).to say(space)
+      end
+    end
+
+  end
+end

data/spec/features/switching_targets_spec.rb

@@ -0,0 +1,70 @@
+require "spec_helper"
+
+if ENV['CF_V2_RUN_INTEGRATION']
+  describe 'A new user tries to use CF against v2 production', ruby19: true do
+
+    let(:target) { ENV['CF_V2_TEST_TARGET'] }
+    let(:space) { ENV['CF_V2_TEST_SPACE'] }
+    let(:space_2) { "#{ENV['CF_V2_TEST_SPACE']}-2"}
+    let(:organization_2) { ENV['CF_V2_TEST_ORGANIZATION_TWO'] }
+
+    let(:created_space_1) { "space-#{rand(10000)}"}
+    let(:created_space_2) { "space-#{rand(10000)}"}
+
+    before do
+      target_file = File.expand_path("~/.truck/target")
+      FileUtils.rm(target_file) if File.exists? target_file
+      Interact::Progress::Dots.start!
+    end
+
+    after do
+      logout
+      Interact::Progress::Dots.stop!
+    end
+
+    it "can switch targets, even if a target is invalid" do
+      BlueShell::Runner.run("#{cf_bin} target") do |runner|
+        expect(runner).to say "  CF instance: N/A"
+      end
+
+      BlueShell::Runner.run("#{cf_bin} target invalid-target") do |runner|
+        expect(runner).to say "Target refused"
+        runner.wait_for_exit
+      end
+
+      BlueShell::Runner.run("#{cf_bin} target #{target}") do |runner|
+        expect(runner).to say "Setting target"
+        expect(runner).to say target
+        runner.wait_for_exit
+      end
+    end
+
+    context "with created spaces in the second org" do
+      it "can switch organizations and spaces" do
+        login
+
+        BlueShell::Runner.run("#{cf_bin} target -o #{organization_2}") do |runner|
+          expect(runner).to say "Switching to organization #{organization_2}"
+          expect(runner).to say "Space>"
+          runner.send_keys space_2
+
+          expect(runner).to say(/Switching to space #{space_2}/)
+
+          runner.wait_for_exit 15
+        end
+
+        BlueShell::Runner.run("#{cf_bin} target -s #{space}") do |runner|
+          expect(runner).to say("Switching to space #{space}")
+          runner.wait_for_exit 15
+        end
+
+        BlueShell::Runner.run("#{cf_bin} target -s #{space_2}") do |runner|
+          expect(runner).to say("Switching to space #{space_2}")
+          runner.wait_for_exit 15
+        end
+      end
+    end
+  end
+else
+  $stderr.puts 'Skipping v2 integration specs; please provide necessary environment variables'
+end

data/spec/manifests/errors_spec.rb

@@ -0,0 +1,43 @@
+require "spec_helper"
+
+describe CFManifests::InvalidManifest do
+  let(:file) { "/path/to/file" }
+
+  subject { described_class.new(file) }
+
+  it { should be_kind_of CF::UserFriendlyError }
+
+  describe "#initialize" do
+    it "is initialized with a file" do
+      described_class.new(file)
+    end
+  end
+
+  describe "#to_s" do
+    it "says the file is malformed" do
+      expect(subject.to_s).to eq(
+        "Manifest file '#{file}' is malformed.")
+    end
+  end
+
+  describe "#file" do
+    it "returns the file it was initialized with" do
+      expect(subject.file).to eq(file)
+    end
+  end
+end
+
+describe CFManifests::CircularDependency do
+  let(:app) { "app" }
+  subject { described_class.new(app) }
+
+  it { should be_kind_of CF::UserFriendlyError }
+end
+
+describe CFManifests::UnknownSymbol do
+  let(:symbol) { "symbol" }
+  subject { described_class.new(symbol) }
+
+  it { should be_kind_of CF::UserFriendlyError }
+end
+

data/spec/manifests/loader/builder_spec.rb

@@ -0,0 +1,80 @@
+require "spec_helper"
+
+describe CFManifests::Builder do
+  subject { CFManifests::Loader.new(nil, nil) }
+
+  describe "#build" do
+    let(:file) { "manifest.yml" }
+
+    before do
+      FakeFS.activate!
+
+      File.open(file, "w") do |io|
+        io.write manifest
+      end
+    end
+
+    after do
+      FakeFS.deactivate!
+      FakeFS::FileSystem.clear
+    end
+
+    context "with a simple manifest" do
+      let(:manifest) do
+        <<EOF
+---
+foo: bar
+EOF
+      end
+
+      it "loads the manifest YAML" do
+        expect(subject.build(file)).to eq("foo" => "bar")
+      end
+    end
+
+    context "with a manifest that inherits another" do
+      let(:manifest) do
+        <<EOF
+---
+inherit: other-manifest.yml
+foo:
+  baz: c
+EOF
+      end
+
+      before do
+        FakeFS.activate!
+
+        File.open("other-manifest.yml", "w") do |io|
+          io.write <<OTHER
+---
+foo:
+  bar: a
+  baz: b
+OTHER
+        end
+      end
+
+      it "merges itself into the parent, by depth" do
+        manifest = subject.build(file)
+        expect(manifest).to include(
+          "foo" => { "bar" => "a", "baz" => "c" })
+      end
+
+      it "does not include the 'inherit' attribute" do
+        manifest = subject.build(file)
+        expect(manifest).to_not include("inherit")
+      end
+    end
+
+    context "with an invalid manifest" do
+      let(:manifest) { "" }
+
+      it "raises an error" do
+        expect {
+          subject.build(file)
+        }.to raise_error(CFManifests::InvalidManifest)
+      end
+    end
+  end
+end

data/spec/manifests/loader/normalizer_spec.rb

@@ -0,0 +1,158 @@
+require "spec_helper"
+
+describe CFManifests::Normalizer do
+  let(:manifest) { {} }
+  let(:loader) { CFManifests::Loader.new(nil, nil) }
+
+  describe '#normalize!' do
+    subject do
+      loader.normalize!(manifest)
+      manifest
+    end
+
+    context 'with a manifest where the applications have no path set' do
+      let(:manifest) { { "applications" => { "." => { "name" => "foo" } } } }
+
+      it "sets the path to their tag, assuming it's a path" do
+        expect(subject).to eq(
+          :applications => [{ :name => "foo", :path => "." }])
+      end
+    end
+
+    context 'with a manifest where the url is nil' do
+      let(:manifest) { { "applications" => { "." => { "url" => nil } } } }
+
+      it "sets it to none" do
+        expect(subject).to eq(
+          :applications => [{ :path => ".", :url => "none" }]
+        )
+      end
+    end
+
+    context 'with a manifest with a subdomain attribute' do
+      let(:manifest) { { "applications" => { "." => { "subdomain" => "use-this-for-host" } } } }
+
+      it "sets the subdomain key to be host" do
+        expect(subject).to eq(
+          :applications => [{ :path => ".", :host => "use-this-for-host" }]
+        )
+      end
+
+      context "when the host attribute is also set" do
+        let(:manifest) { { "applications" => { "." => { "subdomain" => "dont-use-this-for-host", "host" => "canonical-attribute" } } } }
+
+        it 'does not overwrite an explicit host attribute' do
+          expect(subject).to eq(
+            :applications => [{ :path => ".", :host => "canonical-attribute" }]
+          )
+        end
+      end
+    end
+
+    context 'with a manifest with toplevel attributes' do
+      context 'and properties' do
+        let(:manifest) {
+          { "name" => "foo", "properties" => { "fizz" => "buzz" } }
+        }
+
+        it 'keeps the properties at the toplevel' do
+          expect(subject).to eq(
+            :applications => [{ :name => "foo", :path => "." }],
+            :properties => { :fizz => "buzz" })
+        end
+      end
+
+      context 'and no applications' do
+        context 'and no path' do
+          let(:manifest) { { "name" => "foo" } }
+
+          it 'adds it as an application with path .' do
+            expect(subject).to eq(
+              :applications => [{ :name => "foo", :path => "." }])
+          end
+        end
+
+        context 'and a path' do
+          let(:manifest) { { "name" => "foo", "path" => "./foo" } }
+
+          it 'adds it as an application with the proper tag and path' do
+            expect(subject).to eq(
+              :applications => [{ :name => "foo", :path => "./foo" }])
+          end
+        end
+      end
+
+      context 'and applications' do
+        let(:manifest) {
+          { "applications" => {
+              "./foo" => { "name" => "foo" },
+              "./bar" => { "name" => "bar" },
+              "./baz" => { "name" => "baz" }
+            }
+          }
+        }
+
+        it "merges the toplevel attributes into the applications" do
+          expect(subject[:applications]).to match_array [
+            { :name => "foo", :path => "./foo" },
+            { :name => "bar", :path => "./bar" },
+            { :name => "baz", :path => "./baz" }
+          ]
+        end
+      end
+    end
+
+    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 the key' do
+        expect(subject).to eq(
+          :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
+
+  describe '#normalize_app!' do
+    subject do
+      loader.send(:normalize_app!, manifest)
+      manifest
+    end
+
+    context 'with mem instead of memory' do
+      let(:manifest) { { "name" => "foo", "mem" => "128M" } }
+
+      it 'renames mem to memory' do
+        expect(subject).to eq("name" => "foo", "memory" => "128M")
+      end
+    end
+  end
+end