fog 0.7.1 → 2.3.0

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

data/spec/ecloud/bin_spec.rb

@@ -1,22 +0,0 @@
-require 'ecloud/spec_helper'
-
-describe 'Ecloud' do
-  it { Ecloud.should be_available }
-
-  it { Ecloud.should have_at_least(1).services }
-
-  describe "when indexing it like an array" do
-    describe "with a service that exists" do
-      it "should return something when indexed with a configured service" do
-        Ecloud[:compute].should_not be_nil
-      end
-    end
-
-    describe "with a service that does not exist" do
-      it "should raise an ArgumentError" do
-        lambda {Ecloud[:foozle]}.should raise_error(ArgumentError)
-      end
-    end
-
-  end
-end

data/spec/ecloud/models/backup_internet_service_spec.rb

@@ -1,48 +0,0 @@
-require 'ecloud/spec_helper'
-
-if Fog.mocking?
-  describe "Fog::Ecloud::Compute::BackupInternetService", :type => :mock_tmrk_ecloud_model do
-    subject { @vcloud.vdcs[0].backup_internet_services[0] }
-
-    describe :class do
-      subject { Fog::Ecloud::Compute::BackupInternetService }
-
-      it { should have_identity(:href) }
-      it { should have_only_these_attributes([:href, :name, :id, :protocol, :enabled, :description, :timeout, :redirect_url, :monitor]) }
-    end
-
-    context "with no uri" do
-
-      subject { Fog::Ecloud::Compute::BackupInternetService.new() }
-      it { should have_all_attributes_be_nil }
-
-    end
-
-    context "as a collection member" do
-      subject { @vcloud.vdcs[0].backup_internet_services[0].reload }
-
-      let(:composed_service_data) { @vcloud.vdcs[0].backup_internet_services[0].send(:_compose_service_data) }
-
-      it { should be_an_instance_of(Fog::Ecloud::Compute::BackupInternetService) }
-
-      its(:href)                  { should == @mock_backup_service.href }
-      its(:identity)              { should == @mock_backup_service.href }
-      its(:name)                  { should == @mock_backup_service.name }
-      its(:id)                    { should == @mock_backup_service.object_id.to_s }
-      its(:protocol)              { should == @mock_backup_service.protocol }
-      its(:enabled)               { should == @mock_backup_service.enabled.to_s }
-      its(:description)           { should == @mock_backup_service.description }
-      its(:timeout)               { should == @mock_backup_service.timeout.to_s }
-      its(:redirect_url)          { should == (@mock_backup_service.redirect_url || "") }
-      its(:monitor)               { should == nil }
-
-      specify { composed_service_data[:href].should == subject.href.to_s }
-      specify { composed_service_data[:name].should == subject.name }
-      specify { composed_service_data[:id].should == subject.id.to_s }
-      specify { composed_service_data[:protocol].should == subject.protocol }
-      specify { composed_service_data[:enabled].should == subject.enabled.to_s }
-      specify { composed_service_data[:description].should == subject.description }
-      specify { composed_service_data[:timeout].should == subject.timeout.to_s }
-    end
-  end
-end

data/spec/ecloud/models/backup_internet_services_spec.rb

@@ -1,28 +0,0 @@
-require 'ecloud/spec_helper'
-
-if Fog.mocking?
-  describe "Fog::Ecloud::Compute::InternetServices", :type => :mock_tmrk_ecloud_model do
-    context "as an attribute of a VDC" do
-      subject { @vcloud.vdcs[0] }
-
-      it { should respond_to(:backup_internet_services) }
-
-      describe :class do
-        subject { @vcloud.vdcs[0].backup_internet_services.class }
-        its(:model)       { should == Fog::Ecloud::Compute::BackupInternetService }
-      end
-
-      describe :backup_internet_services do
-        subject { @vcloud.vdcs[0].backup_internet_services }
-
-        it { should respond_to(:create) }
-
-        it { should be_an_instance_of(Fog::Ecloud::Compute::BackupInternetServices) }
-
-        its(:length) { should == 1 }
-
-        it { should(have_members_of_the_right_model) }
-      end
-    end
-  end
-end

data/spec/ecloud/models/internet_service_spec.rb

