ultravault 1.0.2.0

data/test/unit/lib/ultravault/data_objects/test_agent.rb

@@ -0,0 +1,133 @@
+require_relative '../../../../test_helper'
+
+module UltraVault
+  class AgentTest < Test::Unit::TestCase
+  
+    context 'a new agent' do
+    
+      setup do
+        @params = { :description=>"test-MSSQL",
+                    :hostname=>"1.2.3.4",
+                    :id=>"e9bd701b-dac1-4921-ab1c-467f35209e21",
+                    :os_type=>"WINDOWS",
+                    :port_number=>"1167"}
+      end
+    
+      context 'attributes' do
+        setup do
+          @agent = Agent.new(@params)
+        end
+      
+        should "match the input description" do
+          assert_equal @params[:description], @agent.description
+        end
+      
+        should "match the input hostname" do
+          assert_equal @params[:hostname], @agent.hostname
+        end
+      
+        should "match the input id" do
+          assert_equal @params[:id], @agent.id
+        end
+      
+        should "match the input os_type" do
+          assert_equal @params[:os_type], @agent.os_type
+        end
+      
+        should "match the input port_number" do
+          assert_equal @params[:port_number], @agent.port_number
+        end
+      
+        should "respond to .disk_safes via an api call" do
+          DiskSafe.expects(
+                :find_all_by_agent_id).with(
+                @params[:id]).returns(stub)
+          @agent.disk_safes
+        end
+      
+      end
+    
+      context 'class methods' do
+        should "pass on the .find_by_id call to the agent service" do
+          AgentService.any_instance.expects(:find_agent_by_id).with('foo')
+          Agent.find_by_id('foo')
+        end
+      
+        should "pass on the .all call to the agent service" do
+          AgentService.any_instance.expects(:all_agents)
+          Agent.all       
+        end
+      
+        should "pass on the .create call to the agent service" do
+          params = {  :hostname => 'foobar', :port_number => 8080,
+                      :description => 'foobar',
+                      :os_type => 'linux'
+                   }
+          AgentService.any_instance.expects(:create_agent).with(params)
+          Agent.expects(:check_params_strict).returns(true)
+          Agent.create(params)
+        end
+      
+        should "pass on the .update call to the agent service" do
+          params = @params.merge({ :hostname => 'bazfoobar' })
+          AgentService.any_instance.expects(:update_agent).with(params)
+          Agent.expects(:check_params).returns(true)
+          agent = Agent.new(@params)
+          agent.update(params)
+        end
+      
+        should "pass on the .destroy call to the agent service" do
+          id = "12345"
+          AgentService.any_instance.expects(:destroy_agent).with(id)
+          agent = Agent.new(@params.merge!(id: id))
+          agent.destroy
+        end
+      end
+      
+      context "params checking" do
+      
+        setup do
+          @complete_legal_params =     {
+                                         :hostname => 'foo', :port_number => 40,
+                                         :description => "Bar", :os_type => "Baz"
+                                       }
+          @incomplete_legal_params =   {
+                                         :port_number => 40,
+                                         :description => "Bar"
+                                       }
+          @incomplete_illegal_params = {
+                                         :rargh => 'foo', :port_number => 40,
+                                         :description => "Bar", :os_type => "Baz"
+                                       }
+        end
+      
+        context '#check_params' do
+          should "return true if params are legal" do
+            assert_equal Agent.check_params(@complete_legal_params), true
+          end
+        
+          should "raise ArgumentError if params are non-legal" do
+            assert_raise ArgumentError do
+              Agent.check_params(@incomplete_illegal_params)
+            end
+          end
+        end
+      
+        context '#check_params_strict' do
+          should "return true if params are legal and all present" do
+            assert_equal Agent.check_params_strict(@complete_legal_params), true
+          end
+        
+          should "raise ArgumentError if params are non-legal/all present" do
+            assert_raise ArgumentError do
+              Agent.check_params_strict(@incomplete_illegal_params)
+            end
+            assert_raise ArgumentError do
+              Agent.check_params_strict(@incomplete_legal_params)
+            end          
+          end
+        end
+      end
+    end
+  end
+end

