gapinc-fog 1.12.1.2.1 → 1.14.0

data/tests/rackspace/models/monitoring/metric_tests.rb

@@ -0,0 +1,19 @@
+Shindo.tests('Fog::Rackspace::Monitoring | metrics', ['rackspace','rackspace_monitoring']) do
+  pending if Fog.mocking?
+  service = Fog::Rackspace::Monitoring.new
+  
+  begin
+    label = "fog_#{Time.now.to_i.to_s}"
+    @entity = service.entities.create :label => label
+    @check = service.checks.create CHECK_CREATE_OPTIONS.merge(:label => label, :entity => @entity)
+    sleep(@check.period + 30) unless Fog.mocking?
+    @metric = service.metrics(:check => @check).first
+    
+    tests('#datapoints').succeeds do
+     @metric.datapoints
+    end
+  ensure
+    @check.destroy rescue nil if @check
+    @entity.destroy rescue nil if @entity
+  end
+end

data/tests/rackspace/models/monitoring/metrics_tests.rb

@@ -0,0 +1,17 @@
+Shindo.tests('Fog::Rackspace::Monitoring | metrics', ['rackspace','rackspace_monitoring']) do
+  pending if Fog.mocking?
+  service = Fog::Rackspace::Monitoring.new
+
+  begin
+    label = "fog_#{Time.now.to_i.to_s}"
+    @entity = service.entities.create :label => label
+    @check = service.checks.create CHECK_CREATE_OPTIONS.merge(:label => label, :entity => @entity)
+    
+    tests('#list_metrics').succeeds do
+      service.metrics(:check => @check).all
+    end
+  ensure
+    @check.destroy rescue nil if @check
+    @entity.destroy rescue nil if @entity
+  end
+end

data/tests/rackspace/monitoring_tests.rb

@@ -0,0 +1,72 @@
+Shindo.tests('Fog::Rackspace::Monitoring', ['rackspace','rackspace_monitoring']) do
+
+  def assert_method(url, method)
+    @service.instance_variable_set "@rackspace_auth_url", url
+    returns(method) { @service.send :authentication_method }
+  end
+
+  tests('#authentication_method') do
+    @service = Fog::Rackspace::Monitoring.new
+
+    assert_method nil, :authenticate_v2
+
+    assert_method 'auth.api.rackspacecloud.com', :authenticate_v1 # chef's default auth endpoint
+
+    assert_method 'https://identity.api.rackspacecloud.com', :authenticate_v1
+    assert_method 'https://identity.api.rackspacecloud.com/v1', :authenticate_v1
+    assert_method 'https://identity.api.rackspacecloud.com/v1.1', :authenticate_v1
+    assert_method 'https://identity.api.rackspacecloud.com/v2.0', :authenticate_v2
+
+    assert_method 'https://lon.identity.api.rackspacecloud.com', :authenticate_v1
+    assert_method 'https://lon.identity.api.rackspacecloud.com/v1', :authenticate_v1
+    assert_method 'https://lon.identity.api.rackspacecloud.com/v1.1', :authenticate_v1
+    assert_method 'https://lon.identity.api.rackspacecloud.com/v2.0', :authenticate_v2
+  end
+
+
+  tests('current authentation') do
+    pending if Fog.mocking?
+
+    tests('variables populated').succeeds do
+      @service = Fog::Rackspace::Monitoring.new :rackspace_auth_url => 'https://identity.api.rackspacecloud.com/v2.0', :connection_options => {:ssl_verify_peer => true}
+      returns(true, "auth token populated") { !@service.send(:auth_token).nil? }
+      returns(false, "path populated") { @service.instance_variable_get("@uri").host.nil? }
+      identity_service = @service.instance_variable_get("@identity_service")
+      returns(false, "identity service was used") { identity_service.nil? }
+      returns(true, "connection_options are passed") { identity_service.instance_variable_get("@connection_options").has_key?(:ssl_verify_peer) }
+      @service.list_entities
+    end
+    tests('custom endpoint') do
+      @service = Fog::Rackspace::Monitoring.new :rackspace_auth_url => 'https://identity.api.rackspacecloud.com/v2.0',
+        :rackspace_monitoring_url => 'https://my-custom-endpoint.com'
+        returns(true, "auth token populated") { !@service.send(:auth_token).nil? }
+        returns(true, "uses custom endpoint") { (@service.instance_variable_get("@uri").host =~ /my-custom-endpoint\.com/) != nil }
+    end
+  end
+
+  tests('default auth') do
+    pending if Fog.mocking?
+
+    tests('no params').succeeds do
+      @service = Fog::Rackspace::Monitoring.new
+      returns(true, "auth token populated") { !@service.send(:auth_token).nil? }
+      returns(true) { (@service.instance_variable_get("@uri").host =~ /monitoring.api.rackspacecloud.com/) != nil }
+      @service.list_entities
+    end
+    tests('custom endpoint') do
+      @service = Fog::Rackspace::Monitoring.new :rackspace_monitoring_url => 'https://my-custom-endpoint.com'
+      returns(true, "auth token populated") { !@service.send(:auth_token).nil? }
+      returns(true, "uses custom endpoint") { (@service.instance_variable_get("@uri").host =~ /my-custom-endpoint\.com/) != nil }
+    end
+  end
+
+  tests('reauthentication') do
+    pending if Fog.mocking?
+
+    @service = Fog::Rackspace::Monitoring.new
+    returns(true, "auth token populated") { !@service.send(:auth_token).nil? }
+    @service.instance_variable_set("@auth_token", "bad_token")
+    returns(true) { [200, 203].include? @service.list_entities.status }
+  end
+
+end

