cloudfoundry-client 0.1.0

data/spec/client/info_spec.rb

@@ -0,0 +1,92 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe "Cloudfoundry::Client::Info" do
+  include CfConnectionHelper
+
+  context "without a user logged in" do
+    before(:all) do
+      VCR.use_cassette("no_logged/client", :record => :new_episodes) do
+        @cf_client = client_no_logged()
+      end
+    end
+
+    use_vcr_cassette "no_logged/info", :record => :new_episodes
+
+    it "should properly get basic information from target cloud" do
+      cloud_info = @cf_client.cloud_info()
+      cloud_info.should have_key :name
+      cloud_info.should have_key :build
+      cloud_info.should have_key :support
+      cloud_info.should have_key :version
+      cloud_info.should have_key :description
+      cloud_info.should have_key :allow_debug
+    end
+
+    it "should not return user account information from target cloud" do
+      cloud_info = @cf_client.cloud_info()
+      cloud_info.should_not have_key :user
+      cloud_info.should_not have_key :usage
+      cloud_info.should_not have_key :limits
+    end
+
+    it "should get a proper list of runtimes available at target cloud" do
+      cloud_runtimes_info = @cf_client.cloud_runtimes_info()
+      cloud_runtimes_info.should have_at_least(1).items
+      runtime_info = cloud_runtimes_info.first[1]
+      runtime_info.should have_key :version
+    end
+
+    it "should raise an AuthError exception when requesting system services" do
+      expect {
+        cloud_services_info = @cf_client.cloud_services_info()
+      }.to raise_exception(CloudFoundry::Client::Exception::AuthError)
+    end
+  end
+
+  context "with a user logged in" do
+    before(:all) do
+      VCR.use_cassette("user_logged/client", :record => :new_episodes) do
+        @cf_client = client_user_logged()
+      end
+    end
+
+    use_vcr_cassette "user_logged/info", :record => :new_episodes
+
+    it "should properly get basic account information from target cloud" do
+      cloud_info = @cf_client.cloud_info()
+      cloud_info.should have_key :name
+      cloud_info.should have_key :build
+      cloud_info.should have_key :support
+      cloud_info.should have_key :version
+      cloud_info.should have_key :description
+      cloud_info.should have_key :allow_debug
+    end
+
+    it "should properly get user account information from target cloud" do
+      cloud_info = @cf_client.cloud_info()
+      cloud_info.should have_key :user
+      cloud_info.should have_key :usage
+      cloud_info.should have_key :limits
+      cloud_info[:user].should eql(@user)
+    end
+
+    it "should get a proper list of runtimes available at target cloud" do
+      cloud_runtimes_info = @cf_client.cloud_runtimes_info()
+      cloud_runtimes_info.should have_at_least(1).items
+      runtime_info = cloud_runtimes_info.first[1]
+      runtime_info.should have_key :version
+    end
+
+    it "should get a proper list of system services available at target cloud" do
+      cloud_services_info = @cf_client.cloud_services_info()
+      cloud_services_info.should have_at_least(1).items
+      system_service_info = cloud_services_info.first[1].values[0].first[1]
+      system_service_info.should have_key :id
+      system_service_info.should have_key :type
+      system_service_info.should have_key :vendor
+      system_service_info.should have_key :version
+      system_service_info.should have_key :description
+      system_service_info.should have_key :tiers
+    end
+  end
+end

data/spec/client/resources_spec.rb