data/test/unit/lib/ultravault/data_objects/test_disk_safe.rb

@@ -0,0 +1,150 @@
+require_relative '../../../../test_helper'
+
+module UltraVault
+  class DiskSafeTest < Test::Unit::TestCase
+    context 'A new disksafe' do
+    
+      setup do
+        load_disk_safe_fixtures
+      end
+    
+      context "attributes" do
+        setup do
+          @disk_safe = DiskSafe.new(@disk_safe_params)
+        end
+      
+        should "match the agent id" do
+          assert_equal @disk_safe.agent_id, @disk_safe_params[:agent_id]
+        end
+      
+        should "match the compression level" do
+          assert_equal @disk_safe.compression_level, @disk_safe_params[:compression_level]
+        end
+      
+        should "match the compression type" do
+          assert_equal @disk_safe.compression_type, @disk_safe_params[:compression_type]
+        end
+      
+        should "match the description" do
+          assert_equal @disk_safe.description, @disk_safe_params[:description]
+        end
+      
+        should "match the device count as an integer" do
+          assert_equal @disk_safe.device_count, @disk_safe_params[:device_count].to_i
+        end
+      
+        context "device_list" do
+          setup do
+            @device = @disk_safe.device_list.first
+          end
+        
+          should "match the capacity at the right byte level" do
+            assert_equal @device.capacity, 64421359616
+          end
+        
+          should "match the device content type" do
+            assert_equal @device.content_type,
+              @disk_safe_params[:device_list][:device_content_type]
+          end
+        
+          should "match the device path" do
+            assert_equal @device.path,
+              @disk_safe_params[:device_list][:device_path]
+          end 
+        
+          should "match the enabled flag" do
+            assert_equal @device.enabled,
+              @disk_safe_params[:device_list][:enabled]
+          end                               
+        
+          should "match the mount point" do
+            assert_equal @device.mount_point,
+              @disk_safe_params[:device_list][:mount_point]
+          end                                   
+        
+          should "match the mounted flag" do
+            assert_equal @device.mounted,
+              @disk_safe_params[:device_list][:mounted]
+          end
+        end
+      
+        should "match the archiving enabled attribute" do
+          assert_equal @disk_safe.archiving_enabled, true
+        end
+      
+        should "match the file excludes enabled attribute" do
+          assert_equal @disk_safe.file_excludes_enabled, true
+        end                                                  
+      
+        should "match the quota type" do
+          assert_equal @disk_safe.quota_type, 'NONE'
+        end                                        
+      
+        should "match the control panels enabled attribute" do
+          assert_equal @disk_safe.controlpanels_enabled, true
+        end                                                  
+      
+        should "match the archive point limit attribute" do
+          assert_equal @disk_safe.archive_point_limit, "-1"
+        end
+
+        should "match the recovery point limit attribute" do
+          assert_equal @disk_safe.recovery_point_limit, "-1"
+        end                                                
+      
+        should "match the soft quota value attribute" do
+          assert_equal @disk_safe.soft_quota_value, "-1.0"
+        end                                               
+      
+        should "match the replication frequency limit" do
+          assert_equal @disk_safe.replication_frequency_limit,
+            "NO_LIMIT"
+        end                   
+      
+        should "match the hard quota value" do
+          assert_equal @disk_safe.hard_quota_value, "-1.0"
+        end
+      
+        should "match the id" do
+          assert_equal @disk_safe.id, @disk_safe_params[:id]
+        end                           
+      
+        should "match the open flag" do
+          assert_equal @disk_safe.open, @disk_safe_params[:open]
+        end                                          
+      
+        should "match the recovery point count as integer" do
+          assert_equal @disk_safe.recovery_point_count,
+            @disk_safe_params[:recovery_point_count].to_i
+        end                                   
+      
+        should "match the size at the right byte level" do
+          assert_equal @disk_safe.size, 20931331073
+        end                                 
+      
+        should "match the size of deltas at the right byte level" do
+          assert_equal @disk_safe.size_of_deltas, 18665326744
+        end   
+      
+        should "match the volume id" do
+          assert_equal @disk_safe.volume_id, @disk_safe_params[:volume_id]
+        end
+      
+        should "define recovery points by api request" do
+          RecoveryPointService.any_instance.expects(
+                :find_recovery_points_by_disk_safe_id).with(
+                @disk_safe_params[:id]).returns(stub)
+          @disk_safe.recovery_points      
+        end
+      
+      end
+    
+      context 'class methods' do
+        should "pass on the call to the disk safe service" do
+          DiskSafeService.any_instance.expects(:find_disksafes_by_agent_id).with('foo')
+          DiskSafe.find_all_by_agent_id('foo')
+        end
+      end
+    end
+  end
+end

