fog 0.7.1 → 0.7.2

data/spec/aws/models/compute/server_spec.rb

@@ -1,105 +0,0 @@
-require 'spec_helper'
-
-describe 'Fog::AWS::Compute::Server' do
-
-  subject { @server = @servers.new(:image_id => GENTOO_AMI) }
-
-  before(:each) do
-    @servers = AWS[:compute].servers
-  end
-
-  after(:each) do
-    if @server && !@server.new_record?
-      @server.wait_for { ready? }
-      @server.destroy.should be_true
-    end
-  end
-
-  describe "#initialize" do
-
-    it "should remap attributes from parser" do
-      server = @servers.new({
-        'amiLaunchIndex'    => 'ami_launch_index',
-        'clientToken'       => 'client_token',
-        'dnsName'           => 'dns_name',
-        'imageId'           => 'image_id',
-        'instanceId'        => 'instance_id',
-        'instanceType'      => 'instance_type',
-        'kernelId'          => 'kernel_id',
-        'keyName'           => 'key_name',
-        'launchTime'        => 'launch_time',
-        'productCodes'      => 'product_codes',
-        'privateDnsName'    => 'private_dns_name',
-        'ramdiskId'         => 'ramdisk_id'
-      })
-      server.ami_launch_index.should == 'ami_launch_index'
-      server.client_token.should == 'client_token'
-      server.dns_name.should == 'dns_name'
-      server.image_id.should == 'image_id'
-      server.id.should == 'instance_id'
-      server.kernel_id.should == 'kernel_id'
-      server.key_name.should == 'key_name'
-      server.created_at.should == 'launch_time'
-      server.product_codes.should == 'product_codes'
-      server.private_dns_name.should == 'private_dns_name'
-      server.ramdisk_id.should == 'ramdisk_id'
-    end
-
-  end
-
-  describe "#addresses" do
-
-    it "should return a Fog::AWS::Compute::Addresses" do
-      subject.save
-      subject.addresses.should be_a(Fog::AWS::Compute::Addresses)
-    end
-
-  end
-
-  describe "#state" do
-    it "should remap values out of hash" do
-      server = Fog::AWS::Compute::Server.new({
-        'instanceState' => { 'name' => 'instance_state' },
-      })
-      server.state.should == 'instance_state'
-    end
-  end
-
-  describe "#key_pair" do
-    it "should have tests"
-  end
-
-  describe "#key_pair=" do
-    it "should have tests"
-  end
-
-  describe "#monitoring=" do
-    it "should remap values out of hash" do
-      server = Fog::AWS::Compute::Server.new({
-        'monitoring' => { 'state' => true }
-      })
-      server.monitoring.should == true
-    end
-  end
-
-  describe "#placement=" do
-
-    it "should remap values into availability_zone" do
-      server = Fog::AWS::Compute::Server.new({
-        'placement' => { 'availabilityZone' => 'availability_zone' }
-      })
-      server.availability_zone.should == 'availability_zone'
-    end
-
-  end
-
-  describe "#volumes" do
-
-    it "should return a Fog::AWS::Compute::Volumes" do
-      subject.save
-      subject.volumes.should be_a(Fog::AWS::Compute::Volumes)
-    end
-
-  end
-
-end

data/spec/aws/models/compute/snapshot_spec.rb

