netscaler 0.5.2 → 0.6.0

data/spec/policy_stringmap_spec.rb

@@ -10,41 +10,41 @@ describe Netscaler::Policy::Stringmap do
     specify 'a name is required' do
       expect {
         connection.policy.stringmap.add('test')
-      }.should raise_error(ArgumentError, /payload must be a hash\./)
+      }.to raise_error(ArgumentError, /payload must be a hash\./)
     end
 
     it 'returns a hash if proper arguments are passed' do
       result = connection.policy.stringmap.add(:name => 'test')
-      result.should be_kind_of(Hash)
+      expect(result).to be_kind_of(Hash)
     end
   end
 
   context 'when getting a list of stringmaps' do
     specify 'a name is optional' do
       result = connection.policy.stringmap.list(:name => 'test')
-      result.should be_kind_of(Hash)
+      expect(result).to be_kind_of(Hash)
     end
 
     specify 'the arg should be a hash' do
       expect {
         connection.policy.stringmap.list('test')
-      }.should raise_error(ArgumentError, /payload must be a hash\./)
+      }.to raise_error(ArgumentError, /payload must be a hash\./)
     end
 
     it 'returns a hash, listing stringmaps' do
       result = connection.policy.stringmap.list
-      result.should be_kind_of(Hash)
+      expect(result).to be_kind_of(Hash)
     end
 
     it 'Method Get will take name parameter and return hash' do
       result = connection.policy.stringmap.get(:name => 'test')
-      result.should be_kind_of(Hash)
+      expect(result).to be_kind_of(Hash)
     end
 
     specify 'Method Get, arg should be a hash' do
       expect {
         connection.policy.stringmap.get('test')
-      }.should raise_error(ArgumentError, /payload must be a hash\./)
+      }.to raise_error(ArgumentError, /payload must be a hash\./)
     end
 
   end
@@ -53,24 +53,24 @@ describe Netscaler::Policy::Stringmap do
     specify 'a name is required' do
       expect {
         connection.policy.stringmap.bind(:key => 'foo', :value => 'bar')
-      }.should raise_error(ArgumentError, /name/)
+      }.to raise_error(ArgumentError, /name/)
     end
 
     specify 'a key is required' do
       expect {
         connection.policy.stringmap.bind(:name => 'foo', :value => 'bar')
-      }.should raise_error(ArgumentError, /key/)
+      }.to raise_error(ArgumentError, /key/)
     end
 
     specify 'a value is required' do
       expect {
         connection.policy.stringmap.bind(:key => 'foo', :name => 'bar')
-      }.should raise_error(ArgumentError, /value/)
+      }.to raise_error(ArgumentError, /value/)
     end
 
     it 'returns a hash if proper arguments are passed' do
       result = connection.policy.stringmap.bind(:name => 'test', :key => 'foo', :value => 'bar')
-      result.should be_kind_of(Hash)
+      expect(result).to be_kind_of(Hash)
     end
  end
 

data/spec/responder_spec.rb

@@ -10,24 +10,24 @@ describe Netscaler::Responder::Action do
   context 'when using the show method in Responder::Action' do
     it 'with no param used it will return all responder actions' do
       result = connection.responder.action.show
-      result.should be_kind_of(Hash)
+      expect(result).to be_kind_of(Hash)
     end
 
     it 'supplying the name parameter will return Hash' do
       result = connection.responder.action.show :name => 'foo'
-      result.should be_kind_of(Hash)
+      expect(result).to be_kind_of(Hash)
     end
 
     it 'when showing a particular responder action, string is invalid' do
       expect {
         connection.responder.action.show('asdf')
-      }.should raise_error(TypeError, /conver(t|sion)/)
+      }.to raise_error(TypeError, /conver(t|sion)/)
     end
 
     it 'when showing a particular responder action :name is required' do
       expect {
         connection.responder.action.show(:foo => 'bar')
-      }.should raise_error(ArgumentError, /name/)
+      }.to raise_error(ArgumentError, /name/)
     end
   end
 end
@@ -40,24 +40,24 @@ describe Netscaler::Responder::Policy do
   context 'when using the show method in Responder::Policy' do
     it 'with no param used it will return all responder policies' do
       result = connection.responder.policy.show
-      result.should be_kind_of(Hash)
+      expect(result).to be_kind_of(Hash)
     end
 
     it 'supplying the name parameter will return Hash' do
       result = connection.responder.policy.show :name => 'foo'
