static 1.0.0 → 1.0.1

data/vendor/cfoundry-0.5.2/spec/support/fake_helper.rb

@@ -0,0 +1,236 @@
+module Fake
+  module FakeMethods
+    def fake_client(attributes = {})
+      CFoundry::V2::FakeClient.new.fake(attributes)
+    end
+
+    def fake(what, attributes = {})
+      fake_client.send(what).fake(attributes)
+    end
+
+    def fake_list(what, count, attributes = {})
+      objs = []
+
+      count.times do
+        objs << fake(what, attributes)
+      end
+
+      objs
+    end
+
+    def fake_model(name = :my_fake_model, &init)
+      # There is a difference between ruby 1.8.7 and 1.8.8 in the order that
+      # the inherited callback gets called. In 1.8.7 the inherited callback
+      # is called after the block; in 1.8.8 and later it's called before.
+      # The upshot for us is we need a failproof way of getting the name
+      # to klass. So we're using a global variable to hand off the value.
+      # Please don't shoot us. - ESH & MMB
+      $object_name = name
+      klass = Class.new(CFoundry::V2::FakeModel) do
+        self.object_name = name
+      end
+
+      klass.class_eval(&init) if init
+
+      klass
+    end
+  end
+
+  def fake(attributes = {})
+    fake_attributes(attributes).each do |k, v|
+      send(:"#{k}=", v)
+      setup_reverse_relationship(v)
+    end
+
+    self
+  end
+
+  def self.define_many_association(target, plural)
+    target.class_eval do
+      define_method(plural) do |*args|
+        options, _ = args
+        options ||= {}
+
+        vals = get_many(plural) || []
+
+        if options[:query]
+          by, val = options[:query]
+          vals.select do |v|
+            v.send(by) == val
+          end
+        else
+          vals
+        end
+      end
+    end
+  end
+end
+
+module CFoundry::V2
+  class Model
+    include Fake
+
+    attr_writer :client
+
+    private
+
+    def get_many(plural)
+      @cache[plural]
+    end
+
+    def fake_attributes(attributes)
+      fakes = default_fakes
+
+      # default relationships to other fake objects
+      self.class.to_one_relations.each do |name, opts|
+        # remove _guid (not an actual attribute)
+        fakes.delete :"#{name}_guid"
+        next if fakes.key?(name)
+
+        fakes[name] =
+          if opts.key?(:default)
+            opts[:default]
+          else
+            @client.send(opts[:as] || name).fake
+          end
+      end
+
+      # make sure that the attributes provided are set after the defaults
+      #
+      # we have to do this for cases like environment_json vs. env,
+      # where one would clobber the other
+      attributes.each do |k, _|
+        fakes.delete k
+      end
+
+      fakes = fakes.to_a
+      fakes += attributes.to_a
+
+      fakes
+    end
+
+    # override this to provide basic attributes (like name) dynamically
+    def default_fakes
+      self.class.defaults.merge(
+        :guid => random_string("fake-#{object_name}-guid"))
+    end
+
+    def setup_reverse_relationship(v)
+      if v.is_a?(Array)
+        v.each do |x|
+          setup_reverse_relationship(x)
+        end
+
+        return
+      end
+
+      return unless v.is_a?(Model)
+
+      relation, type = find_reverse_relationship(v)
+
+      v.client = @client
+
+      if type == :one
+        v.send(:"#{relation}=", self)
+      elsif type == :many
+        v.send(:"#{relation}=", v.send(relation) + [self])
+      end
+    end
+
+    def find_reverse_relationship(v)
+      singular = object_name
+      plural = plural_object_name
+
+      v.class.to_one_relations.each do |attr, opts|
+        return [attr, :one] if attr == singular
+        return [attr, :one] if opts[:as] == singular
+      end
+
+      v.class.to_many_relations.each do |attr, opts|
+        return [attr, :many] if attr == plural
+        return [attr, :many] if opts[:as] == singular
+      end
+    end
+  end
+
+
+  class FakeBase < Base
+  end
+
+
+  class FakeClient < Client
+    include Fake
+
+    def initialize(target = "http://example.com", token = nil)
+      @base = FakeBase.new(target, token)
+    end
+
+    private
+
+    def get_many(plural)
+      instance_variable_get(:"@#{plural}")
+    end
+
+    def fake_attributes(attributes)
+      attributes
+    end
+
+    def setup_reverse_relationship(v)
+      if v.is_a?(Model)
+        v.client = self
+      elsif v.is_a?(Array)
+        v.each do |x|
+          setup_reverse_relationship(x)
+        end
+      end
+    end
+  end
+
+
+  class FakeModel < CFoundry::V2::Model
+    attr_reader :diff
+
+    def self.inherited(klass)
+      class << klass
+        attr_writer :object_name
+      end
+
+      # There is a difference between ruby 1.8.7 and 1.8.8 in the order that
+      # the inherited callback gets called. In 1.8.7 the inherited callback
+      # is called after the block; in 1.8.8 and later it's called before.
+      # The upshot for us is we need a failproof way of getting the name
+      # to klass. So we're using a global variable to hand off the value.
+      # Please don't shoot us. - ESH & MMB
+      klass.object_name = $object_name
+      super
+    end
+
+    class << self
+      attr_writer :object_name
+    end
+  end
+
+
+  module ModelMagic
+    def self.define_client_methods(&blk)
+      FakeClient.module_eval(&blk)
+    end
+
+    def self.define_base_client_methods(&blk)
+      FakeBase.module_eval(&blk)
+    end
+  end
+
+  Model.objects.each_value do |klass|
+    klass.to_many_relations.each do |plural, _|
+      Fake.define_many_association(klass, plural)
+    end
+
+    FakeClient.class_eval do
+      plural = klass.plural_object_name
+
+      attr_writer plural
+      Fake.define_many_association(self, plural)
+    end
+  end
+end

