fog 1.2.0 → 1.3.0

data/tests/ibm/models/compute/keys_tests.rb

@@ -0,0 +1,35 @@
+Shindo.tests('Fog::Compute[:ibm] | keys', ['ibm']) do
+
+  tests('success') do
+
+    @key_name = 'fog-test-key' + Time.now.to_i.to_s(32)
+    @key      = nil
+
+    tests("Fog::Compute[:ibm].keys.create(:name => '#{@key_name}')") do
+      @key = Fog::Compute[:ibm].keys.create(:name => @key_name)
+      returns(@key_name) { @key.name }
+    end
+
+    tests('Fog::Compute[:ibm].keys') do
+      returns(true) { Fog::Compute[:ibm].keys.length > 0 }
+    end
+
+    tests("Fog::Compute[:ibm].keys.default = '#{@key_name}'") do
+      returns(@key_name) { Fog::Compute[:ibm].keys.default = @key_name }
+    end
+
+    tests("Fog::Compute[:ibm].keys.default") do
+      @key = Fog::Compute[:ibm].keys.get(@key_name)
+      returns(@key.name) { Fog::Compute[:ibm].keys.default.name }
+    end
+
+    tests("Fog::Compute[:ibm].keys.get('#{@key_name}')") do
+      key = Fog::Compute[:ibm].keys.get(@key_name)
+      returns(@key_name) { key.name }
+    end
+
+    @key.destroy
+
+  end
+
+end

data/tests/ibm/models/compute/locations_tests.rb

@@ -0,0 +1,18 @@
+Shindo.tests('Fog::Compute[:ibm] | locations', ['ibm']) do
+
+  tests('success') do
+
+    @location_id = '41'
+
+    tests('Fog::Compute[:ibm].locations') do
+      returns(true) { Fog::Compute[:ibm].locations.length > 0 }
+    end
+
+    tests('Fog::Compute[:ibm].locations.get("#{@location_id}")') do
+      @location = Fog::Compute[:ibm].locations.get(@location_id)
+      returns(@location_id) { @location.id }
+    end
+
+  end
+
+end

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

@@ -0,0 +1,88 @@
+Shindo.tests('Fog::Compute[:ibm] | server', ['ibm']) do
+
+  tests('success') do
+    # TODO: Fix this for non-mock tests
+    @server         = nil
+    @instance_id    = nil
+
+    @name           = "fog-test-instance-" + Time.now.to_i.to_s(32)
+    @image_id       = "20010001"
+    @instance_type  = "BRZ32.1/2048/60*175"
+    @location_id    = "41"
+
+    @key_name       = "fog-test-key-" + Time.now.to_i.to_s(32)
+    @key            = Fog::Compute[:ibm].keys.create(:name => @key_name)
+
+    tests('Fog::Compute::IBM::Server.new') do
+      @server = Fog::Compute[:ibm].servers.new(
+        :name           => @name,
+        :image_id       => @image_id,
+        :instance_type  => @instance_type,
+        :location_id    => @location,
+        :key_name       => @key_name
+      )
+      returns(@name) { @server.name }
+    end
+
+    tests('Fog::Compute::IBM::Server#save') do
+      returns(true)   { @server.save }
+      returns(String) { @server.id.class }
+      @instance_id = @server.id
+    end
+
+    tests('Fog::Compute::IBM::Server#wait_for { ready? }') do
+      @server = Fog::Compute[:ibm].servers.get(@instance_id)
+      @server.wait_for(Fog::IBM::TIMEOUT) { ready? }
+    end
+
+    tests('Fog::Compute::IBM::Server#id') do
+      returns(@instance_id) { @server.id }
+    end
+
+    tests('Fog::Compute::IBM::Server#ready?') do
+      returns(true) { @server.ready? }
+    end
+
+    tests('Fog::Compute::IBM::Server#status') do
+      returns("Active") { @server.state }
+    end
+
+    # TODO: make this work
+    # tests('Fog::Compute::IBM::Server#reboot') do
+    #   returns(true) { @server.reboot }
+    # end
+
+    tests('Fog::Compute::IBM::Server#rename("name")') do
+      name = @server.name + "-rename"
+      returns(true) { @server.rename(name) }
+      returns(name) { @server.name }
+    end
+
+    tests('Fog::Compute::IBM::Server#image') do
+      returns(@image_id) { @server.image.id }
+    end
+
+    tests('Fog::Compute::IBM::Server#to_image') do
+      body = @server.to_image(:name => @server.name)
+      returns(@server.name) { body['name'] }
+      image = Fog::Compute[:ibm].images.get(body['id'])
+      image.wait_for(Fog::IBM::TIMEOUT) { ready? || state == 'New' }
+      unless image.state == 'Capturing'
+        returns(true) { Fog::Compute[:ibm].delete_image(image.id).body['success'] }
+      end
+    end
+
+    tests('Fog::Compute::IBM::Server#expire_at') do
+      returns(true) { @server.expire_at(Time.now + 60) }
+    end
+
+    tests('Fog::Compute::IBM::Server#destroy') do
+      returns(true) { @server.destroy }
+    end
+
+    @key.wait_for(Fog::IBM::TIMEOUT) { instance_ids.empty? }
+    @key.destroy
+
+  end
+
+end