-      result.should be_kind_of(Hash)
+      expect(result).to be_kind_of(Hash)
     end
 
     it 'when showing a particular responder policy, string is invalid' do
       expect {
         connection.responder.policy.show('asdf')
-      }.should raise_error(TypeError, /conver(t|sion)/)
+      }.to raise_error(TypeError, /conver(t|sion)/)
     end
 
     it 'when showing a particular responder policy :name is required' do
       expect {
         connection.responder.policy.show(:foo => 'bar')
-      }.should raise_error(ArgumentError, /name/)
+      }.to raise_error(ArgumentError, /name/)
     end
   end
 end

data/spec/rewrite_spec.rb

@@ -10,24 +10,24 @@ describe Netscaler::Rewrite::Action do
   context 'when using the show method in Rewrite::Action' do
     it 'with no param used it will return all rewrite actions' do
       result = connection.rewrite.action.show
-      result.should be_kind_of(Hash)
+      expect(result).to be_kind_of(Hash)
     end
 
     it 'supplying the name parameter will return Hash' do
       result = connection.rewrite.action.show :name => 'foo'
-      result.should be_kind_of(Hash)
+      expect(result).to be_kind_of(Hash)
     end
 
     it 'when showing a particular rewrite action, string is invalid' do
       expect {
         connection.rewrite.action.show('asdf')
-      }.should raise_error(TypeError, /conver(t|sion)/)
+      }.to raise_error(TypeError, /conver(t|sion)/)
     end
 
     it 'when showing a particular rewrite action :name is required' do
       expect {
         connection.rewrite.action.show(:foo => 'bar')
-      }.should raise_error(ArgumentError, /name/)
+      }.to raise_error(ArgumentError, /name/)
     end
   end
 end
@@ -40,24 +40,24 @@ describe Netscaler::Rewrite::Policy do
   context 'when using the show method in Rewrite::Policy' do
     it 'with no param used it will return all rewrite policies' do
       result = connection.rewrite.policy.show
-      result.should be_kind_of(Hash)
+      expect(result).to be_kind_of(Hash)
     end
 
     it 'supplying the name parameter will return Hash' do
       result = connection.rewrite.policy.show :name => 'foo'
-      result.should be_kind_of(Hash)
+      expect(result).to be_kind_of(Hash)
     end
 
     it 'when showing a particular rewrite policy, string is invalid' do
       expect {
         connection.rewrite.policy.show('asdf')
-      }.should raise_error(TypeError, /conver(t|sion)/)
+      }.to raise_error(TypeError, /conver(t|sion)/)
     end
 
     it 'when showing a particular rewrite policy :name is required' do
       expect {
         connection.rewrite.policy.show(:foo => 'bar')
-      }.should raise_error(ArgumentError, /name/)
+      }.to raise_error(ArgumentError, /name/)
     end
   end
 end

data/spec/server_spec.rb

@@ -10,18 +10,18 @@ describe Netscaler::Server do
     it 'a name is required' do
       expect {
         connection.servers.add({'ipaddress'=>'123.123.123.123'})
-      }.should raise_error(ArgumentError, /name/)
+      }.to raise_error(ArgumentError, /name/)
     end
 
     it 'an ipaddress is required' do
       expect {
         connection.servers.add({'name'=>'hostname'})
-      }.should raise_error(ArgumentError, /ipaddress/)
+      }.to raise_error(ArgumentError, /ipaddress/)
     end
 
     it 'returns a Hash object if all necessary args are supplied' do
       result = connection.servers.add :name => 'foo', :domain => 'foo.bar.com'
-      result.should be_kind_of(Hash)
+      expect(result).to be_kind_of(Hash)
     end
   end
 
@@ -29,12 +29,12 @@ describe Netscaler::Server do
     it ':server is required' do
       expect {
         connection.servers.remove({'ipaddress'=>'123.123.123.123'})
-      }.should raise_error(ArgumentError, /server/)
+      }.to raise_error(ArgumentError, /server/)
     end
 
     it 'returns a Hash object if all necessary args are supplied' do
       result = connection.servers.remove :server => 'foo'
-      result.should be_kind_of(Hash)
+      expect(result).to be_kind_of(Hash)
     end
   end
 
@@ -44,12 +44,12 @@ describe Netscaler::Server do
       it ':server is required' do
         expect {
           connection.servers.send(toggle_action, nil)
-        }.should raise_error(ArgumentError, /null/)
+        }.to raise_error(ArgumentError, /null/)
       end
 
       it 'returns a hash if all necesssary args are supplied' do
         result = connection.servers.send(toggle_action, :server => 'foo')