data/tests/rackspace/requests/compute_v2/keypair_tests.rb

@@ -0,0 +1,55 @@
+Shindo.tests('Fog::Compute::RackspaceV2 | keypair_tests', ['rackspace']) do
+
+  keypair_format = {
+    'name'        => String,
+    'public_key'  => String,
+    'fingerprint' => String,
+  }
+
+  create_keypair_format = {
+    'keypair' => keypair_format.merge({
+        'user_id'     => String,
+        'private_key' => String
+    })
+  }
+
+  list_keypair_format = {
+    'keypairs' => [ 'keypair' => keypair_format ]
+  }
+
+  get_keypair_format = {
+    'keypair' => keypair_format
+  }
+
+  service = Fog::Compute.new(:provider => 'Rackspace', :version => 'V2')
+  keypair_name = Fog::Mock.random_letters(32)
+
+  tests('success') do
+    tests('#create_keypair').formats(create_keypair_format) do
+      service.create_keypair(keypair_name).body
+    end
+
+    tests('#list_keypairs').formats(list_keypair_format) do
+      service.list_keypairs.body
+    end
+
+    tests('#get_keypair').formats(get_keypair_format) do
+      service.get_keypair(keypair_name).body
+    end
+
+    tests('#delete_keypair') do
+      service.delete_keypair(keypair_name).body
+    end
+  end
+
+  unknown_keypair_name = Fog::Mock.random_letters(32)
+  tests('failure') do
+    tests('#get_unknown_keypair').raises(Fog::Compute::RackspaceV2::NotFound) do
+      service.get_keypair(unknown_keypair_name).body
+    end
+
+    tests('#delete_unknown_keypair').raises(Fog::Compute::RackspaceV2::NotFound) do
+      service.delete_keypair(unknown_keypair_name).body
+    end
+  end
+end

data/tests/rackspace/requests/monitoring/agent_tests.rb

@@ -0,0 +1,34 @@
+Shindo.tests('Fog::Rackspace::Monitoring | agent_tests', ['rackspace','rackspace_monitoring']) do
+  pending if Fog.mocking?
+
+  account = Fog::Rackspace::Monitoring.new
+  agent_token = nil
+  options = { "label" => "Bar" }
+  tests('success') do
+    tests('#create new agent token').formats(DATA_FORMAT) do
+      response = account.create_agent_token(options).data
+      agent_token = response[:headers]["X-Object-ID"]
+      response
+    end
+    tests('#list agent tokens').formats(LIST_HEADERS_FORMAT) do
+      account.list_agent_tokens().data[:headers]
+    end
+    tests('#get agent token').formats(LIST_HEADERS_FORMAT) do
+      account.get_agent_token(agent_token).data[:headers]
+    end
+    tests('#delete agent token').formats(DELETE_HEADERS_FORMAT) do
+      account.delete_agent_token(agent_token).data[:headers]
+    end
+  end
+  tests('failure') do
+    tests('#fail to create agent token(-1)').raises(TypeError) do
+      account.create_agent_token(-1)
+    end
+    tests('#fail to get agent token(-1)').raises(TypeError) do
+      account.create_agent_token(-1)
+    end
+    tests('#fail to delete agent token(-1)').raises(Fog::Rackspace::Monitoring::NotFound) do
+      account.delete_agent_token(-1)
+    end
+  end
+end

data/tests/rackspace/requests/monitoring/alarm_example_tests.rb

