fog 1.17.0 → 1.18.0

data/tests/hp/requests/dns/domain_tests.rb

@@ -0,0 +1,72 @@
+Shindo.tests("HP::DNS | domain requests", ['hp', 'dns', 'domain']) do
+  @domain_format = {
+    'id'          => String,
+    'name'        => String,
+    'description' => String,
+    'ttl'         => Integer,
+    'serial'      => Integer,
+    'email'       => String,
+    'created_at'  => String
+  }
+
+  @server_format = {
+    'id'          => String,
+    'name'        => String,
+    'created_at'  => String,
+    'updated_at'  => String
+  }
+
+  tests('success') do
+
+    @domain_name = 'www.fogtest.com.'
+    @email = 'test@fogtest.com'
+
+    tests("#create_domain(#{@domain_name}, #{@email})").formats(@domain_format) do
+      data = HP[:dns].create_domain(@domain_name, @email).body
+      @domain_id = data['id']
+      data
+    end
+
+    tests('#list_domains').formats({'domains' => [@domain_format]}) do
+      HP[:dns].list_domains.body
+    end
+
+    tests("#get_domain(#{@domain_id})").formats(@domain_format) do
+      HP[:dns].get_domain(@domain_id).body
+    end
+
+    tests("#get_servers_hosting_domain(#{@domain_id})").formats('servers' => [@server_format]) do
+      HP[:dns].get_servers_hosting_domain(@domain_id).body
+    end
+
+    tests("#update_domain(#{@domain_id}, {:email => 'updated@fogtest.com'})").formats(@domain_format) do
+      HP[:dns].update_domain(@domain_id, {:email => 'updated@fogtest.com'}).body
+    end
+
+    tests("#delete_domain(#{@domain_id})").succeeds do
+      HP[:dns].delete_domain(@domain_id)
+    end
+
+  end
+
+  tests('failure') do
+
+    tests("#get_domain('invalid_domain')").raises(Fog::HP::DNS::NotFound) do
+      HP[:dns].get_domain('invalid_domain')
+    end
+
+    tests("#get_servers_hosting_domain('invalid_domain')").raises(Fog::HP::DNS::NotFound) do
+      HP[:dns].get_servers_hosting_domain('invalid_domain')
+    end
+
+    tests("#update_domain('invalid_domain', {:email => 'updated@fogtest.com'})").raises(Fog::HP::DNS::NotFound) do
+      HP[:dns].update_domain('invalid_domain', {:email => 'updated@fogtest.com'})
+    end
+
+    tests("#delete_domain('invalid_domain')").raises(Fog::HP::DNS::NotFound) do
+      HP[:dns].delete_domain('invalid_domain')
+    end
+
+  end
+
+end

data/tests/hp/requests/dns/records_tests.rb

@@ -0,0 +1,65 @@
+Shindo.tests("HP::DNS | record requests", ['hp', 'dns', 'record']) do
+  @record_format = {
+    'id'          => String,
+    'name'        => String,
+    'description' => String,
+    'type'        => String,
+    'domain_id'   => String,
+    'ttl'         => Integer,
+    'data'        => String,
+    'priority'    => Fog::Nullable::Integer,
+    'created_at'  => String,
+    'updated_at'  => String
+  }
+
+  tests('success') do
+
+    @domain_name = 'www.fogtest.com.'
+    @email = 'test@fogtest.com'
+    @domain_id = HP[:dns].create_domain(@domain_name, @email).body['id']
+    @record_name = 'www.fogtest.com.'
+    @record_data = '15.185.172.152'
+
+    tests("#create_record(#{@domain_id}, #{@record_name}, 'A', #{@record_data})").formats(@record_format) do
+      data = HP[:dns].create_record(@domain_id, @record_name, 'A', @record_data).body
+      @record_id = data['id']
+      data
+    end
+
+    tests("#list_records_in_a_domain(#{@domain_id})").formats({'records' => [@record_format]}) do
+      HP[:dns].list_records_in_a_domain(@domain_id).body
+    end
+
+    tests("#get_record(#{@domain_id}, #{@record_id})").formats(@record_format) do
+      HP[:dns].get_record(@domain_id, @record_id).body
+    end
+
+    tests("#update_record(#{@domain_id}, #{@record_id}, {:description => 'desc for record'})").formats(@record_format) do
+      HP[:dns].update_record(@domain_id, @record_id, {:description => 'desc for record'}).body
+    end
+
+    tests("#delete_record(#{@domain_id}, #{@record_id})").succeeds do
+      HP[:dns].delete_record(@domain_id, @record_id)
+    end
+
+    HP[:dns].delete_domain(@domain_id)
+  end
+
+  tests('failure') do
+
+    tests("#get_record(#{@domain_id}, 'invalid_record')").raises(Fog::HP::DNS::NotFound) do
+      HP[:dns].get_record(@domain_id, 'invalid_record')
+    end
+
+    tests("#update_record(#{@domain_id}, 'invalid_record', {:email => 'updated@fogtest.com'})").raises(Fog::HP::DNS::NotFound) do
+      HP[:dns].update_record(@domain_id, 'invalid_record', {:email => 'updated@fogtest.com'})
+    end
+
+    tests("#delete_record(#{@domain_id}, 'invalid_record')").raises(Fog::HP::DNS::NotFound) do
+      HP[:dns].delete_record(@domain_id, 'invalid_record')
+    end
+
+  end
+
+
+end

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

