tecnh-fog 0.2.23.vpc

data/tests/aws/requests/ec2/snapshot_tests.rb

@@ -0,0 +1,60 @@
+Shindo.tests('AWS::EC2 | snapshot requests', ['aws']) do
+
+  @snapshot_format = {
+    'description' => NilClass,
+    'ownerId'     => String,
+    'progress'    => String,
+    'snapshotId'  => String,
+    'startTime'   => Time,
+    'status'      => String,
+    'volumeId'    => String,
+    'volumeSize'  => Integer
+  }
+
+  @snapshots_format = {
+    'requestId'   => String,
+    'snapshotSet' => [@snapshot_format]
+  }
+
+  @volume = AWS[:ec2].volumes.create(:availability_zone => 'us-east-1a', :size => 1)
+
+  tests('success') do
+
+    @snapshot_id = nil
+
+    tests("#create_snapshot(#{@volume.identity})").formats(@snapshot_format.merge('progress' => NilClass, 'requestId' => String)) do
+      data = AWS[:ec2].create_snapshot(@volume.identity).body
+      @snapshot_id = data['snapshotId']
+      data
+    end
+
+    AWS[:ec2].snapshots.get(@snapshot_id).wait_for { ready? }
+
+    tests("#describe_snapshots").formats(@snapshots_format) do
+      AWS[:ec2].describe_snapshots.body
+    end
+
+    tests("#describe_snapshots('#{@snapshot_id}')").formats(@snapshots_format) do
+      AWS[:ec2].describe_snapshots(@snapshot_id).body
+    end
+
+    tests("#delete_snapshots(#{@snapshot_id})").formats(AWS::EC2::Formats::BASIC) do
+      AWS[:ec2].delete_snapshot(@snapshot_id).body
+    end
+
+  end
+  tests ('failure') do
+
+    tests("#describe_snapshot('snap-00000000')").raises(Fog::AWS::EC2::NotFound) do
+      AWS[:ec2].describe_snapshots('snap-00000000')
+    end
+
+    tests("#delete_snapshot('snap-00000000')").raises(Fog::AWS::EC2::NotFound) do
+      AWS[:ec2].delete_snapshot('snap-00000000')
+    end
+
+  end
+
+  @volume.destroy
+
+end

data/tests/aws/requests/ec2/volume_tests.rb

@@ -0,0 +1,105 @@
+Shindo.tests('AWS::EC2 | volume requests', ['aws']) do
+
+  @volume_format = {
+    'availabilityZone'  => String,
+    'createTime'        => Time,
+    'requestId'         => String,
+    'size'              => Integer,
+    'snapshotId'        => NilClass,
+    'status'            => String,
+    'volumeId'          => String
+  }
+
+  @volume_attachment_format = {
+    'attachTime'  => Time,
+    'device'      => String,
+    'instanceId'  => String,
+    'requestId'   => String,
+    'status'      => String,
+    'volumeId'    => String
+  }
+
+  @volumes_format = {
+    'volumeSet' => [{
+      'availabilityZone'    => String,
+      'attachmentSet'       => [],
+      'createTime'          => Time,
+      'size'                => Integer,
+      'snapshotId'          => NilClass,
+      'status'              => String,
+      'volumeId'            => String
+    }],
+    'requestId' => String
+  }
+
+  @server = AWS[:ec2].servers.create(:image_id => GENTOO_AMI)
+  @server.wait_for { ready? }
+
+  tests('success') do
+
+    @volume_id = nil
+
+    tests('#create_volume').formats(@volume_format) do
+      data = AWS[:ec2].create_volume(@server.availability_zone, 1).body
+      @volume_id = data['volumeId']
+      data
+    end
+
+    AWS[:ec2].volumes.get(@volume_id).wait_for { ready? }
+
+    tests('#describe_volumes').formats(@volumes_format) do
+      AWS[:ec2].describe_volumes.body
+    end
+
+    tests("#describe_volumes(#{@volume_id})").formats(@volumes_format) do
+      AWS[:ec2].describe_volumes.body
+    end
+
+    tests("#attach_volume(#{@server.identity}, #{@volume_id}, '/dev/sdh')").formats(@volume_attachment_format) do
+      AWS[:ec2].attach_volume(@server.identity, @volume_id, '/dev/sdh').body
+    end
+
+    AWS[:ec2].volumes.get(@volume_id).wait_for { state == 'in-use' }
+
+    tests("#detach_volume('#{@volume_id}')").formats(@volume_attachment_format) do
+      AWS[:ec2].detach_volume(@volume_id).body
+    end
+
+    AWS[:ec2].volumes.get(@volume_id).wait_for { ready? }
+
+    tests("#delete_volume('#{@volume_id}')").formats(AWS::EC2::Formats::BASIC) do
+      AWS[:ec2].delete_volume(@volume_id).body
+    end
+
+  end
+  tests ('failure') do
+
+    @volume = AWS[:ec2].volumes.create(:availability_zone => @server.availability_zone, :size => 1)
+
+    tests("#describe_volume('vol-00000000')").raises(Fog::AWS::EC2::NotFound) do
+      AWS[:ec2].describe_volumes('vol-00000000')
+    end
+
+    tests("#attach_volume('i-00000000', '#{@volume.identity}', '/dev/sdh')").raises(Fog::AWS::EC2::NotFound) do
+      AWS[:ec2].attach_volume('i-00000000', @volume.identity, '/dev/sdh')
+    end
+
+    tests("#attach_volume('#{@server.identity}', 'vol-00000000', '/dev/sdh')").raises(Fog::AWS::EC2::NotFound) do
+      AWS[:ec2].attach_volume(@server.identity, 'vol-00000000', '/dev/sdh')
+    end
+
+    tests("#detach_volume('vol-00000000')").raises(Fog::AWS::EC2::NotFound) do
+      AWS[:ec2].detach_volume('vol-00000000')
+    end
+
+    tests("#delete_volume('vol-00000000')").raises(Fog::AWS::EC2::NotFound) do
+      AWS[:ec2].delete_volume('vol-00000000')
+    end
+
+    @volume.destroy
+
+  end
+
+  @server.destroy
+
+end