@@ -0,0 +1,52 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe "Cloudfoundry::Client::Resources" do
+  include CfConnectionHelper
+
+  context "without a user logged in" do
+    before(:all) do
+      VCR.use_cassette("no_logged/client", :record => :new_episodes) do
+        @cf_client = client_no_logged()
+      end
+    end
+
+    use_vcr_cassette "no_logged/resources", :record => :new_episodes
+
+    it "should raise an AuthError exception when checking resources at target cloud" do
+      expect {
+        resources = []
+        resources_manifest = @cf_client.check_resources(resources)
+      }.to raise_exception(CloudFoundry::Client::Exception::AuthError)
+    end
+  end
+
+  context "with a user logged in" do
+    before(:all) do
+      VCR.use_cassette("user_logged/client", :record => :new_episodes) do
+        @cf_client = client_user_logged()
+      end
+    end
+
+    use_vcr_cassette "user_logged/resources", :record => :new_episodes
+
+    it "should properly get an empty resources manifest file from target cloud" do
+      resources = []
+      resources_manifest = @cf_client.check_resources(resources)
+      resources_manifest.should be_empty
+    end
+
+    it "should properly get a resources manifest file from target cloud" do
+      VCR.use_cassette("user_logged/resources_check_action", :record => :new_episodes, :exclusive => true) do
+        resources = []
+        filename = spec_fixture("app.js")
+        resources << {
+          :size => File.size(filename),
+          :sha1 => Digest::SHA1.file(filename).hexdigest,
+          :fn => filename
+        }
+        resources_manifest = @cf_client.check_resources(resources)
+        resources_manifest.should eql(resources)
+      end
+    end
+  end
+end

data/spec/client/services_spec.rb

