netscaler 0.5.2 → 0.6.0

data/spec/csvserver_spec.rb

@@ -11,54 +11,54 @@ describe Netscaler::Cs::Vserver do
     it 'a name is required' do
       expect {
         connection.cs.vserver.add(:serviceType => 'HTTP', :port => '80', :ipv46 => '1.1.1.1')
-      }.should raise_error(ArgumentError, /name/)
+      }.to raise_error(ArgumentError, /name/)
     end
 
     it 'a service type is required' do
       expect {
         connection.cs.vserver.add(:name => 'foo', :port => '80', :ipv46 => '1.1.1.1')
-      }.should raise_error(ArgumentError, /serviceType/)
+      }.to raise_error(ArgumentError, /serviceType/)
     end
 
     it 'a port is required' do
       expect {
         connection.cs.vserver.add(:name => 'foo', :serviceType => 'HTTP', :ipv46 => '1.1.1.1')
-      }.should raise_error(ArgumentError, /port/)
+      }.to raise_error(ArgumentError, /port/)
     end
 
     it 'a ipv46 is required' do
       expect {
         connection.cs.vserver.add(:name => 'foo', :serviceType => 'HTTP', :port => '80')
-      }.should raise_error(ArgumentError, /ipv46/)
+      }.to raise_error(ArgumentError, /ipv46/)
     end
 
     it 'return hash when supplied all required params' do
       result = connection.cs.vserver.add(:name => 'foo', :serviceType => 'HTTP', :port => '80', :ipv46 => '1.1.1.1')
-      result.should be_kind_of(Hash)
+      expect(result).to be_kind_of(Hash)
     end
   end
 
   context 'when using the show method in Cs::Vserver' do
     it 'with no param used it will return all vservers' do
       result = connection.cs.vserver.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.cs.vserver.show :name => 'foo'
-      result.should be_kind_of(Hash)
+      expect(result).to be_kind_of(Hash)
     end
 
     it 'when showing a particular lb vserver string is invalid' do
       expect {
         connection.cs.vserver.show('asdf')
-      }.should raise_error(TypeError, /conver(t|sion)/)
+      }.to raise_error(TypeError, /conver(t|sion)/)
     end
 
     it 'when showing a particular lb vserver :name is required' do
       expect {
         connection.cs.vserver.show(:foo => 'bar')
-      }.should raise_error(ArgumentError, /name/)
+      }.to raise_error(ArgumentError, /name/)
     end
   end
 
@@ -66,18 +66,18 @@ describe Netscaler::Cs::Vserver do
     it 'a name is required' do
       expect {
         connection.cs.vserver.remove()
-      }.should raise_error(ArgumentError, /wrong number/)
+      }.to raise_error(ArgumentError, /wrong number/)
     end
 
     it 'throw an arg error if :name arg is missing' do
       expect {
         connection.cs.vserver.remove(:foo => 'bar')
-      }.should raise_error(ArgumentError, /name/)
+      }.to raise_error(ArgumentError, /name/)
     end
 
     it 'should return a hash if :name is supplied' do
       result = connection.cs.vserver.remove :name => 'foo'
-      result.should be_kind_of(Hash)
+      expect(result).to be_kind_of(Hash)
     end
   end
 
@@ -85,18 +85,18 @@ describe Netscaler::Cs::Vserver do
     it 'should throw an error if there is no arg' do
       expect {
         connection.cs.vserver.show_binding()
-      }.should raise_error(ArgumentError, /wrong number/)
+      }.to raise_error(ArgumentError, /wrong number/)
     end
 
     it 'throw an arg error if :name arg is missing' do
       expect {
         connection.cs.vserver.show_binding(:foo => 'bar')
-      }.should raise_error(ArgumentError, /name/)
+      }.to raise_error(ArgumentError, /name/)
     end
 
     it 'should return a hash if :name is supplied' do
       result = connection.cs.vserver.show_binding :name => 'foo'
-      result.should be_kind_of(Hash)
+      expect(result).to be_kind_of(Hash)
     end
   end
 
