phpfog-fog 0.4.1

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

@@ -0,0 +1,88 @@
+require 'spec_helper'
+
+describe 'Fog::AWS::Compute::SecurityGroup' do
+
+  describe "#initialize" do
+
+    it "should remap attributes from parser" do
+      security_group = AWS[:compute].security_groups.new(
+        'groupDescription' => 'description',
+        'groupName'        => 'name',
+        'ipPermissions'    => 'permissions',
+        'ownerId'          => 'owner'
+      )
+      security_group.description.should == 'description'
+      security_group.name.should == 'name'
+      security_group.ip_permissions.should == 'permissions'
+      security_group.owner_id.should == 'owner'
+    end
+
+  end
+
+  describe "#collection" do
+
+    it "should return a Fog::AWS::Compute::SecurityGroups" do
+      AWS[:compute].security_groups.new.collection.should be_a(Fog::AWS::Compute::SecurityGroups)
+    end
+
+    it "should be the security_groups the keypair is related to" do
+      security_groups = AWS[:compute].security_groups
+      security_groups.new.collection.should == security_groups
+    end
+
+  end
+
+  describe "#destroy" do
+
+    it "should return true if the security_group is deleted" do
+      address = AWS[:compute].security_groups.create(:description => 'groupdescription', :name => 'keyname')
+      address.destroy.should be_true
+    end
+
+  end
+
+  describe "#reload" do
+
+    before(:each) do
+      @security_group = AWS[:compute].security_groups.create(:description => 'groupdescription', :name => 'keyname')
+      @reloaded = @security_group.reload
+    end
+
+    after(:each) do
+      @security_group.destroy
+    end
+
+    it "should return a Fog::AWS::Compute::SecurityGroup" do
+      @reloaded.should be_a(Fog::AWS::Compute::SecurityGroup)
+    end
+
+    it "should reset attributes to remote state" do
+      @security_group.attributes.should == @reloaded.attributes
+    end
+
+  end
+
+  describe "#save" do
+
+    before(:each) do
+      @security_group = AWS[:compute].security_groups.new(:description => 'groupdescription', :name => 'keyname')
+    end
+
+    it "should return true when it succeeds" do
+      @security_group.save.should be_true
+      @security_group.destroy
+    end
+
+    it "should not exist in security_groups before save" do
+      AWS[:compute].security_groups.get(@security_group.name).should be_nil
+    end
+
+    it "should exist in buckets after save" do
+      @security_group.save
+      AWS[:compute].security_groups.get(@security_group.name).should_not be_nil
+      @security_group.destroy
+    end
+
+  end
+
+end

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

@@ -0,0 +1,71 @@
+require 'spec_helper'
+
+describe 'Fog::AWS::Compute::SecurityGroups' do
+
+  describe "#all" do
+
+    it "should return a Fog::AWS::Compute::SecurityGroups" do
+      AWS[:compute].security_groups.all.should be_a(Fog::AWS::Compute::SecurityGroups)
+    end
+
+    it "should include persisted security_groups" do
+      security_group = AWS[:compute].security_groups.create(:description => 'groupdescription', :name => 'keyname')
+      AWS[:compute].security_groups.get(security_group.name).should_not be_nil
+      security_group.destroy
+    end
+
+  end
+
+  describe "#create" do
+
+    before(:each) do
+      @security_group = AWS[:compute].security_groups.create(:description => 'groupdescription', :name => 'keyname')
+    end
+
+    after(:each) do
+      @security_group.destroy
+    end
+
+    it "should return a Fog::AWS::Compute::SecurityGroup" do
+      @security_group.should be_a(Fog::AWS::Compute::SecurityGroup)
+    end
+
+    it "should exist on ec2" do
+      AWS[:compute].security_groups.get(@security_group.name).should_not be_nil
+    end
+
+  end
+
+  describe "#get" do
+
+    it "should return a Fog::AWS::Compute::SecurityGroup if a matching security_group exists" do
+      security_group = AWS[:compute].security_groups.create(:description => 'groupdescription', :name => 'keyname')
+      get = AWS[:compute].security_groups.get(security_group.name)
+      security_group.attributes[:fingerprint].should == get.attributes[:fingerprint]
+      security_group.attributes[:name].should == get.attributes[:name]
+      security_group.destroy
+    end
+
+    it "should return nil if no matching security_group exists" do
+      AWS[:compute].security_groups.get('notasecuritygroupname').should be_nil
+    end
+
+  end
+
+  describe "#new" do
+
+    it "should return a Fog::AWS::Compute::SecurityGroup" do
+      AWS[:compute].security_groups.new(:description => 'groupdescription', :name => 'keyname').should be_a(Fog::AWS::Compute::SecurityGroup)
+    end
+
+  end
+
+  describe "#reload" do
+
+    it "should return a Fog::AWS::Compute::SecurityGroups" do
+      AWS[:compute].security_groups.all.reload.should be_a(Fog::AWS::Compute::SecurityGroups)
+    end
+
+  end
+
+end

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

@@ -0,0 +1,105 @@
+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

@@ -0,0 +1,79 @@
+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

@@ -0,0 +1,85 @@
+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

@@ -0,0 +1,174 @@
+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

@@ -0,0 +1,71 @@
+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

data/spec/spec_helper.rb

@@ -0,0 +1,13 @@
+require 'spec'
+require 'open-uri'
+require 'fog'
+require 'fog/bin'
+require 'fog/bin/vcloud'
+
+if ENV["FOG_MOCK"] == "true"
+  Fog.mock!
+end
+
+unless defined?(GENTOO_AMI)
+  GENTOO_AMI = 'ami-5ee70037'
+end