data/tests/ibm/models/compute/servers_tests.rb

@@ -0,0 +1,37 @@
+Shindo.tests('Fog::Compute[:ibm] | servers', ['ibm']) do
+
+  tests('success') do
+
+    @name           = "fog-test-instance-" + Time.now.to_i.to_s(32)
+    @image_id       = "20010001"
+    @instance_type  = "BRZ32.1/2048/60*175"
+    @location_id    = "41"
+    @key_name       = "fog-test-key-" + Time.now.to_i.to_s(32)
+    @key            = Fog::Compute[:ibm].keys.create(:name => @key_name)
+
+    @n_servers   = Fog::Compute[:ibm].servers.length
+    @instance_id = Fog::Compute[:ibm].create_instance(@name, @image_id, @instance_type, @location_id, :key_name => @key_name).body["instances"][0]["id"]
+
+    tests('Fog::Compute[:ibm].servers') do
+      returns(@n_servers + 1) { Fog::Compute[:ibm].servers.length }
+    end
+
+    tests('Fog::Compute[:ibm].servers.get("#{@instance_id}")') do
+      @server = Fog::Compute[:ibm].servers.get(@instance_id)
+      returns(@instance_id) { @server.id }
+    end
+
+    if @server.wait_for(Fog::IBM::TIMEOUT) { ready? }
+      @server.destroy
+    else
+      pending
+    end
+    if @key.wait_for(Fog::IBM::TIMEOUT) { instance_ids.empty? }
+      @key.destroy
+    else
+      pending
+    end
+
+  end
+
+end

data/tests/ibm/models/storage/volume_tests.rb

@@ -0,0 +1,60 @@
+Shindo.tests('Fog::Storage[:ibm] | volume', ['ibm']) do
+
+  tests('success') do
+
+    @volume       = nil
+    @volume_id    = nil
+    @name         = "fog test volume"
+    @format       = "RAW"
+    @location_id  = "41"
+    @size         = "256"
+    @offering_id  = "20001208"
+
+    tests('Fog::Storage::IBM::Volume.new') do
+      @volume = Fog::Storage[:ibm].volumes.new(
+        :name           => @name,
+        :format         => @format,
+        :location_id    => @location_id,
+        :size           => @size,
+        :offering_id    => @offering_id
+      )
+      returns(@name) { @volume.name }
+    end
+
+    tests('Fog::Storage::IBM::Volume#save') do
+      returns(true)   { @volume.save }
+      returns(String) { @volume.id.class }
+      @volume.wait_for(Fog::IBM::TIMEOUT) { ready? }
+      @volume_id = @volume.id
+    end
+
+    tests("Fog::Storage::IBM::Volume#instance") do
+      returns(nil) { @volume.instance }
+    end
+
+    tests("Fog::Storage::IBM::Volume#location_id") do
+      returns(String) { @volume.location_id.class }
+    end
+
+    tests('Fog::Storage::IBM::Volume#id') do
+      returns(@volume_id) { @volume.id }
+    end
+
+    tests('Fog::Storage::IBM::Volume#ready?') do
+      # We do a "get" to advance the state if we are mocked.
+      # TODO: Fix this for real connections
+      Fog::Storage[:ibm].get_volume(@volume_id)
+      returns(true) { @volume.ready? }
+    end
+
+    tests('Fog::Storage::IBM::Volume#status') do
+      returns("Detached") { @volume.status }
+    end
+
+    tests('Fog::Storage::IBM::Volume#destroy') do
+      returns(true) { @volume.destroy }
+    end
+
+  end
+
+end

data/tests/ibm/requests/compute/address_tests.rb

