fog-maestrodev 1.15.0.20130927082724 → 1.18.0.20131111203459

data/tests/hp/requests/lb/load_balancer_tests.rb

@@ -0,0 +1,56 @@
+Shindo.tests("HP::LB | load balancers requests", ['hp', 'lb', 'load_balancer']) do
+  @lb_format = {
+    'id'        => String,
+    'name'      => String,
+    'protocol'  => String,
+    'port'      => String,
+    'algorithm' => String,
+    'status'    => String,
+    'created'   => String,
+    'updated'   => String,
+    'nodes'     => Array
+  }
+
+  tests('success') do
+    @lb_name = 'fog-lb'
+    @nodes = [{'address' => '15.185.1.1', 'port' => '80'}]
+
+    tests("#create_load_balancer(#{@lb_name}, #{@nodes})").formats(@lb_format) do
+      data = HP[:lb].create_load_balancer(@lb_name, @nodes).body
+      @lb_id = data['id']
+      data
+    end
+
+    tests('#list_load_balancers').formats({'loadBalancers' => [@lb_format]}) do
+      HP[:lb].list_load_balancers.body
+    end
+
+    tests("#get_load_balancer(#{@lb_id})").formats(@lb_format) do
+      HP[:lb].get_load_balancer(@lb_id).body
+    end
+
+    tests("#update_load_balancer(#{@lb_id}, {'name' => 'updated-fog-lb'})").returns('') do
+      HP[:lb].update_load_balancer(@lb_id, {'name' => 'updated-fog-lb'}).body
+    end
+
+    tests("#delete_load_balancer(#{@lb_id})").succeeds do
+      HP[:lb].delete_load_balancer(@lb_id)
+    end
+
+  end
+
+  tests('failure') do
+    tests("#get_load_balancer(0)").raises(Fog::HP::LB::NotFound) do
+      HP[:lb].get_load_balancer('0')
+    end
+
+    tests("#update_load_balancer(0, {'name' => 'updated-fog-lb'})").raises(Fog::HP::LB::NotFound) do
+      HP[:lb].update_load_balancer('0', {'name' => 'updated-fog-lb'})
+    end
+
+    tests("#delete_load_balancer(0)").raises(Fog::HP::LB::NotFound) do
+      HP[:lb].delete_load_balancer('0')
+    end
+  end
+
+end

data/tests/hp/requests/lb/protocols_tests.rb

@@ -0,0 +1,15 @@
+Shindo.tests("HP::LB | protocols requests", ['hp', 'lb', 'protocols']) do
+  @protocol_format = {
+    'name'    => String,
+    'port'    => Integer
+  }
+
+  tests('success') do
+
+    tests('#list_protocols').formats({'protocols' => [@protocol_format]}) do
+      HP[:lb].list_protocols.body
+    end
+  end
+
+
+end

data/tests/hp/requests/lb/versions_tests.rb

@@ -0,0 +1,17 @@
+Shindo.tests("HP::LB | versions requests", ['hp', 'lb', 'versions']) do
+  @version_format = {
+    'id'        => String,
+    'links'     => [Hash],
+    'status'    => String,
+    'updated'   => String
+  }
+
+  tests('success') do
+
+    tests('#list_versions').formats({'versions' => [@version_format]}) do
+      HP[:lb].list_versions.body
+    end
+  end
+
+
+end

data/tests/hp/requests/lb/virtual_ips_tests.rb

@@ -0,0 +1,34 @@
+Shindo.tests("HP::LB | virtual ips requests", ['hp', 'lb', 'virtual_ips']) do
+  @virtual_ips_format = {
+    'id'        => String,
+    'address'   => String,
+    'type'      => String,
+    'ipVersion' => String
+  }
+
+  tests('success') do
+    @nodes = [{'address' => '15.185.1.1', 'port' => '80'}]
+    @virtual_ip = [{
+                     'ipVersion' => 'IPV4',
+                     'type' => 'PUBLIC',
+                     'id' => '11111111',
+                     'address' => '15.185.3.3'
+                  }]
+    data = HP[:lb].create_load_balancer('rg-fog-lb3', @nodes, {'virtualIps' => @virtual_ip}).body
+    @lb_id = data['id']
+
+    tests('#list_load_balancer_virtual_ips').formats({'virtualIps' => [@virtual_ips_format]}) do
+      HP[:lb].list_load_balancer_virtual_ips(@lb_id).body
+    end
+
+    HP[:lb].delete_load_balancer(@lb_id)
+
+  end
+
+  tests('failure') do
+    tests('#list_load_balancer_virtual_ips(0)').raises(Fog::HP::LB::NotFound) do
+      HP[:lb].list_load_balancer_virtual_ips('0')
+    end
+  end
+
+end

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