data/tests/bluebox/helper.rb

@@ -0,0 +1,26 @@
+module Bluebox
+
+  def self.[](service)
+    @@connections ||= Hash.new do |hash, key|
+      credentials = Fog.credentials.reject do |k,v|
+        ![:bluebox_api_key, :bluebox_customer_id].include?(k)
+      end
+      hash[key] = case key
+      when :blocks
+        Fog::Bluebox.new(credentials)
+      end
+    end
+    @@connections[service]
+  end
+
+  module Formats
+
+    PRODUCT = {
+      'cost'        => Float,
+      'description' => String,
+      'id'          => String
+    }
+
+  end
+
+end

data/tests/bluebox/requests/block_tests.rb

@@ -0,0 +1,68 @@
+Shindo.tests('Bluebox | block requests', ['bluebox']) do
+
+  @block_format = {
+    'cpu'       => Float,
+    'hostname'  => String,
+    'id'        => String,
+    'ips'       => [{'address' => String}],
+    'memory'    => Integer,
+    'product'   => Bluebox::Formats::PRODUCT,
+    'status'    => String,
+    'storage'   => Integer,
+    'template'  => String,
+    
+  }
+
+  tests('success') do
+
+    @product_id   = '94fd37a7-2606-47f7-84d5-9000deda52ae' # 1 GB
+    @template_id  = 'a00baa8f-b5d0-4815-8238-b471c4c4bf72' # Ubuntu 9.10 64bit
+    @password     = 'chunkybacon'
+
+    @block_id = nil
+
+    tests("create_block('#{@product_id}', '#{@template_id}', 'password' => '#{@password}')").formats(@block_format) do
+      data = Bluebox[:blocks].create_block(@product_id, @template_id, 'password' => @password).body
+      @block_id = data['id']
+      data
+    end
+
+    Bluebox[:blocks].servers.get(@block_id).wait_for { ready? }
+
+    tests("get_block('#{@block_id}')").formats(@block_format) do
+      Bluebox[:blocks].get_block(@block_id).body
+    end
+
+    tests("get_blocks").formats([@block_format.reject {|key,value| ['product', 'template'].include?(key)}]) do
+      Bluebox[:blocks].get_blocks.body
+    end
+
+    tests("reboot_block('#{@block_id}')").formats({'status' => String, 'text' => String}) do
+      Bluebox[:blocks].reboot_block(@block_id).body
+    end
+
+    Bluebox[:blocks].servers.get(@block_id).wait_for { ready? }
+
+    tests("destroy_block('#{@block_id})'").formats({'text' => String}) do
+      Bluebox[:blocks].destroy_block(@block_id).body
+    end
+
+  end
+
+  tests('failure') do
+
+    tests("get_block('00000000-0000-0000-0000-000000000000')").raises(Fog::Bluebox::NotFound) do
+      Bluebox[:blocks].get_block('00000000-0000-0000-0000-000000000000')
+    end
+
+    tests("reboot_block('00000000-0000-0000-0000-000000000000')").raises(Fog::Bluebox::NotFound) do
+      Bluebox[:blocks].reboot_block('00000000-0000-0000-0000-000000000000')
+    end
+
+    tests("destroy_block('00000000-0000-0000-0000-000000000000')").raises(Fog::Bluebox::NotFound) do
+      Bluebox[:blocks].destroy_block('00000000-0000-0000-0000-000000000000')
+    end
+
+  end
+
+end

data/tests/bluebox/requests/product_tests.rb

