fog-maestrodev 1.7.0.20121114190951 → 1.8.0.20130109172219

data/tests/ecloud/compute/models/detached_disk_tests.rb

@@ -0,0 +1,26 @@
+provider, config = :ecloud, compute_providers[:ecloud]
+
+Shindo.tests("Fog::Compute[:#{provider}] | detached_disks", [provider.to_s]) do
+  connection = Fog::Compute[provider]
+  @organization   = connection.organizations.first
+  @environment    = @organization.environments.first
+  @compute_pool   = @environment.compute_pools.first
+  @detached_disks = @compute_pool.detached_disks
+
+  tests('#all').succeeds do
+    if @detached_disks.is_a?(Fog::Compute::Ecloud::DetachedDisks) && @detached_disks.reload.empty?
+      returns(true, "compute pool has no detached disks") { @detached_disks.all.empty? }
+    else
+      returns(false, "has detached disks") { @detached_disks.all.empty? }
+    end
+  end
+
+  unless @detached_disks.empty?
+    tests('#get') do
+      disk = @detached_disks.first
+      fetched_disk = connection.detached_disks.get(disk.href)
+      returns(false, "disk is not nil") { fetched_disk.nil? }
+      returns(true, "is a DetachedDisk") { fetched_disk.is_a?(Fog::Compute::Ecloud::DetachedDisk) }
+    end
+  end
+end

data/tests/ecloud/compute/models/environment_tests.rb

@@ -0,0 +1,23 @@
+provider, config = :ecloud, compute_providers[:ecloud]
+
+Shindo.tests("Fog::Compute[:#{provider}] | environments", [provider.to_s]) do
+  connection = Fog::Compute[provider]
+  @organization = connection.organizations.first
+
+  tests('#all').succeeds do
+    returns(false) { @organization.environments.all.empty? }
+  end
+
+  tests('#get').succeeds do
+    environment         = @organization.environments.all.first
+    fetched_environment = connection.environments.get(environment.href)
+
+    returns(true) { !fetched_environment.nil? }
+  end
+
+  tests("#organization").succeeds do
+    environment = @organization.environments.all.first
+    returns(false, "returns an organization") { environment.organization.nil? }
+    returns(true, "returns correct organization") { environment.organization.href == @organization.href }
+  end
+end

data/tests/ecloud/compute/models/internet_service_tests.rb

@@ -0,0 +1,28 @@
+provider, config = :ecloud, compute_providers[:ecloud]
+
+Shindo.tests("Fog::Compute[:#{provider}] | internet_services", [provider.to_s, "queries"]) do
+  connection    = Fog::Compute[provider]
+  organization = connection.organizations.first
+  environment  = organization.environments.detect { |e| e.name == config[:ecloud_environment_name] } || organization.environments.first
+  public_ips   = environment.public_ips
+  public_ip    = public_ips.detect { |i| i.name == config[:ecloud_public_ip_name] } || public_ips.first
+  @internet_services = public_ip.internet_services
+
+  tests('#all').succeeds do
+    returns(true, "is a collection") { @internet_services.is_a?(Fog::Compute::Ecloud::InternetServices) }
+    if Fog.mocking?
+      returns(false, "has services") { @internet_services.empty? }
+    else
+      true
+    end
+  end
+
+  unless @internet_services.empty?
+    tests('#get').succeeds do
+      service = @internet_services.first
+      fetched_service = connection.internet_services.get(service.href)
+      returns(false, "service is not nil") { fetched_service.nil? }
+      returns(true, "is an InternetService") { fetched_service.is_a?(Fog::Compute::Ecloud::InternetService) }
+    end
+  end
+end

data/tests/ecloud/compute/models/ip_address_tests.rb

@@ -0,0 +1,19 @@
+provider, config = :ecloud, compute_providers[:ecloud]
+
+Shindo.tests("Fog::Compute[:#{provider}] | ip_addresses", [provider.to_s]) do
+  connection = Fog::Compute[provider]
+  @organization = connection.organizations.first
+  @environment = @organization.environments.first
+  @network = @environment.networks.first
+  @ip_addresses = @network.ips
+
+  tests('#all').succeeds do
+    returns(false) { @ip_addresses.all.empty? }
+  end
+
+  tests('#get').succeeds do
+    address = @ip_addresses.first
+    fetched_network = connection.ip_addresses.get(address.href)
+    returns(false) { fetched_network.nil? }
+  end
+end

data/tests/ecloud/compute/models/network_tests.rb