@@ -104,29 +104,29 @@ describe Netscaler::Cs::Vserver do
     it 'should throw an error if :name arg is not given' do
       expect {
         connection.cs.vserver.bind.cs_policy :serviceName => 'foo'
-      }.should raise_error(ArgumentError, /name/)
+      }.to raise_error(ArgumentError, /name/)
       expect {
         connection.cs.vserver.unbind.cs_policy :serviceName => 'foo'
-      }.should raise_error(ArgumentError, /name/)
+      }.to raise_error(ArgumentError, /name/)
     end
 
     it 'should throw an error if :targetvserver arg is not given' do
       expect {
         connection.cs.vserver.bind.cs_policy :name => 'foo'
-      }.should raise_error(ArgumentError, /targetvserver/)
+      }.to raise_error(ArgumentError, /targetvserver/)
 
       #This is actually not expected when unbinding.
       # expect {
       #   connection.cs.vserver.unbind.cs_policy :name => 'foo'
-      # }.should raise_error(ArgumentError, /targetvserver/)
+      # }.to raise_error(ArgumentError, /targetvserver/)
 
     end
 
     it 'should return a Hash if all require arguments are supplied' do
       result = connection.cs.vserver.bind.cs_policy :name => 'foo', :targetvserver => 'bar'
-      result.should be_kind_of(Hash)
+      expect(result).to be_kind_of(Hash)
       unbind_result = connection.cs.vserver.unbind.cs_policy :name => 'foo'
-      unbind_result.should be_kind_of(Hash)
+      expect(unbind_result).to be_kind_of(Hash)
 
     end
   end
@@ -135,41 +135,41 @@ describe Netscaler::Cs::Vserver do
     it 'should throw an error if :name arg is not given' do
       expect {
         connection.cs.vserver.bind.rewrite_policy :policyName => 'bar', :priority => '10', :bindpoint => 'request'
-      }.should raise_error(ArgumentError, /name/)
+      }.to raise_error(ArgumentError, /name/)
 
       expect {
         connection.cs.vserver.unbind.rewrite_policy :policyName => 'bar', :priority => '10', :bindpoint => 'request'
-      }.should raise_error(ArgumentError, /name/)
+      }.to raise_error(ArgumentError, /name/)
 
     end
 
     it 'should throw an error if :policyName arg is not given' do
       expect {
         connection.cs.vserver.bind.rewrite_policy :name => 'foo', :priority => '10', :bindpoint => 'request'
-      }.should raise_error(ArgumentError, /policyName/)
+      }.to raise_error(ArgumentError, /policyName/)
 
       expect {
         connection.cs.vserver.unbind.rewrite_policy :name => 'foo', :priority => '10', :bindpoint => 'request'
-      }.should raise_error(ArgumentError, /policyName/)
+      }.to raise_error(ArgumentError, /policyName/)
     end
 
     it 'should throw an error if :priority arg is not given' do
       expect {
         connection.cs.vserver.bind.rewrite_policy :name => 'foo', :policyName => 'bar', :bindpoint => 'request'
-      }.should raise_error(ArgumentError, /priority/)
+      }.to raise_error(ArgumentError, /priority/)
     end
 
     it 'should throw an error if :bindpoint arg is not given' do
       expect {
         connection.cs.vserver.bind.rewrite_policy :name => 'foo', :policyName => 'bar', :priority => '10'
-      }.should raise_error(ArgumentError, /bindpoint/)
+      }.to raise_error(ArgumentError, /bindpoint/)
     end
 
     it 'should return a Hash if all require arguments are supplied' do
       result = connection.cs.vserver.bind.rewrite_policy :name => 'foo', :policyName => 'bar', :priority => '10', :bindpoint => 'request'
-      result.should be_kind_of(Hash)
+      expect(result).to be_kind_of(Hash)
       unbind_result = connection.cs.vserver.unbind.rewrite_policy :name => 'foo', :policyName => 'bar'