@@ -1,104 +0,0 @@
-require 'ecloud/spec_helper'
-
-if Fog.mocking?
-  describe "Fog::Ecloud::Compute::InternetService", :type => :mock_tmrk_ecloud_model do
-    subject { @vcloud.vdcs[0].public_ips[0].internet_services[0] }
-
-    describe :class do
-      subject { Fog::Ecloud::Compute::InternetService }
-
-      it { should have_identity(:href) }
-      it { should have_only_these_attributes([:href, :name, :id, :protocol, :port, :enabled, :description, :public_ip, :timeout, :redirect_url, :monitor, :backup_service_data]) }
-    end
-
-    context "with no uri" do
-
-      subject { Fog::Ecloud::Compute::InternetService.new() }
-      it { should have_all_attributes_be_nil }
-
-    end
-
-    context "as a collection member" do
-      subject { @vcloud.vdcs[0].public_ips[0].internet_services[0].reload; @vcloud.vdcs[0].public_ips[0].internet_services[0] }
-
-      let(:public_ip) {
-        pip = @vcloud.get_public_ip(@vcloud.vdcs[0].public_ips[0].internet_services[0].public_ip[:Href]).body
-        pip.delete_if{ |k,v| [:xmlns, :xmlns_i].include?(k)}
-        pip
-      }
-      let(:composed_public_ip_data) { @vcloud.vdcs[0].public_ips[0].internet_services[0].send(:_compose_ip_data) }
-      let(:composed_service_data) { @vcloud.vdcs[0].public_ips[0].internet_services[0].send(:_compose_service_data) }
-
-      it { should be_an_instance_of(Fog::Ecloud::Compute::InternetService) }
-
-      its(:href)               { should == @mock_service.href }
-      its(:identity)           { should == @mock_service.href }
-      its(:name)               { should == @mock_service.name }
-      its(:id)                 { should == @mock_service.object_id.to_s }
-      its(:protocol)           { should == @mock_service.protocol }
-      its(:port)               { should == @mock_service.port.to_s }
-      its(:enabled)            { should == @mock_service.enabled.to_s }
-      its(:description)        { should == @mock_service.description }
-      its(:public_ip)          { should == public_ip }
-      its(:timeout)            { should == @mock_service.timeout.to_s }
-      its(:redirect_url)       { should == @mock_service.redirect_url }
-      its(:monitor)            { should == nil }
-      its(:backup_service_uri) { should be_nil }
-
-      specify { composed_public_ip_data[:href].should == public_ip[:Href].to_s }
-      specify { composed_public_ip_data[:name].should == public_ip[:Name] }
-      specify { composed_public_ip_data[:id].should == public_ip[:Id] }
-
-      specify { composed_service_data[:href].should == subject.href.to_s }
-      specify { composed_service_data[:name].should == subject.name }
-      specify { composed_service_data[:id].should == subject.id.to_s }
-      specify { composed_service_data[:protocol].should == subject.protocol }
-      specify { composed_service_data[:port].should == subject.port.to_s }
-      specify { composed_service_data[:enabled].should == subject.enabled.to_s }
-      specify { composed_service_data[:description].should == subject.description }
-      specify { composed_service_data[:timeout].should == subject.timeout.to_s }
-
-      context "with a backup internet service" do
-        before { @mock_service[:backup_service] = @mock_backup_service }
-
-        its(:backup_service_uri) { should == @mock_backup_service.href }
-      end
-
-      describe "#backup_service_uri=" do
-        specify do
-          expect { subject.backup_service_uri = @mock_backup_service.href }.
-            to change { subject.backup_service_uri }.from(nil).to(@mock_backup_service.href)
-        end
-
-        specify do
-          expect { subject.backup_service_uri = @mock_backup_service.href }.
-            to change { subject.send(:_compose_service_data)[:backup_service_uri] }.from(nil).to(@mock_backup_service.href)
-        end
-      end
-
-      describe "disable monitoring via #monitor=" do
-        specify do
-          expect { subject.monitor = {:type => "Disabled", :is_enabled => "true" }; subject.save }.to change {subject.monitor}.from(nil).to(ecloud_disabled_default_monitor)
-        end
-
-      end
-
-      describe "disable monitoring via #disable_monitor" do
-        specify do
-          expect { subject.disable_monitor }.to change {subject.monitor}.from(nil).to(ecloud_disabled_default_monitor)
-        end
-      end
-
-      context "with a disabled monitor" do
-        before { subject.disable_monitor }
-
-        describe "enable ping monitoring via #enable_ping_monitor" do
-          specify do
-            expect { subject.enable_ping_monitor }.to change {subject.monitor}.from(ecloud_disabled_default_monitor).to(nil)
-          end
-        end
-      end
-    end
-  end
-else
-end