@@ -0,0 +1,44 @@
+Shindo.tests('Fog::Compute[:ibm] | address requests', ['ibm']) do
+
+  @address_format = {
+    "state"     => Integer,
+    "offeringId"=> String,
+    "location"  => String,
+    "ip"        => String,
+    "id"        => String,
+    "mode"      => Integer,
+    "hostname"  => String,
+    "type"      => Integer,
+    "instanceId" => Fog::Nullable::String,
+    "vlan"      => Fog::Nullable::String,
+  }
+
+  # create_address doesn't return mode, hostname or type attributes
+  @create_address_format = @address_format.reject { |k,v| ["mode", "hostname", "type"].include? k }
+  # list_address returns everything
+  @list_address_format   = { 'addresses' => [ @address_format ] }
+
+  @address_id  = nil
+  @location_id = "41"
+  @offering_id = "20001223"
+
+  tests('success') do
+
+    tests("#create_address('#{@location_id}')").formats(@create_address_format) do
+      data        = Fog::Compute[:ibm].create_address(@location_id, @offering_id).body
+      @address_id = data['id']
+      data
+    end
+
+    tests("#list_addresses").formats(@list_address_format) do
+      Fog::Compute[:ibm].list_addresses.body
+    end
+
+    tests("#delete_address('#{@address_id}')") do
+      Fog::Compute[:ibm].addresses.get(@address_id).wait_for(Fog::IBM::TIMEOUT) { ready? }
+      returns(true) { Fog::Compute[:ibm].delete_address(@address_id).body['success'] }
+    end
+
+  end
+
+end

data/tests/ibm/requests/compute/image_tests.rb

@@ -0,0 +1,110 @@
+Shindo.tests('Fog::Compute[:ibm] | image requests', ['ibm']) do
+
+  @image_format  = {
+    'state'         => Integer,
+    'visibility'    => String,
+    'platform'      => String,
+    'owner'         => String,
+    'architecture'  => Fog::Nullable::String,
+    'createdTime'   => Integer,
+    'location'      => String,
+    'productCodes'  => Array,
+    'name'          => String,
+    'id'            => String,
+    'description'   => String,
+    'supportedInstanceTypes'  => Array,
+    'manifest'      => Fog::Nullable::String,
+    'documentation' => Fog::Nullable::String,
+  }
+
+  # TODO: Actually check this format
+  @product_code_format = {
+    'detail'        => String,
+    'label'         => String,
+    'price'         => @price_format,
+    'id'            => String
+  }
+
+  # TODO: Actually check this format
+  @price_format = {
+    'rate'          => Float,
+    'unitOfMeasure' => String,
+    'effectiveDate' => Integer,
+    'currencyCode'  => String,
+    'pricePerQuantity'  => Integer
+  }
+
+  @images_format = {
+    'images'     => [ @image_format ]
+  }
+
+  @create_image_format = {
+    "name"        => String,
+    "createdTime" => Integer,
+    "productCodes"=> Array,
+    "id"          => String,
+    "description" => String,
+    "visibility"  => String,
+    "state"       => Integer
+  }
+
+  @instance_id    = nil
+  @name           = "fog-test-image-instance-" + Time.now.to_i.to_s(32)
+  @image_id       = "20010001"
+  @instance_type  = "BRZ32.1/2048/60*175"
+  @location       = "41"
+
+  @id             = nil
+  @cloned_id      = nil
+  @image_name     = "fog test create image"
+
+  @key_name       = "fog-test-key-" + Time.now.to_i.to_s(32)
+  @key            = Fog::Compute[:ibm].keys.create(:name => @key_name)
+
+  tests('success') do
+
+    tests("#list_images").formats(@images_format) do
+      Fog::Compute[:ibm].list_images.body
+    end
+
+    tests('#get_image').formats(@image_format) do
+      Fog::Compute[:ibm].get_image("20010001").body
+    end
+
+    tests('#create_image').formats(@create_image_format) do
+      response = Fog::Compute[:ibm].create_instance(
+        @name,
+        @image_id,
+        @instance_type,
+        @location,
+        :key_name => @key_name
+      ).body
+      @instance_id  = response['instances'][0]['id']
+      Fog::Compute[:ibm].servers.get(@instance_id).wait_for(Fog::IBM::TIMEOUT) { ready? }
+      data          = Fog::Compute[:ibm].create_image(@instance_id, @image_name, "").body
+      @id           = data['id']
+      data
+    end
+
+    tests('#clone_image') do
+      clone_name = 'fog-test-clone-image-' + Time.now.to_i.to_s(32)
+      data = Fog::Compute[:ibm].clone_image(@image_id, clone_name, clone_name).body
+      @cloned_id = data['ImageID']
+      returns(String) { data['ImageID'].class }
+    end
+
+    tests('#delete_image') do
+      pending
+      returns(true) { Fog::Compute[:ibm].delete_image(@id).body['success'] }
+      returns(true) { Fog::Compute[:ibm].delete_image(@cloned_id).body['success'] }
+    end
+
+    @server = Fog::Compute[:ibm].servers.get(@instance_id)
+    @server.wait_for(Fog::IBM::TIMEOUT) { ready? }
+    @server.destroy
+    @key.wait_for(Fog::IBM::TIMEOUT) { instance_ids.empty? }
+    @key.destroy
+
+  end
+
+end

