right_api_provision 0.1.0

data/spec/right_api_provision/api15_spec.rb

@@ -0,0 +1,262 @@
+require 'spec_helper'
+require 'json'
+require 'right_api_client'
+
+describe "API15 object" do
+
+  BAD_USER_DATA = "RS_server=my.rightscale.com&RS_token=89eeb0b19af40b5b72668dc3caa9934a&RS_sketchy=sketchy1-166.rightscale.com"
+
+  before(:each) do
+    @api = RightApiProvision::API15.new()
+    apiStub = double("RightApi::Client")
+    RightApi::Client.should_receive(:new).and_return(apiStub)
+    @api.connection("someemail", "somepasswd", "someaccountid", "https://my.rightscale.com")
+  end
+
+  it "should find deployment by name" do
+    deploymentsStub = double("deployments", :index => [ :name => "my_fake_deployment" ])
+    @api.instance_variable_get("@connection").should_receive(:deployments).and_return(deploymentsStub)
+    @api.find_deployment_by_name("my_fake_deployment")
+  end
+
+  it "should raise error if deployment not found by name" do
+    deploymentsStub = double("deployments", :index => nil)
+    @api.instance_variable_get("@connection").should_receive(:deployments).and_return(deploymentsStub)
+    lambda{@api.find_deployment_by_name("my_fake_deployment")}.should raise_error
+  end
+
+  it "should raise error if multiple deployments found by name" do
+    deploymentsStub = double("deployments", :index => [ {:name => "my_fake_deployment"}, {:name => "my_fake_deployment2"} ])
+    @api.instance_variable_get("@connection").should_receive(:deployments).and_return(deploymentsStub)
+    lambda{@api.find_deployment_by_name("my_fake_deployment")}.should raise_error
+  end
+
+  it "should find server by name" do
+    serversStub = double("servers", :index => [ :name => "my_fake_server" ])
+    @api.instance_variable_get("@connection").should_receive(:servers).and_return(serversStub)
+    @api.find_server_by_name("my_fake_server")
+  end
+
+  it "should raise error if multiple servers found by name" do
+    serversStub = double("servers", :index => [ {:name => "my_fake_server"}, {:name => "my_fake_server2"} ])
+    @api.instance_variable_get("@connection").should_receive(:servers).and_return(serversStub)
+    lambda{@api.find_server_by_name("my_fake_server")}.should raise_error
+  end
+
+  it "should find cloud by name" do
+    cloudsStub = double("clouds", :index => [ :name => "my_fake_cloud" ])
+    @api.instance_variable_get("@connection").should_receive(:clouds).and_return(cloudsStub)
+    @api.find_cloud_by_name("my_fake_cloud")
+  end
+
+  it "should raise error if cloud not found by name" do
+    cloudsStub = double("clouds", :index => nil)
+    @api.instance_variable_get("@connection").should_receive(:clouds).and_return(cloudsStub)
+    lambda{@api.find_cloud_by_name("my_fake_cloud")}.should raise_error
+  end
+
+  it "should find MCI by name" do
+    mcisStub = double("multi_cloud_images", :index => [ :name => "my_fake_mci" ])
+    @api.instance_variable_get("@connection").should_receive(:multi_cloud_images).and_return(mcisStub)
+    @api.find_mci_by_name("my_fake_mci")
+  end
+
+  it "should raise error if multiple MCI found by name" do
+    mcisStub = double("multi_cloud_images", :index => [ {:name => "my_fake_mci"}, {:name => "my_fake_mci2"} ])
+    @api.instance_variable_get("@connection").should_receive(:multi_cloud_images).and_return(mcisStub)
+    lambda{@api.find_mci_by_name("my_fake_mci")}.should raise_error
+  end
+
+  it "should find servertemplate by name" do
+    servertemplatesStub = double("servertemplates", :index => [ double("servertemplate", :name => "my_fake_servertemplate") ])
+    @api.instance_variable_get("@connection").should_receive(:server_templates).and_return(servertemplatesStub)
+    @api.find_servertemplate("my_fake_servertemplate")
+  end
+
+  it "should raise error if no servertemplates found by name" do
+    servertemplatesStub = double("servertemplates", :index => [])
+    @api.instance_variable_get("@connection").should_receive(:server_templates).and_return(servertemplatesStub)
+    lambda{@api.find_servertemplate("my_fake_servertemplate")}.should raise_error
+  end
+
+  it "should raise error if multiple servertemplates found by name" do
+    servertemplatesStub = double("servertemplates", :index => [ double("servertemplate", :name => "my_fake_servertemplate"), double("servertemplate", :name => "my_fake_servertemplate") ])
+    @api.instance_variable_get("@connection").should_receive(:server_templates).and_return(servertemplatesStub)
+    lambda{@api.find_servertemplate("my_fake_servertemplate")}.should raise_error
+  end
+
+  it "should find servertemplate by id" do
+    servertemplatesStub = double("servertemplates", :index => [ :name => "my_fake_servertemplate" ])
+    @api.instance_variable_get("@connection").should_receive(:server_templates).and_return(servertemplatesStub)
+    @api.find_servertemplate(1234)
+  end
+
+  it "should create deployment" do
+    deploymentsStub = double("deployments", :create => [ {:name => "my_fake_deployment"} ])
+    @api.instance_variable_get("@connection").should_receive(:deployments).and_return(deploymentsStub)
+    deploymentsStub.should_receive(:create)
+    @api.create_deployment("my_deployment")
+  end
+
+  it "should destroy a deployment" do
+    deploymentsStub = double("deployments", :destroy => nil)
+    deploymentsStub.should_receive(:destroy)
+    @api.destroy_deployment(deploymentsStub)
+  end
+
+  it "should create server with the default MCI" do
+    dStub = double("deployment", :href => "/some/fake/path")
+    dsStub = double("deployments", :show => dStub)
+    @api.should_receive(:create_deployment).and_return(dsStub)
+    deployment = @api.create_deployment("my_deployment")
+
+    stStub = double("servertemplate", :href => "/some/fake/path", :show => "")
+    stsStub = double("servertemplates", :show => stStub)
+    @api.should_receive(:find_servertemplate).and_return(stsStub)
+    server_template = @api.find_servertemplate(1234)
+
+    cStub = double("cloud", :href => "/some/fake/path")
+    csStub = double("clouds", :show => cStub)
+    @api.should_receive(:find_cloud_by_name).and_return(csStub)
+    cloud = @api.find_cloud_by_name(1234)
+
+    serversStub = double("servers", :create => [ :name => "my_fake_server" ])
+    @api.instance_variable_get("@connection").should_receive(:servers).and_return(serversStub)
+    @api.create_server(deployment, server_template, nil, cloud, "my_fake_server")
+  end
+
+  it "should create server with the MCI given" do
+    dStub = double("deployment", :href => "/some/fake/path")
+    dsStub = double("deployments", :show => dStub)
+    @api.should_receive(:create_deployment).and_return(dsStub)
+    deployment = @api.create_deployment("my_deployment")
+
+    stStub = double("servertemplate", :href => "/some/fake/path", :show => "")
+    stsStub = double("servertemplates", :show => stStub)
+    @api.should_receive(:find_servertemplate).and_return(stsStub)
+    server_template = @api.find_servertemplate(1234)
+
+    mciStub = double("mci", :href => "/some/fake/path")
+    mcisStub = double("mcis", :show => mciStub)
+    @api.should_receive(:find_mci_by_name).and_return(mcisStub)
+    mci = @api.find_mci_by_name("CentOS")
+
+    cStub = double("cloud", :href => "/some/fake/path")
+    csStub = double("clouds", :show => cStub)
+    @api.should_receive(:find_cloud_by_name).and_return(csStub)
+    cloud = @api.find_cloud_by_name(1234)
+
+    serversStub = double("servers", :create => [ :name => "my_fake_server" ])
+    @api.instance_variable_get("@connection").should_receive(:servers).and_return(serversStub)
+    @api.create_server(deployment, server_template, mci, cloud, "my_fake_server")
+  end
+
+  it "should launch server with inputs" do
+    serverStub = double("server", :name => "foo")
+    serversStub = double("servers", :launch => true, :show => serverStub, :index => [ :name => "my_fake_server" ])
+    @api.should_receive(:create_server).and_return(serversStub)
+    server = @api.create_server("foo", "bar", "my_fake_server")
+    @api.instance_variable_get("@connection").should_receive(:servers).and_return(serversStub)
+    @api.launch_server(server, [ {:name => "input1", :value => 1} ])
+  end
+
+  it "should launch server without inputs" do
+    serverStub = double("server", :name => "foo")
+    serversStub = double("servers", :launch => true, :show => serverStub, :index => [ :name => "my_fake_server" ])
+    @api.should_receive(:create_server).and_return(serversStub)
+    server = @api.create_server("foo", "bar", "my_fake_server")
+    @api.instance_variable_get("@connection").should_receive(:servers).and_return(serversStub)
+    @api.launch_server(server)
+  end
+
+  it "returns user_data" do
+    instanceDataStub = double("idata", :user_data => "someuserdata")
+    instanceStub = double("instance", :show => instanceDataStub)
+    serverDataStub = double("sdata", :current_instance => instanceStub)
+    serverStub = double("server", :show => serverDataStub)
+    serverDataStub.should_receive(:current_instance).with(:view=>"extended")
+    @api.user_data(serverStub).should == "someuserdata"
+  end
+
+  it "returns data_request_url for instance" do
+    @user_data = "RS_rn_url=amqp://b915586461:278a854748@orange2-broker.test.rightscale.com/right_net&RS_rn_id=4985249009&RS_server=orange2-moo.test.rightscale.com&RS_rn_auth=d98106775832c174ffd55bd7b7cb175077574adf&RS_token=b233a57d1d24f27bd8650d0f9b6bfd54&RS_sketchy=sketchy1-145.rightscale.com&RS_rn_host=:0"
+    @request_data_url = "https://my.rightscale.com/servers/data_injection_payload/d98106775832c174ffd55bd7b7cb175077574adf"
+    @api.data_request_url(@user_data).should == @request_data_url
+  end
+
+  it "returns true if server has a current instance" do
+    serverDataStub = double("sdata", :api_methods => [:current_instance])
+    serverStub = double("server", :show => serverDataStub)
+    @api.is_provisioned?(serverStub).should == true
+  end
+
+  it "returns false if server does not have a current instance" do
+    serverDataStub = double("sdata", :api_methods => [])
+    serverStub = double("server", :show => serverDataStub)
+    @api.is_provisioned?(serverStub).should == false
+  end
+
+  it "will not wait if server is in expected state" do
+    @api.should_receive(:server_state).and_return("booting")
+    @api.server_wait_for_state("fakeserver", "booting")
+  end
+
+  it "throws an error if server is stranded" do
+    @api.should_receive(:server_state).and_return("stranded")
+    @api.set_bad_states([ "stranded", "terminated"])
+    lambda{@api.server_wait_for_state("fakeserver", "operational")}.should raise_error
+  end
+
+  it "returns the server's cloud" do
+    cData = double("clouddata", :name => "cloudname")
+    cStub = double("cloud", :show => cData)
+    @api.should_receive(:instance_from_server)
+    @api.should_receive(:cloud_from_instance).and_return(cStub)
+    @api.server_cloud_name("foo").should == "cloudname"
+  end
+
+  it "returns the current instance from the server is provisioned" do
+    serverDataStub = double("sdata", :current_instance => "current")
+    serverStub = double("server", :show => serverDataStub)
+    @api.should_receive(:is_provisioned?).and_return(true)
+    @api.send(:instance_from_server, serverStub).should == "current"
+  end
+
+  it "returns the next instance from the server is not provisioned" do
+    serverDataStub = double("sdata", :next_instance => "next")
+    serverStub = double("server", :show => serverDataStub)
+    @api.should_receive(:is_provisioned?).and_return(false)
+    @api.send(:instance_from_server, serverStub).should == "next"
+  end
+
+  it "returns server state" do
+    instanceDataStub = double("idata", :state => "booting")
+    instanceStub = double("instance", :show => instanceDataStub)
+    @api.should_receive(:instance_from_server).and_return(instanceStub)
+    @api.send(:server_state, "server").should == "booting"
+  end
+
+  it "returns the cloud from the instance" do
+    instanceDataStub = double("idata", :cloud => "somecloudobj")
+    instanceStub = double("instance", :show => instanceDataStub)
+    @api.send(:cloud_from_instance, instanceStub).should == "somecloudobj"
+  end
+
+  it "sets inputs on the next instance" do
+    inputsStub = double("inputs")
+    inputsStub.should_receive(:multi_update).with({"inputs" => "heynow"})
+    instanceDataStub = double("idata", :inputs => inputsStub)
+    instanceStub = double("instance", :show => instanceDataStub)
+    serverDataStub = double("sdata", :next_instance => instanceStub)
+    serverStub = double("server", :show => serverDataStub)
+    @api.set_server_inputs(serverStub, "heynow")
+  end
+
+  it "terminates a server" do
+    serverStub = double("server")
+    serverStub.should_receive(:terminate)
+    @api.terminate_server(serverStub)
+  end
+
+
+end