@@ -1,79 +0,0 @@
-require 'spec_helper'
-
-describe 'Fog::AWS::Compute::Snapshot' do
-
-  before(:all) do
-    @volume = AWS[:compute].volumes.create(:availability_zone => 'us-east-1a', :size => 1, :device => 'dev/sdz1')
-    @volume.wait_for { ready? }
-  end
-
-  after(:all) do
-    @volume.destroy
-  end
-
-  after(:each) do
-    if @snapshot && !@snapshot.new_record?
-      @snapshot.wait_for { ready? }
-      @snapshot.destroy
-    end
-  end
-
-  describe "#initialize" do
-
-    it "should remap attributes from parser" do
-      snapshot = AWS[:compute].snapshots.new(
-        'snapshotId'  => 'snap-00000000',
-        'startTime'   => 'now',
-        'volumeId'    => 'vol-00000000',
-        'description' => 'taken for safety'
-      )
-      snapshot.id.should == 'snap-00000000'
-      snapshot.created_at.should == 'now'
-      snapshot.volume_id.should == 'vol-00000000'
-      snapshot.description.should == 'taken for safety'
-    end
-
-  end
-
-  describe "#destroy" do
-
-    it "should return true if the snapshot is deleted" do
-      @snapshot = @volume.snapshots.create
-      @snapshot.wait_for { ready? }
-      @snapshot.destroy.should be_true
-      @snapshot = nil # avoid the after(:each) block
-    end
-
-  end
-
-  describe "#reload" do
-
-    before(:each) do
-      @snapshot = @volume.snapshots.create
-      @reloaded = @snapshot.reload
-    end
-
-    it "should match the original" do
-      @reloaded.should be_a(Fog::AWS::Compute::Snapshot)
-      @reloaded.attributes.should == @snapshot.attributes
-    end
-
-  end
-
-  describe "#save" do
-
-    it "should persist the snapshot" do
-      @snapshot = @volume.snapshots.new
-      AWS[:compute].snapshots.get(@snapshot.id).should be_nil
-      @snapshot.save.should be_true
-      AWS[:compute].snapshots.get(@snapshot.id).should_not be_nil
-    end
-
-    it "should allow a description" do
-      @snapshot = @volume.snapshots.create(:description => 'taken for safety')
-      AWS[:compute].snapshots.get(@snapshot.id).description.should == 'taken for safety'
-    end
-
-  end
-
-end

data/spec/aws/models/compute/snapshots_spec.rb

@@ -1,85 +0,0 @@
-require 'spec_helper'
-
-describe 'Fog::AWS::Compute::Snapshots' do
-
-  before(:all) do
-    @volume = AWS[:compute].volumes.create(:availability_zone => 'us-east-1a', :size => 1, :device => 'dev/sdz1')
-    @volume.wait_for { ready? }
-  end
-
-  after(:all) do
-    @volume.destroy
-  end
-
-  after(:each) do
-    if @snapshot && !@snapshot.new_record?
-      @snapshot.wait_for { ready? }
-      @snapshot.destroy
-    end
-  end
-
-  describe "#all" do
-
-    before(:each) do
-      @snapshot = @volume.snapshots.create
-    end
-
-    it "should include persisted snapshots" do
-      AWS[:compute].snapshots.all.map {|snapshot| snapshot.id}.should include(@snapshot.id)
-    end
-
-    it "should limit snapshots by volume if present" do
-      @other_volume = AWS[:compute].volumes.create(:availability_zone => 'us-east-1a', :size => 1, :device => 'dev/sdz1')
-
-      @volume.snapshots.map {|snapshot| snapshot.id}.should include(@snapshot.identity)
-      @other_volume.snapshots.map {|snapshot| snapshot.id}.should_not include(@snapshot.identity)
-
-      @other_volume.destroy
-    end
-
-  end
-
-  describe "#create" do
-
-    before(:each) do
-      @snapshot = @volume.snapshots.create
-    end
-
-    it "should exist on ec2" do
-      AWS[:compute].snapshots.get(@snapshot.id).should_not be_nil
-    end
-
-  end
-
-  describe "#get" do
-
-    it "should return a Fog::AWS::Compute::Snapshot if a matching snapshot exists" do
-      @snapshot = @volume.snapshots.create
-      @snapshot.wait_for { ready? }
-      get = AWS[:compute].snapshots.get(@snapshot.id)
-      @snapshot.attributes.should == get.attributes
-    end
-
-    it "should return nil if no matching address exists" do
-      AWS[:compute].snapshots.get('snap-00000000').should be_nil
-    end
-
-  end
-
-  describe "#new" do
-
-    it "should return a Fog::AWS::Compute::Snapshot" do
-      AWS[:compute].snapshots.new.should be_a(Fog::AWS::Compute::Snapshot)
-    end
-
-  end
-
-  describe "#reload" do
-
-    it "should return a Fog::AWS::Compute::Snapshots" do
-      AWS[:compute].snapshots.all.reload.should be_a(Fog::AWS::Compute::Snapshots)
-    end
-
-  end
-
-end