-        result.should be_kind_of(Hash)
+        expect(result).to be_kind_of(Hash)
       end
 
     end
@@ -59,12 +59,12 @@ describe Netscaler::Server do
     it ':server is required' do
       expect {
         connection.servers.show_bindings({})
-      }.should raise_error(ArgumentError, /server/)
+      }.to raise_error(ArgumentError, /server/)
     end
 
     it 'returns a Hash object if all necessary args are supplied' do
       result = connection.servers.show_bindings :server => 'foo'
-      result.should be_kind_of(Hash)
+      expect(result).to be_kind_of(Hash)
     end
   end
 
@@ -72,17 +72,17 @@ describe Netscaler::Server do
     it ':server is required if arguments are specified' do
       expect {
         connection.servers.show_bindings({something: 'notcool'})
-      }.should raise_error(ArgumentError, /server/)
+      }.to raise_error(ArgumentError, /server/)
     end
 
     it 'returns a Hash object if server arg supplied' do
       result = connection.servers.show_bindings :server => 'foo'
-      result.should be_kind_of(Hash)
+      expect(result).to be_kind_of(Hash)
     end
 
     it 'returns a Hash object if no args supplied since it then returns all servers' do
       result = connection.servers.show_bindings :server => 'foo'
-      result.should be_kind_of(Hash)
+      expect(result).to be_kind_of(Hash)
     end
   end
 end

data/spec/service_spec.rb

@@ -10,31 +10,31 @@ describe Netscaler::Server do
     it 'a name is required' do
       expect {
         connection.service.add(:serverName => 'foo', :serviceType => 'HTTP', :port => '80')
-      }.should raise_error(ArgumentError, /name/)
+      }.to raise_error(ArgumentError, /name/)
     end
 
     it 'a serverName is required' do
       expect {
         connection.service.add(:name => 'foo_80', :serviceType => 'HTTP', :port => '80')
-      }.should raise_error(ArgumentError, /serverName/)
+      }.to raise_error(ArgumentError, /serverName/)
     end
 
     it 'a serviceType is required' do
       expect {
         connection.service.add(:name => 'foo_80', :serverName => 'foo', :port => '80')
-      }.should raise_error(ArgumentError, /serviceType/)
+      }.to raise_error(ArgumentError, /serviceType/)
     end
 
     it 'a port is required' do
       expect {
         connection.service.add(:name => 'foo_80', :serverName => 'foo', :serviceType => 'HTTP')
-      }.should raise_error(ArgumentError, /port/)
+      }.to raise_error(ArgumentError, /port/)
     end
 
 
     it 'returns a Hash object if all necessary args are supplied' do
       result = connection.service.add(:name => 'foo_80', :serverName => 'foo', :serviceType => 'HTTP', :port => '80')
-      result.should be_kind_of(Hash)
+      expect(result).to be_kind_of(Hash)
     end
   end
 

data/spec/servicegroup_spec.rb

@@ -12,13 +12,13 @@ describe Netscaler::ServiceGroup do
     it 'a name is required' do
       expect {
         connection.servicegroups.add({ 'serviceType' => 'tcp' })
-      }.should raise_error(ArgumentError, /serviceGroupName/)
+      }.to raise_error(ArgumentError, /serviceGroupName/)
     end
 
     it 'a service type is required' do
       expect {
         connection.servicegroups.add({ 'serviceGroupName' => 'test-serviceGroup' })
-      }.should raise_error(ArgumentError, /serviceType/)
+      }.to raise_error(ArgumentError, /serviceType/)
     end
 
   end
@@ -28,15 +28,15 @@ describe Netscaler::ServiceGroup do
     it 'has to require a serviceGroupName' do
       expect {
         connection.servicegroups.remove()
-      }.should raise_error(ArgumentError, /wrong number of arguments/)
+      }.to raise_error(ArgumentError, /wrong number of arguments/)
       expect {
         connection.servicegroups.remove(:foo => 'bar')
-      }.should raise_error(ArgumentError, /serviceGroupName/)
+      }.to raise_error(ArgumentError, /serviceGroupName/)
     end
 
     it 'returns a Hash object if all necessary args are supplied' do
       result = connection.servicegroups.show_bindings :serviceGroupName => 'foo'
-      result.should be_kind_of(Hash)
+      expect(result).to be_kind_of(Hash)
     end
 
   end