@@ -0,0 +1,70 @@
+Shindo.tests('HP::Network | networking floating ip requests', ['hp', 'networking', 'floatingip']) do
+
+  @floating_ip_format = {
+    'id'                  => String,
+    'tenant_id'           => String,
+    'floating_network_id' => String,
+    'router_id'           => Fog::Nullable::String,
+    'fixed_ip_address'    => Fog::Nullable::String,
+    'floating_ip_address' => String,
+    'port_id'             => Fog::Nullable::String
+  }
+
+  @ext_network_id = HP[:network].list_networks({'router:external'=>true}).body['networks'][0]['id']
+  s_data = HP[:network].create_port(@ext_network_id, {:name => 'fog_port'}).body['port']
+  @port_id = s_data['id']
+
+  tests('success') do
+
+    @floating_ip_id = nil
+
+    tests("#create_floating_ip(#{@ext_network_id})").formats(@floating_ip_format) do
+      data = HP[:network].create_floating_ip(@ext_network_id).body['floatingip']
+      @floating_ip_id = data['id']
+      data
+    end
+
+    tests('#list_floating_ips').formats({'floatingips' => [@floating_ip_format]}) do
+      HP[:network].list_floating_ips.body
+    end
+
+    tests("#get_floating_ip(#{@floating_ip_id})").formats({'floatingip' => @floating_ip_format}) do
+      HP[:network].get_floating_ip(@floating_ip_id).body
+    end
+
+    tests("#associate_floating_ip(#{@floating_ip_id}, #{@port_id})").formats({'floatingip' => @floating_ip_format}) do
+      HP[:network].associate_floating_ip(@floating_ip_id, @port_id).body
+    end
+
+    tests("#disassociate_floating_ip(#{@floating_ip_id}, nil)").formats({'floatingip' => @floating_ip_format}) do
+      HP[:network].disassociate_floating_ip(@floating_ip_id, nil).body
+    end
+
+    tests("#delete_floating_ip(#{@floating_ip_id})").succeeds do
+      HP[:network].delete_floating_ip(@floating_ip_id)
+    end
+
+  end
+
+  tests('failure') do
+    tests('#get_floating_ip("0")').raises(Fog::HP::Network::NotFound) do
+      HP[:network].get_floating_ip(0)
+    end
+
+    tests("#associate_floating_ip('0', #{@port_id})").raises(Fog::HP::Network::NotFound) do
+      HP[:network].associate_floating_ip('0', @port_id)
+    end
+
+    tests('#disassociate_floating_ip("0")').raises(Fog::HP::Network::NotFound) do
+      HP[:network].disassociate_floating_ip("0")
+    end
+
+    tests('#delete_floating_ip("0")').raises(Fog::HP::Network::NotFound) do
+      HP[:network].delete_floating_ip("0")
+    end
+  end
+
+  # cleanup
+  HP[:network].delete_port(@port_id)
+
+end

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

@@ -0,0 +1,57 @@
+Shindo.tests('HP::Network | networking network requests', ['hp',  'networking', 'network']) do
+
+  @network_format = {
+    'id'              => String,
+    'name'            => Fog::Nullable::String,
+    'tenant_id'       => String,
+    'status'          => String,
+    'subnets'         => Array,
+    'router:external' => Fog::Boolean,
+    'admin_state_up'  => Fog::Boolean,
+    'shared'          => Fog::Boolean
+  }
+
+  tests('success') do
+
+    @network_id = nil
+
+    tests('#create_network').formats(@network_format) do
+      attributes = {:name => 'my_network', :admin_state_up => true, :shared => false}
+      data = HP[:network].create_network(attributes).body['network']
+      @network_id = data['id']
+      data
+    end
+
+    tests('#list_networks').formats({'networks' => [@network_format]}) do
+      HP[:network].list_networks.body
+    end
+
+    tests("#get_network(#{@network_id})").formats({'network' => @network_format}) do
+      HP[:network].get_network(@network_id).body
+    end
+
+    tests("#update_network(#{@network_id})").formats({'network' => @network_format}) do
+      attributes = {:name => 'my_network_upd', :shared => false, :admin_state_up => true}
+      HP[:network].update_network(@network_id, attributes).body
+    end
+
+    tests("#delete_network(#{@network_id})").succeeds do
+      HP[:network].delete_network(@network_id)
+    end
+  end
+
+  tests('failure') do
+    tests('#get_network(0)').raises(Fog::HP::Network::NotFound) do
+      HP[:network].get_network(0)
+    end
+
+    tests('#update_network(0)').raises(Fog::HP::Network::NotFound) do
+      HP[:network].update_network(0, {})
+    end
+
+    tests('#delete_network(0)').raises(Fog::HP::Network::NotFound) do
+      HP[:network].delete_network(0)
+    end
+  end
+
+end

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