fog 1.17.0 → 1.18.0

data/tests/hp/requests/network/port_tests.rb

@@ -0,0 +1,71 @@
+Shindo.tests('HP::Network | networking port requests', ['hp', 'networking', 'port']) do
+
+  @port_format = {
+    'id'                => String,
+    'name'              => Fog::Nullable::String,
+    'network_id'        => String,
+    'fixed_ips'         => Array,
+    'mac_address'       => String,
+    'status'            => String,
+    'admin_state_up'    => Fog::Boolean,
+    'binding:vif_type'  => String,
+    'device_owner'      => String,
+    'device_id'         => String,
+    'security_groups'   => Array,
+    'tenant_id'         => String
+  }
+
+  n_data = HP[:network].create_network({:name => 'fog_network'}).body['network']
+  @network_id = n_data['id']
+
+  tests('success') do
+
+    @port_id = nil
+
+    tests('#create_port').formats(@port_format) do
+      attributes = {:name => 'myport', :fixed_ips => [],
+                    :mac_address => 'fa:16:3e:71:26:c8', :admin_state_up => true,
+                    :device_owner => '2222222', :device_id => '3333333', :tenant_id => '111111111'}
+      data = HP[:network].create_port(@network_id, attributes).body['port']
+      @port_id = data['id']
+      data
+    end
+
+    tests('#list_port').formats({'ports' => [@port_format]}) do
+      HP[:network].list_ports.body
+    end
+
+    tests("#get_port(#{@port_id})").formats({'port' => @port_format}) do
+      HP[:network].get_port(@port_id).body
+    end
+
+    tests("#update_port(#{@port_id})").formats({'port' => @port_format}) do
+      attributes = {:name => 'myport_upd', :fixed_ips => [],
+                    :admin_state_up => true, :device_owner => 'device_owner',
+                    :device_id => 'device_id'}
+      HP[:network].update_port(@port_id, attributes).body
+    end
+
+    tests("#delete_port(#{@port_id})").succeeds do
+      HP[:network].delete_port(@port_id)
+    end
+  end
+
+  tests('failure') do
+    tests('#get_port(0)').raises(Fog::HP::Network::NotFound) do
+      HP[:network].get_port(0)
+    end
+
+    tests('#update_port(0)').raises(Fog::HP::Network::NotFound) do
+      HP[:network].update_port(0, {})
+    end
+
+    tests('#delete_port(0)').raises(Fog::HP::Network::NotFound) do
+      HP[:network].delete_port(0)
+    end
+  end
+
+  # cleanup
+  HP[:network].delete_network(@network_id)
+
+end

data/tests/hp/requests/network/router_tests.rb

@@ -0,0 +1,108 @@
+Shindo.tests('HP::Network | networking router requests', ['hp', 'networking', 'router']) do
+
+  @router_format = {
+    'id'                    => String,
+    'name'                  => String,
+    'tenant_id'             => String,
+    'status'                => String,
+    'admin_state_up'        => Fog::Boolean,
+    'external_gateway_info' => Fog::Nullable::Hash
+  }
+
+  @router_interface_format = {
+    'subnet_id'  => String,
+    'port_id'    => String
+  }
+
+  n_data = HP[:network].create_network({:name => 'fog_network'}).body['network']
+  @network_id = n_data['id']
+
+  p_data = HP[:network].create_port(@network_id, {:name => 'fog_port'}).body['port']
+  @port_id = p_data['id']
+
+  tests('success') do
+
+    @router_id = nil
+
+    tests('#create_router').formats(@router_format) do
+      attributes = {:name => 'my_router', :admin_state_up => true}
+      data = HP[:network].create_router(attributes).body['router']
+      @router_id = data['id']
+      data
+    end
+
+    tests('#list_routers').formats({'routers' => [@router_format]}) do
+      HP[:network].list_routers.body
+    end
+
+    tests("#get_router(#{@router_id})").formats({'router' => @router_format}) do
+      HP[:network].get_router(@router_id).body
+    end
+
+    tests("#update_router(#{@router_id})").formats({'router' => @router_format}) do
+      attributes = {
+        :name => 'my_router_upd',
+        :external_gateway_info => { :network_id => '11111111111' },
+        :admin_state_up => true
+      }
+      HP[:network].update_router(@router_id, attributes).body
+    end
+
+    tests("#add_router_interface(#{@router_id}, '1111111111', nil) - using subnet_id").formats(@router_interface_format) do
+      HP[:network].add_router_interface(@router_id, '1111111111', nil).body
+    end
+
+    #tests("#remove_router_interface(#{@router_id}, '1111111111', nil) - using subnet_id").formats('') do
+    #  HP[:network].remove_router_interface(@router_id, '1111111111', nil).body
+    #end
+
+    tests("#add_router_interface(#{@router_id}, nil, #{@port_id}) - using port_id").formats(@router_interface_format) do
+      HP[:network].add_router_interface(@router_id, nil, @port_id).body
+    end
+
+    tests("#add_router_interface(#{@router_id}, '1111111111', '2222222222') - using port_id and subnet_id").raises(ArgumentError) do
+      HP[:network].add_router_interface(@router_id, '1111111111', '2222222222').body
+    end
+
+    tests("#remove_router_interface(#{@router_id}, nil, #{@port_id}) - using port_id").formats('') do
+      HP[:network].remove_router_interface(@router_id, nil, @port_id).body
+    end
+
+    tests("#remove_router_interface(#{@router_id}, '1111111111', '2222222222') - using port_id and subnet_id").raises(ArgumentError) do
+      HP[:network].remove_router_interface(@router_id, '1111111111', '2222222222').body
+    end
+
+    tests("#delete_router(#{@router_id})").succeeds do
+      HP[:network].delete_router(@router_id)
+    end
+  end
+
+  tests('failure') do
+    tests('#get_router(0)').raises(Fog::HP::Network::NotFound) do
+      HP[:network].get_router(0)
+    end
+
+    tests('#update_router(0)').raises(Fog::HP::Network::NotFound) do
+      HP[:network].update_router(0, {})
+    end
+
+    tests('#delete_router(0)').raises(Fog::HP::Network::NotFound) do
+      HP[:network].delete_router(0)
+    end
+
+    tests("#add_router_interface(0, '1111111111')").raises(Fog::HP::Network::NotFound) do
+      HP[:network].add_router_interface(0, '1111111111').body
+    end
+
+    tests("#remove_router_interface(0, '1111111111')").raises(Fog::HP::Network::NotFound) do
+      HP[:network].remove_router_interface(0, '1111111111').body
+    end
+
+  end
+
+  # cleanup
+  # remove_router_interface method removes the port
+  #HP[:network].delete_port(@port_id)
+  HP[:network].delete_network(@network_id)
+
+end