-      unbind_result.should be_kind_of(Hash)
+      expect(unbind_result).to be_kind_of(Hash)
     end
   end
 
@@ -177,35 +177,35 @@ describe Netscaler::Cs::Vserver do
     it 'should throw an error if :name arg is not given' do
       expect {
         connection.cs.vserver.bind.responder_policy :policyName => 'bar', :priority => '10'
-      }.should raise_error(ArgumentError, /name/)
+      }.to raise_error(ArgumentError, /name/)
 
       expect {
         connection.cs.vserver.unbind.responder_policy :policyName => 'bar', :priority => '10'
-      }.should raise_error(ArgumentError, /name/)
+      }.to raise_error(ArgumentError, /name/)
 
     end
 
     it 'should throw an error if :policyName arg is not given' do
       expect {
         connection.cs.vserver.bind.responder_policy :name => 'foo', :priority => '10'
-      }.should raise_error(ArgumentError, /policyName/)
+      }.to raise_error(ArgumentError, /policyName/)
 
       expect {
         connection.cs.vserver.unbind.responder_policy :name => 'foo', :priority => '10'
-      }.should raise_error(ArgumentError, /policyName/)
+      }.to raise_error(ArgumentError, /policyName/)
     end
 
     it 'should throw an error if :priority arg is not given' do
       expect {
         connection.cs.vserver.bind.responder_policy :name => 'foo', :policyName => 'bar'
-      }.should raise_error(ArgumentError, /priority/)
+      }.to raise_error(ArgumentError, /priority/)
     end
 
     it 'should return a Hash if all require arguments are supplied' do
       result = connection.cs.vserver.bind.responder_policy :name => 'foo', :policyName => 'bar', :priority => '10', :bindpoint => 'request'
-      result.should be_kind_of(Hash)
+      expect(result).to be_kind_of(Hash)
       unbind_result = connection.cs.vserver.unbind.responder_policy :name => 'foo', :policyName => 'bar'
-      unbind_result.should be_kind_of(Hash)
+      expect(unbind_result).to be_kind_of(Hash)
     end
   end
 

data/spec/lbvserver_spec.rb

@@ -11,54 +11,54 @@ describe Netscaler::Lb::Vserver do
     it 'a name is required' do
       expect {
         connection.lb.vserver.add(:serviceType => 'HTTP', :port => '80', :ipv46 => '1.1.1.1')
-      }.should raise_error(ArgumentError, /name/)
+      }.to raise_error(ArgumentError, /name/)
     end
 
     it 'a service type is required' do
       expect {
         connection.lb.vserver.add(:name => 'foo', :port => '80', :ipv46 => '1.1.1.1')
-      }.should raise_error(ArgumentError, /serviceType/)
+      }.to raise_error(ArgumentError, /serviceType/)
     end
 
     it 'a port is required' do
       expect {
         connection.lb.vserver.add(:name => 'foo', :serviceType => 'HTTP', :ipv46 => '1.1.1.1')
-      }.should raise_error(ArgumentError, /port/)
+      }.to raise_error(ArgumentError, /port/)
     end
 
     it 'a ipv46 is required' do
       expect {
         connection.lb.vserver.add(:name => 'foo', :serviceType => 'HTTP', :port => '80')
-      }.should raise_error(ArgumentError, /ipv46/)
+      }.to raise_error(ArgumentError, /ipv46/)
     end
 
     it 'return hash when supplied all required params' do
       result = connection.lb.vserver.add(:name => 'foo', :serviceType => 'HTTP', :port => '80', :ipv46 => '1.1.1.1')
-      result.should be_kind_of(Hash)
+      expect(result).to be_kind_of(Hash)
     end
   end
 
   context 'when using the show method in Lb::Vserver' do
     it 'with no param used it will return all vservers' do
       result = connection.lb.vserver.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.lb.vserver.show :name => 'foo'
