cfoundry 0.6.1.rc4 → 0.7.0.rc1

data/lib/cfoundry/v1/model_magic.rb

@@ -1,129 +0,0 @@
-require "cfoundry/validator"
-
-module CFoundry::V1
-  module BaseClientMethods
-  end
-
-  module ClientMethods
-  end
-
-  module ModelMagic
-    attr_accessor :guid_name
-
-    def read_locations
-      @read_locations ||= {}
-    end
-
-    def write_locations
-      @write_locations ||= {}
-    end
-
-    def read_only_attributes
-      @read_only_attributes ||= []
-    end
-
-    def on_client(&blk)
-      ClientMethods.module_eval(&blk)
-    end
-
-    def on_base_client(&blk)
-      BaseClientMethods.module_eval(&blk)
-    end
-
-    def define_client_methods(klass = self)
-      singular = klass.object_name
-      plural = klass.plural_object_name
-
-      base_singular = klass.base_object_name
-      base_plural = klass.plural_base_object_name
-
-      on_base_client do
-        define_method(base_singular) do |guid|
-          get(base_plural, guid, :accept => :json)
-        end
-
-        define_method(:"create_#{base_singular}") do |payload|
-          post(base_plural, :content => :json, :accept => :json, :payload => payload)
-        end
-
-        define_method(:"delete_#{base_singular}") do |guid|
-          delete(base_plural, guid)
-          true
-        end
-
-        define_method(:"update_#{base_singular}") do |guid, payload|
-          put(base_plural, guid, :content => :json, :payload => payload)
-        end
-
-        define_method(base_plural) do |*args|
-          get(base_plural, :accept => :json)
-        end
-      end
-
-      on_client do
-        if klass.guid_name
-          define_method(:"#{singular}_by_#{klass.guid_name}") do |guid|
-            obj = send(singular, guid)
-            obj if obj.exists?
-          end
-        end
-
-        define_method(singular) do |*args|
-          guid, _ = args
-          klass.new(guid, self)
-        end
-
-        define_method(plural) do |*args|
-          options, _ = args
-          options ||= {}
-
-          @base.send(base_plural).collect do |json|
-            klass.new(json[klass.guid_name], self, json)
-          end
-        end
-      end
-    end
-
-    def attribute(name, type, opts = {})
-      default = opts[:default]
-      is_guid = opts[:guid]
-      read_only = opts[:read_only]
-      write_only = opts[:write_only]
-      has_default = opts.key?(:default)
-
-      read_locations[name] = Array(opts[:read] || opts[:at] || name) unless write_only
-      write_locations[name] = Array(opts[:write] || opts[:at] || name) unless read_only
-
-      read_only_attributes << name if read_only
-
-      self.guid_name = name if is_guid
-
-      define_method(name) do
-        return @guid if @guid && is_guid
-
-        read = read_manifest
-        read.key?(name) ? read[name] : default
-      end
-
-      define_method(:"#{name}=") do |val|
-        unless has_default && val == default
-          CFoundry::Validator.validate_type(val, type)
-        end
-
-        @guid = val if is_guid
-
-        @manifest ||= {}
-
-        old = read_manifest[name]
-        @changes[name] = [old, val] if old != val
-
-        write_to = read_only ? self.class.read_locations : self.class.write_locations
-
-        put(val, @manifest, write_to[name])
-      end
-
-      private name if write_only
-      private :"#{name}=" if read_only
-    end
-  end
-end

data/lib/cfoundry/v1/runtime.rb

@@ -1,24 +0,0 @@
-module CFoundry::V1
-  class Runtime
-    attr_accessor :name, :description, :debug_modes
-
-    def initialize(name, description = nil, debug_modes = nil)
-      @name = name
-      @description = description
-      @debug_modes = debug_modes
-    end
-
-    def eql?(other)
-      other.is_a?(self.class) && other.name == @name
-    end
-    alias :== :eql?
-
-    def apps
-      [] # not supported by v1
-    end
-
-    def debug_modes
-      @debug_modes || []
-    end
-  end
-end

data/lib/cfoundry/v1/service.rb