@@ -0,0 +1,30 @@
+Shindo.tests('Fog::Rackspace::Monitoring | alarm_example_tests', ['rackspace','rackspace_monitoring']) do
+  pending if Fog.mocking? 
+
+  account = Fog::Rackspace::Monitoring.new
+  example_id = "remote.http_body_match_1"
+  tests('success') do
+    tests('#list alarm examples').formats(LIST_HEADERS_FORMAT) do
+      account.list_alarm_examples().data[:headers]
+    end
+    tests('#get alarm example').formats(LIST_HEADERS_FORMAT) do
+      account.get_alarm_example(example_id).data[:headers]
+    end
+    tests('#evaluate alarm example').formats(LIST_HEADERS_FORMAT) do
+      options = { :string => "Foo"}
+      account.evaluate_alarm_example(example_id,options).data[:headers]
+    end
+  end
+  tests('failure') do
+    tests('#fail to list alarm examples(-1)').raises(ArgumentError) do
+      account.list_alarm_examples(-1).data[:headers]
+    end
+    tests('#fail to get alarm example(-1)').raises(Fog::Rackspace::Monitoring::NotFound) do
+      account.get_alarm_example(-1).data[:headers]
+    end
+    tests('#fail to evaluate alarm example').raises(Fog::Rackspace::Monitoring::BadRequest) do
+      options = { }
+      account.evaluate_alarm_example(example_id,options).data[:headers]
+    end
+  end
+end

data/tests/rackspace/requests/monitoring/alarm_tests.rb

@@ -0,0 +1,56 @@
+Shindo.tests('Fog::Rackspace::Monitoring | alarm_tests', ['rackspace','rackspace_monitoring']) do
+  pending if Fog.mocking?
+
+  account = Fog::Rackspace::Monitoring.new
+  entity_id = account.create_entity(:label => "Foo").data[:headers]["X-Object-ID"]
+  check_id = account.create_check(entity_id, CHECK_CREATE_OPTIONS).data[:headers]["X-Object-ID"]
+  alarm_id = nil
+  np = "npTechnicalContactsEmail"
+  tests('success') do
+    tests('#create new alarm').formats(DATA_FORMAT) do
+      alarm_criteria = "if (metric['code'] == '404') { return new AlarmStatus(CRITICAL, 'Page not found');}"
+      options = {
+        :check_id => check_id,
+        :notification_plan_id => np,
+        :criteria => alarm_criteria
+      }
+      response = account.create_alarm(entity_id,options).data
+      alarm_id = response[:headers]["X-Object-ID"]
+      response
+    end
+    tests('#update alarm').formats(DATA_FORMAT) do
+      options = { :label => "Bar"}
+      account.update_alarm(entity_id,alarm_id,options).data
+    end
+    tests('#list alarms').formats(LIST_HEADERS_FORMAT) do
+      account.list_alarms(entity_id).data[:headers]
+    end
+    tests('#get alarm').formats(LIST_HEADERS_FORMAT) do
+      account.get_alarm(entity_id,alarm_id).data[:headers]
+    end
+    tests('#delete alarm').formats(DELETE_DATA_FORMAT) do
+      account.delete_alarm(entity_id,alarm_id).data
+    end
+  end
+  tests('failure') do
+    tests('#fail to create new alarm(-1)').raises(Fog::Rackspace::Monitoring::BadRequest) do
+      account.create_alarm(entity_id, {:type => ""})
+    end
+    # Commenting out update because incorrect update throws a 502
+    #tests('#fail to update invalid alarm(-1)').raises(Fog::Rackspace::Monitoring::NotFound) do
+      #options = { :testing => "Bar" }
+      #response = account.update_alarm(-1,-1,options)
+    #end
+    tests('#fail to list alarms').raises(Fog::Rackspace::Monitoring::NotFound) do
+      account.list_alarms(-1)
+    end
+    tests('#fail to get alarm').raises(Fog::Rackspace::Monitoring::NotFound) do
+      account.get_alarm(-1,-1)
+    end
+    tests('#fail to delete alarm(-1)').raises(Fog::Rackspace::Monitoring::NotFound) do
+      account.delete_alarm(-1,-1)
+    end
+  end
+  account.delete_check(entity_id,check_id)
+  account.delete_entity(entity_id)
+end

data/tests/rackspace/requests/monitoring/check_tests.rb

@@ -0,0 +1,40 @@
+Shindo.tests('Fog::Rackspace::Monitoring | check_tests', ['rackspace', 'rackspace_monitoring']) do
+  pending if Fog.mocking? 
+
+  account = Fog::Rackspace::Monitoring.new
+  entity_id = account.create_entity(:label => "Foo").data[:headers]["X-Object-ID"]
+  check_id = nil
+  tests('success') do
+    tests('#create new check').formats(DATA_FORMAT) do
+      response = account.create_check(entity_id, CHECK_CREATE_OPTIONS).data
+      check_id = response[:headers]['X-Object-ID']
+      response
+    end
+    tests('#get check').formats(LIST_HEADERS_FORMAT) do
+      account.get_check(entity_id,check_id).data[:headers]
+    end
+    tests('#update check').formats(DATA_FORMAT) do
+      options = { :label => "Bar"}
+      account.update_check(entity_id,check_id,options).data
+    end
+    tests('#delete check').formats(DELETE_DATA_FORMAT) do
+      account.delete_check(entity_id,check_id).data
+    end
+  end
+  tests('failure') do
+    tests('#create new check(-1)').raises(Fog::Rackspace::Monitoring::BadRequest) do
+      account.create_check(entity_id, {:type => ""})
+    end
+    tests('#get check(-1)').raises(Fog::Rackspace::Monitoring::NotFound) do
+      account.get_check(-1, -1)
+    end
+    tests('#update invalid check(-1)').raises(Fog::Rackspace::Monitoring::NotFound) do
+      options = { :testing => "Bar" }
+      response = account.update_check(-1,-1,options)
+    end
+    tests('#delete check(-1)').raises(Fog::Rackspace::Monitoring::NotFound) do
+      account.delete_check(-1,-1)
+    end
+  end
+  account.delete_entity(entity_id)
+end

