fog-rackspace 0.1.0

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

@@ -0,0 +1,49 @@
+Shindo.tests('Fog::Compute::RackspaceV2 | network_tests', ['rackspace']) do
+  service   = Fog::Compute.new(:provider => 'Rackspace', :version => 'V2')
+
+  network_format = {
+    'id' => String,
+    'label' => String,
+    'cidr' => Fog::Nullable::String
+  }
+
+  get_network_format = {
+    'network' => network_format
+  }
+
+  list_networks_format = {
+    'networks' => [network_format]
+  }
+
+  tests('success') do
+    network_id = nil
+
+    tests('#create_network').formats(get_network_format) do
+      service.create_network("fog_#{Time.now.to_i.to_s}", '192.168.0.0/24').body.tap do |r|
+        network_id = r['network']['id']
+      end
+    end
+
+    tests('#list_networks').formats(list_networks_format) do
+      service.list_networks.body
+    end
+
+    tests('#get_network').formats(get_network_format) do
+      service.get_network(network_id).body
+    end
+
+    tests('#delete_network').succeeds do
+      service.delete_network(network_id)
+    end
+  end
+
+  test('failure') do
+    tests('#get_network').raises(Fog::Compute::RackspaceV2::NotFound) do
+      service.get_network(0)
+    end
+
+    tests('#delete_network').raises(Fog::Compute::RackspaceV2::NotFound) do
+      service.delete_network(0)
+    end
+  end
+end

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

