cf 4.2.9.rc5 → 4.2.10.rc1

checksums.yaml

@@ -1,7 +0,0 @@
----
-SHA1:
-  metadata.gz: e4e2f3033d9d821a41f9ddc7f2dbeab8de538317
-  data.tar.gz: b6aa6ef1017ce73a108cac2dcf560a443c82882c
-SHA512:
-  metadata.gz: 5df73a8dd292d078af3679f56f1729415af83706513028997a7d9264fbef9dda9c96feae5422e1e138a93879e87621258a3128acd59b7574e7a9bff0f74d7329
-  data.tar.gz: 26a10354a3e832f2a395c18f2f7d090d09675ac648bd298e56220157f7aaf53308163611d74f6d856225bc3a1712a62bf8b7d332e684ff122fa27e7e283ecbfc

data/lib/cf/cli/service/service_instance_helper.rb

@@ -1,99 +0,0 @@
-class ServiceInstanceHelper
-  def self.new(instance)
-    "#{instance.class.name.demodulize}Helper".constantize.new(instance)
-  end
-end
-
-class UserProvidedServiceInstanceHelper
-  def initialize(instance)
-    @instance = instance
-  end
-
-  def service_label
-    "user-provided"
-  end
-
-  def service_provider
-    "n/a"
-  end
-
-  def version
-    "n/a"
-  end
-
-  def plan_name
-    "n/a"
-  end
-
-  def matches(opts = {})
-    label = opts[:service]
-    if label
-      return label == service_label
-    end
-
-    true
-  end
-
-  def name
-    @instance.name
-  end
-
-  def service_bindings
-    @instance.service_bindings
-  end
-end
-
-class ManagedServiceInstanceHelper
-  def initialize(service_instance)
-    @instance = service_instance
-  end
-
-  def service_label
-    @instance.service_plan.service.label
-  end
-
-  def service_provider
-    @instance.service_plan.service.provider
-  end
-
-  def version
-    @instance.service_plan.service.version
-  end
-
-  def plan_name
-    @instance.service_plan.name
-  end
-
-  def service_bindings
-    @instance.service_bindings
-  end
-
-  def name
-    @instance.name
-  end
-
-  def matches(opts = {})
-    service = opts[:service]
-    plan = opts[:plan]
-    provider = opts[:provider]
-    version = opts[:version]
-
-    if service
-      return false unless File.fnmatch(service, service_label)
-    end
-
-    if plan
-      return false unless File.fnmatch(plan.upcase, plan_name.upcase)
-    end
-
-    if provider
-      return false unless File.fnmatch(provider, service_provider)
-    end
-
-    if version
-      return false unless File.fnmatch(version, self.version)
-    end
-
-    true
-  end
-end

data/spec/assets/env/Gemfile

@@ -1,4 +0,0 @@
-source "http://rubygems.org"
-gem 'bundler'
-gem 'sinatra'
-gem 'json'

data/spec/assets/env/Gemfile.lock

@@ -1,17 +0,0 @@
-GEM
-  remote: http://rubygems.org/
-  specs:
-    json (1.5.1)
-    rack (1.2.2)
-    sinatra (1.2.1)
-      rack (~> 1.1)
-      tilt (>= 1.2.2, < 2.0)
-    tilt (1.2.2)
-
-PLATFORMS
-  ruby
-
-DEPENDENCIES
-  bundler
-  json
-  sinatra

data/spec/assets/env/env_test.rb

@@ -1,58 +0,0 @@
-require 'rubygems'
-require 'bundler/setup'
-require 'sinatra'
-require 'json'
-
-$stdout.sync = true
-
-def dump_env(fmt)
-  if fmt == 'html' || fmt == nil
-    res = ''
-    ENV.each do |k, v|
-      res << "#{k}: #{v}<br/>"
-    end
-    res
-  elsif fmt == 'json'
-    res = {}
-    ENV.each do |k, v|
-      res[k] = v
-    end
-    puts res
-    res.to_json
-  end
-end
-
-get '/' do
-  dump_env('html')
-end
-
-get '/healthcheck' do
-  "OK"
-end
-
-get '/env' do
-  dump_env('json')
-end
-
-
-get '/services' do
-  app_instance = JSON.parse(ENV['VCAP_APPLICATION'])
-  services = JSON.parse(ENV['VCAP_SERVICES'])
-
-  valid_services = false
-  service_list = []
-  services.each do |k, v|
-    v.each do |i|
-      s = {}
-      s['vendor'] = k.split('-')[0]
-      s['name'] = i['name']
-      service_list << s
-      valid_services = true
-    end
-  end
-  response = "{\"status\":\"ok\", \"services\": #{service_list.to_json}}" if valid_services
-  response = "{\"status\":\"fail\", \"services\": []}" if !valid_services
-
-  puts "my response: #{response}"
-  response
-end

data/spec/assets/hello-sinatra/manifest.yml