@@ -1,39 +0,0 @@
-module CFoundry::V1
-  class Service
-    attr_accessor :label, :version, :description, :type, :provider, :state, :service_plans
-
-    def initialize(label, version = nil, description = nil,
-                   type = nil, provider = "core", state = nil,
-                   service_plans = [])
-      @label = label
-      @description = description
-      @version = version
-      @type = type
-      @provider = provider
-      @state = state
-      @service_plans = service_plans
-    end
-
-    def eql?(other)
-      other.is_a?(self.class) && other.label == @label
-    end
-    alias :== :eql?
-
-    def active
-      true
-    end
-
-    def deprecated?
-      @state == :deprecated
-    end
-
-    def current?
-      @state == :current
-    end
-
-    def default_service_plan
-      service_plans.find(&:default?)
-    end
-
-  end
-end

data/lib/cfoundry/v1/service_instance.rb

@@ -1,32 +0,0 @@
-require "cfoundry/v1/model"
-
-module CFoundry::V1
-  class ServiceInstance < Model
-    self.base_object_name = :service
-
-    attribute :name,       :string,   :guid => true
-    attribute :created,    :integer,  :at => [:meta, :created]
-    attribute :updated,    :integer,  :at => [:meta, :updated]
-    attribute :tags,       [:string], :at => [:meta, :tags]
-    attribute :type,       :string
-    attribute :vendor,     :string
-    attribute :version,    :string
-    attribute :tier,       :string
-    attribute :properties, :hash
-
-    define_client_methods
-
-    alias_method :created_unix, :created
-    alias_method :updated_unix, :updated
-
-    # Timestamp of when the service was created.
-    def created
-      Time.at(created_unix)
-    end
-
-    # Timestamp of when the service was last updated.
-    def updated
-      Time.at(updated_unix)
-    end
-  end
-end

data/lib/cfoundry/v1/service_plan.rb

@@ -1,19 +0,0 @@
-module CFoundry::V1
-
-  class ServicePlan
-
-    attr_accessor :name, :description
-
-    def initialize(name, description, is_default)
-      @name = name
-      @description = description
-      @is_default = is_default
-    end
-
-    def default?
-      @is_default
-    end
-
-  end
-
-end

data/lib/cfoundry/v1/user.rb

@@ -1,22 +0,0 @@
-require "cfoundry/v1/model"
-
-module CFoundry::V1
-  class User < Model
-    attribute :email,    :string, :guid => true
-    attribute :password, :string, :write_only => true
-    attribute :admin,    :boolean
-
-    define_client_methods
-
-    alias_method :admin?, :admin
-
-    def change_password!(new, old)
-      if @client.base.uaa
-        @client.base.uaa.change_password(guid, new, old)
-      else
-        self.password = new
-        update!
-      end
-    end
-  end
-end

data/spec/cfoundry/v1/base_spec.rb