data/vendor/cfoundry-0.5.2/spec/support/randoms.rb

@@ -0,0 +1,3 @@
+def random_string(tag = "random")
+  sprintf("%s-%x", tag, rand(10 ** 6))
+end

data/vendor/cfoundry-0.5.2/spec/support/shared_examples/cc_api_stub_request_examples.rb

@@ -0,0 +1,79 @@
+shared_examples_for 'a stubbed get request' do |*options|
+  options = {:code => 200}.merge(options.first || {})
+
+  it "stubs a get request" do
+    subject
+    response = Net::HTTP.get_response(URI.parse(url))
+    check_response(response, options)
+  end
+end
+
+shared_examples_for 'a stubbed post request' do |*options|
+  options = {:code => 201, :params => {}}.merge(options.first || {})
+
+  it "stubs a post request" do
+    subject
+    response = Net::HTTP.post_form(URI.parse(url), options[:params])
+    check_response(response, options)
+  end
+end
+
+shared_examples_for 'a stubbed put request' do |*options|
+  options = {:code => 200, :params => {}}.merge(options.first || {})
+
+  it "stubs a put request" do
+    subject
+    uri = URI.parse(url)
+    Net::HTTP.start(uri.host, uri.port) do |http|
+      request = Net::HTTP::Put.new(url, options[:params])
+      response = http.request(request)
+      check_response(response, options)
+    end
+  end
+end
+
+shared_examples_for 'a stubbed delete request' do |*options|
+  options = {:code => 200, :ignore_response => true}.merge(options.first || {})
+
+  it "stubs a delete request" do
+    subject
+    uri = URI.parse(url)
+    Net::HTTP.start(uri.host, uri.port) do |http|
+      request = Net::HTTP::Delete.new(url)
+      response = http.request(request)
+      check_response(response, options)
+    end
+  end
+end
+
+def check_response(response, options)
+  response.code.should == options[:code].to_s
+
+  unless options[:ignore_response]
+    json = JSON.parse(response.body)
+    json.should be_a(Hash)
+
+    if options[:including_json]
+      if Proc === options[:including_json]
+        options[:including_json][json]
+      else
+        json.should deep_hash_include(options[:including_json])
+      end
+    end
+  end
+end
+
+RSpec::Matchers.define :deep_hash_include do |expected|
+  def deep_hash_include_rec(actual_hash, partial_hash)
+    partial_hash.reduce(true) do |bool, (key, val)|
+      actual_val = actual_hash[key]
+      bool && ((Hash === actual_val) ?
+        deep_hash_include_rec(actual_val, partial_hash[key]) :
+        actual_val == val)
+    end
+  end
+
+  match do |actual|
+    deep_hash_include_rec(actual, expected)
+  end
+end

data/vendor/cfoundry-0.5.2/spec/support/shared_examples/client_login_examples.rb

@@ -0,0 +1,46 @@
+shared_examples_for 'client login prompts' do
+  let(:uaa) { CFoundry::UAAClient.new }
+  let(:prompts) do
+    {
+      :user_id => ["text", "User ID"],
+      :pin => ["password", "Your 8-digit Pin #"]
+    }
+  end
+
+  before do
+    stub(client.base).uaa { uaa }
+    stub(uaa).prompts { prompts }
+  end
+
+  subject { client.login_prompts }
+
+  it 'returns the prompts provided by UAA' do
+    expect(subject).to eq(prompts)
+  end
+end
+
+shared_examples_for 'client login' do
+  let(:email) { 'test@test.com' }
+  let(:password) { 'secret' }
+  let(:uaa) { CFoundry::UAAClient.new }
+  let(:access_token) { "some-access-token" }
+  let(:token_info) { CF::UAA::TokenInfo.new({ :access_token => access_token, :token_type => "bearer" }) }
+
+  before do
+    stub(client.base).uaa { uaa }
+    stub(uaa).authorize(email, password) { token_info }
+  end
+
+  subject { client.login(email, password) }
+
+  it 'returns a UAA token' do
+    expect(subject).to be_a(CFoundry::AuthToken)
+    expect(subject.auth_header).to eq("bearer #{access_token}")
+  end
+
+  it 'saves the data as the token' do
+    subject
+    expect(client.token).to be_a(CFoundry::AuthToken)
+    expect(client.token.auth_header).to eq("bearer #{access_token}")
+  end
+end