@@ -1,17 +0,0 @@
----
-applications:
-- name: hello-sinatra-1375741878_010056
-  memory: 256M
-  instances: 1
-  host: hello-sinatra-subdomain-1375741878_010056
-  domain: a1-app.cf-app.com
-  path: .
-  services:
-    user-provided-1375741878_010056:
-      label: user-provided
-      credentials:
-        username: abc123
-        password: sunshine
-        hostname: oracle.enterprise.com
-        port: 1234
-        name: myoracledb2

data/spec/cf/cli/service/service_instance_helper_spec.rb

@@ -1,155 +0,0 @@
-require "spec_helper"
-
-describe ServiceInstanceHelper do
-  describe ".new" do
-    let(:provided_instance) { build(:user_provided_service_instance) }
-    let(:managed_instance) { build(:managed_service_instance) }
-
-    it "returns a ManagedSerivceInstanceHelper when the argument is a ManagedServiceInstance" do
-      expect(ServiceInstanceHelper.new(managed_instance)).to be_a ManagedServiceInstanceHelper
-    end
-
-    it "returns a ManagedSerivceInstanceHelper when the argument is a ManagedServiceInstance" do
-      expect(ServiceInstanceHelper.new(provided_instance)).to be_a UserProvidedServiceInstanceHelper
-    end
-  end
-end
-
-describe UserProvidedServiceInstanceHelper do
-  let(:bindings) { [] }
-  let(:instance) { build(:user_provided_service_instance, service_bindings: bindings) }
-  subject(:helper) { UserProvidedServiceInstanceHelper.new(instance) }
-  describe "matches" do
-    it "returns true when 'user-provided' is the given label" do
-      expect(helper.matches(service: "user-provided")).to eq true
-    end
-
-    it "returns false when 'user-provided' is not the given label" do
-      expect(helper.matches(service: "a-different-label")).to eq false
-    end
-
-    it "returns true when a label is not given" do
-      expect(helper.matches).to eq true
-    end
-  end
-
-  its(:service_label) { should eq("user-provided") }
-  its(:service_provider) { should eq("n/a") }
-  its(:version) { should eq("n/a") }
-  its(:plan_name) { should eq("n/a") }
-  its(:name) { should eq instance.name }
-  its(:service_bindings) { should eq instance.service_bindings }
-end
-
-describe ManagedServiceInstanceHelper do
-  let(:label) { "some-label" }
-  let(:provider) { "some-provider" }
-  let(:version) { "some-version" }
-  let(:plan_name) { "some-plan-name" }
-
-  let(:service) { build(:service, label: label, provider: provider, version: version) }
-  let(:plan) { build(:service_plan, service: service, name: plan_name) }
-  let(:bindings) { [] }
-  let(:instance) { build(:managed_service_instance, service_plan: plan, service_bindings: bindings) }
-  subject(:helper) { ManagedServiceInstanceHelper.new(instance) }
-
-  describe "matches" do
-    it "returns true when no condition is specified" do
-      expect(helper.matches).to eq(true)
-    end
-
-    context "filtering based on service" do
-      it "returns true if the service label matches given service" do
-        expect(helper.matches(service: label)).to eq(true)
-      end
-
-      it "returns false if the service label does not match given service" do
-        expect(helper.matches(service: "a-different-label")).to eq(false)
-      end
-    end
-
-    context "filtering based on service plan" do
-      it "returns true if the plan name matches given plan" do
-        expect(helper.matches(plan: plan_name)).to eq(true)
-      end
-
-      it "returns true if the plan name does not match given plan" do
-        expect(helper.matches(plan: "some-other-plan-name")).to eq(false)
-      end
-
-      it "is case insensitive" do
-        expect(helper.matches(plan: plan_name.upcase)).to eq(true)
-      end
-    end
-
-    context "filtering based on provider" do
-      it "returns true if the provider name matches given provider" do
-        expect(helper.matches(provider: provider)).to eq(true)
-      end
-
-      it "returns true if the provider does not match given provider" do
-        expect(helper.matches(provider: "a-different-provider")).to eq(false)
-      end
-    end
-
-    context "filtering based on version" do
-      it "returns true if the version matches given version" do
-        expect(helper.matches(version: version)).to eq(true)
-      end
-
-      it "returns true if the version does not match given version" do
-        expect(helper.matches(version: "a-different-version")).to eq(false)
-      end
-    end
-
-    context "multiple filters" do
-      it "returns true if the service instance matches all four parameters" do
-        expect(helper.matches(service: label, plan: plan_name,
-                              provider: provider, version: version)).to eq true
-      end
-
-      it "return false if any of the parameters does not match the attribute of the service instance" do
-        expect(helper.matches(service: label, plan: plan_name,
-                              provider: provider, version: "a-different-version")).to eq false
-      end
-    end
-
-    context "with patterns for args" do
-      it "returns true when service label matches the given glob" do
-        expect(helper.matches(service: label.gsub(/.$/, "*"))).to eq(true)
-      end
-
-      it "returns false when the service label doesn not match the given glob" do
-        expect(helper.matches(service: label + "_*")).to eq(false)
-      end
-    end
-  end
-
-  describe "service_label" do
-
-    it "returns the label of instance's service offering" do
-      expect(helper.service_label).to eq label
-    end
-  end
-
-  describe "service_provider" do
-    it "returns the provider of the instance's service offering" do
-      expect(helper.service_provider).to eq provider
-    end
-  end
-
-  describe "version" do
-    it "returns the version of the instance's service offering" do
-      expect(helper.version).to eq version
-    end
-  end
-
-  describe "plan_name" do
-    it "returns the name of the instance's service plan" do
-      expect(helper.plan_name).to eq plan_name
-    end
-  end
-
-  its(:name) { should eq instance.name }
-  its(:service_bindings) { should eq instance.service_bindings }
-end