@@ -0,0 +1,17 @@
+provider, config = :ecloud, compute_providers[:ecloud]
+
+Shindo.tests("Fog::Compute[:#{provider}] | networks", [provider.to_s]) do
+  connection = Fog::Compute[provider]
+  @organization = connection.organizations.first
+  @environment = @organization.environments.first
+
+  tests('#all').succeeds do
+    returns(false) { @environment.networks.all.empty? }
+  end
+
+  tests('#get').succeeds do
+    network = @environment.networks.all.first
+    fetched_network = connection.networks.get(network.href)
+    returns(true) { !fetched_network.nil? }
+  end
+end

data/tests/ecloud/compute/models/operating_system_families_tests.rb

@@ -0,0 +1,13 @@
+provider, config = :ecloud, compute_providers[:ecloud]
+
+Shindo.tests("Fog::Compute[:#{provider}] | operating_system_families", [provider.to_s]) do
+  connection = Fog::Compute[provider]
+  @organization = connection.organizations.first
+  @environment  = @organization.environments.find{|e| e.name == config[:server_attributes][:environment_name]} || @organization.environments.first
+  @compute_pool = @environment.compute_pools.first
+
+  tests('#all').succeeds do
+    operating_system_families = @compute_pool.operating_system_families
+    returns(false) { operating_system_families.empty? }
+  end
+end

data/tests/ecloud/compute/models/operating_system_tests.rb

@@ -0,0 +1,22 @@
+provider, config = :ecloud, compute_providers[:ecloud]
+
+Shindo.tests("Fog::Compute[:#{provider}] | operating_system", [provider.to_s]) do
+  connection = Fog::Compute[provider]
+  @organization = connection.organizations.first
+  @environment  = @organization.environments.find{|e| e.name == config[:server_attributes][:environment_name]} || @organization.environments.first
+  @compute_pool = @environment.compute_pools.first
+
+  tests('#all').succeeds do
+    family            = @compute_pool.operating_system_families.first
+    operating_systems = family.operating_systems
+
+    returns(false) { operating_systems.empty? }
+  end
+
+  tests('#get').succeeds do
+    family           = @compute_pool.operating_system_families.first
+    operating_system = family.operating_systems.first
+
+    returns(false) { family.operating_systems.get(operating_system.href).nil? }
+  end
+end

data/tests/ecloud/compute/models/organization_tests.rb

@@ -0,0 +1,21 @@
+provider, config = :ecloud, compute_providers[:ecloud]
+
+Shindo.tests("Fog::Compute[:#{provider}] | organizations", [provider.to_s]) do
+  connection = Fog::Compute[provider]
+
+  tests('#all').succeeds do
+    returns(false) { connection.organizations.all.empty? }
+  end
+
+  tests('#get').succeeds do
+    organization = connection.organizations.all.first
+    fetched_organization = connection.organizations.get(organization.href)
+    returns(true) { !fetched_organization.nil? }
+  end
+
+  tests("#admin").succeeds do
+    organization = connection.organizations.all.first
+
+    returns(true, "return AdminOrganization") { organization.admin.is_a?(Fog::Compute::Ecloud::AdminOrganization) }
+  end
+end

data/tests/ecloud/compute/models/public_ip_tests.rb

@@ -0,0 +1,19 @@
+provider, config = :ecloud, compute_providers[:ecloud]
+
+Shindo.tests("Fog::Compute[:#{provider}] | ip_addresses", [provider.to_s]) do
+  connection = Fog::Compute[provider]
+  @organization = connection.organizations.first
+  @environment = @organization.environments.first
+  @public_ips = @environment.public_ips
+
+  tests('#all').succeeds do
+    returns(false, "has ips") { @public_ips.all.empty? }
+  end
+
+  tests('#get').succeeds do
+    address = @public_ips.first
+    fetched_ip = connection.public_ips.get(address.href)
+    returns(false, "ip is not nil") { fetched_ip.nil? }
+    returns(true, "is a PublicIp") { fetched_ip.is_a?(Fog::Compute::Ecloud::PublicIp) }
+  end
+end

data/tests/ecloud/compute/models/server_tests.rb

