pulp 0.0.8

data/spec/pulp/connection/base_spec.rb

@@ -0,0 +1,312 @@
+#! /usr/bin/env ruby
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+module Pulp
+  class Test < Pulp::Connection::Base
+  end
+end
+
+module Pulp
+  class Test2 < Pulp::Connection::Base
+  end
+end
+
+describe Pulp::Connection::Base do
+  describe ".reset" do
+    it "resets the used base" do
+      a = Pulp::Test.send(:base)
+      Pulp::Test.reset
+      a.should_not eql(Pulp::Test.send(:base))
+    end
+  end
+  
+  describe ".identifier" do
+    it "is the downcased class name" do
+      Pulp::Test.identifier.should eql('test')
+    end
+  end
+  
+  describe ".base" do
+    it "differs based on the used class" do
+      Pulp::Test.base.should_not eql(Pulp::Test2.send(:base))
+    end
+  end
+  
+  describe ".plain_base" do
+    it "is without any context" do
+      Pulp::Test.plain_base.url.should eql('https://localhost/pulp/api/')
+    end
+  end
+  
+  describe ".parse_item_cmd" do
+    context "with an item" do
+      it "should prefix with an item" do
+        Pulp::Test.parse_item_cmd('foo','bla').should eql('/foo/bla')
+      end
+      it "should not double prefix the cmd" do
+        Pulp::Test.parse_item_cmd('foo','/bla').should eql('/foo/bla')
+      end
+    end
+    context "without an item" do
+      it "should prefix the cmd with a slash" do
+        Pulp::Test.parse_item_cmd(nil,'bla').should eql('/bla')
+      end
+      it "should not double prefix the cmd" do
+        Pulp::Test.parse_item_cmd(nil,'/bla').should eql('/bla')
+      end
+    end
+  end
+  
+  describe ".merge_params" do
+    it "should return an empty hash on no params" do
+      Pulp::Test.merge_params(nil).should eql({})
+    end
+    it "should add the params" do
+      Pulp::Test.merge_params({:b => 2}).should eql({ :params => {:b => 2}})
+    end
+  end
+  describe "base actions" do
+    before(:each) do
+      @context = Object.new
+    end
+    describe ".plain_get" do
+      before(:each) do
+        Pulp::Test.plain_base.connection.expects(:[]).with('foo').returns(@context)
+      end
+      context "without params" do
+        before(:each) do
+          @context.expects(:get).with({}).returns(DummyResult)  
+        end
+        it "should return a parsed get" do
+          Pulp::Test.plain_get('foo').should eql(DummyResult.real_body)
+        end
+        it "should strip the api url prefix" do
+          Pulp::Test.plain_get('/pulp/api/foo').should eql(DummyResult.real_body)
+        end
+      end
+      context "with params" do
+        before(:each) do
+          @context.expects(:get).with(:params => { :b => 2}).returns(DummyResult)
+        end
+        it "should add the params" do
+          Pulp::Test.plain_get('/pulp/api/foo',:b => 2).should eql(DummyResult.real_body)
+        end
+      end
+    end
+    context "parsed" do
+      [:get, :delete ].each do |method|
+        describe ".base_#{method}" do
+          context "with an item" do
+            before(:each) do
+              Pulp::Test.base.connection.expects(:[]).with('/blub/foo').returns(@context)
+            end
+            context "without params" do
+              before(:each) do
+                @context.expects(method).with({}).returns(DummyResult)
+              end
+              it "should return a parsed #{method}" do
+                Pulp::Test.send(:"base_#{method}",'foo','blub').should eql(DummyResult.real_body)
+              end
+            end
+            context "with a params" do
+              before(:each) do
+                @context.expects(method).with({ :params => {:b => 2 }}).returns(DummyResult)
+              end
+              it "should return a parsed #{method}" do
+                Pulp::Test.send(:"base_#{method}",'foo','blub',:b => 2).should eql(DummyResult.real_body)
+              end
+            end
+          end
+          context "without an item" do
+            before(:each) do
+              Pulp::Test.base.connection.expects(:[]).with('/foo').returns(@context)
+            end
+            context "without params" do
+              before(:each) do
+                @context.expects(method).with({}).returns(DummyResult)
+              end
+              it "should return a parsed #{method}" do
+                Pulp::Test.send(:"base_#{method}",'foo').should eql(DummyResult.real_body)
+              end
+            end
+            context "with params" do
+              before(:each) do
+                @context.expects(method).with({:params => {:b => 2 }}).returns(DummyResult)
+              end
+              it "should return a parsed #{method}" do
+                Pulp::Test.send(:"base_#{method}",'foo',nil,:b => 2).should eql(DummyResult.real_body)
+              end
+            end
+          end
+        end
+      end
+      [:post,:put].each do |method|
+        describe ".base_#{method}" do
+          context "with an item" do
+            before(:each) do
+              Pulp::Test.base.connection.expects(:[]).with('/blub/foo').returns(@context)
+            end
+            context "without params" do
+              before(:each) do
+                @context.expects(method).with(nil,{:content_type => :json}).returns(DummyResult)
+              end
+              it "should return a parsed #{method}" do
+                Pulp::Test.send(:"base_#{method}",'foo','blub').should eql(DummyResult.real_body)
+              end
+            end
+            context "with a params" do
+              before(:each) do
+                @context.expects(method).with({:b => 2 }.to_json,{:content_type => :json}).returns(DummyResult)
+              end
+              it "should return a parsed #{method}" do
+                Pulp::Test.send(:"base_#{method}",'foo','blub',:b => 2).should eql(DummyResult.real_body)
+              end
+            end
+          end
+          context "without an item" do
+            before(:each) do
+              Pulp::Test.base.connection.expects(:[]).with('/foo').returns(@context)
+            end
+            context "without params" do
+              before(:each) do
+                @context.expects(method).with(nil,{:content_type => :json}).returns(DummyResult)
+              end
+              it "should return a parsed #{method}" do
+                Pulp::Test.send(:"base_#{method}",'foo').should eql(DummyResult.real_body)
+              end
+            end
+            context "with params" do
+              before(:each) do
+                @context.expects(method).with({:b => 2 }.to_json, {:content_type => :json}).returns(DummyResult)
+              end
+              it "should return a parsed #{method}" do
+                Pulp::Test.send(:"base_#{method}",'foo',nil,:b => 2).should eql(DummyResult.real_body)
+              end
+            end
+          end
+        end
+      end
+    end
+    context "unparsed" do
+       [:get, :delete ].each do |method|
+        describe ".base_unparsed_#{method}" do
+          context "with an item" do
+            before(:each) do
+              Pulp::Test.base.connection.expects(:[]).with('/blub/foo').returns(@context)
+            end
+            context "without params" do
+              before(:each) do
+                @context.expects(method).with({}).returns(UnparsedDummyResult)
+              end
+              it "should return an unparsed #{method}" do
+                Pulp::Test.send(:"base_unparsed_#{method}",'foo','blub').should eql(UnparsedDummyResult.real_body)
+              end
+            end
+            context "with a params" do
+              before(:each) do
+                @context.expects(method).with({ :params => {:b => 2 }}).returns(UnparsedDummyResult)
+              end
+              it "should return an unparsed #{method}" do
+                Pulp::Test.send(:"base_unparsed_#{method}",'foo','blub',:b => 2).should eql(UnparsedDummyResult.real_body)
+              end
+            end
+          end
+          context "without an item" do
+            before(:each) do
+              Pulp::Test.base.connection.expects(:[]).with('/foo').returns(@context)
+            end
+            context "without params" do
+              before(:each) do
+                @context.expects(method).with({}).returns(UnparsedDummyResult)
+              end
+              it "should return an unparsed #{method}" do
+                Pulp::Test.send(:"base_unparsed_#{method}",'foo').should eql(UnparsedDummyResult.real_body)
+              end
+            end
+            context "with params" do
+              before(:each) do
+                @context.expects(method).with({:params => {:b => 2 }}).returns(UnparsedDummyResult)
+              end
+              it "should return an unparsed #{method}" do
+                Pulp::Test.send(:"base_unparsed_#{method}",'foo',nil,:b => 2).should eql(UnparsedDummyResult.real_body)
+              end
+            end
+          end
+        end
+      end
+      [:post,:put].each do |method|
+        describe ".base_#{method}" do
+          context "with an item" do
+            before(:each) do
+              Pulp::Test.base.connection.expects(:[]).with('/blub/foo').returns(@context)
+            end
+            context "without params" do
+              before(:each) do
+                @context.expects(method).with(nil,{:content_type => :json}).returns(UnparsedDummyResult)
+              end
+              it "should return an unparsed #{method}" do
+                Pulp::Test.send(:"base_unparsed_#{method}",'foo','blub').should eql(UnparsedDummyResult.real_body)
+              end
+            end
+            context "with a params" do
+              before(:each) do
+                @context.expects(method).with({:b => 2 }.to_json,{:content_type => :json}).returns(UnparsedDummyResult)
+              end
+              it "should return a unparsed #{method}" do
+                Pulp::Test.send(:"base_unparsed_#{method}",'foo','blub',:b => 2).should eql(UnparsedDummyResult.real_body)
+              end
+            end
+          end
+          context "without an item" do
+            before(:each) do
+              Pulp::Test.base.connection.expects(:[]).with('/foo').returns(@context)
+            end
+            context "without params" do
+              before(:each) do
+                @context.expects(method).with(nil,{:content_type => :json}).returns(UnparsedDummyResult)
+              end
+              it "should return an unparsed #{method}" do
+                Pulp::Test.send(:"base_unparsed_#{method}",'foo').should eql(UnparsedDummyResult.real_body)
+              end
+            end
+            context "with params" do
+              before(:each) do
+                @context.expects(method).with({:b => 2 }.to_json, {:content_type => :json}).returns(UnparsedDummyResult)
+              end
+              it "should return an unparsed #{method}" do
+                Pulp::Test.send(:"base_unparsed_#{method}",'foo',nil,:b => 2).should eql(UnparsedDummyResult.real_body)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+  [:hostname,:username, :password].each do |field|
+    describe ".#{field}" do
+      it "provides a way to set and read a #{field}" do
+        Pulp::Test.should respond_to("#{field}=")
+        Pulp::Test.should respond_to("#{field}")
+      end
+      
+      it "is used for the base connection" do
+        Pulp::Test.reset
+        Pulp::Test.send("#{field}=","foo")
+        Pulp::Test.send(:base).instance_variable_get("@#{field}").should eql("foo")
+      end
+    end
+  end
+  describe "default special fields" do
+    [:id, :_id].each do |field|
+      it "#{field} is a special_field" do
+        Pulp::Connection::Base.special_fields.should include(field)
+      end
+    end
+  end
+  
+  describe "initialization" do
+    it "initializes the fields with the supplied data" do
+      Pulp::Test.new(:a => 1).fields[:a].should eql(1)
+    end
+  end
+end