@@ -0,0 +1,172 @@
+Shindo.tests('Fog::Compute::RackspaceV2 | server_tests', ['rackspace']) do
+  service   = Fog::Compute.new(:provider => 'Rackspace', :version => 'V2')
+
+  link_format = {
+    'href' => String,
+    'rel' => String
+  }
+
+  server_format = {
+    'id' => String,
+    'name' => String,
+    'hostId' => Fog::Nullable::String,
+    'created' => Fog::Nullable::String,
+    'updated' => Fog::Nullable::String,
+    'status' => Fog::Nullable::String,
+    'progress' => Fog::Nullable::Integer,
+    'user_id' => Fog::Nullable::String,
+    'tenant_id' => Fog::Nullable::String,
+    'links' => [link_format],
+    'metadata' => Fog::Nullable::Hash
+  }
+
+  list_servers_format = {
+    'servers' => [server_format]
+  }
+
+  get_server_format = {
+    'server' => server_format.merge({
+      'accessIPv4' => String,
+      'accessIPv6' => String,
+      'OS-DCF:diskConfig' => String,
+      'rax-bandwidth:bandwidth' => Fog::Nullable::Array,
+      'addresses' => Fog::Nullable::Hash,
+      'flavor' => {
+        'id' => String,
+        'links' => [link_format]
+      },
+      'image' => {
+        'id' => String,
+        'links' => [link_format]
+      }
+    })
+  }
+
+  create_server_format = {
+    'server' => {
+      'id' => String,
+      'adminPass' => String,
+      'links' => [link_format],
+      'OS-DCF:diskConfig' => String
+    }
+  }
+
+  rescue_server_format = {
+    'adminPass' => Fog::Nullable::String
+  }
+
+  tests('success') do
+
+    server_id = nil
+    server_name = "fog#{Time.now.to_i.to_s}"
+    image_id = rackspace_test_image_id(service)
+    flavor_id = rackspace_test_flavor_id(service)
+    bootable_flavor_id = if Fog.mocking?
+      flavor_id
+    else
+      service.flavors.find { |f| f.name =~ /Performance/ }.id
+    end
+
+    tests("#create_server(#{server_name}, #{image_id}, #{flavor_id}, 1, 1)").formats(create_server_format) do
+      body = service.create_server(server_name, image_id, flavor_id, 1, 1).body
+      server_id = body['server']['id']
+      body
+    end
+    wait_for_server_state(service, server_id, 'ACTIVE', 'ERROR')
+
+    tests("#create_server(#{server_name}_bfv_1, '', #{flavor_id}, 1, 1, :boot_volume_id => bootable_volume_id)").succeeds do
+      # First, create a bootable volume.
+      volume_service = Fog::Rackspace::BlockStorage.new
+      bootable_volume_id = volume_service.create_volume(100, :image_id => image_id).body['volume']['id']
+      wait_for_volume_state(volume_service, bootable_volume_id, 'available')
+
+      body = service.create_server(server_name + "_bfv_1", '', bootable_flavor_id, 1, 1, :boot_volume_id => bootable_volume_id).body
+      bfv_server_id = body['server']['id']
+      wait_for_server_state(service, bfv_server_id, 'ACTIVE', 'ERROR')
+      service.delete_server(bfv_server_id)
+
+      wait_for_volume_state(volume_service, bootable_volume_id, 'available')
+      volume_service.delete_volume(bootable_volume_id)
+    end
+
+    tests("#create_server(#{server_name}_bfv_2, '', #{flavor_id}, 1, 1, :boot_image_id => #{image_id})").succeeds do
+      body = service.create_server(server_name + "_bfv_2", '', bootable_flavor_id, 1, 1, :boot_image_id => image_id).body
+      bfv_server_id = body['server']['id']
+      wait_for_server_state(service, bfv_server_id, 'ACTIVE', 'ERROR')
+      service.delete_server(bfv_server_id)
+    end
+
+    tests('#list_servers').formats(list_servers_format, false) do
+      service.list_servers.body
+    end
+
+    tests('#get_server').formats(get_server_format, false) do
+      service.get_server(server_id).body
+    end
+
+    tests("#update_server(#{server_id}, #{server_name}_update) LEGACY").formats(get_server_format) do
+      service.update_server(server_id, "#{server_name}_update").body
+    end
+
+    tests("#update_server(#{server_id}, { 'name' => #{server_name}_update)} ").formats(get_server_format) do
+      service.update_server(server_id, 'name' => "#{server_name}_update").body
+    end
+
+    tests('#change_server_password').succeeds do
+      service.change_server_password(server_id, 'some_server_password')
+    end
+    wait_for_server_state(service, server_id, 'ACTIVE', 'ERROR')
+
+    tests('#reboot_server').succeeds do
+      service.reboot_server(server_id, 'SOFT')
+    end
+    wait_for_server_state(service, server_id, 'ACTIVE')
+
+    tests('#rebuild_server').succeeds do
+      rebuild_image_id = image_id
+      service.rebuild_server(server_id, rebuild_image_id)
+    end
+    wait_for_server_state(service, server_id, 'ACTIVE', 'ERROR')
+    sleep 120 unless Fog.mocking?
+
+    tests('#resize_server').succeeds do
+      resize_flavor_id = Fog.mocking? ? flavor_id : service.flavors[1].id
+      service.resize_server(server_id, resize_flavor_id)
+    end
+    wait_for_server_state(service, server_id, 'VERIFY_RESIZE', 'ACTIVE')
+
+   tests('#confirm_resize_server').succeeds do
+      service.confirm_resize_server(server_id)
+    end
+    wait_for_server_state(service, server_id, 'ACTIVE', 'ERROR')
+
+    tests('#resize_server').succeeds do
+      resize_flavor_id = Fog.mocking? ? flavor_id : service.flavors[2].id
+      service.resize_server(server_id, resize_flavor_id)
+    end
+    wait_for_server_state(service, server_id, 'VERIFY_RESIZE', 'ACTIVE')
+
+    tests('#revert_resize_server').succeeds do
+      service.revert_resize_server(server_id)
+    end
+    wait_for_server_state(service, server_id, 'ACTIVE', 'ERROR')
+
+    tests('#rescue_server').formats(rescue_server_format, false) do
+      service.rescue_server(server_id)
+    end
+    wait_for_server_state(service, server_id, 'RESCUE', 'ACTIVE')
+
+    tests('#unrescue_server').succeeds do
+      service.unrescue_server(server_id)
+    end
+    wait_for_server_state(service, server_id, 'ACTIVE', 'ERROR')
+
+    tests('#delete_server').succeeds do
+      service.delete_server(server_id)
+    end
+
+    tests('#get_vnc_console').succeeds do
+      service.get_vnc_console(server_id, 'novnc')
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+Shindo.tests('Fog::Compute::RackspaceV2 | virtual_interface_tests', ['rackspace']) do
+  @service   = Fog::Compute.new(:provider => 'Rackspace', :version => 'V2')
+
+  virtual_interface_format = {
+    "virtual_interfaces"=> [{
+      "ip_addresses"=> [{
+        "network_id"=> String,
+        "network_label"=> String,
+        "address"=> String
+      }],
+      "id"=> String,
+      "mac_address"=> String
+    }]
+  }
+
+  begin
+    unless Fog.mocking?
+      network_id = nil
+
+      @server = @service.servers.create(:name => "fog_virtual_interface_test_#{Time.now.to_i.to_s}",
+                                        :flavor_id => rackspace_test_flavor_id(@service),
+                                        :image_id => rackspace_test_image_id(@service))
+      @server.wait_for { ready? }
+
+      @network = @service.networks.create(:label => "fog_#{Time.now.to_i.to_s}", :cidr => '192.168.0.0/24')
+    end
+
+    tests('success') do
+      pending if Fog.mocking?
+
+      tests('#create_virtual_interface').formats(virtual_interface_format) do
+        response = @service.create_virtual_interface @server.id, @network.id
+        body = response.body
+        @virtual_network_interface_id = body["virtual_interfaces"].first["id"]
+        body
+      end
+        tests('#list_virtual_interfaces').formats(virtual_interface_format) do
+          @service.list_virtual_interfaces(@server.id).body
+        end
+
+        tests('#delete_virtual_interfaces').succeeds do
+          @service.delete_virtual_interface(@server.id, @virtual_network_interface_id)
+        end
+      end
+  ensure
+    @server.destroy if @server
+    delete_test_network @network
+  end
+end