-      result.should be_kind_of(Hash)
+      expect(result).to be_kind_of(Hash)
     end
 
     it 'when showing a particular lb vserver string is invalid' do
       expect {
         connection.lb.vserver.show('asdf')
-      }.should raise_error(TypeError, /conver(t|sion)/)
+      }.to raise_error(TypeError, /conver(t|sion)/)
     end
 
     it 'when showing a particular lb vserver :name is required' do
       expect {
         connection.lb.vserver.show(:foo => 'bar')
-      }.should raise_error(ArgumentError, /name/)
+      }.to raise_error(ArgumentError, /name/)
     end
   end
 
@@ -66,18 +66,18 @@ describe Netscaler::Lb::Vserver do
     it 'a name is required' do
       expect {
         connection.lb.vserver.remove()
-      }.should raise_error(ArgumentError, /wrong number/)
+      }.to raise_error(ArgumentError, /wrong number/)
     end
 
     it 'throw an arg error if :name arg is missing' do
       expect {
         connection.lb.vserver.remove(:foo => 'bar')
-      }.should raise_error(ArgumentError, /name/)
+      }.to raise_error(ArgumentError, /name/)
     end
 
     it 'should return a hash if :name is supplied' do
       result = connection.lb.vserver.remove :name => 'foo'
-      result.should be_kind_of(Hash)
+      expect(result).to be_kind_of(Hash)
     end
   end
 
@@ -85,18 +85,18 @@ describe Netscaler::Lb::Vserver do
     it 'should throw an error if there is no arg' do
       expect {
         connection.lb.vserver.show_binding()
-      }.should raise_error(ArgumentError, /wrong number/)
+      }.to raise_error(ArgumentError, /wrong number/)
     end
 
     it 'throw an arg error if :name arg is missing' do
       expect {
         connection.lb.vserver.show_binding(:foo => 'bar')
-      }.should raise_error(ArgumentError, /name/)
+      }.to raise_error(ArgumentError, /name/)
     end
 
     it 'should return a hash if :name is supplied' do
       result = connection.lb.vserver.show_binding :name => 'foo'
-      result.should be_kind_of(Hash)
+      expect(result).to be_kind_of(Hash)
     end
   end
 
@@ -104,28 +104,28 @@ describe Netscaler::Lb::Vserver do
     it 'should throw an error if :name arg is not given' do
       expect {
         connection.lb.vserver.bind.service :serviceName => 'foo'
-      }.should raise_error(ArgumentError, /name/)
+      }.to raise_error(ArgumentError, /name/)
       expect {
         connection.lb.vserver.unbind.service :serviceName => 'foo'
-      }.should raise_error(ArgumentError, /name/)
+      }.to raise_error(ArgumentError, /name/)
     end
 
     it 'should throw an error if :serviceName arg is not given' do
       expect {
         connection.lb.vserver.bind.service :name => 'foo'
-      }.should raise_error(ArgumentError, /serviceName/)
+      }.to raise_error(ArgumentError, /serviceName/)
 
       expect {
         connection.lb.vserver.unbind.service :name => 'foo'
-      }.should raise_error(ArgumentError, /serviceName/)
+      }.to raise_error(ArgumentError, /serviceName/)
 
     end
 
     it 'should return a Hash if all require arguments are supplied' do
       result = connection.lb.vserver.bind.service :name => 'foo', :serviceName => ''
-      result.should be_kind_of(Hash)
+      expect(result).to be_kind_of(Hash)
       unbind_result = connection.lb.vserver.unbind.service :name => 'foo', :serviceName => ''
-      unbind_result.should be_kind_of(Hash)
+      expect(unbind_result).to be_kind_of(Hash)
 
     end
   end