@@ -47,19 +47,19 @@ describe Netscaler::ServiceGroup do
     it 'a Service group name is required' do
       expect {
         connection.servicegroups.bind({ 'port'=> '8080', 'ip' => '199.199.199.199' })
-      }.should raise_error(ArgumentError, /serviceGroupName/)
+      }.to raise_error(ArgumentError, /serviceGroupName/)
     end
 
     it 'a server entity is required' do
       expect {
         connection.servicegroups.bind({ 'serviceGroupName' => 'test-serviceGroup', 'port' => '8080' })
-      }.should raise_error(ArgumentError, /serverName/)
+      }.to raise_error(ArgumentError, /serverName/)
     end
 
     it 'a port is required' do
       expect {
         connection.servicegroups.bind({ 'serviceGroupName' => 'test-serviceGroup', 'ip' => '199.199.199.199' })
-      }.should raise_error(ArgumentError, /port/)
+      }.to raise_error(ArgumentError, /port/)
     end
 
   end
@@ -69,19 +69,19 @@ describe Netscaler::ServiceGroup do
     it 'a Service group name is required' do
       expect {
         connection.servicegroups.unbind({ 'port' => '8080', 'ip' => '199.199.199.199' })
-      }.should raise_error(ArgumentError, /serviceGroupName/)
+      }.to raise_error(ArgumentError, /serviceGroupName/)
     end
 
     it 'a server entity is required' do
       expect {
         connection.servicegroups.unbind({ 'serviceGroupName' => 'test-serviceGroup', 'port' => '8080' })
-      }.should raise_error(ArgumentError, /serverName/)
+      }.to raise_error(ArgumentError, /serverName/)
     end
 
     it 'a port is required' do
       expect {
         connection.servicegroups.unbind({ 'serviceGroupName' => 'test-serviceGroup', 'ip' => '199.199.199.199' })
-      }.should raise_error(ArgumentError, /port/)
+      }.to raise_error(ArgumentError, /port/)
     end
 
   end
@@ -92,12 +92,12 @@ describe Netscaler::ServiceGroup do
       it ':serviceGroupName is required' do
         expect {
           connection.servicegroups.send(toggle_action, {})
-        }.should raise_error(ArgumentError, /serviceGroupName/)
+        }.to raise_error(ArgumentError, /serviceGroupName/)
       end
 
       it 'returns a hash if all necesssary args are supplied' do
         result = connection.servicegroups.send(toggle_action, :serviceGroupName => 'foo')
-        result.should be_kind_of(Hash)
+        expect(result).to be_kind_of(Hash)
       end
 
     end
@@ -107,24 +107,24 @@ describe Netscaler::ServiceGroup do
       it ':serviceGroupName is required' do
         expect {
           connection.servicegroups.send("#{toggle_action}_server", {:serverName => 'foo', :port => '80'})
-        }.should raise_error(ArgumentError, /serviceGroupName/)
+        }.to raise_error(ArgumentError, /serviceGroupName/)
       end
 
       it ':serviceGroupName is required' do
         expect {
           connection.servicegroups.send("#{toggle_action}_server", {:serviceGroupName => 'foo', :port => '80'})
-        }.should raise_error(ArgumentError, /serverName/)
+        }.to raise_error(ArgumentError, /serverName/)
       end
 
       it ':serviceGroupName is required' do
         expect {
           connection.servicegroups.send("#{toggle_action}_server", {:serviceGroupName => 'bar', :serverName => 'foo'})
-        }.should raise_error(ArgumentError, /port/)
+        }.to raise_error(ArgumentError, /port/)
       end
 
       it 'should return a Hash if all args are returned' do
         result = connection.servicegroups.send("#{toggle_action}_server", {:serviceGroupName => 'bar', :serverName => 'foo', :port => '80'})
-        result.should be_kind_of(Hash)
+        expect(result).to be_kind_of(Hash)
       end
 
     end

data/spec/sslvserver_spec.rb