data/tests/rackspace/requests/databases/database_tests.rb

@@ -0,0 +1,39 @@
+Shindo.tests('Fog::Rackspace::Database | database_tests', ['rackspace']) do
+
+  pending if Fog.mocking?
+
+  service = Fog::Rackspace::Databases.new
+  instance_name = 'fog' + Time.now.to_i.to_s
+
+    begin
+    @instance_id = service.create_instance(instance_name, 1, 1).body['instance']['id']
+
+    wait_for_request("waiting for database to be created") do
+      service.get_instance(@instance_id).body["instance"]["status"] == 'ACTIVE'
+    end
+
+    tests('success') do
+      database_name = 'fogdb' + Time.now.to_i.to_s
+
+      tests("#create_database(#{@instance_id}, #{database_name})").returns(202) do
+        service.create_database(@instance_id, database_name).status
+      end
+
+      tests("#list_databases{#{@instance_id})").formats(LIST_DATABASES_FORMAT) do
+        service.list_databases(@instance_id).body
+      end
+
+      tests("#delete_database(#{@instance_id}, #{database_name})").returns(202) do
+        service.delete_database(@instance_id, database_name).status
+      end
+    end
+
+    tests('failure') do
+      tests("#create_database(#{@instance_id}, '') => Invalid Create Critera").raises(Fog::Rackspace::Databases::BadRequest) do
+        service.create_database(@instance_id, '')
+      end
+    end
+  ensure
+    service.delete_instance(@instance_id) if @instance_id
+  end
+end

data/tests/rackspace/requests/databases/flavor_tests.rb

@@ -0,0 +1,16 @@
+Shindo.tests('Fog::Rackspace::Database | flavor_tests', ['rackspace']) do
+
+  pending if Fog.mocking?
+
+  service = Fog::Rackspace::Databases.new
+
+  tests('success') do
+    tests('#list_flavors_details').formats(LIST_FLAVORS_FORMAT) do
+      service.list_flavors().body
+    end
+
+    tests('#get_flavor(1)').formats(GET_FLAVOR_FORMAT) do
+      service.get_flavor(1).body
+    end
+  end
+end

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