@@ -134,41 +134,41 @@ describe Netscaler::Lb::Vserver do
     it 'should throw an error if :name arg is not given' do
       expect {
         connection.lb.vserver.bind.rewrite_policy :policyName => 'bar', :priority => '10', :bindpoint => 'request'
-      }.should raise_error(ArgumentError, /name/)
+      }.to raise_error(ArgumentError, /name/)
 
       expect {
         connection.lb.vserver.unbind.rewrite_policy :policyName => 'bar', :priority => '10', :bindpoint => 'request'
-      }.should raise_error(ArgumentError, /name/)
+      }.to raise_error(ArgumentError, /name/)
 
     end
 
     it 'should throw an error if :policyName arg is not given' do
       expect {
         connection.lb.vserver.bind.rewrite_policy :name => 'foo', :priority => '10', :bindpoint => 'request'
-      }.should raise_error(ArgumentError, /policyName/)
+      }.to raise_error(ArgumentError, /policyName/)
 
       expect {
         connection.lb.vserver.unbind.rewrite_policy :name => 'foo', :priority => '10', :bindpoint => 'request'
-      }.should raise_error(ArgumentError, /policyName/)
+      }.to raise_error(ArgumentError, /policyName/)
     end
 
     it 'should throw an error if :priority arg is not given' do
       expect {
         connection.lb.vserver.bind.rewrite_policy :name => 'foo', :policyName => 'bar', :bindpoint => 'request'
-      }.should raise_error(ArgumentError, /priority/)
+      }.to raise_error(ArgumentError, /priority/)
     end
 
     it 'should throw an error if :bindpoint arg is not given' do
       expect {
         connection.lb.vserver.bind.rewrite_policy :name => 'foo', :policyName => 'bar', :priority => '10'
-      }.should raise_error(ArgumentError, /bindpoint/)
+      }.to raise_error(ArgumentError, /bindpoint/)
     end
 
     it 'should return a Hash if all require arguments are supplied' do
       result = connection.lb.vserver.bind.rewrite_policy :name => 'foo', :policyName => 'bar', :priority => '10', :bindpoint => 'request'
-      result.should be_kind_of(Hash)
+      expect(result).to be_kind_of(Hash)
       unbind_result = connection.lb.vserver.unbind.rewrite_policy :name => 'foo', :policyName => 'bar'
-      unbind_result.should be_kind_of(Hash)
+      expect(unbind_result).to be_kind_of(Hash)
     end
   end
 

data/spec/netscaler_spec.rb

@@ -7,17 +7,17 @@ describe Netscaler do
     it 'a hostname is required' do
       expect {
         netscaler = Netscaler::Connection.new 'username'=> 'foo', 'password' => 'bar'
-      }.should raise_error(ArgumentError, /hostname/)
+      }.to raise_error(ArgumentError, /hostname/)
     end
     it 'a username is required' do
       expect {
         netscaler = Netscaler::Connection.new 'hostname'=> 'foo', 'password' => 'bar'
-      }.should raise_error(ArgumentError, /username/)
+      }.to raise_error(ArgumentError, /username/)
     end
     it 'a password is required' do
       expect {
         netscaler = Netscaler::Connection.new 'username'=> 'foo', 'hostname' => 'bar'
-      }.should raise_error(ArgumentError, /password/)
+      }.to raise_error(ArgumentError, /password/)
     end
     it 'verify_ssl should be true' do
       netscaler = Netscaler::Connection.new 'username'=> 'foo', 'hostname' => 'bar', 'password' => 'baz'
@@ -36,8 +36,8 @@ describe Netscaler do
       netscaler = Netscaler::Connection.new 'username'=> 'foo', 'hostname' => 'bar', 'password' => 'asdf'
       netscaler.adapter = Netscaler::MockAdapter.new :body => '{ "errorcode": 0, "message": "Done", "sessionid": "##074E17E8CD4C9E95A206C2A5E543D82BCDA57F16A7BE74F985733D6C241B" }'
       result = netscaler.login
-      result.should be_a_kind_of(String)
-      result.should == "##074E17E8CD4C9E95A206C2A5E543D82BCDA57F16A7BE74F985733D6C241B"
+      expect(result).to be_a_kind_of(String)
+      expect(result).to eq("##074E17E8CD4C9E95A206C2A5E543D82BCDA57F16A7BE74F985733D6C241B")
     end
   end
 end