@@ -0,0 +1,25 @@
+Shindo.tests('Bluebox | product requests', ['bluebox']) do
+
+  tests('success') do
+
+    @product_id   = '94fd37a7-2606-47f7-84d5-9000deda52ae' # 1 GB
+
+    tests("get_product('#{@product_id}')").formats(Bluebox::Formats::PRODUCT) do
+      Bluebox[:blocks].get_product(@product_id).body
+    end
+
+    tests("get_products").formats([Bluebox::Formats::PRODUCT]) do
+      Bluebox[:blocks].get_products.body
+    end
+
+  end
+
+  tests('failure') do
+
+    tests("get_product('00000000-0000-0000-0000-000000000000')").raises(Fog::Bluebox::NotFound) do
+      Bluebox[:blocks].get_product('00000000-0000-0000-0000-000000000000')
+    end
+
+  end
+
+end

data/tests/bluebox/requests/template_tests.rb

@@ -0,0 +1,32 @@
+Shindo.tests('Bluebox | template requests', ['bluebox']) do
+
+  @template_format = {
+    'created'     => String,
+    'description' => String,
+    'id'          => String,
+    'public'      => Fog::Boolean
+  }
+
+  tests('success') do
+
+    @template_id  = 'a00baa8f-b5d0-4815-8238-b471c4c4bf72' # Ubuntu 9.10 64bit
+
+    tests("get_template('#{@template_id}')").formats(@template_format) do
+      Bluebox[:blocks].get_template(@template_id).body
+    end
+
+    tests("get_templates").formats([@template_format]) do
+      Bluebox[:blocks].get_templates.body
+    end
+
+  end
+
+  tests('failure') do
+
+    tests("get_template('00000000-0000-0000-0000-000000000000')").raises(Fog::Bluebox::NotFound) do
+      Bluebox[:blocks].get_template('00000000-0000-0000-0000-000000000000')
+    end
+
+  end
+
+end

data/tests/helper.rb

@@ -0,0 +1,81 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib', 'fog'))
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib', 'fog', 'bin'))
+
+require File.expand_path(File.join(File.dirname(__FILE__), 'helpers', 'model_helper'))
+
+if ENV["FOG_MOCK"] == "true"
+  Fog.mock!
+end
+
+# Boolean hax
+module Fog
+  module Boolean
+  end
+end
+FalseClass.send(:include, Fog::Boolean)
+TrueClass.send(:include, Fog::Boolean)
+
+module Shindo
+  class Tests
+
+    def formats(format, &block)
+      test('has proper format') do
+        formats_kernel(instance_eval(&block), format)
+      end
+    end
+
+    def succeeds(&block)
+      test('succeeds') do
+        instance_eval(&block)
+        true
+      end
+    end
+
+    private
+
+    def formats_kernel(original_data, original_format, original = true)
+      valid = true
+      data = original_data.dup
+      format = original_format.dup
+      if format.is_a?(Array)
+        data   = {:element => data}
+        format = {:element => format}
+      end
+      for key, value in format
+        valid &&= data.has_key?(key)
+        datum = data.delete(key)
+        format.delete(key)
+        case value
+        when Array
+          valid &&= datum.is_a?(Array)
+          if datum.is_a?(Array)
+            for element in datum
+              type = value.first
+              if type.is_a?(Hash)
+                valid &&= formats_kernel({:element => element}, {:element => type}, false)
+              elsif type.nil?
+                p "#{key} => #{value}"
+              else
+                valid &&= element.is_a?(type)
+              end
+            end
+          end
+        when Hash
+          valid &&= datum.is_a?(Hash)
+          valid &&= formats_kernel(datum, value, false)
+        else
+          p "#{key} => #{value}" unless datum.is_a?(value)
+          valid &&= datum.is_a?(value)
+        end
+      end
+      p data unless data.empty?
+      p format unless format.empty?
+      valid &&= data.empty? && format.empty?
+      if !valid && original
+        @message = "#{original_data.inspect} does not match #{original_format.inspect}"
+      end
+      valid
+    end
+
+  end
+end

data/tests/helper_tests.rb

@@ -0,0 +1,43 @@
+Shindo.tests('test_helper', 'meta') do
+
+  tests('#formats_kernel') do
+
+    tests('returns true') do
+
+      test('when format of value matches') do
+        formats_kernel({:a => :b}, {:a => Symbol})
+      end
+
+      test('when format of nested array elements matches') do
+        formats_kernel({:a => [:b, :c]}, {:a => [Symbol]})
+      end
+
+      test('when format of nested hash matches') do
+        formats_kernel({:a => {:b => :c}}, {:a => {:b => Symbol}})
+      end
+
+      test('when format of an array') do
+        formats_kernel([{:a => :b}], [{:a => Symbol}])
+      end
+
+    end
+
+    tests('returns false') do
+
+      test('when format of value does not match') do
+        !formats_kernel({:a => :b}, {:a => String})
+      end
+
+      test('when not all keys are checked') do
+        !formats_kernel({:a => :b}, {})
+      end
+
+      test('when some keys do not appear') do
+        !formats_kernel({}, {:a => String})
+      end
+
+    end
+
+  end
+
+end