@@ -0,0 +1,143 @@
+provider, config = :ecloud, compute_providers[:ecloud]
+
+Shindo.tests("Fog::Compute[:#{provider}] | servers", [provider.to_s, "operations"]) do
+  connection   = Fog::Compute[provider]
+  organization = connection.organizations.first
+  environment  = organization.environments.find{|e| e.name == config[:server_attributes][:environment_name]} || organization.environments.first
+  public_ip    = environment.public_ips.first
+  compute_pool = environment.compute_pools.first
+  image_href   = Fog.credentials[:ecloud_image_href] || compute_pool.templates.first.href
+  ssh_key      = organization.admin.ssh_keys.detect { |key| key.name == "root" }
+
+  @network = environment.networks.first
+  options  = config[:server_attributes].merge(:network_uri => @network.href, :ssh_key_uri => ssh_key.href)
+  #if Fog.credentials[:ecloud_ssh_key_id]
+  #  options = options.merge(:ssh_key_uri => "/cloudapi/ecloud/admin/sshkeys/#{Fog.credentials[:ecloud_ssh_key_id]}")
+  #end
+
+  @server = compute_pool.servers.create(image_href, options)
+
+  tests('#create_server').succeeds do
+    @server.wait_for { ready? } # server
+  end
+
+  tests('#environment_has_a_row_and_group_with_the_right_names').succeeds do
+    row = environment.rows.detect { |r| r.name == options[:row] }
+    returns(false, "row is not nil") { row.nil? }
+    group = row.groups.detect { |g| g.name == options[:group] }
+    returns(false, "group is not nil") { group.nil? }
+    server = group.servers.detect { |s| s.name == @server.name }
+    returns(false, "group has server") { server.nil? }
+  end
+
+  tests('#get_server_flavor').succeeds do
+    @server.flavor_id == {:ram => 512, :cpus => 1}
+  end
+
+  @hwc = @server.hardware_configuration
+  tests('#add_disk_to_server').succeeds do
+    disk_count = @hwc.storage.is_a?(Hash) ? [@hwc.storage].count : @hwc.storage.count
+    @server.add_disk(25).wait_for { ready? }
+    @server.reload.wait_for { ready? }
+    returns(true, "disk count increased by 1") { @server.reload.hardware_configuration.storage.count == disk_count + 1 }
+  end
+
+  tests('#detach_disk_from_server').succeeds do
+    disk_count = @hwc.reload.storage.is_a?(Hash) ? [@hwc.storage].count : @hwc.storage.count
+    @server.detach_disk(1).wait_for { ready? }
+    @server.reload.wait_for { ready? }
+    returns(true, "disk count decreased by 1") { @server.reload.hardware_configuration.storage.count == disk_count - 1 }
+  end
+
+  @detached_disk = compute_pool.reload.detached_disks.detect { |d| d.name == @server.name }
+  tests('#attach_disk_to_server').succeeds do
+    disk_count = @hwc.reload.storage.is_a?(Hash) ? [@hwc.storage].count : @hwc.storage.count
+    @server.attach_disk(@detached_disk).wait_for { ready? }
+    @server.reload.wait_for { ready? }
+    returns(true, "disk count increased by 1") { @server.reload.hardware_configuration.storage.count == disk_count + 1 }
+  end
+
+  tests('#delete_disk').succeeds do
+    disk_count = @hwc.reload.storage.is_a?(Hash) ? [@hwc.storage].count : @hwc.storage.count
+    @server.delete_disk(1).wait_for { ready? }
+    @server.reload.wait_for { ready? }
+    returns(true, "disk count decreased by 1") { @server.reload.hardware_configuration.storage.count == disk_count - 1 }
+  end
+
+  @ip = @network.ips.reload.detect { |i| i.host.nil? && i.detected_on.nil? }
+  tests('#add_ip_to_server').succeeds do
+    @server.add_ip(:href => @network.href, :network_name => @network.name, :ip => @ip.name)
+  end
+
+  service_name     = Fog.credentials[:ecloud_internet_service_name] || Fog::Mock.random_letters(6)
+  service_port     = Fog.credentials[:ecloud_internet_service_port] || Fog::Mock.random_numbers(3).to_i
+  service_protocol = Fog.credentials[:ecloud_internet_service_protocol]
+  @service = public_ip.internet_services.create(:name => service_name, :port => service_port, :protocol => service_protocol, :description => "", :enabled => true)
+
+  tests('#create_internet_service').succeeds do
+    @service.wait_for { ready? }
+    returns(true, "is an internet service") { @service.is_a?(Fog::Compute::Ecloud::InternetService) }
+  end
+
+  unless @server.ips.empty?
+    @ip_address = @server.ips.first
+    @ip         = @server.ips.first.network.ips.detect { |i| i.name == @ip_address.address.name }
+    @node       = @service.nodes.create(:name => @server.name, :port => service_port, :ip_address => @ip.href, :description => "", :enabled => true)
+    tests('#create_node_service').succeeds do
+      @node.wait_for { ready? }
+      returns(true, "is a node server") { @node.is_a?(Fog::Compute::Ecloud::Node) }
+    end
+
+    tests('#destroy_node_service').succeeds do
+      @node.destroy.wait_for { ready? }
+    end
+  end
+
+  #tests('#delete_ip_from_server').succeeds do
+  #  @server.delete_ip(:href => @network.href, :network_name => @network.name, :ip => @ip.name)
+  #end
+
+  tests('#destroy_internet_service').succeeds do
+    @service.destroy.wait_for { ready? }
+  end
+
+  @server_count = environment.servers.count
+  tests('#destroy_server').succeeds do
+    @server.destroy.wait_for { ready? } # task
+  end
+  @new_server_count = environment.servers.reload.count
+
+  tests('#server_count_reduced').succeeds do
+    returns(true, "server count is reduced") { @new_server_count < @server_count }
+  end
+
+  @row = environment.rows.detect { |r| r.name == options[:row] }
+  @group = @row.groups.detect { |g| g.name == options[:group] }
+  if @group.servers.empty?
+    tests('#delete_group').succeeds do
+      @group.destroy
+      returns(true, "group no longer exists") { @group.reload.nil? }
+    end
+  end
+  if @row.groups.reload.empty?
+    tests("#delete_row").succeeds do
+      @row.destroy
+      returns(true, "row no longer exists") { @row.reload.nil? }
+    end
+  end
+end
+
+Shindo.tests("Fog::Compute[:#{provider}] | server", "attributes") do
+  @network = environment.networks.first
+  options = config[:server_attributes].merge(:network_uri => @network.href, :ssh_key_uri => ssh_key.href)
+  #if Fog.credentials[:ecloud_ssh_key_id]
+  #  options = options.merge(:ssh_key_uri => "/cloudapi/ecloud/admin/sshkeys/#{Fog.credentials[:ecloud_ssh_key_id]}")
+  #end
+
+  @server = compute_pool.servers.first || compute_pool.servers.create(image_href, options).tap{|s| s.wait_for { ready? }}
+
+  tests('#ip_addresses').succeeds do
+    returns(true, "is an array") { @server.ips.is_a?(Array) }
+    returns(true, "contains an VirtualMachineAssignedIp") { @server.ips.all?{|ip| ip.is_a?(Fog::Compute::Ecloud::VirtualMachineAssignedIp) } }
+  end
+end

