ridley 0.11.0.rc1 → 0.11.1

data/spec/acceptance/data_bag_resource_spec.rb

@@ -1,24 +1,10 @@
 require 'spec_helper'
 
 describe "DataBag API operations", type: "acceptance" do
-  let(:server_url) { "https://api.opscode.com/organizations/ridley" }
+  let(:server_url)  { Ridley::RSpec::ChefServer.server_url }
   let(:client_name) { "reset" }
-  let(:client_key) { "/Users/reset/.chef/reset.pem" }
-
-  let(:connection) do
-    Ridley.new(
-      server_url: server_url,
-      client_name: client_name,
-      client_key: client_key
-    )
-  end
-
-  before(:all) { WebMock.allow_net_connect! }
-  after(:all) { WebMock.disable_net_connect! }
-
-  before(:each) do
-    connection.data_bag.delete_all
-  end
+  let(:client_key)  { fixtures_path.join('reset.pem').to_s }
+  let(:connection)  { Ridley.new(server_url: server_url, client_name: client_name, client_key: client_key) }
 
   describe "listing data bags" do
     context "when no data bags exist" do
@@ -28,9 +14,9 @@ describe "DataBag API operations", type: "acceptance" do
     end
 
     context "when the server has data bags" do
-      before(:each) do
-        connection.data_bag.create(name: "ridley-one")
-        connection.data_bag.create(name: "ridley-two")
+      before do
+        chef_data_bag("ridley-one")
+        chef_data_bag("ridley-two")
       end
 
       it "returns an array of data bags" do
@@ -44,6 +30,8 @@ describe "DataBag API operations", type: "acceptance" do
   end
 
   describe "creating a data bag" do
-    pending
+    it "returns a Ridley::DataBagObject" do
+      connection.data_bag.create(name: "ridley-one").should be_a(Ridley::DataBagObject)
+    end
   end
 end

data/spec/acceptance/environment_resource_spec.rb

@@ -1,63 +1,46 @@
 require 'spec_helper'
 
 describe "Environment API operations", type: "acceptance" do
-  let(:server_url) { "https://api.opscode.com/organizations/ridley" }
+  let(:server_url)  { Ridley::RSpec::ChefServer.server_url }
   let(:client_name) { "reset" }
-  let(:client_key) { "/Users/reset/.chef/reset.pem" }
-  let(:resource) { double('environment-resource') }
-
-  let(:connection) do
-    Ridley.new(
-      server_url: server_url,
-      client_name: client_name,
-      client_key: client_key
-    )
-  end
-
-  before(:all) { WebMock.allow_net_connect! }
-  after(:all) { WebMock.disable_net_connect! }
-
-  before(:each) do
-    connection.environment.delete_all
-  end
+  let(:client_key)  { fixtures_path.join('reset.pem').to_s }
+  let(:connection)  { Ridley.new(server_url: server_url, client_name: client_name, client_key: client_key) }
 
   describe "finding an environment" do
-    let(:target) { Ridley::EnvironmentObject.new(resource, name: "ridley-test-env") }
+    before { chef_environment("ridley-test-env") }
 
-    before(:each) do
-      connection.environment.create(target)
+    it "returns a valid Ridley::EnvironmentObject object" do
+      connection.environment.find("ridley-test-env").should be_a(Ridley::EnvironmentObject)
     end
+  end
 
+  describe "creating an environment" do
     it "returns a valid Ridley::EnvironmentObject object" do
-      connection.sync do
-        obj = environment.find(target)
+      obj = connection.environment.create(name: "ridley-test-env", description: "a testing env for ridley")
 
-        obj.should be_a(Ridley::EnvironmentObject)
-        obj.should be_valid
-      end
+      obj.should be_a(Ridley::EnvironmentObject)
+    end
+
+    it "adds an environment to the chef server" do
+      old = connection.environment.all.length
+      connection.environment.create(name: "ridley")
+      connection.environment.all.should have(old + 1).item
     end
   end
 
-  describe "creating an environment" do
-    let(:target) do
-      Ridley::EnvironmentObject.new(
-        resource,
-        name: "ridley-test-env",
-        description: "a testing environment for ridley"
-      )
+  describe "deleting an environment" do
+    before { chef_environment("ridley-env") }
+
+    it "returns a Ridley::EnvironmentObject object" do
+      connection.environment.delete("ridley-env").should be_a(Ridley::EnvironmentObject)
     end
 
-    it "returns a valid Ridley::EnvironmentObject object" do
-      connection.sync do
-        obj = environment.create(target)
+    it "removes the environment from the server" do
+      connection.environment.delete("ridley-env")
 
-        obj.should be_a(Ridley::EnvironmentObject)
-        obj.should be_valid
-      end
+      connection.environment.find("ridley-env").should be_nil
     end
-  end
 