data/tests/hp/requests/network/security_group_rule_tests.rb

@@ -0,0 +1,58 @@
+Shindo.tests('HP::Network | networking security group rule requests', ['hp', 'networking', 'securitygroup']) do
+
+  @security_group_rule_format = {
+    'id'                    => String,
+    'remote_group_id'       => Fog::Nullable::String,
+    'direction'             => String,
+    'remote_ip_prefix'      => Fog::Nullable::String,
+    'protocol'              => Fog::Nullable::String,
+    'ethertype'             => String,
+    'port_range_max'        => Fog::Nullable::Integer,
+    'port_range_min'        => Fog::Nullable::Integer,
+    'security_group_id'     => String,
+    'tenant_id'             => String
+  }
+
+  tests('success') do
+
+    attributes = {:name => 'my_security_group', :description => 'tests group'}
+    data = HP[:network].create_security_group(attributes).body['security_group']
+    @sec_group_id = data['id']
+
+    @sec_group_rule_id = nil
+
+    tests("#create_security_group_rule(#{@sec_group_id}, 'ingress', attributes)").formats(@security_group_rule_format) do
+      attributes = {:remote_ip_prefix => '0.0.0.0/0', :protocol => 'tcp', :port_range_min => 22, :port_range_max => 22}
+      data = HP[:network].create_security_group_rule(@sec_group_id, 'ingress', attributes).body['security_group_rule']
+      @sec_group_rule_id = data['id']
+      data
+    end
+
+    tests("#get_security_group_rule('#{@sec_group_rule_id}')").formats(@security_group_rule_format) do
+      HP[:network].get_security_group_rule(@sec_group_rule_id).body['security_group_rule']
+    end
+
+    tests("#list_security_group_rules").formats('security_group_rules' => [@security_group_rule_format]) do
+      HP[:network].list_security_group_rules.body
+    end
+
+    tests("#delete_security_group_rule('#{@sec_group_rule_id}')").succeeds do
+      HP[:network].delete_security_group_rule(@sec_group_rule_id)
+    end
+
+  end
+
+  tests('failure') do
+
+    tests('#get_security_group_rule(0)').raises(Fog::HP::Network::NotFound) do
+      HP[:network].get_security_group_rule(0)
+    end
+
+    tests('#delete_security_group_rule(0)').raises(Fog::HP::Network::NotFound) do
+      HP[:network].delete_security_group_rule(0)
+    end
+
+  end
+
+  HP[:network].delete_security_group(@sec_group_id)
+end

data/tests/hp/requests/network/security_group_tests.rb