@@ -0,0 +1,15 @@
+Shindo.tests("HP::LB | algorithms", ['hp', 'lb', 'algorithms']) do
+  @algo_format = {
+    'name' => String
+  }
+
+  tests('success') do
+
+    tests('#list_algorithms').formats({'algorithms' => [@algo_format]}) do
+      HP[:lb].list_algorithms.body
+    end
+
+  end
+
+
+end

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

@@ -0,0 +1,18 @@
+Shindo.tests("HP::LB | limits requests", ['hp', 'lb', 'limits']) do
+  @limits_format = {
+    'maxLoadBalancerNameLength' => Integer,
+    'maxLoadBalancers'          => Integer,
+    'maxNodesPerLoadBalancer'   => Integer,
+    'maxVIPsPerLoadBalancer'    => Integer,
+  }
+
+
+  tests('success') do
+
+    tests('#list_limits').formats({'limits' => [{'values' => @limits_format }]}) do
+      HP[:lb].list_limits.body
+    end
+  end
+
+
+end

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

@@ -0,0 +1,47 @@
+Shindo.tests('HP::LB | load balancer nodes', ['hp', 'lb', 'nodes']) do
+  @node_format = {
+    'id'        => String,
+    'address'   => String,
+    'port'      => String,
+    'condition' => String,
+    'status'    => String
+  }
+
+  tests('successs') do
+    data = HP[:lb].create_load_balancer('rg-fog-lb2', [{'address' => '15.185.1.1', 'port' => '80'}]).body
+    @lb_id = data['id']
+
+    tests("#create_load_balancer_node(#{@lb_id}, '15.185.2.2', '88')").formats({'nodes' => [@node_format]}) do
+      data = HP[:lb].create_load_balancer_node(@lb_id, '15.185.2.2', '88').body
+      @lb_node_id = data['nodes'][0]['id']
+      data
+    end
+
+    tests("#list_load_balancer_nodes(#{@lb_id})").formats({'nodes' => [@node_format]}) do
+      HP[:lb].list_load_balancer_nodes(@lb_id).body
+    end
+
+    tests("#get_load_balancer_node(#{@lb_id}, #{@lb_node_id})").formats(@node_format) do
+      HP[:lb].get_load_balancer_node(@lb_id, @lb_node_id).body
+    end
+
+    tests("#update_load_balancer_node(#{@lb_id}, #{@lb_node_id}, 'DISABLED')").succeeds do
+      HP[:lb].update_load_balancer_node(@lb_id, @lb_node_id, 'DISABLED')
+    end
+
+    tests("#delete_load_balancer_node(#{@lb_id}, #{@lb_node_id})").succeeds do
+      HP[:lb].delete_load_balancer_node(@lb_id, @lb_node_id)
+    end
+
+    HP[:lb].delete_load_balancer(@lb_id)
+
+  end
+
+  tests('failure') do
+    tests('#list_node_balancer_nodes(0)').raises(Fog::HP::LB::NotFound) do
+      HP[:lb].list_load_balancer_nodes('0')
+    end
+  end
+
+
+end

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