data/test/unit/lib/ultravault/data_objects/test_recovery_point.rb

@@ -0,0 +1,59 @@
+require_relative '../../../../test_helper'
+
+module UltraVault
+  class RecoveryPointTest < Test::Unit::TestCase
+  
+    context "creating a recovery point" do
+    
+      setup do
+        @input = { agent_id: 'e9bd701b-dac1-4921-ab1c-467f35209e21',
+                   created_on_timestamp_in_millis: 1330361712361,
+                   disk_safe_id: '3067f030-9814-4314-ae03-75933ac29e37',
+                   recovery_point_id: 1,
+                   recovery_point_state: 'AVAILABLE'}
+      end
+    
+      context 'attributes' do
+      
+        setup do
+          @recovery_point = RecoveryPoint.new(@input)
+        end
+      
+        should "match the input agent id" do
+          assert_equal @recovery_point.agent_id, @input[:agent_id]
+        end
+      
+        should "give the created_at as a ruby date_time" do
+          assert_equal @recovery_point.created_at.year, 2012
+          assert_equal @recovery_point.created_at.month, 02
+          assert_equal @recovery_point.created_at.day, 27
+          assert_equal @recovery_point.created_at.hour, 16
+          assert_equal @recovery_point.created_at.min, 55
+          assert_equal @recovery_point.created_at.sec, 12
+        end
+      
+        should "match the disk safe id" do
+          assert_equal @recovery_point.disk_safe_id, @input[:disk_safe_id]
+        end
+      
+        should "match the recovery point ID" do
+          assert_equal @recovery_point.id, @input[:recovery_point_id]
+        end
+      
+        should "match the recovery point state" do
+          assert_equal @recovery_point.state, @input[:recovery_point_state].downcase
+        end
+      end
+    
+      context 'class methods' do
+         should "pass on the call to the disk safe service" do
+           RecoveryPointService.any_instance.expects(
+             :find_recovery_points_by_disk_safe_id).with('foo')
+           RecoveryPoint.find_all_by_disk_safe_id('foo')
+         end
+       end
+    
+    end
+  
+  end
+end

data/test/unit/lib/ultravault/soap_service/test_agent_service.rb