data/spec/factories/cfoundry/v2/user_provided_service_instances_factory.rb

@@ -1,12 +0,0 @@
-FactoryGirl.define do
-  factory :user_provided_service_instance, :class => CFoundry::V2::UserProvidedServiceInstance do
-    sequence(:guid) { |n| "user-provided-service-instance-guid-#{n}" }
-    sequence(:name) { |n| "user-provided-service-instance-name-#{n}" }
-
-    ignore do
-      client { FactoryGirl.build(:client) }
-    end
-
-    initialize_with { new(guid, client) }
-  end
-end

data/spec/features/manifests_spec.rb

@@ -1,86 +0,0 @@
-require "spec_helper"
-require "webmock/rspec"
-
-if ENV["CF_V2_RUN_INTEGRATION"]
-  describe "A user pushing a new sinatra app" do
-
-    let(:run_id) { TRAVIS_BUILD_ID.to_s + Time.new.to_f.to_s.gsub(".", "_") }
-    let(:app) { "hello-sinatra-#{run_id}" }
-    let(:subdomain) { "hello-sinatra-subdomain-#{run_id}" }
-    let(:user_provided_name) { "user-provided-#{run_id}"}
-
-    before do
-      FileUtils.rm_rf File.expand_path(CF::CONFIG_DIR)
-      WebMock.allow_net_connect!
-      login
-    end
-
-    after do
-      `#{cf_bin} unbind-service -f --no-script #{user_provided_name} #{app}`
-      `#{cf_bin} delete-service -f --no-script #{user_provided_name}`
-
-      `#{cf_bin} delete #{app} -f --routes --no-script`
-      logout
-    end
-
-    context "with user-provided service" do
-      it "reads the manifest when pushing" do
-        Dir.chdir("#{SPEC_ROOT}/assets/hello-sinatra") do
-          FileUtils.rm("manifest.yml", force: true)
-          File.open("manifest.yml", "w") do |f|
-            f.write(<<-MANIFEST)
----
-applications:
-- name: #{app}
-  memory: 256M
-  instances: 1
-  host: #{subdomain}
-  domain: a1-app.cf-app.com
-  path: .
-  services:
-    #{user_provided_name}:
-      label: user-provided
-      credentials:
-        username: abc123
-        password: sunshine
-        hostname: oracle.enterprise.com
-        port: 1234
-        name: myoracledb2
-            MANIFEST
-          end
-
-          BlueShell::Runner.run("#{cf_bin} push") do |runner|
-            expect(runner).to say "Using manifest file manifest.yml"
-            expect(runner).to say "Creating #{app}... OK"
-
-            expect(runner).to say(/Creating route #{subdomain}\..*\.\.\. OK/)
-            expect(runner).to say(/Binding #{subdomain}\..* to #{app}\.\.\. OK/)
-
-            expect(runner).to say /Creating service #{user_provided_name}.*OK/
-            expect(runner).to say /Binding #{user_provided_name} to #{app}... OK/
-
-            expect(runner).to say "Uploading #{app}... OK", 180
-            expect(runner).to say "Preparing to start #{app}... OK", 180
-            expect(runner).to say "Checking status of app '#{app}'...", 180
-            expect(runner).to say "1 of 1 instances running"
-            expect(runner).to say "Push successful! App '#{app}' available at http://#{subdomain}.a1-app.cf-app.com", 30
-          end
-        end
-
-        BlueShell::Runner.run("#{cf_bin} services") do |runner|
-          expect(runner).to say /name\s+service\s+provider\s+version\s+plan\s+bound apps/
-          expect(runner).to say /#{user_provided_name}\s+ # name
-            user-provided\s+                        # service
-            n\/a\s+                              # provider
-            n\/a\s+                             # version
-            n\/a\s+                             # plan
-            #{app}                              # bound apps
-          /x
-        end
-      end
-    end
-
-  end
-else
-  $stderr.puts 'Skipping v2 integration specs; please provide necessary environment variables'
-end