data/tests/ibm/requests/compute/instance_tests.rb

@@ -0,0 +1,102 @@
+Shindo.tests('Fog::Compute[:ibm] | instance requests', ['ibm']) do
+
+  @instance_format = {
+    'name'          => String,
+    'location'      => String,
+    'keyName'       => String,
+    'primaryIP'     => {
+      'vlan'        => Fog::Nullable::String,
+      'type'        => Integer,
+      'ip'          => String,
+      'hostname'    => String,
+    },
+    'productCodes'  => Array,
+    'requestId'     => String,
+    'imageId'       => String,
+    'launchTime'    => Integer,
+    'id'            => String,
+    'ip'            => Fog::Nullable::String,
+    'volumes'       => Array,
+    'root-only'     => Fog::Nullable::String,
+    'isMiniEphemeral' => Fog::Nullable::String,
+    'instanceType'  => String,
+    'diskSize'      => Fog::Nullable::String,
+    'requestName'   => String,
+    'secondaryIP'   => Array,
+    'status'        => Integer,
+    'software'      => Array,
+    'expirationTime'=> Integer,
+    'owner'         => String,
+  }
+
+  @instances_format = {
+    'instances' => [ @instance_format ]
+  }
+
+  tests('success') do
+
+    @instance_id    = nil
+    @name           = "fog-test-instance-" + Time.now.to_i.to_s(32)
+    @image_id       = "20010001"
+    @instance_type  = "COP32.1/2048/60"
+    @location       = "41"
+    @key_name       = "fog-test-key-" + Time.now.to_i.to_s(32)
+    @key            = Fog::Compute[:ibm].keys.create(:name => @key_name)
+
+    tests("#create_instance('#{@name}', '#{@image_id}', '#{@instance_type}', '#{@location}', :key_name => '#{@key_name}')").formats(@instances_format) do
+      response = Fog::Compute[:ibm].create_instance(@name, @image_id, @instance_type, @location, :key_name => @key_name).body
+      @instance_id = response['instances'][0]['id']
+      response
+    end
+
+    tests("#get_instance('#{@instance_id}')").formats(@instance_format) do
+      response = Fog::Compute[:ibm].get_instance(@instance_id).body
+    end
+
+    Fog::Compute[:ibm].servers.get(@instance_id).wait_for(Fog::IBM::TIMEOUT) { ready? }
+
+    tests("#list_instances").formats(@instances_format) do
+      instances = Fog::Compute[:ibm].list_instances.body
+    end
+
+    tests("#modify_instance('#{@instance_id}', 'state' => 'restart')") do
+      returns(true) { Fog::Compute[:ibm].modify_instance(@instance_id, 'state' => 'restart').body["success"] }
+    end
+
+    tests("#modify_instance('#{@instance_id}', 'name' => '#{@name} 2')") do
+      returns(true) { Fog::Compute[:ibm].modify_instance(@instance_id, 'name' => @name + " 2").body["success"] }
+    end
+
+    @expiration_time = (Time.now.to_i + 10) * 1000
+
+    tests("#modify_instance('#{@instance_id}', 'expirationTime' => '#{@expiration_time}')") do
+      returns(@expiration_time) { Fog::Compute[:ibm].modify_instance(@instance_id, 'expirationTime' => @expiration_time).body["expirationTime"] }
+    end
+
+    tests("#delete_instance('#{@instance_id}')") do
+      if Fog::Compute[:ibm].servers.get(@instance_id).wait_for(Fog::IBM::TIMEOUT) { ready? }
+        data = Fog::Compute[:ibm].delete_instance(@instance_id)
+      else
+        pending
+      end
+    end
+
+    if @key.wait_for(Fog::IBM::TIMEOUT) { instance_ids.empty? }
+      @key.destroy
+    else
+      pending
+    end
+
+  end
+
+  tests('failures') do
+
+    tests('#create_instance => 412') do
+      raises(Excon::Errors::PreconditionFailed) do
+        Fog::Compute[:ibm].create_instance("FAIL: 412", @image_id, @instance_type, @location, :key_name => "invalid")
+      end
+    end
+
+  end
+
+end