spice 0.4.2 → 0.5.0.beta.1

data/.watchr

@@ -0,0 +1,22 @@
+def run_spec(file)
+  unless File.exist?(file)
+    puts "#{file} does not exist"
+    return
+  end
+
+  puts "Running #{file}"
+  system "bundle exec rspec #{file}"
+  puts
+end
+
+watch("spec/.*/*_spec\.rb") do |match|
+  run_spec match[0]
+end
+
+watch("lib/(.*/.*)\.rb") do |match|
+  run_spec %{spec/#{match[1]}_spec.rb}
+end
+
+watch("lib/spice.rb") do |match|
+	run_spec %{spec/spice_spec.rb}
+end

data/Gemfile

@@ -1,3 +1,16 @@
 source "http://rubygems.org"
 
-gemspec
+gem 'rest-client'
+gem 'mixlib-authentication'
+gem 'yajl-ruby'
+
+group :development, :test do
+  gem "yard", "~> 0.6.4"
+  gem "rspec", "~> 2.5.0"
+  gem "cucumber", "~> 0.10.0"
+  gem "webmock", "~> 1.6.2"
+  gem "timecop", "~> 0.3.5"
+  gem 'watchr'
+  gem 'spork', '~> 0.9.0.rc'
+  gem 'webmock', '~> 1.6.2'
+end

data/Rakefile

@@ -19,3 +19,8 @@ task :default => :spec
 
 require 'yard'
 YARD::Rake::YardocTask.new
+
+desc "Run watchr"
+task :watchr do
+  sh %{bundle exec watchr .watchr}
+end

data/lib/spice.rb

@@ -89,7 +89,7 @@ module Spice
 
     def connect!
       @connection = Connection.new(
-        :url => "#{scheme}://#{host}:#{port}/#{url_path}",
+        :url => "#{scheme}://#{host}:#{port}#{url_path}",
         :client_name => client_name,
         :key_file => key_file
       )

data/lib/spice/client.rb

@@ -3,7 +3,7 @@ module Spice
     def self.all(options={})
       if options[:complete]
         results = []
-        connection.get("/clients").map { |c| c[0] }.each do |client|
+        connection.get("clients").map { |c| c[0] }.each do |client|
           results << connection.get("/clients/#{client}")
         end
         results
@@ -24,19 +24,19 @@ module Spice
     
     def self.create(options={})
       raise ArgumentError, "Option :name must be present" unless options[:name]
-      connection.post("/clients", payload, options)
+      connection.post("/clients", options)
     end
     
     def self.update(options={})
       raise ArgumentError, "Option :name must be present" unless options[:name]
       name = options.delete(:name)
-      connection.put("/clients/#{name}", payload, options)
+      connection.put("/clients/#{name}", options)
     end
     
     def self.delete(options={})
       raise ArgumentError, "Option :name must be present" unless options[:name]
       name = options.delete(:name)
-      connection.delete("/clients/#{name}", payload, options)
+      connection.delete("/clients/#{name}", options)
     end
   end
 end

data/lib/spice/connection.rb

@@ -17,10 +17,12 @@ module Spice
     
     def get(path, headers={})
       begin
-        RestClient.get(
+        response = RestClient.get(
           "#{@url}#{path}", 
           build_headers(:GET, "#{@url_path}#{path}", headers)
         )
+        # response
+        response
       rescue => e
         e.response
       end
@@ -28,11 +30,12 @@ module Spice
     
     def post(path, payload, headers={})
       begin
-        RestClient.post(
+        response = RestClient.post(
           "#{@url}#{path}",
           JSON.generate(payload),
           build_headers(:POST, "#{@url_path}#{path}", headers, JSON.generate(payload))
         )
+        response
       rescue => e
         e.response
       end
@@ -40,11 +43,12 @@ module Spice
     
     def put(path, payload, headers={})
       begin
-        RestClient.put(
+        response = RestClient.put(
           "#{@url}#{path}",
           JSON.generate(payload),
           build_headers(:PUT, "#{@url_path}#{path}", headers, JSON.generate(payload))
         )
+        response
       rescue => e
         e.response
       end
@@ -52,10 +56,11 @@ module Spice
     
     def delete(path, headers={})
       begin
-        RestClient.delete(
+        response = RestClient.delete(
           "#{@url}#{path}",
           build_headers(:DELETE, "#{@url_path}#{path}", headers)
         )
+        response
       rescue => e
         e.response
       end

data/lib/spice/node.rb

@@ -15,6 +15,13 @@ module Spice
     end
     
     def self.create(options={})
+      raise ArgumentError, "Option :name must be present" unless options[:name]
+      options[:chef_type] ||= "node"
+      options[:json_class] ||= "Chef::Node"
+      options[:attributes] ||= {}
+      options[:overrides] ||= {}
+      options[:defaults] ||={}
+      options[:run_list] ||= []
       connection.post("/nodes", options)
     end
     

data/lib/spice/version.rb

@@ -1,3 +1,3 @@
 module Spice
-  VERSION = "0.4.2"
+  VERSION = "0.5.0.beta.1"
 end

data/spec/spec_helper.rb

@@ -1,24 +1,34 @@
-$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
-$LOAD_PATH.unshift(File.dirname(__FILE__))
-require 'bundler'
-Bundler.require
+require 'rubygems'
+require 'spork'
 
-require 'rspec'
-require 'webmock/rspec'
-require 'timecop'
-require 'rest-client'
+Spork.prefork do
+  $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+  $LOAD_PATH.unshift(File.dirname(__FILE__))
+  require 'bundler'
+  Bundler.require
 
-require 'spice'
-# Requires supporting files with custom matchers and macros, etc,
-# in ./support/ and its subdirectories.
-Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
+  require 'rspec'
+  require 'webmock/rspec'
+  require 'timecop'
+  require 'rest-client'
 
-RSpec.configure do |config|
-  config.before do
-    Timecop.freeze
-    Spice.mock
-  end
-  config.after do
-    Timecop.return
+  require 'spice'
+  # Requires supporting files with custom matchers and macros, etc,
+  # in ./support/ and its subdirectories.
+  Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
+
+  RSpec.configure do |config|
+    config.before do
+      Timecop.freeze
+      Spice.mock
+    end
+    config.after do
+      Timecop.return
+    end
   end
 end
+
+Spork.each_run do
+  require 'spice'
+  # This code will be run each time you run your specs.
+end

data/spec/spice/chef_spec.rb

@@ -9,97 +9,45 @@ module Spice
       end
     end
     
-    describe '.clients' do
-      let(:clients) { Chef.clients }
-      
-      before do
-        stub_request(:get, "http://localhost:4000/clients").
-          to_return(
-            :status => 200, 
-            :body => '{"testclient":"http://localhost:4000/clients/testclient",
-                      "goodclient":"http://localhost:4000/clients/goodclient"}',    
-            :headers => {})
-      end
-      it "should return a list of all clients" do
-        JSON.parse(clients).length.should == 2
-      end
-      it "should provide valid client" do
-        clients["testclient"].should == "testclient"
-      end
+    describe ".clients" do
+      before { stub_client_list }
+      subject { Chef.clients }
+
+      it { should have_body(client_list_response) }
+      it { should respond_with(200) }
     end
     
-    describe '.nodes' do
-      let(:nodes) { Chef.nodes }
-      
-      before do
-        stub_request(:get, "http://localhost:4000/nodes").
-          to_return(
-            :status => 200,
-            :body => '{"testnode":"http://localhost:4000/nodes/testnode"}',
-            :headers => {}
-          )
-      end
-      it "should return a list of all nodes" do
-        JSON.parse(nodes).length.should == 1
-        # nodes.first["testnode"].should == "http://localhost:4000/nodes/testnode"
-      end
-      it "should provide valid node" do
-        nodes["testnode"].should == "testnode"
-      end
+    describe ".cookbooks" do
+      before { stub_cookbook_list }
+      subject { Chef.cookbooks }
+
+      it { should have_body(cookbook_list_response) }
+      it { should respond_with(200) }
     end
     
-    describe '.data_bags' do
-      let(:data_bags) { Chef.data_bags }
-      before do
-        stub_request(:get, "http://localhost:4000/data").
-          to_return(
-            :status => 200,
-            :body => '{"testdata":"http://localhost:4000/data/testdata"}',
-            :headers => {}
-          )
-      end
-      it "should return a list of all data bags" do
-        JSON.parse(data_bags).length.should == 1
-      end
-      it "should provide valid data" do
-        data_bags["testdata"].should == "testdata"
-      end
+    describe ".data_bags" do
+      before { stub_data_bag_list }
+      subject { Chef.data_bags }
+
+      it { should have_body(data_bag_list_response) }
+      it { should respond_with(200) }
     end
     
-    describe '.roles' do
-      let(:roles) { Chef.roles }
-      before do
-        stub_request(:get, "http://localhost:4000/roles").
-          to_return(
-            :status => 200,
-            :body => '{"testrole":"testrole"}',
-            :headers => {}
-          )
-      end
-      it "should return a list of all roles" do
-        JSON.parse(roles).length.should == 1
-      end
-      it "should provide valid role" do
-        roles["testrole"].should == "testrole"
-      end
+    describe ".nodes" do
+      before { stub_node_list }
+      subject { Chef.nodes }
+
+      it { should have_body(node_list_response) }
+      it { should respond_with(200) }
     end
     
-    describe '.cookbooks' do
-      let(:cookbooks) { Chef.cookbooks }
-      before do
-        stub_request(:get, "http://localhost:4000/cookbooks").
-          to_return(
-            :status => 200,
-            :body => '{"testcookbook":"http://localhost:4000/cookbooks/testcookbook"}',
-            :headers => {}
-          )
-      end
-      it "should return a list of all cookbooks" do
-        JSON.parse(cookbooks).length.should == 1
-      end
-      it "should provide valid cookbook" do
-        cookbooks["testcookbook"].should == "testcookbook"
-      end
+    describe ".roles" do
+      before { stub_role_list }
+      subject { Chef.roles }
+
+      it { should have_body(role_list_response) }
+      it { should respond_with(200) }
     end
+
   end
 end

data/spec/spice/client_spec.rb

@@ -3,109 +3,66 @@ require 'spec_helper'
 module Spice
   describe Client do
     describe ".all" do
-      before {  }
+      before { stub_client_list }
+      subject { Client.all }
 
-      it "returns a list of clients" do
-        stub_client_list
-        Client.all.length.should == 1
-      end
+      it { should have_body(client_list_response) }
+      it { should respond_with(200) }
     end
-
+    
     describe ".show" do
-      
-      context "valid" do
-        it "returns a valid client" do
-          stub_client_show("monkeypants")
-          client = Client.show(:name => "monkeypants")
-          client["name"].should == "monkeypants"
-          client["admin"].should == true
-        end
+      context "if the client is found" do
+        before { stub_client_show }
+        subject { Client.show(:name => "testclient") }
+    
+        it { should have_body(client_show_response) }
+        it { should respond_with(200) } 
       end
       
-      context "errors" do
-        it "return a 404 when a client is not found" do
-          stub_client_show("applesauce", 404)
-          lambda { Client.show(:name => "applesauce") }.
-            should raise_error(RestClient::ResourceNotFound)
-        end
+      context "if the client is not found" do
+        before { stub_client_show(404) }
+        subject { Client.show(:name => "testclient") }
         
-        it "raises ArgumentError if option :name not present" do
-          stub_client_show("pizza")
-          lambda {Client.show() }.should raise_error ArgumentError
-        end
+        it { should_not have_body(client_show_response) }
+        it { should respond_with(404) }
       end
     end
-
+    
     describe ".create" do
-      before {  }
-
-      context "valid" do
-        it "creates a valid non-admin client" do
-          stub_client_create("spork")
-          client = Client.create(:name => "spork", :admin => false)
-          client["private_key"].should == "RSA PRIVATE KEY"
-          client["uri"].should == "http://http://localhost:4000/clients/spork"
-        end
+      context "if the client can be created" do
+        before { stub_client_create }
+        subject { Client.create(:name => "testclient") }
         
-        it "creates a valid admin client" do
-          stub_client_create("pants", true)
-          response = Client.create(:name => "pants", :admin => true)
-          response["private_key"].should == "RSA PRIVATE KEY"
-          response["uri"].should == "http://http://localhost:4000/clients/pants"
-
-          stub_client_show("pants")
-          client = Client.show(:name => "pants")
-          client["admin"].should == true
-        end
+        it { should have_body(client_create_response) }
+        it { should respond_with(201) }
       end
       
-      context "errors" do
-        it "does not create a client that already exists" do
-          stub_client_create("pants", false, 409)
-          lambda { Client.create(:name => "pants", :admin => false) }.
-            should raise_error(RestClient::Conflict)
-        end
-      end
-    end
-
-    describe ".update" do
-      before {  }
-
-      context "valid" do
-        it "makes a client an admin" do
-          stub_client_update("awesome", true, false, 200)
-          Client.update(:name => "awesome", :admin => true, :private_key => false)
-        end
+      context "if the client already exists" do
+        before { stub_client_create(409) }
+        subject { Client.create(:name => "testclient") }
         
-        it "regenerates the client private key" do
-          stub_client_update("awesome", false, true, 200)
-          Client.update(:name => "awesome", :admin => false, :private_key => true)
-        end
-      end
+        it { should have_body(client_conflict) }
+        it { should respond_with(409) }
+      end      
     end
-
+    
     describe ".delete" do
-      before {  }
-
-      context "valid" do
-        it "deletes a client" do
-          stub_client_delete("spork")
-          Client.delete(:name => "spork")
-        end
+      context "if the client can be deleted" do
+        before { stub_client_delete }
+        subject { Client.delete(:name => "testclient") }
+        
+        it { should have_body(client_delete_response) }
+        it { should respond_with(200) }
       end
-      
-      context "errors" do
-        it "raises ArgumentError if option :name not present" do
-          stub_client_delete("pizza")
-          lambda {Client.delete }.should raise_error ArgumentError
-        end
+    
+      context "if the client cannot be deleted" do
+        before { stub_client_delete(404) }
+        subject { Client.delete(:name => "testclient") }
         
-        it "does not delete a non-existent client" do
-          stub_client_delete("spork", 404)
-          lambda { Client.delete(:name => "spork") }.
-            should raise_error(RestClient::ResourceNotFound)
-        end
+        it { should have_body(client_not_found) }
+        it { should respond_with(404) }
       end
     end
+     
   end
 end