data/spec/pulp/connection/handler_spec.rb

@@ -0,0 +1,123 @@
+#! /usr/bin/env ruby
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe Pulp::Connection::Handler do
+  
+  [:hostname,:username, :password].each do |field|
+    it "provides a way to set and read a default #{field}" do
+      Pulp::Connection::Handler.should respond_to("#{field}=")
+      Pulp::Connection::Handler.should respond_to("#{field}")
+    end
+  end
+  
+  describe ".instance_for" do
+    it "returns an instance of Pulp::Connection::Handler" do
+      Pulp::Connection::Handler.instance_for(:foo).should be_a(Pulp::Connection::Handler) 
+    end
+    
+    it "caches the instances" do
+      Pulp::Connection::Handler.instance_for(:foo).should eql(Pulp::Connection::Handler.instance_for(:foo))
+    end
+    
+    it "takes default hostname if no argument is passed" do
+      Pulp::Connection::Handler.hostname = 'blub'
+      Pulp::Connection::Handler.instance_for(:default_hostname).instance_variable_get('@hostname').should eql('blub')
+    end
+    it "takes passed hostname" do
+      Pulp::Connection::Handler.hostname = 'blub'
+      Pulp::Connection::Handler.instance_for(:default_hostname2,'bla').instance_variable_get('@hostname').should eql('bla')
+    end
+    
+    it "takes default username if no argument is passed" do
+      Pulp::Connection::Handler.username = 'user'
+      Pulp::Connection::Handler.instance_for(:default_user,'bla').instance_variable_get('@username').should eql('user')
+    end
+    it "takes passed username" do
+      Pulp::Connection::Handler.username = 'user'
+      Pulp::Connection::Handler.instance_for(:default_user2,'bla','user2').instance_variable_get('@username').should eql('user2')
+    end
+    
+    it "takes default password if no argument is passed" do
+      Pulp::Connection::Handler.password = 'secret'
+      Pulp::Connection::Handler.instance_for(:default_pwd,'bla','user').instance_variable_get('@password').should eql('secret')
+    end
+    it "takes passed password" do
+      Pulp::Connection::Handler.password = 'secret'
+      Pulp::Connection::Handler.instance_for(:default_pwd2,'bla','user2','secret2').instance_variable_get('@password').should eql('secret2')
+    end
+    
+    it "defaults https to true" do
+      Pulp::Connection::Handler.instance_for(:default_https,'bla','user','secret2').instance_variable_get('@https').should eql(true)
+    end
+    it "takes passed https setting" do
+      Pulp::Connection::Handler.instance_for(:default_https2,'bla','user2','secret2',false).instance_variable_get('@https').should eql(false)
+    end
+  end
+  
+  describe ".reset" do
+    it "removes a cached instance" do
+      a = Pulp::Connection::Handler.instance_for(:cache_reset)
+      Pulp::Connection::Handler.reset_instance(:cache_reset)
+      Pulp::Connection::Handler.instance_for(:cache_reset).should_not eql(a)
+    end
+    
+    it "does not raise an error on an inexistant instance" do
+      lambda { Pulp::Connection::Handler.reset_instance(:blablablabla) }.should_not raise_error
+    end
+  end
+  describe ".reset_all" do
+    it "resets all connections" do
+      a = Pulp::Connection::Handler.instance_for(:cache_reset)
+      Pulp::Connection::Handler.send(:instances).should_not be_empty
+      Pulp::Connection::Handler.reset_all
+      Pulp::Connection::Handler.send(:instances).should be_empty
+    end
+  end
+
+  describe "an instance" do
+    let(:instance) do
+      Pulp::Connection::Handler.hostname = 'localhost'
+      Pulp::Connection::Handler.username = 'admin'
+      Pulp::Connection::Handler.password = 'admin'
+      Pulp::Connection::Handler.instance_for(:instance)
+    end
+    before(:each) { Pulp::Connection::Handler.reset_all }
+    describe "#parsed" do
+      it "gets the connection passed" do
+        instance.parsed{|conn| conn.should eql(instance.connection); DummyResult }
+      end
+      
+      it "parses the result" do
+        instance.parsed{|conn| DummyResult }['a'].should eql(1)
+      end
+    end
+    
+    describe "#connection" do
+      it "'s url should match our url" do
+        instance.connection.url.should eql(instance.url)
+      end
+      it "'s user should match our username" do
+        instance.connection.user.should eql(Pulp::Connection::Handler.username)
+      end
+      it "'s passowrd should match our password" do
+        instance.connection.password.should eql(Pulp::Connection::Handler.password)
+      end
+    end
+    
+    describe "#api_path" do
+      it "is a fixed apth" do
+        instance.api_path.should eql("/pulp/api")
+      end
+    end
+    
+    describe "#url" do
+      it "should be a full url depending on the identifier" do
+        instance.url.should eql("https://localhost/pulp/api/instances")
+      end
+      it "should depend on the https flag" do
+        i = Pulp::Connection::Handler.instance_for(:second_instance,'localhost','user','password',false)
+        i.url.should eql("http://localhost/pulp/api/second_instances")
+      end
+    end
+  end
+end

data/spec/pulp/content_spec.rb

@@ -0,0 +1,21 @@
+#! /usr/bin/env ruby
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe Pulp::Content do
+  
+  
+  describe ".file" do
+    it "should get the file content of the passed id" do
+      Pulp::Content.expects(:base_get).with('','files/',{:id => 'ff'}).returns('a')
+      Pulp::Content.file('ff').should eql('a')
+    end
+  end
+  
+  describe ".delete_file" do
+    it "shold delete the file with the passed id" do
+      Pulp::Content.expects(:base_delete).with('','files/ff/',nil).returns(nil)
+      Pulp::Content.delete_file('ff').should be_nil
+    end
+  end
+  
+end