fog 0.7.1 → 0.7.2

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

@@ -1,103 +0,0 @@
-require 'spec_helper'
-
-describe 'Fog::AWS::Compute::Address' do
-
-  describe "#initialize" do
-
-    it "should remap attributes from parser" do
-      address = AWS[:compute].addresses.new(
-        'instanceId'  => 'i-00000000',
-        'publicIp'    => '0.0.0.0'
-      )
-      address.server_id.should == 'i-00000000'
-      address.public_ip.should == '0.0.0.0'
-    end
-
-  end
-
-  describe "#addresses" do
-
-    it "should return a Fog::AWS::Compute::Addresses" do
-      AWS[:compute].addresses.new.collection.should be_a(Fog::AWS::Compute::Addresses)
-    end
-
-    it "should be the addresses the address is related to" do
-      addresses = AWS[:compute].addresses
-      addresses.new.collection.should == addresses
-    end
-
-  end
-
-  describe "#destroy" do
-
-    it "should return true if the address is deleted" do
-      address = AWS[:compute].addresses.create
-      address.destroy.should be_true
-    end
-
-  end
-
-  describe "#server=" do
-    before(:each) do
-      @address = AWS[:compute].addresses.new
-      @server = AWS[:compute].servers.create(:image_id => GENTOO_AMI)
-    end
-
-    after(:each) do
-      @address.destroy
-      @server.destroy
-    end
-
-    it "should associate with server to an already saved address" do
-      @address.save.should be_true
-      @server.wait_for { state == 'running' }
-      @address.server = @server
-      @address.server_id.should == @server.id
-    end
-  end
-
-  describe "#reload" do
-
-    before(:each) do
-      @address = AWS[:compute].addresses.create
-      @reloaded = @address.reload
-    end
-
-    after(:each) do
-      @address.destroy
-    end
-
-    it "should return a Fog::AWS::Compute::Address" do
-      @reloaded.should be_a(Fog::AWS::Compute::Address)
-    end
-
-    it "should reset attributes to remote state" do
-      @address.attributes.should == @reloaded.attributes
-    end
-
-  end
-
-  describe "#save" do
-
-    before(:each) do
-      @address = AWS[:compute].addresses.new
-    end
-
-    it "should return true when it succeeds" do
-      @address.save.should be_true
-      @address.destroy
-    end
-
-    it "should not exist in addresses before save" do
-      @address.collection.get(@address.public_ip).should be_nil
-    end
-
-    it "should exist in buckets after save" do
-      @address.save
-      @address.collection.get(@address.public_ip).should_not be_nil
-      @address.destroy
-    end
-
-  end
-
-end

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

@@ -1,70 +0,0 @@
-require 'spec_helper'
-
-describe 'Fog::AWS::Compute::Addresses' do
-
-  describe "#all" do
-
-    it "should return a Fog::AWS::Compute::Addresses" do
-      AWS[:compute].addresses.all.should be_a(Fog::AWS::Compute::Addresses)
-    end
-
-    it "should include persisted addresses" do
-      address = AWS[:compute].addresses.create
-      AWS[:compute].addresses.get(address.public_ip).should_not be_nil
-      address.destroy
-    end
-
-  end
-
-  describe "#create" do
-
-    before(:each) do
-      @address = AWS[:compute].addresses.create
-    end
-
-    after(:each) do
-      @address.destroy
-    end
-
-    it "should return a Fog::AWS::Compute::Address" do
-      @address.should be_a(Fog::AWS::Compute::Address)
-    end
-
-    it "should exist on ec2" do
-      AWS[:compute].addresses.get(@address.public_ip).should_not be_nil
-    end
-
-  end
-
-  describe "#get" do
-
-    it "should return a Fog::AWS::Compute::Address if a matching address exists" do
-      address = AWS[:compute].addresses.create
-      get = AWS[:compute].addresses.get(address.public_ip)
-      address.attributes.should == get.attributes
-      address.destroy
-    end
-
-    it "should return nil if no matching address exists" do
-      AWS[:compute].addresses.get('0.0.0.0').should be_nil
-    end
-
-  end
-
-  describe "#new" do
-
-    it "should return a Fog::AWS::Compute::Address" do
-      AWS[:compute].addresses.new.should be_a(Fog::AWS::Compute::Address)
-    end
-
-  end
-
-  describe "#reload" do
-
-    it "should return a Fog::AWS::Compute::Addresses" do
-      AWS[:compute].addresses.all.reload.should be_a(Fog::AWS::Compute::Addresses)
-    end
-
-  end
-
-end

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

@@ -1,86 +0,0 @@
-require 'spec_helper'
-
-describe 'Fog::AWS::Compute::KeyPair' do
-
-  describe "#initialize" do
-
-    it "should remap attributes from parser" do
-      key_pair = AWS[:compute].key_pairs.new(
-        'keyFingerprint'  => 'fingerprint',
-        'keyMaterial'     => 'material',
-        'keyName'         => 'name'
-      )
-      key_pair.fingerprint.should == 'fingerprint'
-      key_pair.private_key.should == 'material'
-      key_pair.name.should == 'name'
-    end
-
-  end
-
-  describe "#collection" do
-
-    it "should return a Fog::AWS::Compute::KeyPairs" do
-      AWS[:compute].key_pairs.new.collection.should be_a(Fog::AWS::Compute::KeyPairs)
-    end
-
-    it "should be the key_pairs the keypair is related to" do
-      key_pairs = AWS[:compute].key_pairs
-      key_pairs.new.collection.should == key_pairs
-    end
-
-  end
-
-  describe "#destroy" do
-
-    it "should return true if the key_pair is deleted" do
-      address = AWS[:compute].key_pairs.create(:name => 'keyname')
-      address.destroy.should be_true
-    end
-
-  end
-
-  describe "#reload" do
-
-    before(:each) do
-      @key_pair = AWS[:compute].key_pairs.create(:name => 'keyname')
-      @reloaded = @key_pair.reload
-    end
-
-    after(:each) do
-      @key_pair.destroy
-    end
-
-    it "should return a Fog::AWS::Compute::KeyPair" do
-      @reloaded.should be_a(Fog::AWS::Compute::KeyPair)
-    end
-
-    it "should reset attributes to remote state" do
-      @key_pair.attributes.should == @reloaded.attributes
-    end
-
-  end
-
-  describe "#save" do
-
-    before(:each) do
-      @key_pair = AWS[:compute].key_pairs.new(:name => 'keyname')
-    end
-
-    it "should return true when it succeeds" do
-      @key_pair.save.should be_true
-      @key_pair.destroy
-    end
-
-    it "should not exist in key_pairs before save" do
-      AWS[:compute].key_pairs.get(@key_pair.name).should be_nil
-    end
-
-    it "should exist in buckets after save" do
-      @key_pair.save
-      AWS[:compute].key_pairs.get(@key_pair.name).should_not be_nil
-      @key_pair.destroy
-    end
-
-  end
-
-end

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

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

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

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

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