@@ -0,0 +1,230 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe "Cloudfoundry::Client::Services" do
+  include CfConnectionHelper
+
+  context "without a user logged in" do
+    before(:all) do
+      VCR.use_cassette("no_logged/client", :record => :new_episodes) do
+        @cf_client = client_no_logged()
+      end
+    end
+
+    use_vcr_cassette "no_logged/services", :record => :new_episodes
+
+    it "should raise an AuthError exception when creating a provisioned service" do
+      expect {
+        created = @cf_client.create_service("redis", "redis-mock")
+      }.to raise_exception(CloudFoundry::Client::Exception::AuthError)
+    end
+
+    it "should raise an AuthError exception when listing provisioned services at target cloud" do
+      expect {
+        services = @cf_client.list_services()
+      }.to raise_exception(CloudFoundry::Client::Exception::AuthError)
+    end
+
+    it "should raise an AuthError exception when retrieving provisioned service information from target cloud" do
+      expect {
+        service_info = @cf_client.service_info("redis-mock")
+      }.to raise_exception(CloudFoundry::Client::Exception::AuthError)
+    end
+
+    it "should raise an AuthError exception when binding a provisioned service to an application at target cloud" do
+      expect {
+        binded = @cf_client.bind_service("redis-mock", "newapp")
+      }.to raise_exception(CloudFoundry::Client::Exception::AuthError)
+    end
+
+    it "should raise an AuthError exception when unbinding a provisioned service to an application at target cloud" do
+      expect {
+        unbinded = @cf_client.unbind_service("redis-mock", "newapp")
+      }.to raise_exception(CloudFoundry::Client::Exception::AuthError)
+    end
+
+    it "should raise an AuthError exception when deleting a provisioned service at target cloud" do
+      expect {
+        deleted = @cf_client.delete_service("redis-mock")
+      }.to raise_exception(CloudFoundry::Client::Exception::AuthError)
+    end
+  end
+
+  context "with a user logged in" do
+    before(:all) do
+      VCR.use_cassette("user_logged/client", :record => :new_episodes) do
+        @cf_client = client_user_logged()
+      end
+    end
+
+    use_vcr_cassette "user_logged/services", :record => :new_episodes
+
+    it "should raise a BadParams exception when creating a provisioned service with a blank system service" do
+      expect {
+        created = @cf_client.create_service("", "redis-mock")
+      }.to raise_exception(CloudFoundry::Client::Exception::BadParams)
+    end
+
+    it "should raise a BadParams exception when creating a provisioned service with a blank name" do
+      expect {
+        created = @cf_client.create_service("redis", "")
+      }.to raise_exception(CloudFoundry::Client::Exception::BadParams)
+    end
+
+    it "should raise a BadParams exception when creating a provisioned service with an invalid system service" do
+      expect {
+        created = @cf_client.create_service("noservice", "redis-mock")
+      }.to raise_exception(CloudFoundry::Client::Exception::BadParams)
+    end
+
+    it "should return true if a new provisioned service is created at target cloud" do
+      VCR.use_cassette("user_logged/services_create_action", :record => :new_episodes, :exclusive => true) do
+        created = @cf_client.create_service("redis", "redis-mock")
+        created.should be_true
+      end
+    end
+
+    it "should raise a BadRequest exception when creating a provisioned service that already exists at target cloud" do
+      expect {
+        created = @cf_client.create_service("redis", "redis-mock")
+      }.to raise_exception(CloudFoundry::Client::Exception::BadRequest)
+    end
+
+    it "should get a proper list of provisioned services at target cloud" do
+      services = @cf_client.list_services()
+      services.should have_at_least(1).items
+      service_info = services.first
+      service_info.should have_key :type
+      service_info.should have_key :vendor
+      service_info.should have_key :name
+      service_info.should have_key :version
+      service_info.should have_key :tier
+      service_info.should have_key :meta
+      service_info.should have_key :properties
+    end
+
+    it "should raise a BadParams exception when retrieving information about a provisioned service with a blank name" do
+      expect {
+        service_info = @cf_client.service_info("")
+      }.to raise_exception(CloudFoundry::Client::Exception::BadParams)
+    end
+
+    it "should raise a NotFound exception when retrieving information about a provisioned service that does not exists at target cloud" do
+      expect {
+        service_info = @cf_client.service_info("noservice")
+      }.to raise_exception(CloudFoundry::Client::Exception::NotFound)
+    end
+
+    it "should properly get provisioned service information from target cloud" do
+      service_info = @cf_client.service_info("redis-mock")
+      service_info.should have_key :type
+      service_info.should have_key :vendor
+      service_info.should have_key :name
+      service_info.should have_key :version
+      service_info.should have_key :tier
+      service_info.should have_key :meta
+      service_info.should have_key :properties
+    end
+
+    it "should raise a BadParams exception when binding to an application a provisioned service with a blank name" do
+      expect {
+        binded = @cf_client.bind_service("", "appname")
+      }.to raise_exception(CloudFoundry::Client::Exception::BadParams)
+    end
+
+    it "should raise a BadParams exception when binding a provisioned service to an application with a blank name" do
+      expect {
+        binded = @cf_client.bind_service("redis-mock", "")
+      }.to raise_exception(CloudFoundry::Client::Exception::BadParams)
+    end
+
+    it "should raise a NotFound exception when binding to an application a provisioned service that does not exists" do
+      expect {
+        binded = @cf_client.bind_service("noservice", "appname")
+      }.to raise_exception(CloudFoundry::Client::Exception::NotFound)
+    end
+
+    it "should raise a NotFound exception when binding a provisioned service to an application that does not exists" do
+      expect {
+        binded = @cf_client.bind_service("redis-mock", "appname")
+      }.to raise_exception(CloudFoundry::Client::Exception::NotFound)
+    end
+
+    it "should return true if a provisioned service is binded to an application at target cloud" do
+      VCR.use_cassette("user_logged/services_bind_action", :record => :new_episodes, :exclusive => true) do
+        manifest = {
+          :name => "newapp",
+          :uris => ["newapp.vcap.me"],
+          :instances => 1,
+          :staging => {:model => "node"},
+          :resources => {:memory => 64}
+        }
+        created = @cf_client.create_app("newapp", manifest)
+        binded = @cf_client.bind_service("redis-mock", "newapp")
+        binded.should be_true
+      end
+    end
+
+    it "should raise a BadParams exception when binding a provisioned service to an application already binded" do
+      expect {
+        binded = @cf_client.bind_service("redis-mock", "newapp")
+      }.to raise_exception(CloudFoundry::Client::Exception::BadParams)
+    end
+
+    it "should raise a BadParams exception when unbinding from an application a provisioned service with a blank name" do
+      expect {
+        unbinded = @cf_client.unbind_service("", "appname")
+      }.to raise_exception(CloudFoundry::Client::Exception::BadParams)
+    end
+
+    it "should raise a BadParams exception when unbinding a provisioned service from an application with a blank name" do
+      expect {
+        unbinded = @cf_client.unbind_service("redis-mock", "")
+      }.to raise_exception(CloudFoundry::Client::Exception::BadParams)
+    end
+
+    it "should raise a NotFound exception when unbinding a provisioned service that does not exists from an application" do
+      expect {
+        unbinded = @cf_client.unbind_service("noservice", "appname")
+      }.to raise_exception(CloudFoundry::Client::Exception::NotFound)
+    end
+
+    it "should raise a NotFound exception when unbinding a provisioned service from an application that does not exists" do
+      expect {
+        unbinded = @cf_client.unbind_service("redis-mock", "appname")
+      }.to raise_exception(CloudFoundry::Client::Exception::NotFound)
+    end
+
+    it "should return true if a provisioned service is binded to an application at target cloud" do
+      VCR.use_cassette("user_logged/services_unbind_action", :record => :new_episodes, :exclusive => true) do
+        unbinded = @cf_client.unbind_service("redis-mock", "newapp")
+        unbinded.should be_true
+      end
+    end
+
+    it "should raise a BadParams exception when unbinding a provisioned service from an application that is not binded" do
+      VCR.use_cassette("user_logged/services_unbind_fail_action", :record => :new_episodes, :exclusive => true) do
+        expect {
+          unbinded = @cf_client.unbind_service("redis-mock", "newapp")
+        }.to raise_exception(CloudFoundry::Client::Exception::BadParams)
+        deleted = @cf_client.delete_app("newapp")
+      end
+    end
+
+    it "should raise a BadParams exception when deleting a provisioned service with a blank name" do
+      expect {
+        deleted = @cf_client.delete_service("")
+      }.to raise_exception(CloudFoundry::Client::Exception::BadParams)
+    end
+
+    it "should raise a NotFound exception when deleting a provisioned service that does not exists at target cloud" do
+      expect {
+        deleted = @cf_client.delete_service("noservice")
+      }.to raise_exception(CloudFoundry::Client::Exception::NotFound)
+    end
+
+    it "should return true if a provisioned service is deleted at target cloud" do
+      deleted = @cf_client.delete_service("redis-mock")
+      deleted.should be_true
+    end
+  end
+end