@@ -0,0 +1,48 @@
+Shindo.tests('HP::Network | networking security group requests', ['hp', 'networking', 'securitygroup']) do
+
+  @security_group_format = {
+    'id'                    => String,
+    'name'                  => String,
+    'description'           => String,
+    'tenant_id'             => String,
+    'security_group_rules'  => [Hash]
+  }
+
+  tests('success') do
+
+    @sec_group_id = nil
+
+    tests("#create_security_group('fog_security_group', 'tests group')").formats(@security_group_format) do
+      attributes = {:name => 'fog_security_group', :description => 'tests group'}
+      data = HP[:network].create_security_group(attributes).body['security_group']
+      @sec_group_id = data['id']
+      data
+    end
+
+    tests("#get_security_group('#{@sec_group_id}')").formats(@security_group_format) do
+      HP[:network].get_security_group(@sec_group_id).body['security_group']
+    end
+
+    tests("#list_security_groups").formats('security_groups' => [@security_group_format]) do
+      HP[:network].list_security_groups.body
+    end
+
+    tests("#delete_security_group('#{@sec_group_id}')").succeeds do
+      HP[:network].delete_security_group(@sec_group_id)
+    end
+
+  end
+
+  tests('failure') do
+
+    tests("#get_security_group(0)").raises(Fog::HP::Network::NotFound) do
+      HP[:network].get_security_group(0)
+    end
+
+    tests("#delete_security_group(0)").raises(Fog::HP::Network::NotFound) do
+      HP[:network].delete_security_group(0)
+    end
+
+  end
+
+end

data/tests/hp/requests/network/subnet_tests.rb

@@ -0,0 +1,71 @@
+Shindo.tests('HP::Network | networking subnet requests', ['hp', 'networking', 'subnet']) do
+
+  @subnet_format = {
+    'id'               => String,
+    'name'             => Fog::Nullable::String,
+    'network_id'       => String,
+    'cidr'             => String,
+    'ip_version'       => Integer,
+    'gateway_ip'       => Fog::Nullable::String,
+    'allocation_pools' => Fog::Nullable::Array,
+    'dns_nameservers'  => Fog::Nullable::Array,
+    'host_routes'      => Fog::Nullable::Array,
+    'enable_dhcp'      => Fog::Boolean,
+    'tenant_id'        => String,
+  }
+
+  n_data = HP[:network].create_network({:name => 'fog_network'}).body['network']
+  @network_id = n_data['id']
+
+  tests('success') do
+
+    @subnet_id = nil
+
+    tests('#create_subnet').formats(@subnet_format) do
+      attributes = {:name => 'mysubnet', :gateway_ip => '10.0.3.1',
+                    :allocation_pools => [], :dns_nameservers => [],
+                    :host_routes => [], :enable_dhcp => true, :tenant_id => '111111111'}
+      data = HP[:network].create_subnet(@network_id, '10.0.3.0/24', 4, attributes).body['subnet']
+      @subnet_id = data['id']
+      data
+    end
+
+    tests('#list_subnets').formats({'subnets' => [@subnet_format]}) do
+      HP[:network].list_subnets.body
+    end
+
+    tests("#get_subnet(#{@subnet_id})").formats({'subnet' => @subnet_format}) do
+      HP[:network].get_subnet(@subnet_id).body
+    end
+
+    tests("#update_subnet(#{@subnet_id})").formats({'subnet' => @subnet_format}) do
+      attributes = {:name => 'mysubnet_upd',:gateway_ip => '10.0.3.1',
+                          :dns_nameservers => [], :host_routes => [],
+                          :enable_dhcp => true}
+      HP[:network].update_subnet(@subnet_id, attributes).body
+    end
+
+    tests("#delete_subnet(#{@subnet_id})").succeeds do
+      HP[:network].delete_subnet(@subnet_id)
+    end
+
+  end
+
+  tests('failure') do
+    tests('#get_subnet(0)').raises(Fog::HP::Network::NotFound) do
+      HP[:network].get_subnet(0)
+    end
+
+    tests('#update_subnet(0)').raises(Fog::HP::Network::NotFound) do
+      HP[:network].update_subnet(0, {})
+    end
+
+    tests('#delete_subnet(0)').raises(Fog::HP::Network::NotFound) do
+      HP[:network].delete_subnet(0)
+    end
+  end
+
+  # cleanup
+  HP[:network].delete_network(@network_id)
+
+end

data/tests/hp/requests/storage/container_tests.rb

@@ -14,6 +14,10 @@ Shindo.tests("Fog::Storage[:hp] | container requests", ['hp']) do
       Fog::Storage[:hp].put_container('fogcontainertests')
     end
 