@@ -1,96 +0,0 @@
-require "spec_helper"
-
-describe CFoundry::V1::Base do
-  let(:base) { CFoundry::V1::Base.new("https://api.cloudfoundry.com") }
-
-  describe '#get' do
-    let(:options) { {} }
-    subject { base.get("foo", options) }
-
-    context 'when successful' do
-      context 'and the accept type is JSON' do
-        let(:options) { {:accept => :json} }
-
-        it 'returns the parsed JSON' do
-          stub_request(:get, 'https://api.cloudfoundry.com/foo').to_return :status => 201, :body => "{\"hello\": \"there\"}"
-          expect(subject).to eq(:hello => "there")
-        end
-      end
-
-      context 'and the accept type is not JSON' do
-        let(:options) { {:accept => :form} }
-
-        it 'returns the body' do
-          stub_request(:get, 'https://api.cloudfoundry.com/foo').to_return :status => 201, :body =>  "body"
-          expect(subject).to eq "body"
-        end
-      end
-    end
-
-    context 'when an error occurs' do
-      let(:response_code) { 404 }
-
-      it 'raises the correct error if JSON is parsed successfully' do
-        stub_request(:get, 'https://api.cloudfoundry.com/foo').to_return :status => response_code,
-          :body =>  "{\"code\": 111, \"description\": \"Something bad happened\"}"
-        expect {subject}.to raise_error CFoundry::SystemError, "111: Something bad happened"
-      end
-
-      it 'raises the correct error if code is missing from response' do
-        stub_request(:get, 'https://api.cloudfoundry.com/foo').to_return :status => response_code,
-          :body =>  "{\"description\": \"Something bad happened\"}"
-        expect {subject}.to raise_error CFoundry::NotFound
-      end
-
-      it 'raises the correct error if response body is not JSON' do
-        stub_request(:get, 'https://api.cloudfoundry.com/foo').to_return :status => response_code,
-          :body =>  "Error happened"
-        expect {subject}.to raise_error CFoundry::NotFound
-      end
-
-      it 'raises a generic APIError if code is not recognized' do
-        stub_request(:get, 'https://api.cloudfoundry.com/foo').to_return :status => response_code,
-          :body =>  "{\"code\": 6932, \"description\": \"Something bad happened\"}"
-        expect {subject}.to raise_error CFoundry::APIError, "6932: Something bad happened"
-      end
-    end
-  end
-
-  describe "#upload_app" do
-    let!(:stubbed_request) do
-      stub_request(:post, 'https://api.cloudfoundry.com/apps/app_name/application').to_return(:status => 200).with(:body => /#{expected_zipfile}/)
-    end
-
-    subject { base.upload_app("app_name", zipfile)}
-
-    context "when passed a falsy zipfile" do
-      let(:zipfile) { false }
-      let(:expected_zipfile) { "empty.zip" }
-
-      it "creates a temporary empty zipfile" do
-        subject
-
-        stubbed_request.should have_been_requested
-      end
-    end
-
-    context "when passed a valid zipfile" do
-      let(:zipfile) { "proper-zipfile.zip" }
-      let(:expected_zipfile) { zipfile }
-
-      before do
-        File.new(zipfile, "wb")
-      end
-
-      after do
-        FileUtils.rm(zipfile)
-      end
-
-      it "uses that zipfile" do
-        subject
-
-        stubbed_request.should have_been_requested
-      end
-    end
-  end
-end

data/spec/cfoundry/v1/client_spec.rb

@@ -1,17 +0,0 @@
-require "spec_helper"
-
-describe CFoundry::V1::Client do
-  let(:client) { CFoundry::V1::Client.new }
-
-  describe "#version" do
-    its(:version) { should eq 1 }
-  end
-
-  describe "#login" do
-    include_examples "client login"
-  end
-
-  describe "#login_prompts" do
-    include_examples "client login prompts"
-  end
-end

data/spec/cfoundry/v1/model_magic_spec.rb

@@ -1,43 +0,0 @@
-require "spec_helper"
-
-describe CFoundry::V1::ModelMagic do
-  let(:client) { v1_fake_client }
-  let(:mymodel) { v1_fake_model }
-  let(:guid) { random_string("my-object-guid") }
-  let(:myobject) { mymodel.new(guid, client) }
-
-  describe "#read_manifest" do
-    context "with an attribute with different read/write locations" do
-      let(:mymodel) do
-        v1_fake_model do
-          attribute :foo, :string, :read => :x, :write => [:y, :z]
-        end
-      end
-
-      before do
-        stub(client.base).my_fake_model { { :x => "abc" } }
-      end
-
-      it "reads from the write location" do
-        expect {
-          myobject.foo = "def"
-        }.to change { myobject.read_manifest[:foo] }.from("abc").to("def")
-      end
-    end
-  end
-
-  describe "#write_manifest" do
-    context "with a read-only attribute" do
-      let(:mymodel) do
-        v1_fake_model do
-          attribute :foo, :string, :read_only => true
-        end
-      end
-
-      it "does not include the attribute" do
-        myobject.fake(:foo => "bar")
-        expect(myobject.write_manifest).to_not include :foo
-      end
-    end
-  end
-end

data/spec/support/v1_fake_helper.rb

@@ -1,144 +0,0 @@
-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 V1Fake
-
-    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