data/tests/ecloud/compute/models/ssh_key_tests.rb

@@ -0,0 +1,19 @@
+provider, config = :ecloud, compute_providers[:ecloud]
+
+Shindo.tests("Fog::Compute[:#{provider}] | ssh_keys", [provider.to_s]) do
+  connection = Fog::Compute[provider]
+  @organization = connection.organizations.first
+  @admin_organization = @organization.admin
+  @admin_organization.reload
+  @ssh_keys = @admin_organization.ssh_keys
+
+  tests('#all').succeeds do
+    returns(false) { @ssh_keys.empty? }
+  end
+
+  tests('#get').succeeds do
+    ssh_key = @ssh_keys.first
+
+    returns(false) { @ssh_keys.get(ssh_key.href).nil? }
+  end
+end

data/tests/ecloud/compute/models/template_tests.rb

@@ -0,0 +1,20 @@
+provider, config = :ecloud, compute_providers[:ecloud]
+
+Shindo.tests("Fog::Compute[:#{provider}] | templates", [provider.to_s]) do
+  connection = Fog::Compute[provider]
+  @organization = connection.organizations.first
+  @environment  = @organization.environments.find{|e| e.name == config[:server_attributes][:environment_name]} || @organization.environments.first
+  @compute_pool = @environment.compute_pools.first
+
+  tests('#all').succeeds do
+    templates = @compute_pool.templates
+    returns(false) { templates.empty? }
+  end
+
+  tests('#get').succeeds do
+    templates = @compute_pool.templates
+    template = templates.first
+
+    returns(false) { @compute_pool.templates.get(template.href).nil? }
+  end
+end

data/tests/openstack/authenticate_tests.rb