+    tests("#post_container('fogcontainertests', {'X-Container-Meta-Foo' => 'foometa'})").succeeds do
+      Fog::Storage[:hp].post_container('fogcontainertests', {'X-Container-Meta-Foo' => 'foometa'})
+    end
+
     tests("#get_container('fogcontainertests')").formats(@container_format) do
       Fog::Storage[:hp].get_container('fogcontainertests').body
     end
@@ -57,6 +61,10 @@ Shindo.tests("Fog::Storage[:hp] | container requests", ['hp']) do
       Fog::Storage[:hp].get_container('fognoncontainer')
     end
 
+    tests("#post_container('fognoncontainer', {})").raises(Fog::Storage::HP::NotFound) do
+      Fog::Storage[:hp].post_container('fognoncontainer', {})
+    end
+
     tests("#head_container('fognoncontainer')").raises(Fog::Storage::HP::NotFound) do
       Fog::Storage[:hp].head_container('fognoncontainer')
     end
@@ -75,4 +83,4 @@ Shindo.tests("Fog::Storage[:hp] | container requests", ['hp']) do
 
   end
 
-end
+end

data/tests/hp/requests/storage/object_tests.rb

@@ -9,6 +9,10 @@ Shindo.tests("Fog::Storage[:hp] | object requests", ['hp', 'storage']) do
       Fog::Storage[:hp].put_object(@dir_name, 'fog_object', lorem_file)
     end
 
+    tests("#post_object('#{@dir_name}', 'fog_object', {'X-Object-Meta-Foo' => 'foometa'})").succeeds do
+      Fog::Storage[:hp].post_object(@dir_name, 'fog_object', {'X-Object-Meta-Foo' => 'foometa'})
+    end
+
     tests("#get_object('#{@dir_name}', 'fog_object')").succeeds do
       Fog::Storage[:hp].get_object(@dir_name, 'fog_object')
     end
@@ -43,8 +47,14 @@ Shindo.tests("Fog::Storage[:hp] | object requests", ['hp', 'storage']) do
     @another_dir.files.get('fog_another_object').destroy
     @another_dir.destroy
 
+    tests("#post_object('#{@dir_name}', 'fog_delete_object', {'X-Delete-After' => 40})" ).succeeds do
+      Fog::Storage[:hp].put_object(@dir_name, 'fog_delete_object', lorem_file)
+      Fog::Storage[:hp].post_object(@dir_name, 'fog_delete_object', {'X-Delete-After' => 40})
+    end
+
     tests("#delete_object('#{@dir_name}', 'fog_object')").succeeds do
       Fog::Storage[:hp].delete_object(@dir_name, 'fog_object')
+      Fog::Storage[:hp].delete_object(@dir_name, 'fog_delete_object')
     end
     
     tests("#get_object_http_url('#{@directory.identity}', 'fog_object', expiration timestamp)").returns(true) do
@@ -72,6 +82,10 @@ Shindo.tests("Fog::Storage[:hp] | object requests", ['hp', 'storage']) do
       Fog::Storage[:hp].put_object('fognoncontainer', 'fog_object', lorem_file)
     end
 
+    tests("#post_object('fognoncontainer', 'fog_object')").raises(Fog::Storage::HP::NotFound) do
+      Fog::Storage[:hp].post_object('fognoncontainer', 'fog_object')
+    end
+
     tests("#get_object('#{@dir_name}', 'fog_non_object')").raises(Fog::Storage::HP::NotFound) do
       Fog::Storage[:hp].get_object(@dir_name, 'fog_non_object')
     end
@@ -104,4 +118,4 @@ Shindo.tests("Fog::Storage[:hp] | object requests", ['hp', 'storage']) do
   
   @directory.destroy
 
-end
+end

data/tests/hp/storage_tests.rb

@@ -0,0 +1,25 @@
+Shindo.tests('Fog::Storage::HP', ['hp', 'storage']) do
+  credentials = {
+    :auth_token => 'auth_token',
+    :endpoint_url => 'http://127.0.0.1/path/',
+    :cdn_endpoint_url => 'http://127.0.0.1/cdnpath/',
+    :service_catalog => {
+      :"Object Storage" => {
+      :zone => 'http://127.0.0.1/path/'},
+      :"CDN" => {
+      :zone => 'http://127.0.0.1/cdnpath/'}},
+    :expires => (DateTime.now + 1).to_s
+  }
+  options = {
+    :hp_access_key => 'key',
+    :hp_secret_key => 'secret',
+    :hp_tenant_id => 'tenant',
+    :hp_avl_zone => 'zone',
+    :hp_auth_uri => 'https://region-a.geo-1.identity.hpcloudsvc.com:35357/v2.0/tokens',
+    :credentials => credentials
+  }
+  tests('Test cached Storage credentials').returns(credentials) do
+    conn = Fog::Storage::HP::Real.new(options)
+    conn.credentials
+  end
+end