data/spec/client/users_spec.rb

@@ -0,0 +1,367 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe "Cloudfoundry::Client::Users" do
+  include CfConnectionHelper
+
+  context "without a user logged in" do
+    before(:all) do
+      VCR.use_cassette("no_logged/client", :record => :new_episodes) do
+        @cf_client = client_no_logged()
+      end
+    end
+
+    use_vcr_cassette "no_logged/users", :record => :new_episodes
+
+    it "should return true if a new user is created at target cloud" do
+      created = @cf_client.create_user("fakeuser1@vcap.me", "foobar")
+      created.should be_true
+    end
+
+    it "should raise an AuthError exception when listing all users at target cloud" do
+      expect {
+        users = @cf_client.list_users()
+      }.to raise_exception(CloudFoundry::Client::Exception::AuthError)
+    end
+
+    it "should raise an AuthError exception when retrieving user information from target cloud" do
+      expect {
+        user_info = @cf_client.user_info("user@vcap.me")
+      }.to raise_exception(CloudFoundry::Client::Exception::AuthError)
+    end
+
+    it "should raise an AuthError exception when updating a user at target cloud" do
+      expect {
+        updated = @cf_client.update_user("user@vcap.me", "foobar")
+      }.to raise_exception(CloudFoundry::Client::Exception::AuthError)
+    end
+
+    it "should raise an AuthError exception when deleting a user at target cloud" do
+      expect {
+        deleted = @cf_client.delete_user("user@vcap.me")
+      }.to raise_exception(CloudFoundry::Client::Exception::AuthError)
+    end
+
+    it "should allow to proxy a user" do
+      proxied_user = @cf_client.set_proxy_user("user@vcap.me")
+      proxied_user.should eql("user@vcap.me")
+      proxied_user.should eql(@cf_client.proxy_user)
+    end
+
+    it "should raise a Forbidden exception when retrieving proxy user account information from target cloud" do
+      VCR.use_cassette("no_logged/users_proxy_action", :record => :new_episodes, :exclusive => true) do
+        expect {
+          proxied_user = @cf_client.set_proxy_user("user@vcap.me")
+          cloud_info = @cf_client.cloud_info()
+        }.to raise_exception(CloudFoundry::Client::Exception::Forbidden)
+      end
+    end
+
+    it "should allow to unproxy a user" do
+      proxied_user = @cf_client.unset_proxy_user()
+      proxied_user.should be_nil
+      @cf_client.proxy_user.should be_nil
+    end
+
+    it "should not get user account information from target cloud" do
+      VCR.use_cassette("no_logged/users_unproxy_action", :record => :new_episodes, :exclusive => true) do
+        proxied_user = @cf_client.unset_proxy_user()
+        cloud_info = @cf_client.cloud_info()
+        cloud_info.should_not have_key :user
+      end
+    end
+
+    it "should raise a BadParams exception when login with a blank email" do
+      expect {
+        @cf_client.login("", "foobar")
+      }.to raise_exception(CloudFoundry::Client::Exception::BadParams)
+    end
+
+    it "should raise a BadParams exception when login with a blank password" do
+      expect {
+        @cf_client.login("user@vcap.me", "")
+      }.to raise_exception(CloudFoundry::Client::Exception::BadParams)
+    end
+
+    it "should raise a Forbidden exception if login to the target cloud fails" do
+      expect {
+        @cf_client.login("user@vcap.me", "password")
+      }.to raise_exception(CloudFoundry::Client::Exception::Forbidden)
+    end
+
+    it "should return false if user is not logged in at target cloud" do
+      @cf_client.logged_in?.should be_false
+      @cf_client.user.should be_nil
+      @cf_client.auth_token.should be_nil
+    end
+
+    it "should allow to login correctly at target cloud and return an auth_token" do
+      VCR.use_cassette("no_logged/users_login_action", :record => :new_episodes, :exclusive => true) do
+        auth_token = @cf_client.login("user@vcap.me", "foobar")
+        @cf_client.user.should_not be_nil
+        @cf_client.user.should eql("user@vcap.me")
+        @cf_client.auth_token.should_not be_nil
+        @cf_client.auth_token.should eql(auth_token)
+      end
+    end
+
+    it "should return true if user is logged in at target cloud" do
+      VCR.use_cassette("no_logged/users_login_action", :record => :new_episodes, :exclusive => true) do
+        @cf_client.logged_in?.should be_true
+      end
+    end
+  end
+
+  context "with a user logged in" do
+    before(:all) do
+      VCR.use_cassette("user_logged/client", :record => :new_episodes) do
+        @cf_client = client_user_logged()
+      end
+    end
+
+    use_vcr_cassette "user_logged/users", :record => :new_episodes
+
+    it "should return true if a new user is created at target cloud" do
+      created = @cf_client.create_user("fakeuser2@vcap.me", "foobar")
+      created.should be_true
+    end
+
+    it "should raise a Forbidden exception when listing all users at target cloud" do
+      expect {
+        users = @cf_client.list_users()
+      }.to raise_exception(CloudFoundry::Client::Exception::Forbidden)
+    end
+
+    it "should raise an Forbidden exception when retrieving not own user information from target cloud" do
+      expect {
+        user_info = @cf_client.user_info("fakeuser1@vcap.me")
+      }.to raise_exception(CloudFoundry::Client::Exception::Forbidden)
+    end
+
+    it "should properly get basic user information from target cloud" do
+      user_info = @cf_client.user_info("user@vcap.me")
+      user_info.should have_key :email
+    end
+
+    it "should raise a Forbidden exception when updating not own user at target cloud" do
+      expect {
+        updated = @cf_client.update_user("fakeuser1@vcap.me", "foobar")
+      }.to raise_exception(CloudFoundry::Client::Exception::Forbidden)
+    end
+
+    it "should return true if a user is updated at target cloud" do
+      updated = @cf_client.update_user("user@vcap.me", "foobar")
+      updated.should be_true
+    end
+
+    it "should raise a Forbidden exception when deleting not now user at target cloud" do
+      expect {
+        deleted = @cf_client.delete_user("fakeuser1@vcap.me")
+      }.to raise_exception(CloudFoundry::Client::Exception::Forbidden)
+    end
+
+    it "should raise a Forbidden exception when deleting a user at target cloud" do
+      expect {
+        deleted = @cf_client.delete_user("user@vcap.me")
+      }.to raise_exception(CloudFoundry::Client::Exception::Forbidden)
+    end
+
+    it "should allow to proxy a user" do
+      proxied_user = @cf_client.set_proxy_user("fakeuser1@vcap.me")
+      proxied_user.should eql("fakeuser1@vcap.me")
+      proxied_user.should eql(@cf_client.proxy_user)
+    end
+
+    it "should raise a Forbidden exception when retrieving proxy user account information from target cloud" do
+      VCR.use_cassette("user_logged/users_proxy_action", :record => :new_episodes, :exclusive => true) do
+        expect {
+          proxied_user = @cf_client.set_proxy_user("fakeuser1@vcap.me")
+          cloud_info = @cf_client.cloud_info()
+        }.to raise_exception(CloudFoundry::Client::Exception::Forbidden)
+      end
+    end
+
+    it "should allow to unproxy a user" do
+      proxied_user = @cf_client.unset_proxy_user()
+      proxied_user.should be_nil
+      @cf_client.proxy_user.should be_nil
+    end
+
+    it "should properly get current user account information from target cloud" do
+      VCR.use_cassette("user_logged/users_unproxy_action", :record => :new_episodes, :exclusive => true) do
+        proxied_user = @cf_client.unset_proxy_user()
+        cloud_info = @cf_client.cloud_info()
+        cloud_info[:user].should eql(@user)
+      end
+    end
+
+    it "should return true if user is logged in at target cloud" do
+      @cf_client.logged_in?.should be_true
+      @cf_client.user.should_not be_nil
+      @cf_client.user.should eql(@user)
+      @cf_client.auth_token.should_not be_nil
+      @cf_client.auth_token.should eql(@auth_token)
+    end
+  end
+
+  context "with an admin user logged in" do
+    before(:all) do
+      VCR.use_cassette("admin_logged/client", :record => :new_episodes) do
+        @cf_client = client_admin_logged()
+      end
+    end
+
+    use_vcr_cassette "admin_logged/users", :record => :new_episodes
+
+    it "should raise a BadParams exception when creating a user with a blank email" do
+      expect {
+        created = @cf_client.create_user("", "foobar")
+      }.to raise_exception(CloudFoundry::Client::Exception::BadParams)
+    end
+
+    it "should raise a BadParams exception when creating a user with a blank password" do
+      expect {
+        created = @cf_client.create_user("fakeuser@vcap.me", "")
+      }.to raise_exception(CloudFoundry::Client::Exception::BadParams)
+    end
+
+    it "should raise a BadRequest exception when creating a user that already exists at target cloud" do
+      expect {
+        created = @cf_client.create_user("user@vcap.me", "foobar")
+      }.to raise_exception(CloudFoundry::Client::Exception::BadRequest)
+    end
+
+    it "should return true if a new user is created at target cloud" do
+      VCR.use_cassette("admin_logged/users_create_action", :record => :new_episodes, :exclusive => true) do
+        created = @cf_client.create_user("fakeuser@vcap.me", "foobar")
+        created.should be_true
+      end
+    end
+
+    it "should get a proper list of users at target cloud" do
+      users = @cf_client.list_users()
+      users.should have_at_least(1).items
+      user_info = users.first
+      user_info.should have_key :email
+      user_info.should have_key :admin
+      user_info.should have_key :apps
+    end
+
+    it "should raise a BadParams exception when retrieving information about a user with a blank email" do
+      expect {
+        user_info = @cf_client.user_info("")
+      }.to raise_exception(CloudFoundry::Client::Exception::BadParams)
+    end
+
+    it "should raise a Forbidden exception when retrieving information about a user that does not exists at target cloud" do
+      expect {
+        user_info = @cf_client.user_info("nouser@vcap.me")
+      }.to raise_exception(CloudFoundry::Client::Exception::Forbidden)
+    end
+
+    it "should properly get basic user information from target cloud" do
+      user_info = @cf_client.user_info("fakeuser@vcap.me")
+      user_info.should have_key :email
+    end
+
+    it "should raise a BadParams exception when updating a user with a blank email" do
+      expect {
+        created = @cf_client.update_user("", "foobar")
+      }.to raise_exception(CloudFoundry::Client::Exception::BadParams)
+    end
+
+    it "should raise a BadParams exception when updating a user with a blank password" do
+      expect {
+        created = @cf_client.update_user("fakeuser@vcap.me", "")
+      }.to raise_exception(CloudFoundry::Client::Exception::BadParams)
+    end
+
+    it "should raise a Forbidden exception when updating a user that does not exists at target cloud" do
+      expect {
+        updated = @cf_client.update_user("nouser@vcap.me", "foobar")
+      }.to raise_exception(CloudFoundry::Client::Exception::Forbidden)
+    end
+
+    it "should return true if a user is updated at target cloud" do
+      updated = @cf_client.update_user("fakeuser@vcap.me", "foobar")
+      updated.should be_true
+    end
+
+    it "should raise a BadParams exception when deleting a user with a blank email" do
+      expect {
+        created = @cf_client.delete_user("")
+      }.to raise_exception(CloudFoundry::Client::Exception::BadParams)
+    end
+
+    it "should raise a Forbidden exception when deleting a user that does not exists at target cloud" do
+      expect {
+        deleted = @cf_client.delete_user("nouser@vcap.me")
+      }.to raise_exception(CloudFoundry::Client::Exception::Forbidden)
+    end
+
+    it "should return true if a user is deleted at target cloud" do
+      deleted = @cf_client.delete_user("fakeuser@vcap.me")
+      deleted.should be_true
+    end
+
+    it "should return true if a user is deleted at target cloud" do
+      deleted = @cf_client.delete_user("fakeuser1@vcap.me")
+      deleted.should be_true
+    end
+
+    it "should return true if a user is deleted at target cloud" do
+      deleted = @cf_client.delete_user("fakeuser2@vcap.me")
+      deleted.should be_true
+    end
+
+    it "should allow to proxy a user" do
+      proxied_user = @cf_client.set_proxy_user("user@vcap.me")
+      proxied_user.should eql("user@vcap.me")
+      proxied_user.should eql(@cf_client.proxy_user)
+    end
+
+    it "should properly get proxy user account information from target cloud" do
+      VCR.use_cassette("admin_logged/users_proxy_action", :record => :new_episodes, :exclusive => true) do
+        proxied_user = @cf_client.set_proxy_user("user@vcap.me")
+        cloud_info = @cf_client.cloud_info()
+        cloud_info[:user].should eql("user@vcap.me")
+        cloud_info[:user].should eql(@cf_client.proxy_user)
+      end
+    end
+
+    it "should allow to proxy a user that does not exists at target cloud" do
+      proxied_user = @cf_client.set_proxy_user("nouser@vcap.me")
+      proxied_user.should eql("nouser@vcap.me")
+      proxied_user.should eql(@cf_client.proxy_user)
+    end
+
+    it "should raise a Forbidden exception when retrieving proxy user account information that does not exists at target cloud" do
+      VCR.use_cassette("admin_logged/users_proxy_nouser_action", :record => :new_episodes, :exclusive => true) do
+        expect {
+          proxied_user = @cf_client.set_proxy_user("nouser@vcap.me")
+          cloud_info = @cf_client.cloud_info()
+        }.to raise_exception(CloudFoundry::Client::Exception::Forbidden)
+      end
+    end
+
+    it "should allow to unproxy a user" do
+      proxied_user = @cf_client.unset_proxy_user()
+      proxied_user.should be_nil
+      @cf_client.proxy_user.should be_nil
+    end
+
+    it "should properly get current user account information from target cloud" do
+      VCR.use_cassette("admin_logged/users_unproxy_action", :record => :new_episodes, :exclusive => true) do
+        proxied_user = @cf_client.unset_proxy_user()
+        cloud_info = @cf_client.cloud_info()
+        cloud_info[:user].should eql(@user)
+      end
+    end
+
+    it "should return true if user is logged in at target cloud" do
+      @cf_client.logged_in?.should be_true
+      @cf_client.user.should_not be_nil
+      @cf_client.user.should eql(@user)
+      @cf_client.auth_token.should eql(@auth_token)
+    end
+  end
+end