@@ -0,0 +1,79 @@
+FLAVOR_FORMAT = {
+  'id' => Integer,
+  'name' => String,
+  'ram' => Integer,
+  'links' => LINKS_FORMAT
+}
+
+GET_FLAVOR_FORMAT = {
+  'flavor' => FLAVOR_FORMAT
+}
+
+LIST_FLAVORS_FORMAT = {
+  'flavors' => [FLAVOR_FORMAT]
+}
+
+INSTANCE_FORMAT = {
+  'id' => String,
+  'name' => String,
+  'status' => String,
+  'links' => LINKS_FORMAT,
+  'flavor' => {
+    'id' => String,
+    'links' => LINKS_FORMAT
+  },
+  'volume' => {
+    'size' => Integer
+  }
+}
+
+INSTANCE_DETAILS_FORMAT = INSTANCE_FORMAT.merge({
+  'created' => String,
+  'updated' => String,
+  'hostname' => String,
+})
+
+CREATE_INSTANCE_FORMAT = {
+  'instance' => INSTANCE_DETAILS_FORMAT
+}
+
+GET_INSTANCE_FORMAT = {
+  'instance' => INSTANCE_DETAILS_FORMAT.merge({
+    'volume' => {
+      'size' => Integer,
+      'used' => Float
+    }
+  })
+}
+
+LIST_INSTANCES_FORMAT = {
+  'instances' => [
+    INSTANCE_FORMAT
+  ]
+}
+
+CHECK_ROOT_USER_FORMAT = {
+  'rootEnabled' => Fog::Boolean
+}
+
+ENABLE_ROOT_USER_FORMAT = {
+  'user' => {
+    'name' => String,
+    'password' => String
+  }
+}
+
+LIST_DATABASES_FORMAT = {
+  'databases' => [{
+    'name' => String
+  }]
+}
+
+LIST_USERS_FORMAT = {
+  'users' => [{
+    'name' => String,
+    'databases' => [{
+      'name' => String
+    }]
+  }]
+}

data/tests/rackspace/requests/databases/instance_tests.rb

@@ -0,0 +1,77 @@
+Shindo.tests('Fog::Rackspace::Database | instance_tests', ['rackspace']) do
+
+  pending if Fog.mocking?
+
+  service = Fog::Rackspace::Databases.new
+
+  tests('success') do
+
+    instance_id = nil
+    instance_name = 'fog' + Time.now.to_i.to_s
+
+    tests("#list_instances").formats(LIST_INSTANCES_FORMAT) do
+      service.list_instances.body
+    end
+
+    tests("#create_instance(#{instance_name}, 1, 1)").formats(CREATE_INSTANCE_FORMAT) do
+      data = service.create_instance(instance_name, 1, 1).body
+      instance_id = data['instance']['id']
+      data
+    end
+
+    until service.get_instance(instance_id).body["instance"]["status"] == 'ACTIVE'
+      sleep 10
+    end
+
+    tests("#get_instance(#{instance_id})").formats(GET_INSTANCE_FORMAT) do
+      service.get_instance(instance_id).body
+    end
+
+    tests("#check_root_user(#{instance_id})").formats(CHECK_ROOT_USER_FORMAT) do
+      service.check_root_user(instance_id).body
+    end
+
+    tests("#enable_root_user(#{instance_id})").formats(ENABLE_ROOT_USER_FORMAT) do
+      service.enable_root_user(instance_id).body
+    end
+
+    tests("#restart_instance(#{instance_id})").succeeds do
+      service.restart_instance(instance_id)
+    end
+
+    until service.get_instance(instance_id).body["instance"]["status"] == 'ACTIVE'
+      sleep 10
+    end
+
+    tests("#resize_instance(#{instance_id}, 2)").succeeds do
+      service.resize_instance(instance_id, 2)
+    end
+
+    until service.get_instance(instance_id).body["instance"]["status"] == 'ACTIVE'
+      sleep 10
+    end
+
+    tests("#resize_instance_volume(#{instance_id}, 2)").succeeds do
+      service.resize_instance_volume(instance_id, 2)
+    end
+
+    until service.get_instance(instance_id).body["instance"]["status"] == 'ACTIVE'
+      sleep 10
+    end
+
+    tests("#delete_instance(#{instance_id})").succeeds do
+      service.delete_instance(instance_id)
+    end
+  end
+
+  tests('failure') do
+    tests("#create_instance('', 0, 0) => Invalid Create Critera").raises(Fog::Rackspace::Databases::BadRequest) do
+      service.create_instance('', 0, 0)
+    end
+
+    tests("#get_instance('') => Does not exist").raises(Fog::Rackspace::Databases::NotFound) do
+      service.get_instance('')
+    end
+
+  end
+end