data/spec/ecloud/models/internet_services_spec.rb

@@ -1,29 +0,0 @@
-require 'ecloud/spec_helper'
-
-if Fog.mocking?
-  describe "Fog::Ecloud::Compute::InternetServices", :type => :mock_tmrk_ecloud_model do
-    context "as an attribute of a VDC" do
-      subject { @vcloud.vdcs[0] }
-
-      it { should respond_to(:internet_services) }
-
-      describe :class do
-        subject { @vcloud.vdcs[0].internet_services.class }
-        its(:model)       { should == Fog::Ecloud::Compute::InternetService }
-      end
-
-      describe :internet_services do
-        subject { @vcloud.vdcs[0].internet_services }
-
-        it { should respond_to(:create) }
-
-        it { should be_an_instance_of(Fog::Ecloud::Compute::InternetServices) }
-
-        its(:length) { should == 4 }
-
-        it { should have_members_of_the_right_model }
-      end
-    end
-  end
-else
-end

data/spec/ecloud/models/ip_spec.rb

@@ -1,33 +0,0 @@
-require 'ecloud/spec_helper'
-
-if Fog.mocking?
-  describe "Fog::Ecloud::Compute::Ip", :type => :mock_tmrk_ecloud_model do
-    subject { @vcloud }
-
-    describe :class do
-      subject { Fog::Ecloud::Compute::Ip }
-
-      it { should have_identity(:href) }
-      it { should have_only_these_attributes([:href, :name, :status, :server, :rnat, :id]) }
-    end
-
-    context "with no uri" do
-      subject { Fog::Ecloud::Compute::Ip.new() }
-
-      it { should have_all_attributes_be_nil }
-    end
-
-    context "as a collection member" do
-      subject { @ip = @vcloud.vdcs[0].networks[0].ips[0] }
-
-      it { should be_an_instance_of(Fog::Ecloud::Compute::Ip) }
-
-      its(:name) { should == @mock_data.network_ip_from_href(@ip.href).name }
-      its(:status) { should == @mock_data.network_ip_from_href(@ip.href).status }
-      its(:server) { should == @mock_data.network_ip_from_href(@ip.href).used_by.name }
-
-    end
-  end
-else
-end
-

data/spec/ecloud/models/ips_spec.rb

@@ -1,28 +0,0 @@
-require 'ecloud/spec_helper'
-
-if Fog.mocking?
-  describe "Fog::Ecloud::Compute::Ips", :type => :mock_tmrk_ecloud_model do
-    subject { @vcloud }
-
-    it { should respond_to(:ips) }
-
-    describe :class do
-      subject { @vcloud.vdcs[0].networks[0].ips.class }
-      its(:model)       { should == Fog::Ecloud::Compute::Ip }
-    end
-
-    describe :ips do
-      subject { @vcloud.vdcs[0].networks[0].ips.reload }
-      it { should_not respond_to(:create) }
-
-      it { should be_an_instance_of(Fog::Ecloud::Compute::Ips) }
-
-      its(:length) { should == 252 }
-
-      it { should have_members_of_the_right_model }
-    end
-  end
-else
-end
-
-

data/spec/ecloud/models/network_spec.rb