data/spec/right_api_provision/client_spec_old.rb

@@ -0,0 +1,342 @@
+require 'right_api_provision'
+require 'right_api_client'
+
+describe RightApiProvision::Client do
+
+  before(:all) do
+    @client = RightApiProvision::Client.instance
+    @server_template = RightApiProvision::Objects::ServerTemplate.new(@client, "href", "name", "revision")
+    @cloud = RightApiProvision::Objects::Cloud.new(@client, "href", "name", "description")
+  end
+
+  it "initializes a connection" do
+    apiStub = double("RightApi::Client")
+    RightApi::Client.should_receive(:new).and_return(apiStub)
+    args = {:email => 'my@email.com', :password => 'my_password', :account_id => 'my_account_id'}
+    @conn = @client.connection(args)
+  end
+
+  describe "list_clouds" do
+    it "lists clouds" do
+      list = [
+          double("cloud1", :href => "/some/obj/1", :name => "cumulus1", :description => "a cloud"),
+          double("cloud2", :href => "/some/obj/2", :name => "cumulus2", :description => "a cloud")
+        ]
+      @client.should_receive(:list_resources).with(:clouds, :by_name, "cumulus").and_return(list)
+      @client.list_clouds("cumulus").size.should == 2
+    end
+
+    it "returns empty array if no clouds found" do
+      @client.should_receive(:list_resources).with(:clouds, :by_name, "cumulus").and_return([])
+      @client.list_clouds("cumulus").size.should == 0
+    end
+  end
+
+  describe "find_cloud_by_name" do
+    it "finds a cloud by name" do
+      obj = double("cloud", :href => "/some/obj/1", :name => "stratus", :description => "a cloud")
+      @client.should_receive(:find_resource).with(:clouds, :by_name, "stratus").and_return(obj)
+      cloud = @client.find_cloud_by_name("stratus")
+      cloud.should be_a(RightApiProvision::Objects::Cloud)
+    end
+
+    it "returns nil if cloud not found by name" do
+      @client.should_receive(:find_resource).with(:clouds, :by_name, "cirrus").and_return(nil)
+      @client.find_cloud_by_name("cirrus").should == nil
+    end
+  end
+
+  describe "list_deployment" do
+    it "lists deployment" do
+      list = [
+          double("deployment1", :href => "/some/obj/1", :name => "cumulus1", :description => "a deployment"),
+          double("deployment2", :href => "/some/obj/2", :name => "cumulus2", :description => "a deployment")
+        ]
+      @client.should_receive(:list_resources).with(:deployments, :by_name, "cumulus").and_return(list)
+      @client.list_deployments("cumulus").size.should == 2
+    end
+
+    it "returns empty array if no deployments found" do
+      @client.should_receive(:list_resources).with(:deployments, :by_name, "cumulus").and_return([])
+      @client.list_deployments("cumulus").size.should == 0
+    end
+  end
+
+  describe "find_deployment_by_name" do
+    it "finds a deployment by name" do
+      obj = double("deployment", :href => "/some/obj/1", :name => "stratus", :description => "a deployment")
+      @client.should_receive(:find_resource).with(:deployments, :by_name, "stratus").and_return(obj)
+      cloud = @client.find_deployment_by_name("stratus")
+      cloud.should be_a(RightApiProvision::Objects::Deployment)
+    end
+
+    it "returns nil if deployment not found by name" do
+      @client.should_receive(:find_resource).with(:deployments, :by_name, "cirrus").and_return(nil)
+      @client.find_deployment_by_name("cirrus").should == nil
+    end
+  end
+
+  describe "list_multi_cloud_images" do
+    it "lists multi_cloud_images" do
+      list = [
+          double("multi_cloud_images1", :href => "/some/obj/1", :name => "cumulus1"),
+          double("multi_cloud_images2", :href => "/some/obj/2", :name => "cumulus2")
+        ]
+      @client.should_receive(:list_subresources).with(@server_template, :multi_cloud_images, :by_name, "cumulus").and_return(list)
+      @client.list_multi_cloud_images(@server_template, "cumulus").size.should == 2
+    end
+
+    it "returns empty array if no multi_cloud_images found" do
+      @client.should_receive(:list_subresources).with(@server_template, :multi_cloud_images, :by_name, "cumulus").and_return([])
+      @client.list_multi_cloud_images(@server_template, "cumulus").size.should == 0
+    end
+  end
+
+  describe "find_multi_cloud_image_by_name" do
+    it "finds a multi_cloud_image by name" do
+      obj = double("multi_cloud_image", :href => "/some/obj/1", :name => "stratus")
+      @client.should_receive(:find_subresource).with(@server_template, :multi_cloud_images, :by_name, "stratus").and_return(obj)
+      cloud = @client.find_multi_cloud_image_by_name(@server_template, "stratus")
+      cloud.should be_a(RightApiProvision::Objects::MultiCloudImage)
+    end
+
+    it "returns nil if multi_cloud_image not found by name" do
+      @client.should_receive(:find_subresource).with(@server_template, :multi_cloud_images, :by_name, "cirrus").and_return(nil)
+      @client.find_multi_cloud_image_by_name(@server_template, "cirrus").should == nil
+    end
+  end
+
+  describe "list_security_groups" do
+    it "lists security_groups" do
+      list = [
+          double("security_groups1", :href => "/some/obj/1", :name => "cumulus1", :resource_uid => "1234"),
+          double("security_groups2", :href => "/some/obj/2", :name => "cumulus2", :resource_uid => "5678")
+        ]
+      @client.should_receive(:list_subresources).with(@cloud, :security_groups, :by_name, "cumulus").and_return(list)
+      @client.list_security_groups(@cloud, "cumulus").size.should == 2
+    end
+
+    it "returns empty array if no security_groups found" do
+      @client.should_receive(:list_subresources).with(@cloud, :security_groups, :by_name, "cumulus").and_return([])
+      @client.list_security_groups(@cloud, "cumulus").size.should == 0
+    end
+  end
+
+  describe "find_security_group_by_name" do
+    it "finds a security_group by name" do
+      obj = double("security_group", :href => "/some/obj/1", :name => "stratus", :resource_uid => "1234")
+      @client.should_receive(:find_subresource).with(@cloud, :security_groups, :by_name, "stratus").and_return(obj)
+      cloud = @client.find_security_group_by_name(@cloud, "stratus")
+      cloud.should be_a(RightApiProvision::Objects::SecurityGroup)
+    end
+
+    it "returns nil if security_group not found by name" do
+      @client.should_receive(:find_subresource).with(@cloud, :security_groups, :by_name, "cirrus").and_return(nil)
+      @client.find_security_group_by_name(@cloud, "cirrus").should == nil
+    end
+  end
+
+  describe "list_server_template" do
+    it "lists server_template" do
+      list = [
+          double("server_template", :href => "/some/obj/1", :name => "cumulus1", :revision => "1"),
+          double("server_template", :href => "/some/obj/2", :name => "cumulus2", :revision => "HEAD")
+        ]
+      @client.should_receive(:list_resources).with(:server_templates, :by_name, "cumulus").and_return(list)
+      @client.list_server_templates("cumulus").size.should == 2
+    end
+
+    it "returns empty array if no server_templates found" do
+      @client.should_receive(:list_resources).with(:server_templates, :by_name, "cumulus").and_return([])
+      @client.list_server_templates("cumulus").size.should == 0
+    end
+  end
+
+  describe "find_server_template" do
+    it "finds a server_template by name" do
+      list = [
+          double("server_template", :href => "/some/obj/1", :name => "cumulus1", :revision => "1"),
+          double("server_template", :href => "/some/obj/2", :name => "cumulus2", :revision => "HEAD")
+        ]
+      @client.should_receive(:list_resources).with(:server_templates, :by_name, "stratus").and_return(list)
+      cloud = @client.find_server_template("stratus")
+      cloud.should be_a(RightApiProvision::Objects::ServerTemplate)
+    end
+
+    it "finds a server_template by id" do
+      obj = double("server_template", :href => "/some/obj/1", :name => "stratus", :revision => "HEAD")
+      servertemplatesStub = double("servertemplates", :index => obj)
+      @client.handle.should_receive(:server_templates).and_return(servertemplatesStub)
+      cloud = @client.find_server_template(1)
+      cloud.should be_a(RightApiProvision::Objects::ServerTemplate)
+    end
+
+    it "returns nil if server_template not found by name" do
+      @client.should_receive(:list_resources).with(:server_templates, :by_name, "cirrus").and_return([])
+      @client.find_server_template("cirrus").should == nil
+    end
+  end
+
+  describe "list_servers" do
+    it "lists servers" do
+      list = [
+          double("server1", :href => "/some/obj/1", :name => "cumulus1", :description => "a server"),
+          double("server2", :href => "/some/obj/2", :name => "cumulus2", :description => "a server")
+        ]
+      @client.should_receive(:list_resources).with(:servers, :by_name, "cumulus").and_return(list)
+      @client.list_servers("cumulus").size.should == 2
+    end
+
+    it "returns empty array if no servers found" do
+      @client.should_receive(:list_resources).with(:servers, :by_name, "cumulus").and_return([])
+      @client.list_servers("cumulus").size.should == 0
+    end
+  end
+
+  describe "find_server_by_name" do
+    it "finds a server by name" do
+      obj = double("server", :href => "/some/obj/1", :name => "stratus", :description => "a server")
+      @client.should_receive(:find_resource).with(:servers, :by_name, "stratus").and_return(obj)
+      cloud = @client.find_server_by_name("stratus")
+      cloud.should be_a(RightApiProvision::Objects::Server)
+    end
+
+    it "returns nil if server not found by name" do
+      @client.should_receive(:find_resource).with(:servers, :by_name, "cirrus").and_return(nil)
+      @client.find_server_by_name("cirrus").should == nil
+    end
+  end
+
+  describe "private find_resource" do
+    it "finds a resource" do
+      resourcesStub = double("servers", :index => [ double("server", :name => "my_fake_resource", :id => 12345) ])
+      @client.handle.should_receive(:servers).and_return(resourcesStub)
+      r = @client.send(:find_resource, :servers, :by_name, "my_fake_resource")
+      r.should_not == nil
+    end
+
+    it "raises if duplicate resources are found" do
+      serversStub = double("servers", :index => [ {:name => "my_fake_resource"}, {:name => "my_fake_resource"} ])
+      @client.handle.should_receive(:servers).and_return(serversStub)
+      lambda{@client.send(:find_resource, :servers, :by_name, "my_fake_resource")}.should raise_error RightApiProvision::MultipleMatchesFound
+    end
+  end
+
+  describe "private list_resources" do
+    it "lists resources" do
+      servertemplatesStub =
+        double("servertemplates", :index => [
+          double("servertemplate", :name => "my_fake_servertemplate1"),
+          double("servertemplate", :name => "my_fake_servertemplate2")
+        ])
+      @client.handle.should_receive(:server_templates).and_return(servertemplatesStub)
+      list = @client.send(:list_resources, :server_templates, :by_name, "my_fake_resource")
+      list.size.should == 2
+    end
+  end
+
+  describe "private find_subresource" do
+
+    it "finds a subresource" do
+      subresourceStub =
+        double("subresources", :index => [
+          double("subresource", :name => "subresource1")
+        ])
+      subresourcesStub = double("subresources", :subresource => subresourceStub )
+      resourceStub = double("resource", :show => subresourcesStub, :id => "1")
+      @client.handle.should_receive(:mocks).and_return(resourceStub)
+      r = @client.send(:find_subresource, resourceStub, :subresource, :by_name, "subresource1")
+      r.should_not == nil
+    end
+
+    it "raises if duplicate subresources are found" do
+      subresourceStub =
+        double("subresources", :index => [
+          double("subresource", :name => "subresource1"),
+          double("subresource", :name => "subresource2")
+        ])
+      subresourcesStub = double("subresources", :subresource => subresourceStub )
+      resourceStub = double("resource", :show => subresourcesStub, :id => "1")
+      @client.handle.should_receive(:mocks).and_return(resourceStub)
+      lambda{@client.send(:find_subresource, resourceStub, :subresource, :by_name, "subresource1")}.should raise_error RightApiProvision::MultipleMatchesFound
+    end
+
+    it "raises if subresource param is not a Symbol" do
+      subresourceStub =
+        double("subresources", :index => [
+          double("subresource", :name => "subresource2")
+        ])
+      subresourcesStub = double("subresources", :subresource => subresourceStub )
+      resourceStub = double("resource", :show => subresourcesStub, :id => "1")
+      lambda{@client.send(:find_subresource, resourceStub, "subresource", :by_name, "subresource1")}.should raise_error ArgumentError
+    end
+
+    # it "raises if type param is not kind of RightApi::Resource class" do
+    #   lambda{@client.send(:find_subresource, :server_template, "subresource", :by_name, "subresource1")}.should raise_error ArgumentError
+    # end
+
+    it "raises if filter_value param is not a String" do
+       subresourceStub =
+        double("subresources", :index => [
+          double("subresource", :name => "subresource2")
+        ])
+      subresourcesStub = double("subresources", :subresource => subresourceStub )
+      resourceStub = double("resource", :show => subresourcesStub, :id => "1")
+      lambda{@client.send(:find_subresource, resourceStub, :subresource, :by_name, :subresource1)}.should raise_error ArgumentError
+    end
+
+    it "raises if filter_key param is not a Symbol" do
+      subresourceStub =
+        double("subresources", :index => [
+          double("subresource", :name => "subresource2")
+        ])
+      subresourcesStub = double("subresources", :subresource => subresourceStub )
+      resourceStub = double("resource", :show => subresourcesStub, :id => "1")
+      lambda{@client.send(:find_subresource, resourceStub, :subresource, "by_name", :subresource1)}.should raise_error ArgumentError
+    end
+
+    it "raises if filter_key param does not start with 'by_'" do
+      subresourceStub =
+        double("subresources", :index => [
+          double("subresource", :name => "subresource2")
+        ])
+      subresourcesStub = double("subresources", :subresource => subresourceStub )
+      resourceStub = double("resource", :show => subresourcesStub, :id => "1")
+      lambda{@client.send(:find_subresource, resourceStub, :subresource, :buy_name, :subresource1)}.should raise_error ArgumentError
+    end
+
+  end
+
+
+  describe "private list_subresources" do
+    it "lists subresources" do
+      subresourceStub =
+        double("subresources", :index => [
+          double("subresource", :name => "subresource1"),
+          double("subresource", :name => "subresource2")
+        ])
+      subresourcesStub = double("subresources", :subresource => subresourceStub )
+      resourceStub = double("resource", :show => subresourcesStub, :id => "1")
+      @client.handle.should_receive(:mocks).and_return(resourceStub)
+      list = @client.send(:list_subresources, resourceStub, :subresource, :by_name, "my_fake_resource")
+      list.size.should == 2
+    end
+  end
+
+  describe "private assert_kind_of" do
+    it "throws exception if not kind of" do
+      lambda{
+        @client.send(:assert_kind_of, "not a string", ["hey","now"], String)
+      }.should raise_error ArgumentError
+    end
+
+    it "does nothing if kind of" do
+      @client.send(:assert_kind_of, "string", "hey now", String)
+    end
+
+    it "does nothing if optional and nil" do
+      @client.send(:assert_kind_of, "undefined", nil, String, true)
+    end
+  end
+
+end

data/spec/right_api_provision/provisioner_spec.rb

@@ -0,0 +1,27 @@
+require 'right_api_provision'
+require 'right_api_client'
+
+describe RightApiProvision::Provisioner do
+
+  before(:all) do
+
+  end
+
+  it "initializes a connection" do
+    apiStub = double("RightApiProvision::API15")
+    RightApiProvision::API15.should_receive(:new).and_return(apiStub)
+    apiStub.should_receive(:connection)
+    provisioner = RightApiProvision::Provisioner.new('my@email.com', 'my_password', 'my_account_id')
+    provisioner.should_not == nil
+  end
+
+  it "initializes a connection with custom endpoint" do
+    apiStub = double("RightApiProvision::API15")
+    RightApiProvision::API15.should_receive(:new).and_return(apiStub)
+    apiStub.should_receive(:connection)
+    provisioner = RightApiProvision::Provisioner.new('my@email.com', 'my_password', 'my_account_id', 'custom_url')
+    provisioner.should_not == nil
+  end
+
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,2 @@
+require 'right_api_provision'
+require 'right_api_client'