data/vendor/cfoundry-0.5.2/spec/support/shared_examples/model_summary_examples.rb

@@ -0,0 +1,34 @@
+require "multi_json"
+
+shared_examples_for 'a summarizeable model' do
+  describe '#summary' do
+    let(:summary_endpoint) {
+      [ client.target,
+        "v2",
+        mymodel.plural_object_name,
+        myobject.guid,
+        "summary"
+      ].join("/")
+    }
+
+    it 'returns the summary endpoint payload' do
+      req = stub_request(:get, summary_endpoint).to_return :status => 200,
+        :body => MultiJson.encode(summary_attributes)
+
+      expect(subject.summary).to eq(summary_attributes)
+      expect(req).to have_been_requested
+    end
+  end
+
+  describe '#summarize!' do
+    it 'defines basic attributes via #summary' do
+      stub(subject).summary { summary_attributes }
+
+      subject.summarize!
+
+      summary_attributes.each do |k, v|
+        expect(subject.send(k)).to eq v
+      end
+    end
+  end
+end

data/vendor/cfoundry-0.5.2/spec/support/v1_fake_helper.rb

@@ -0,0 +1,144 @@
+module V1Fake
+  module FakeMethods
+    def v1_fake_client(attributes = {})
+      CFoundry::V1::FakeClient.new.fake(attributes)
+    end
+
+    def v1_fake(what, attributes = {})
+      v1_fake_client.send(what).fake(attributes)
+    end
+
+    def v1_fake_list(what, count, attributes = {})
+      objs = []
+
+      count.times do
+        objs << fake(what, attributes)
+      end
+
+      objs
+    end
+
+    def v1_fake_model(name = :my_fake_model, &init)
+      # There is a difference between ruby 1.8.7 and 1.8.8 in the order that
+      # the inherited callback gets called. In 1.8.7 the inherited callback
+      # is called after the block; in 1.8.8 and later it's called before.
+      # The upshot for us is we need a failproof way of getting the name
+      # to klass. So we're using a global variable to hand off the value.
+      # Please don't shoot us. - ESH & MMB
+      $object_name = name
+      klass = Class.new(CFoundry::V1::FakeModel) do
+        self.object_name = name
+      end
+
+      klass.class_eval(&init) if init
+
+      klass.define_client_methods
+
+      klass
+    end
+  end
+
+  def fake(attributes = {})
+    fake_attributes(attributes).each do |k, v|
+      send(:"#{k}=", v)
+      setup_reverse_relationship(v)
+    end
+
+    self
+  end
+
+  def setup_reverse_relationship(v)
+    # assign relationship for 'v' pointing back to this object
+  end
+end
+
+module CFoundry::V1
+  class Model
+    include V1Fake
+
+    attr_writer :client
+
+    private
+
+    def get_many(plural)
+      @cache[plural]
+    end
+
+    def fake_attributes(attributes)
+      default_fakes.merge(attributes)
+    end
+
+    # override this to provide basic attributes (like name) dynamically
+    def default_fakes
+      {}
+    end
+  end
+
+
+  class FakeBase < Base
+  end
+
+
+  class FakeClient < Client
+    include Fake
+
+    def initialize(target = "http://example.com", token = nil)
+      @base = FakeBase.new(target, token)
+    end
+
+    private
+
+    def get_many(plural)
+      instance_variable_get(:"@#{plural}")
+    end
+
+    def fake_attributes(attributes)
+      attributes
+    end
+
+    def setup_reverse_relationship(v)
+      if v.is_a?(Model)
+        v.client = self
+      elsif v.is_a?(Array)
+        v.each do |x|
+          setup_reverse_relationship(x)
+        end
+      end
+    end
+  end
+
+
+  class FakeModel < CFoundry::V1::Model
+    attr_reader :diff
+
+    def self.inherited(klass)
+      class << klass
+        attr_writer :object_name
+      end
+
+      # There is a difference between ruby 1.8.7 and 1.8.8 in the order that
+      # the inherited callback gets called. In 1.8.7 the inherited callback
+      # is called after the block; in 1.8.8 and later it's called before.
+      # The upshot for us is we need a failproof way of getting the name
+      # to klass. So we're using a global variable to hand off the value.
+      # Please don't shoot us. - ESH & MMB
+      klass.object_name = $object_name
+      super
+    end
+
+    class << self
+      attr_writer :object_name
+    end
+  end
+
+
+  module ModelMagic
+    def self.on_client(&blk)
+      FakeClient.module_eval(&blk)
+    end
+
+    def self.on_base_client(&blk)
+      FakeBase.module_eval(&blk)
+    end
+  end
+end

data/vendor/cfoundry-0.5.2/vendor/errors/README.md

@@ -0,0 +1,4 @@
+cf-errors
+=========
+
+Shared error codes and messages for Cloud Foundry