@@ -1,71 +0,0 @@
-require 'ecloud/spec_helper'
-
-if Fog.mocking?
-  describe "Fog::Ecloud::Compute::Network", :type => :mock_tmrk_ecloud_model do
-    subject { @vcloud }
-
-    describe :class do
-      subject { Fog::Ecloud::Compute::Network }
-
-      it { should have_identity(:href) }
-      it { should have_only_these_attributes([:href, :name, :features, :links, :type, :gateway, :broadcast, :address, :rnat, :extension_href, :network_type, :vlan, :friendly_name]) }
-    end
-
-    context "with no uri" do
-
-      subject { Fog::Ecloud::Compute::Network.new() }
-
-      it { should have_all_attributes_be_nil }
-    end
-
-    context "as a collection member" do
-      subject { @vcloud.vdcs[0].networks[0].reload }
-
-      it { should be_an_instance_of(Fog::Ecloud::Compute::Network) }
-
-      its(:href)                  { should == @mock_network.href }
-      its(:identity)              { should == @mock_network.href }
-      its(:name)                  { should == @mock_network.name }
-      its(:type)                  { should == "application/vnd.vmware.vcloud.network+xml" }
-      its(:gateway)               { should == @mock_network.gateway }
-      its(:broadcast)             { should == @mock_network.broadcast }
-      its(:address)               { should == @mock_network.address }
-      its(:rnat)                  { should == @mock_network.rnat }
-      its(:extension_href)        { should == @mock_network.extensions.href }
-      its(:network_type)          { should == @mock_network.extensions.type }
-      its(:vlan)                  { should == @mock_network.extensions.vlan }
-      its(:friendly_name)         { should == @mock_network.extensions.friendly_name }
-
-      it { should have(1).features }
-
-      describe :features do
-        let(:feature) { subject.features.first }
-        specify { feature.should be_an_instance_of(Array) }
-        specify { feature.last.should == @mock_network.features[0][:value] }
-      end
-
-      it { should have(2).links }
-
-      describe :links do
-        context "[0]" do
-          let(:link) { subject.links[0] }
-          specify { link[:rel].should == "down" }
-          specify { link[:href].should == @mock_network_ip_collection.href }
-          specify { link[:type].should == "application/xml" }
-          specify { link[:name].should == @mock_network_ip_collection.name }
-        end
-
-        context "[1]" do
-          let(:link) { subject.links[1] }
-          specify { link[:rel].should == "down" }
-          specify { link[:href].should == @mock_network.extensions.href }
-          specify { link[:type].should == "application/xml" }
-          specify { link[:name].should == @mock_network.name }
-        end
-      end
-
-    end
-  end
-else
-end
-

data/spec/ecloud/models/networks_spec.rb

@@ -1,27 +0,0 @@
-require 'ecloud/spec_helper'
-
-if Fog.mocking?
-  describe "Fog::Ecloud::Compute::Networks", :type => :mock_tmrk_ecloud_model do
-    subject { @vcloud }
-
-    it { should respond_to(:networks) }
-
-    describe :class do
-      subject { @vcloud.networks.class }
-      its(:model)       { should == Fog::Ecloud::Compute::Network }
-    end
-
-    describe :networks do
-      subject { @vcloud.vdcs[0].networks }
-      it { should_not respond_to(:create) }
-
-      it { should be_an_instance_of(Fog::Ecloud::Compute::Networks) }
-
-      its(:length) { should == 2 }
-
-      it { should have_members_of_the_right_model }
-    end
-  end
-else
-end
-

data/spec/ecloud/models/node_spec.rb

@@ -1,38 +0,0 @@
-require 'ecloud/spec_helper'
-
-if Fog.mocking?
-  describe "Fog::Ecloud::Compute::Node", :type => :mock_tmrk_ecloud_model do
-
-    subject { @vcloud.vdcs.first.public_ips.first.internet_services.first.nodes.first }
-
-    describe :class do
-      subject { Fog::Ecloud::Compute::Node }
-
-      it { should have_identity(:href) }
-      it { should have_only_these_attributes([:href, :ip_address, :description, :name, :port, :enabled, :id]) }
-    end
-
-    context "with no uri" do
-
-      subject { Fog::Ecloud::Compute::Node.new() }
-      it { should have_all_attributes_be_nil }
-
-    end
-
-    context "as a collection member" do
-      subject { @vcloud.vdcs.first.public_ips.first.internet_services.first.nodes.first.reload }
-
-      it { should be_an_instance_of(Fog::Ecloud::Compute::Node) }
-
-      its(:href)                  { should == @mock_node.href }
-      its(:identity)              { should == @mock_node.href }
-      its(:name)                  { should == @mock_node.name }
-      its(:id)                    { should == @mock_node.object_id.to_s }
-      its(:port)                  { should == @mock_node.port.to_s }
-      its(:enabled)               { should == @mock_node.enabled.to_s }
-      its(:description)           { should == @mock_node.description }
-
-    end
-  end
-else
-end