@@ -0,0 +1,131 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+require 'netscaler'
+require 'netscaler/mock_adapter'
+
+describe Netscaler::Cs::Vserver do
+
+  connection = Netscaler::Connection.new 'hostname' => 'foo', 'password' => 'bar', 'username' => 'bar'
+  connection.adapter = Netscaler::MockAdapter.new :body => '{ "errorcode": 0, "message": "Done" }'
+
+  context 'when adding a new ssl vserver' do
+    it 'a name is required' do
+      expect {
+        connection.ssl.vserver.add(:serviceType => 'SSL', :port => '443', :ipv46 => '1.1.1.1')
+      }.to raise_error(ArgumentError, /name/)
+    end
+
+    it 'a service type is required' do
+      expect {
+        connection.ssl.vserver.add(:name => 'foo', :port => '443', :ipv46 => '1.1.1.1')
+      }.to raise_error(ArgumentError, /serviceType/)
+    end
+
+    it 'a port is required' do
+      expect {
+        connection.ssl.vserver.add(:name => 'foo', :serviceType => 'SSL', :ipv46 => '1.1.1.1')
+      }.to raise_error(ArgumentError, /port/)
+    end
+
+    it 'a ipv46 is required' do
+      expect {
+        connection.ssl.vserver.add(:name => 'foo', :serviceType => 'SSL', :port => '443')
+      }.to raise_error(ArgumentError, /ipv46/)
+    end
+
+    it 'return hash when supplied all required params' do
+      result = connection.ssl.vserver.add(:name => 'foo', :serviceType => 'SSL', :port => '443', :ipv46 => '1.1.1.1')
+      expect(result).to be_kind_of(Hash)
+    end
+  end
+
+  context 'when using the show method in Ssl::Vserver' do
+    it 'with no param used it will return all vservers' do
+      result = connection.ssl.vserver.show
+      expect(result).to be_kind_of(Hash)
+    end
+
+    it 'supplying the name parameter will return Hash' do
+      result = connection.ssl.vserver.show :name => 'foo'
+      expect(result).to be_kind_of(Hash)
+    end
+
+    it 'when showing a particular lb vserver string is invalid' do
+      expect {
+        connection.ssl.vserver.show('asdf')
+      }.to raise_error(TypeError, /conver(t|sion)/)
+    end
+
+    it 'when showing a particular ssl vserver :name is required' do
+      expect {
+        connection.ssl.vserver.show(:foo => 'bar')
+      }.to raise_error(ArgumentError, /name/)
+    end
+  end
+
+  context 'when removing an ssl vserver' do
+    it 'a name is required' do
+      expect {
+        connection.ssl.vserver.remove()
+      }.to raise_error(ArgumentError, /wrong number/)
+    end
+
+    it 'throw an arg error if :name arg is missing' do
+      expect {
+        connection.ssl.vserver.remove(:foo => 'bar')
+      }.to raise_error(ArgumentError, /name/)
+    end
+
+    it 'should return a hash if :name is supplied' do
+      result = connection.ssl.vserver.remove :name => 'foo'
+      expect(result).to be_kind_of(Hash)
+    end
+  end
+
+  context 'when showing ssl vserver bindings' do
+    it 'should throw an error if there is no arg' do
+      expect {
+        connection.ssl.vserver.show_binding()
+      }.to raise_error(ArgumentError, /wrong number/)
+    end
+
+    it 'throw an arg error if :name arg is missing' do
+      expect {
+        connection.ssl.vserver.show_binding(:foo => 'bar')
+      }.to raise_error(ArgumentError, /name/)
+    end
+
+    it 'should return a hash if :name is supplied' do
+      result = connection.ssl.vserver.show_binding :name => 'foo'
+      expect(result).to be_kind_of(Hash)
+    end
+  end
+
+  context 'when [un]binding certificate to ssl vserver' do
+    it 'should throw an error if :sslcertkey arg is not given' do
+      expect {
+        connection.ssl.vserver.bind.sslcertkey :name => 'foo'
+      }.to raise_error(ArgumentError, /name/)
+      expect {
+        connection.ssl.vserver.unbind.sslcertkey :name => 'foo'
+      }.to raise_error(ArgumentError, /name/)
+    end
+
+    it 'should throw an error if :name arg is not given' do
+      expect {
+        connection.ssl.vserver.bind.sslcertkey :sslcertkey => 'foo'
+      }.to raise_error(ArgumentError, /name/)
+      expect {
+        connection.ssl.vserver.unbind.sslcertkey :sslcertkey => 'foo'
+      }.to raise_error(ArgumentError, /name/)
+    end
+
+    it 'should return a Hash if all require arguments are supplied' do
+      result = connection.ssl.vserver.bind.sslcertkey :certkeyname => 'foo', :name => 'bar'
+      expect(result).to be_kind_of(Hash)
+      unbind_result = connection.ssl.vserver.unbind.sslcertkey :certkeyname => 'foo', :name => 'bar'
+      expect(unbind_result).to be_kind_of(Hash)
+
+    end
+  end
+
+end