-  describe "deleting an environment" do
     it "raises Ridley::Errors::HTTPMethodNotAllowed when attempting to delete the '_default' environment" do
       lambda {
         connection.environment.delete("_default")
@@ -66,11 +49,9 @@ describe "Environment API operations", type: "acceptance" do
   end
 
   describe "deleting all environments" do
-    before(:each) do
-      connection.sync do
-        environment.create(name: "ridley-one")
-        environment.create(name: "ridley-two")
-      end
+    before do
+      chef_environment("ridley-one")
+      chef_environment("ridley-two")
     end
 
     it "returns an array of Ridley::EnvironmentObject objects" do
@@ -78,12 +59,9 @@ describe "Environment API operations", type: "acceptance" do
     end
 
     it "deletes all environments but '_default' from the remote" do
-      connection.sync do
-        environment.delete_all
+      connection.environment.delete_all
 
-        environment.all.should have(1).clients
-        environment.find("_default").should_not be_nil
-      end
+      connection.environment.all.should have(1).item
     end
   end
 
@@ -94,21 +72,14 @@ describe "Environment API operations", type: "acceptance" do
   end
 
   describe "updating an environment" do
-    let(:target) { Ridley::EnvironmentObject.new(resource, name: "ridley-test-env") }
+    before { chef_environment("ridley-env") }
+    let(:target ) { connection.environment.find("ridley-env") }
 
-    before(:each) do
-      connection.environment.create(target)
-    end
-
-    it "saves a new 'description'" do
+    it "saves a new #description" do
       target.description = description = "ridley testing environment"
 
-      connection.sync do
-        environment.update(target)
-        obj = environment.find(target)
-
-        obj.description.should eql(description)
-      end
+      connection.environment.update(target)
+      target.reload.description.should eql(description)
     end
 
     it "saves a new set of 'default_attributes'" do

data/spec/acceptance/node_resource_spec.rb

@@ -1,48 +1,30 @@
 require 'spec_helper'
 
 describe "Node API operations", type: "acceptance" do
-  let(:server_url) { "https://api.opscode.com/organizations/ridley" }
+  let(:server_url)  { Ridley::RSpec::ChefServer.server_url }
   let(:client_name) { "reset" }
-  let(:client_key) { "/Users/reset/.chef/reset.pem" }
-  let(:resource) { double('node-resource') }
-
-  let(:connection) do
-    Ridley.new(
-      server_url: server_url,
-      client_name: client_name,
-      client_key: client_key
-    )
-  end
-
-  before(:all) { WebMock.allow_net_connect! }
-  after(:all) { WebMock.disable_net_connect! }
-
-  before(:each) do
-    connection.node.delete_all
-  end
+  let(:client_key)  { fixtures_path.join('reset.pem').to_s }
+  let(:connection)  { Ridley.new(server_url: server_url, client_name: client_name, client_key: client_key) }
 
   describe "finding a node" do
-    let(:target) { Ridley::NodeObject.new(resource, name: "ridley-one") }
+    let(:node_name) { "ridley.localhost" }
+    before { chef_node(node_name) }
 
-    before(:each) do
-      connection.node.create(target)
-    end
-
-    it "returns a Ridley::NodeResource object" do
-      connection.node.find(target.name).should eql(target)
+    it "returns a Ridley::NodeObject" do
+      connection.node.find(node_name).should be_a(Ridley::NodeObject)
     end
   end
 
   describe "creating a node" do
-    let(:target) { Ridley::NodeObject.new(resource, name: "ridley-one") }
+    let(:node_name) { "ridley.localhost" }
 
     it "returns a new Ridley::NodeObject object" do
-      connection.node.create(target).should eql(target)
+      connection.node.create(name: node_name).should be_a(Ridley::NodeObject)
     end
 
     it "adds a new node to the server" do
       connection.sync do
-        node.create(target)
+        node.create(name: node_name)
 
         node.all.should have(1).node
       end
@@ -50,26 +32,28 @@ describe "Node API operations", type: "acceptance" do
   end
 
   describe "deleting a node" do
-    let(:target) { Ridley::NodeObject.new(resource, name: "ridley-one") }
-
-    before(:each) do
-      connection.node.create(target)
-    end
+    let(:node_name) { "ridley.localhost" }
+    before { chef_node(node_name) }
 
-    it "returns the deleted object" do
-      connection.node.delete(target).should eql(target)
+    it "returns a Ridley::NodeObject" do
+      connection.node.delete(node_name).should be_a(Ridley::NodeObject)
     end
 
     it "removes the node from the server" do
       connection.sync do
-        node.delete(target)
+        node.delete(node_name)
 
-        node.find(target).should be_nil
+        node.find(node_name).should be_nil
       end
     end
   end
 
   describe "deleting all nodes" do
+    before do
+      chef_node("ridley.localhost")
+      chef_node("motherbrain.localhost")
+    end
+
     it "deletes all nodes from the remote server" do
       connection.sync do
         node.delete_all
@@ -80,11 +64,9 @@ describe "Node API operations", type: "acceptance" do
   end
 
   describe "listing all nodes" do
-    before(:each) do
-      connection.sync do
-        node.create(name: "ridley-one")
-        node.create(name: "ridley-two")
-      end
+    before do
+      chef_node("ridley.localhost")
+      chef_node("motherbrain.localhost")
     end
 
     it "returns an array of Ridley::NodeObject" do
@@ -98,11 +80,9 @@ describe "Node API operations", type: "acceptance" do
   end
 
   describe "updating a node" do
-    let(:target) { Ridley::NodeObject.new(resource, name: "ridley-one") }
-
-    before(:each) do
-      connection.node.create(target)
-    end
+    let(:node_name) { "ridley.localhost" }
+    before { chef_node(node_name) }
+    let(:target) { connection.node.find(node_name) }
 
     it "returns the updated node" do
       connection.node.update(target).should eql(target)

data/spec/acceptance/role_resource_spec.rb

@@ -1,58 +1,30 @@
 require 'spec_helper'
 
 describe "Role API operations", type: "acceptance" do
-  let(:server_url) { "https://api.opscode.com/organizations/ridley" }
+  let(:server_url)  { Ridley::RSpec::ChefServer.server_url }
   let(:client_name) { "reset" }
-  let(:client_key) { "/Users/reset/.chef/reset.pem" }
-  let(:resource) { double('role-resource') }
-
-  let(:connection) do
-    Ridley.new(
-      server_url: server_url,
-      client_name: client_name,
-      client_key: client_key
-    )
-  end
-
-  before(:all) { WebMock.allow_net_connect! }
-  after(:all) { WebMock.disable_net_connect! }
-
-  before(:each) { connection.role.delete_all }
+  let(:client_key)  { fixtures_path.join('reset.pem').to_s }
+  let(:connection)  { Ridley.new(server_url: server_url, client_name: client_name, client_key: client_key) }
 
   describe "finding a role" do
-    let(:target) do
-      Ridley::RoleObject.new(
-        resource,
-        name: "ridley-test",
-        description: "a testing role for ridley" 
-      )
-    end
+    let(:role_name) { "ridley-role" }
+    before { chef_role(role_name) }
 
-    before(:each) do
-      connection.role.create(target)
-    end
-
-    it "returns the target Ridley::RoleObject from the server" do
-      connection.role.find(target.name).should eql(target)
+    it "returns a Ridley::RoleObject" do
+      connection.role.find(role_name).should be_a(Ridley::RoleObject)
     end
   end
 
   describe "creating a role" do
-    let(:target) do
-      Ridley::RoleObject.new(
-        resource,
-        name: "ridley-test",
-        description: "a testing role for ridley" 
-      )
-    end
+    let(:role_name) { "ridley-role" }
 
     it "returns a new Ridley::RoleObject" do
-      connection.role.create(target).should eql(target)
+      connection.role.create(name: role_name).should be_a(Ridley::RoleObject)
     end
 
     it "adds a new role to the server" do
       connection.sync do
-        role.create(target)
+        role.create(name: role_name)
 
         role.all.should have(1).role
       end
@@ -60,31 +32,28 @@ describe "Role API operations", type: "acceptance" do
   end
 
   describe "deleting a role" do
-    let(:target) do
-      Ridley::RoleObject.new(
-        resource,
-        name: "ridley-role-one"
-      )
-    end
-
-    before(:each) do
-      connection.role.create(target)
-    end
+    let(:role_name) { "ridley-role" }
+    before { chef_role(role_name) }
 
     it "returns the deleted Ridley::RoleObject resource" do
-      connection.role.delete(target).should eql(target)
+      connection.role.delete(role_name).should be_a(Ridley::RoleObject)
     end
 
     it "removes the role from the server" do
       connection.sync do
-        role.delete(target)
+        role.delete(role_name)
 
-        role.find(target).should be_nil
+        role.find(role_name).should be_nil
       end
     end
   end
 
   describe "deleting all roles" do
+    before do
+      chef_role("role_one")
+      chef_role("role_two")
+    end
+
     it "deletes all nodes from the remote server" do
       connection.sync do
         role.delete_all
@@ -95,14 +64,12 @@ describe "Role API operations", type: "acceptance" do
   end
 
   describe "listing all roles" do
-    before(:each) do
-      connection.sync do
-        role.create(name: "jamie")
-        role.create(name: "winsor")
-      end
+    before do
+      chef_role("role_one")
+      chef_role("role_two")
     end
 
-    it "should return an array of Ridley::RoleResource objects" do
+    it "should return an array of Ridley::RoleObject" do
       connection.sync do
         obj = role.all
 
@@ -113,16 +80,9 @@ describe "Role API operations", type: "acceptance" do
   end
 
   describe "updating a role" do
-    let(:target) do
-      Ridley::RoleObject.new(
-        resource,
-        name: "ridley-role-one"
-      )
-    end
-
-    before(:each) do
-      connection.role.create(target)
-    end
+    let(:role_name) { "ridley-role" }
+    before { chef_role(role_name) }
+    let(:target) { connection.role.find(role_name) }
 
     it "returns an updated Ridley::RoleObject object" do
       connection.role.update(target).should eql(target)