@@ -0,0 +1,139 @@
+require_relative '../../../../test_helper'
+
+module UltraVault
+  class AgentServiceTest < Test::Unit::TestCase
+  
+    context 'a new agent service' do
+    
+      setup do
+        load_agent_service_fixtures
+      end
+    
+      context 'public methods' do
+      
+        setup do
+          ApiRequest.expects(:new).returns(stub(endpoint: 'foo',
+              namespace: 'bar'))
+          @service = AgentService.new
+          @client = stub
+          @service.expects(:client).returns(@client)
+          @error = Savon::SOAP::Fault.new(stub(body: 'foo'))
+        end
+      
+        context '#find_agent_by_id' do
+          should "return an agent object if it exists" do
+            @client.expects(:request).with(
+              :getAgentByID, id: 'foo').returns(mock(to_hash: @agent_by_id_wrapper))
+            Agent.expects(:new).returns(stub_everything)
+            agent = @service.find_agent_by_id('foo')
+          end
+      
+          should "raise an error if it does not exist" do
+            @client.expects(:request).with(
+              :getAgentByID, id: 'bar').raises(@error)
+            assert_raise Savon::SOAP::Fault do
+              agent = @service.find_agent_by_id('bar')
+            end
+          end
+        end
+    
+        context '#all_agents' do
+          should "return all agents available" do
+            @client.expects(:request).with(:getAgents).returns(
+              mock(to_hash: @all_agents_wrapper)) 
+            Agent.expects(:new).at_least_once.returns(stub_everything)
+            agents = @service.all_agents         
+          end
+        
+          should "raise an error if something goes wrong" do
+            @client.expects(:request).with(:getAgents).raises(@error)
+            assert_raise Savon::SOAP::Fault do
+              agent = @service.all_agents
+            end
+          end
+        end
+      
+        context "#create_agent" do
+          setup do
+            @params = { :hostname => 'foobar', :portNumber => 8080,
+                        :description => 'foobar', :databaseAddOnEnabled => true,
+                        :osType => 'linux' }
+          end
+        
+          should "return a new agent object" do
+            @client.expects(:request).with(:createAgentWithObject,
+              :agent => @params).returns(mock(to_hash: @agent_with_object_wrapper))
+            Agent.expects(:new).returns(stub_everything)
+            agent = @service.create_agent(@params)         
+          end
+        
+          should "raise an error if something goes wrong" do
+            @client.expects(:request).with(:createAgentWithObject, :agent => @params).raises(@error)
+            assert_raise Savon::SOAP::Fault do
+              agent = @service.create_agent(@params)
+            end
+          end
+        end
+      
+        context "#update_agent" do
+          setup do
+            @params = { :hostname => 'foobarbazbar', :portNumber => 8080,
+                        :description => 'foobar', :databaseAddOnEnabled => true,
+                        :osType => 'linux' }
+          end
+        
+          should "update an agent object" do
+            @client.expects(:request).with(:updateAgent,
+              :agent => @params).returns(
+                 mock(to_hash: @update_agent_wrapper))
+            Agent.expects(:new).returns(stub_everything)
+            agent = @service.update_agent(@params)         
+          end
+        
+          should "raise an error if something goes wrong" do
+            @client.expects(:request).with(:updateAgent, :agent => @params
+              ).raises(@error)
+            assert_raise Savon::SOAP::Fault do
+              agent = @service.update_agent(@params)
+            end
+          end
+        end
+    
+        context "#destroy_agent" do
+          setup do
+            @params = { id: "12345" }
+          end
+        
+          should "destroy an agent object" do
+            @client.expects(:request).with(:deleteAgentById,
+              @params).returns(nil)
+            @service.destroy_agent(@params[:id])         
+          end
+        
+          should "raise an error if something goes wrong" do
+            @client.expects(:request).with(:updateAgent, :agent => @params
+              ).raises(@error)
+            assert_raise Savon::SOAP::Fault do
+              agent = @service.update_agent(@params)
+            end
+          end
+        end
+      end
+    
+    
+      context "#map_agent_params" do
+        should "turn agent params ruby into agent params soap" do
+          @input = { :hostname => 'foobar', :port_number => 8080,
+                     :description => 'foobar',
+                     :os_type => 'linux'}
+          @output = { :hostname => 'foobar', :portNumber => 8080,
+                      :description => 'foobar',
+                      :osType => 'linux'}
+          assert_equal AgentService.new.send(:map_agent_params, @input),
+            @output 
+        end
+      end
+    end
+  
+  end
+end