data/spec/aws/models/compute/volume_spec.rb

@@ -1,174 +0,0 @@
-require 'spec_helper'
-
-describe 'Fog::AWS::Compute::Volume' do
-
-  describe "#initialize" do
-
-    it "should remap attributes from parser" do
-      volume = AWS[:compute].volumes.new(
-        'attachTime'        => 'now',
-        'availabilityZone'  => 'us-east-1a',
-        'createTime'        => 'recently',
-        'instanceId'        => 'i-00000000',
-        'snapshotId'        => 'snap-00000000',
-        'volumeId'          => 'vol-00000000'
-      )
-      volume.attached_at.should == 'now'
-      volume.availability_zone.should == 'us-east-1a'
-      volume.created_at.should == 'recently'
-      volume.server_id.should == 'i-00000000'
-      volume.snapshot_id.should == 'snap-00000000'
-      volume.id.should == 'vol-00000000'
-    end
-
-  end
-
-  describe "#collection" do
-
-    it "should return a Fog::AWS::Compute::Volumes" do
-      AWS[:compute].volumes.new.collection.should be_a(Fog::AWS::Compute::Volumes)
-    end
-
-    it "should be the volumes the volume is related to" do
-      volumes = AWS[:compute].volumes
-      volumes.new.collection.should == volumes
-    end
-
-  end
-
-  describe "#destroy" do
-
-    it "should return true if the volume is deleted" do
-      volume = AWS[:compute].volumes.create(:availability_zone => 'us-east-1a', :size => 1, :device => '/dev/sdz1')
-      volume.destroy.should be_true
-    end
-
-    it 'should fail if the volume is attached to an instance' do
-      server = AWS[:compute].servers.create(:image_id => GENTOO_AMI)
-      server.wait_for { ready? }
-      volume = AWS[:compute].volumes.create(:availability_zone => server.availability_zone, :size => 1, :device => '/dev/sdz1')
-      volume.server = server
-      lambda { volume.destroy }.should raise_error
-    end
-
-  end
-
-  describe "#server=" do
-    before(:all) do
-      @server = AWS[:compute].servers.create(:image_id => GENTOO_AMI)
-      @server.wait_for { ready? }
-    end
-
-    after(:all) do
-      @server.destroy
-    end
-
-    before(:each) do
-      @volume = AWS[:compute].volumes.new(:availability_zone => @server.availability_zone, :size => 1, :device => '/dev/sdz1')
-    end
-
-    describe "when set to a server" do
-      after(:each) do
-        if @volume.id
-          @volume.wait_for { state == 'in-use' }
-          @volume.server = nil
-          @volume.wait_for { ready? }
-          @volume.destroy
-        end
-      end
-
-      it "should not attach to server if the volume has not been saved" do
-        @volume.server = @server
-        @volume.server_id.should_not == @server.id
-      end
-
-      it "should change the availability_zone if the volume has not been saved" do
-        @volume.server = @server
-        @volume.availability_zone.should == @server.availability_zone
-      end
-
-      it "should attach to server when the volume is saved" do
-        @volume.server = @server
-        @volume.save.should be_true
-        @volume.server_id.should == @server.id
-      end
-
-      it "should attach to server to an already saved volume" do
-        @volume.save.should be_true
-        @volume.server = @server
-        @volume.server_id.should == @server.id
-      end
-
-      it "should not change the availability_zone if the volume has been saved" do
-        @volume.save.should be_true
-        @volume.server = @server
-        @volume.availability_zone.should == @server.availability_zone
-      end
-
-    end
-
-    describe "when set to nil" do
-      after(:each) do
-        @volume.destroy
-      end
-
-      it "should detach from server if the volume has been saved" do
-        @volume.server = @server
-        @volume.save.should be_true
-        @server.reload.volumes.map(&:id).should include(@volume.id)
-
-        @volume.server = nil
-        @volume.wait_for { ready? }
-        @volume.server_id.should be_nil
-        @server.reload.volumes.map(&:id).should_not include(@volume.id)
-      end
-
-    end
-
-  end
-
-  describe "#reload" do
-
-    before(:each) do
-      @volume = AWS[:compute].volumes.create(:availability_zone => 'us-east-1a', :size => 1, :device => '/dev/sdz1')
-      @reloaded = @volume.reload
-    end
-
-    after(:each) do
-      @volume.destroy
-    end
-
-    it "should return a Fog::AWS::Compute::Volume" do
-      @reloaded.should be_a(Fog::AWS::Compute::Volume)
-    end
-
-    it "should reset attributes to remote state" do
-      @volume.attributes.should == @reloaded.attributes
-    end
-
-  end
-
-  describe "#save" do
-
-    before(:each) do
-      @volume = AWS[:compute].volumes.new(:availability_zone => 'us-east-1a', :size => 1, :device => '/dev/sdz1')
-    end
-
-    it "should return true when it succeeds" do
-      @volume.save.should be_true
-      @volume.destroy
-    end
-
-    it "should not exist in volumes before save" do
-      AWS[:compute].volumes.get(@volume.id).should be_nil
-    end
-
-    it "should exist in buckets after save" do
-      @volume.save
-      AWS[:compute].volumes.get(@volume.id).should_not be_nil
-      @volume.destroy
-    end
-
-  end
-
-end