data/tests/rackspace/requests/monitoring/entity_tests.rb

@@ -0,0 +1,37 @@
+Shindo.tests('Fog::Rackspace::Monitoring | entity_tests', ['rackspace','rackspace_monitoring']) do
+  pending if Fog.mocking? 
+  account = Fog::Rackspace::Monitoring.new
+  entity_id = nil
+  tests('success') do
+    tests('#create new entity').formats(DATA_FORMAT) do
+      response = account.create_entity(:label => "Foo").data
+      entity_id = response[:headers]["X-Object-ID"]
+      response
+    end
+    tests('#get entity').formats(LIST_HEADERS_FORMAT) do
+      account.get_entity(entity_id).data[:headers]
+    end
+    tests('#update entity').formats(DATA_FORMAT) do
+      options = { :testing => "Bar"}
+      account.update_entity(entity_id,options).data
+    end
+    tests('#delete entity').formats(DELETE_DATA_FORMAT) do
+      account.delete_entity(entity_id).data
+    end
+  end
+  tests('failure') do
+    tests('#create new entity(-1)').raises(Fog::Rackspace::Monitoring::BadRequest) do
+      account.create_entity(:label => "")
+    end
+    tests('#get entity(-1)').raises(Fog::Rackspace::Monitoring::NotFound) do
+      account.get_entity(-1)
+    end
+    tests('#update invalid entity(-1)').raises(Fog::Rackspace::Monitoring::NotFound) do
+      options = { :testing => "Bar" }
+      response = account.update_entity(-1,options)
+    end
+    tests('#delete entity(-1)').raises(Fog::Rackspace::Monitoring::NotFound) do
+      account.delete_entity(-1)
+    end
+  end
+end

data/tests/rackspace/requests/monitoring/helper.rb

@@ -0,0 +1,78 @@
+MINIMAL_HEADERS_FORMAT = {
+  'X-RateLimit-Window' => String,
+  'X-RateLimit-Limit' => String,
+  'X-RateLimit-Type' => String,
+  'Content-Type' => String,
+  'Date' => String,
+}
+DELETE_HEADERS_FORMAT = MINIMAL_HEADERS_FORMAT.merge({
+  'Content-Length' => String
+})
+HEADERS_FORMAT = MINIMAL_HEADERS_FORMAT.merge({
+  'Content-Length' => String,
+  'X-Object-ID' => String,
+  'Location' => String
+})
+LIST_HEADERS_FORMAT = MINIMAL_HEADERS_FORMAT.merge({
+  'X-RateLimit-Remaining' => String,
+  'X-Response-Id' => String,
+  'Transfer-Encoding' => String,
+  'X-LB' => String,
+  'Vary' => String
+})
+
+DATA_FORMAT = {
+  :status => Integer,
+  :body => String,
+  :headers => HEADERS_FORMAT,
+  :remote_ip => String
+}
+DELETE_DATA_FORMAT = {
+  :status => Integer,
+  :body => String,
+  :headers => DELETE_HEADERS_FORMAT,
+  :remote_ip => String
+}
+
+CHECK_CREATE_OPTIONS = {
+  :details => {
+    :url => 'http://www.rackspace.com',
+    :method => 'GET',
+  },
+  :type => 'remote.http',
+  :monitoring_zones_poll => ['mzdfw'],
+  :target_hostname => 'rackspace.com',
+  :timeout => 30,
+  :period => 100
+}
+
+OVERVIEW_FORMAT = {
+  :status => Integer,
+  :body=> {
+    :values => [
+      {
+        :entity => {
+          :id => String,
+          :label => String,
+          :ip_addresses => { },
+          :metadata => String
+        },
+        :checks => [
+        ],
+        :alarms => [
+        ],
+        :latest_alarm_states => [
+        ]
+      }
+    ],
+    :metadata => {
+      :count => Integer,
+      :limit => Integer,
+      :marker => String,
+      :next_marker => String,
+      :next_href => String 
+    }
+  },
+  :headers => LIST_HEADERS_FORMAT,
+  :remote_ip => String
+}