@@ -0,0 +1,142 @@
+Shindo.tests('OpenStack | authenticate', ['openstack']) do
+  begin
+    @old_mock_value = Excon.defaults[:mock]
+    Excon.defaults[:mock] = true
+    Excon.stubs.clear
+
+    expires      = Time.now.utc + 600
+    token        = Fog::Mock.random_numbers(8).to_s
+    tenant_token = Fog::Mock.random_numbers(8).to_s
+
+    body = {
+      "access" => {
+        "token" => {
+          "expires" => expires.iso8601,
+          "id"      => token,
+          "tenant"  => {
+            "enabled"     => true,
+            "description" => nil,
+            "name"        => "admin",
+            "id"          => tenant_token,
+          }
+        },
+        "serviceCatalog" => [{
+          "endpoints" => [{
+            "adminURL" =>
+              "http://example:8774/v2/#{tenant_token}",
+              "region" => "RegionOne",
+            "internalURL" =>
+              "http://example:8774/v2/#{tenant_token}",
+            "id" => Fog::Mock.random_numbers(8).to_s,
+            "publicURL" =>
+             "http://example:8774/v2/#{tenant_token}"
+          }],
+          "endpoints_links" => [],
+          "type" => "compute",
+          "name" => "nova"
+        },
+        { "endpoints" => [{
+            "adminURL"    => "http://example:9292",
+            "region"      => "RegionOne",
+            "internalURL" => "http://example:9292",
+            "id"          => Fog::Mock.random_numbers(8).to_s,
+            "publicURL"   => "http://example:9292"
+          }],
+          "endpoints_links" => [],
+          "type"            => "image",
+          "name"            => "glance"
+        }],
+        "user" => {
+          "username" => "admin",
+          "roles_links" => [],
+          "id" => Fog::Mock.random_numbers(8).to_s,
+          "roles" => [
+            { "name" => "admin" },
+            { "name" => "KeystoneAdmin" },
+            { "name" => "KeystoneServiceAdmin" }
+          ],
+          "name" => "admin"
+        },
+        "metadata" => {
+          "is_admin" => 0,
+          "roles" => [
+            Fog::Mock.random_numbers(8).to_s,
+            Fog::Mock.random_numbers(8).to_s,
+            Fog::Mock.random_numbers(8).to_s,]}}}
+
+    tests("v2") do
+      Excon.stub({ :method => 'POST', :path => "/v2.0/tokens" },
+                 { :status => 200, :body => Fog::JSON.encode(body) })
+
+      expected = {
+        :user                     => body['access']['user'],
+        :tenant                   => body['access']['token']['tenant'],
+        :identity_public_endpoint => nil,
+        :server_management_url    =>
+          body['access']['serviceCatalog'].
+            first['endpoints'].first['publicURL'],
+        :token                    => token,
+        :expires                  => expires.iso8601,
+        :current_user_id          => body['access']['user']['id'],
+        :unscoped_token           => token,
+      }
+
+      returns(expected) do
+        Fog::OpenStack.authenticate_v2(
+          :openstack_auth_uri     => URI('http://example/v2.0/tokens'),
+          :openstack_tenant       => 'admin',
+          :openstack_service_type => %w[compute])
+      end
+    end
+
+    tests("v2 missing service") do
+      Excon.stub({ :method => 'POST', :path => "/v2.0/tokens" },
+                 { :status => 200, :body => Fog::JSON.encode(body) })
+
+      raises(Fog::Errors::NotFound,
+             'Could not find service network.  Have compute, image') do
+        Fog::OpenStack.authenticate_v2(
+          :openstack_auth_uri     => URI('http://example/v2.0/tokens'),
+          :openstack_tenant       => 'admin',
+          :openstack_service_type => %w[network])
+      end
+    end
+
+    tests("v2 auth with two compute services") do
+      body_clone = body.clone
+      body_clone["access"]["serviceCatalog"] << 
+        {
+        "endpoints" => [{
+          "adminURL" =>
+            "http://example2:8774/v2/#{tenant_token}",
+            "region" => "RegionOne",
+          "internalURL" =>
+            "http://example2:8774/v2/#{tenant_token}",
+          "id" => Fog::Mock.random_numbers(8).to_s,
+          "publicURL" =>
+           "http://example2:8774/v2/#{tenant_token}"
+        }],
+        "endpoints_links" => [],
+        "type" => "compute",
+        "name" => "nova2"
+        }
+
+      Excon.stub({ :method => 'POST', :path => "/v2.0/tokens" },
+                 { :status => 200, :body => Fog::JSON.encode(body_clone) })
+
+      returns("http://example2:8774/v2/#{tenant_token}") do
+        Fog::OpenStack.authenticate_v2(
+          :openstack_auth_uri     => URI('http://example/v2.0/tokens'),
+          :openstack_tenant       => 'admin',
+          :openstack_service_type => %w[compute],
+          :openstack_service_name => 'nova2')[:server_management_url]
+      end
+
+    end
+
+  ensure
+    Excon.stubs.clear
+    Excon.defaults[:mock] = @old_mock_value
+  end
+end
+