data/spec/aws/models/compute/volumes_spec.rb

@@ -1,71 +0,0 @@
-require 'spec_helper'
-
-describe 'Fog::AWS::Compute::Volumes' do
-
-  describe "#all" do
-
-    it "should return a Fog::AWS::Compute::Volumes" do
-      AWS[:compute].volumes.all.should be_a(Fog::AWS::Compute::Volumes)
-    end
-
-    it "should include persisted volumes" do
-      volume = AWS[:compute].volumes.create(:availability_zone => 'us-east-1a', :size => 1, :device => 'dev/sdz1')
-      AWS[:compute].volumes.get(volume.id).should_not be_nil
-      volume.destroy
-    end
-
-  end
-
-  describe "#create" do
-
-    before(:each) do
-      @volume = AWS[:compute].volumes.create(:availability_zone => 'us-east-1a', :size => 1, :device => 'dev/sdz1')
-    end
-
-    after(:each) do
-      @volume.destroy
-    end
-
-    it "should return a Fog::AWS::Compute::Volume" do
-      @volume.should be_a(Fog::AWS::Compute::Volume)
-    end
-
-    it "should exist on ec2" do
-      AWS[:compute].volumes.get(@volume.id).should_not be_nil
-    end
-
-  end
-
-  describe "#get" do
-
-    it "should return a Fog::AWS::Compute::Volume if a matching volume exists" do
-      volume = AWS[:compute].volumes.create(:availability_zone => 'us-east-1a', :size => 1)
-      volume.wait_for { ready? }
-      get = AWS[:compute].volumes.get(volume.id)
-      volume.attributes.should == get.attributes
-      volume.destroy
-    end
-
-    it "should return nil if no matching address exists" do
-      AWS[:compute].volumes.get('vol-00000000').should be_nil
-    end
-
-  end
-
-  describe "#new" do
-
-    it "should return a Fog::AWS::Compute::Volume" do
-      AWS[:compute].volumes.new.should be_a(Fog::AWS::Compute::Volume)
-    end
-
-  end
-
-  describe "#reload" do
-
-    it "should return a Fog::AWS::Compute::Volumes" do
-      AWS[:compute].volumes.all.reload.should be_a(Fog::AWS::Compute::Volumes)
-    end
-
-  end
-
-end