fog 0.11.0 → 1.0.0

data/spec/core/current_machine_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+require 'fog/core/current_machine'
+
+describe Fog::CurrentMachine do
+  context '#ip_address' do
+    before(:each){ described_class.ip_address = nil }
+
+    it 'should be threadsafe' do
+      Net::HTTP.should_receive(:get_response).once{ Struct.new(:body).new('') }
+
+      (1..10).map {
+        Thread.new { described_class.ip_address }
+      }.each{ |t| t.join }
+    end
+
+    it 'should remove trailing endline characters' do
+      Net::HTTP.stub(:get_response){ Struct.new(:body).new("192.168.0.1\n") }
+
+      described_class.ip_address.should == '192.168.0.1'
+    end
+  end
+end

data/tests/aws/models/auto_scaling/activities_tests.rb

@@ -1,6 +1,6 @@
 Shindo.tests('AWS::AutoScaling | activities', ['aws', 'auto_scaling_m']) do
 
   pending # FIXME: activity#save is not implemented
-  collection_tests(AWS[:auto_scaling].activities, {}, false)
+  collection_tests(Fog::AWS[:auto_scaling].activities, {}, false)
 
 end

data/tests/aws/models/auto_scaling/configuration_test.rb

@@ -6,7 +6,7 @@ Shindo.tests('AWS::AutoScaling | configuration', ['aws', 'auto_scaling_m']) do
     :instance_type => 't1.micro'
   }
 
-  model_tests(AWS[:auto_scaling].configurations, params, false) do
+  model_tests(Fog::AWS[:auto_scaling].configurations, params, false) do
     @instance.wait_for { ready? }
   end
 

data/tests/aws/models/auto_scaling/configurations_tests.rb

@@ -6,6 +6,6 @@ Shindo.tests('AWS::AutoScaling | configurations', ['aws', 'auto_scaling_m']) do
     :instance_type => 't1.micro'
   }
 
-  collection_tests(AWS[:auto_scaling].configurations, params, false)
+  collection_tests(Fog::AWS[:auto_scaling].configurations, params, false)
 
 end

data/tests/aws/models/auto_scaling/instances_tests.rb

@@ -1,6 +1,6 @@
 Shindo.tests('AWS::AutoScaling | instances', ['aws', 'auto_scaling_m']) do
 
   pending # FIXME: instance#save is not defined
-  #collection_tests(AWS[:auto_scaling].instances, {}, false)
+  #collection_tests(Fog::AWS[:auto_scaling].instances, {}, false)
 
 end

data/tests/aws/models/cloud_watch/metric_statistics_tests.rb

@@ -12,7 +12,7 @@ Shindo.tests("AWS::CloudWatch | metric_statistics", ['aws', 'cloudwatch']) do
     statisticTypes = ['Minimum','Maximum','Sum','SampleCount','Average']
     
     tests("#all").succeeds do
-      @statistics = AWS[:cloud_watch].metric_statistics.all({'Statistics' => statisticTypes, 'StartTime' => startTime, 'EndTime' => endTime, 'Period' => period, 'MetricName' => metricName, 'Namespace' => namespace, 'Dimensions' => [{'Name' => 'InstanceId', 'Value' => instanceId}]})
+      @statistics = Fog::AWS[:cloud_watch].metric_statistics.all({'Statistics' => statisticTypes, 'StartTime' => startTime, 'EndTime' => endTime, 'Period' => period, 'MetricName' => metricName, 'Namespace' => namespace, 'Dimensions' => [{'Name' => 'InstanceId', 'Value' => instanceId}]})
     end
     
     tests("#all_not_empty").returns(true) do
@@ -26,11 +26,11 @@ Shindo.tests("AWS::CloudWatch | metric_statistics", ['aws', 'cloudwatch']) do
       :unit => 'None'
     }
     tests('#new').returns(new_attributes) do
-      AWS[:cloud_watch].metric_statistics.new(new_attributes).attributes
+      Fog::AWS[:cloud_watch].metric_statistics.new(new_attributes).attributes
     end
     
     tests('#create').returns(new_attributes) do
-      AWS[:cloud_watch].metric_statistics.create(new_attributes).attributes
+      Fog::AWS[:cloud_watch].metric_statistics.create(new_attributes).attributes
     end
     
     stats_set_attributes = {
@@ -44,7 +44,7 @@ Shindo.tests("AWS::CloudWatch | metric_statistics", ['aws', 'cloudwatch']) do
       :unit => 'None'
     }
     tests('#create_stats_set').returns(stats_set_attributes) do
-      AWS[:cloud_watch].metric_statistics.create(stats_set_attributes).attributes
+      Fog::AWS[:cloud_watch].metric_statistics.create(stats_set_attributes).attributes
     end
   end
 

data/tests/aws/models/cloud_watch/metrics_tests.rb

@@ -3,13 +3,13 @@ Shindo.tests("AWS::CloudWatch | metrics", ['aws', 'cloudwatch']) do
   tests('success') do
     pending # FIXME: the hardcoded instance id won't be available
     tests("#all").succeeds do
-      AWS[:cloud_watch].metrics.all
+      Fog::AWS[:cloud_watch].metrics.all
     end
     instanceId = 'i-fd713391'
     metricName = 'CPUUtilization'
     namespace = 'AWS/EC2'
     tests("#get").returns({:dimensions=>[{"Name"=>"InstanceId", "Value"=>instanceId}], :name=>metricName, :namespace=>namespace}) do
-      AWS[:cloud_watch].metrics.get(namespace, metricName, {'InstanceId' => instanceId}).attributes
+      Fog::AWS[:cloud_watch].metrics.get(namespace, metricName, {'InstanceId' => instanceId}).attributes
     end
     
   end

data/tests/aws/models/compute/security_group_tests.rb

@@ -0,0 +1,32 @@
+Shindo.tests("Fog::Compute[:aws] | security_group", ['aws']) do
+
+  model_tests(Fog::Compute[:aws].security_groups, {:description => 'foggroupdescription', :name => 'foggroupname'}, true)
+
+  tests("a group with trailing whitespace") do
+    @group = Fog::Compute[:aws].security_groups.create(:name => "foggroup with spaces   ", :description => "   fog group desc   ")
+    test("name is correct") do
+      @group.name ==  "foggroup with spaces   "
+    end
+
+    test("description is correct") do
+      @group.description == "   fog group desc   "
+    end
+
+    @other_group = Fog::Compute[:aws].security_groups.create(:name => 'other group', :description => 'another group')
+
+    test("authorize access by another security group") do
+      @group.authorize_group_and_owner(@other_group.name)
+      @group.reload
+      @group.ip_permissions.size == 3
+    end
+
+    test("revoke access from another security group") do
+      @group.revoke_group_and_owner(@other_group.name)
+      @group.reload
+      @group.ip_permissions.empty?
+    end
+
+    @other_group.destroy
+    @group.destroy
+  end
+end

data/tests/aws/models/compute/server_tests.rb

@@ -0,0 +1,63 @@
+Shindo.tests("Fog::Compute[:aws] | monitor", ['aws']) do
+
+  @instance = Fog::Compute[:aws].servers.new
+
+  [:addresses, :flavor, :key_pair, :key_pair=, :volumes].each do |association|
+    responds_to(association)
+  end
+
+  tests('new instance') do
+
+    test('#monitor = true') do
+      @instance.monitor = true
+      @instance.attributes[:monitoring] == true
+    end
+
+    test('#monitor = false') do
+      @instance.monitor = false
+      @instance.attributes[:monitoring] == false
+    end
+
+  end
+
+  tests('existing instance') do
+
+    @instance.save
+
+    [:id, :availability_zone, :flavor_id, :kernel_id, :image_id, :state].each do |attr|
+      test("instance##{attr} should not contain whitespace") do
+        nil == @instance.send(attr).match(/\s/)
+      end
+    end
+
+    test('#monitor = true') do
+      @instance.monitor = true
+      @instance.monitoring == true
+    end
+
+    test('#monitor = false') do
+      @instance.monitor = false
+      @instance.monitoring == false
+    end
+
+  end
+
+  @instance.destroy
+
+  tests('tags') do
+    @instance = Fog::Compute[:aws].servers.create(:tags => {'key' => 'value'})
+
+    @instance.wait_for { ready? }
+
+    tests('@instance.reload.tags').returns({'key' => 'value'}) do
+      @instance.reload.tags
+    end
+
+    unless Fog.mocking?
+      Fog::Compute[:aws].tags.all('resource-id' => @instance.identity).each {|tag| tag.destroy}
+    end
+
+    @instance.destroy
+  end
+
+end

data/tests/aws/models/elasticache/cluster_tests.rb

@@ -0,0 +1,30 @@
+Shindo.tests('AWS::Elasticache | cache clusters', ['aws', 'elasticache']) do
+  cluster_params = {
+    :id               => "fog-test-cluster-#{rand(999).to_s}",
+    :node_type        => 'cache.m1.large',
+    :security_groups  => ['default'],
+    :engine           => 'memcached',
+    :num_nodes        => 1
+  }
+
+  pending if Fog.mocking?
+
+  Formatador.display_line "Creating cluster #{cluster_params[:id]}..."
+  model_tests(AWS[:elasticache].clusters, cluster_params, false) do
+    @instance.reload  # Reload to get the cluster info from AWS
+    Formatador.display_line "Waiting for #{@instance.id} "+
+      "to become available (#{@instance.status})..."
+    @instance.wait_for {ready?}
+  end
+
+  # Single model is still deleting, so re-randomize the cluster ID
+  cluster_params[:id] = "fog-test-cluster-#{rand(999).to_s}"
+  Formatador.display_line "Creating cluster #{cluster_params[:id]}..."
+  collection_tests(AWS[:elasticache].clusters, cluster_params, false) do
+    @instance.reload  # Reload to get the cluster info from AWS
+    Formatador.display_line "Waiting for #{@instance.id} "+
+      "to become available (#{@instance.status})..."
+    @instance.wait_for {ready?}
+  end
+
+end

data/tests/aws/models/elasticache/parameter_groups_tests.rb

@@ -0,0 +1,17 @@
+Shindo.tests('AWS::Elasticache | parameter groups', ['aws', 'elasticache']) do
+  group_name = 'fog-test'
+  description = 'Fog Test'
+
+  pending if Fog.mocking?
+
+  model_tests(
+    AWS[:elasticache].parameter_groups,
+    {:id => group_name, :description => description}, false
+  )
+
+  collection_tests(
+    AWS[:elasticache].parameter_groups,
+    {:id => group_name, :description => description}, false
+  )
+
+end

data/tests/aws/models/elasticache/security_groups_tests.rb

@@ -0,0 +1,52 @@
+Shindo.tests('AWS::Elasticache | security groups', ['aws', 'elasticache']) do
+  group_name = 'fog-test'
+  description = 'Fog Test'
+
+  pending if Fog.mocking?
+
+  model_tests(
+  AWS[:elasticache].security_groups,
+  {:id => group_name, :description => description}, false
+  ) do
+
+    # An EC2 group to authorize
+    ec2_group = Fog::Compute.new(:provider => 'AWS').security_groups.create(
+      :name => 'fog-test-elasticache', :description => 'fog test'
+    )
+
+    # Reload to get the instance owner_id
+    @instance.reload
+
+    tests('#authorize_ec2_group') do
+      @instance.authorize_ec2_group(ec2_group.name)
+      returns('authorizing') do
+        group = @instance.ec2_groups.detect do |g|
+          g['EC2SecurityGroupName'] == ec2_group.name
+        end
+        group['Status']
+      end
+      returns(false, 'not ready') { @instance.ready? }
+    end
+
+    @instance.wait_for { ready? }
+
+    tests('#revoke_ec2_group') do
+      @instance.revoke_ec2_group(ec2_group.name)
+      returns('revoking') do
+        group = @instance.ec2_groups.detect do |g|
+          g['EC2SecurityGroupName'] == ec2_group.name
+        end
+        group['Status']
+      end
+      returns(false, 'not ready') { @instance.ready? }
+    end
+
+    ec2_group.destroy
+  end
+
+  collection_tests(
+    AWS[:elasticache].security_groups,
+    {:id => group_name, :description => description}, false
+  )
+
+end

data/tests/aws/models/elb/model_tests.rb

@@ -5,13 +5,13 @@ Shindo.tests('AWS::ELB | models', ['aws', 'elb']) do
   tests('success') do
     tests('load_balancers') do
       tests('getting a missing elb') do
-        returns(nil) { AWS[:elb].load_balancers.get('no-such-elb') }
+        returns(nil) { Fog::AWS[:elb].load_balancers.get('no-such-elb') }
       end
     end
 
     tests('listeners') do
       tests("default attributes") do
-        listener = AWS[:elb].listeners.new
+        listener = Fog::AWS[:elb].listeners.new
         tests('instance_port is 80').returns(80) { listener.instance_port }
         tests('lb_port is 80').returns(80) { listener.lb_port }
         tests('protocol is HTTP').returns('HTTP') { listener.protocol }
@@ -20,7 +20,7 @@ Shindo.tests('AWS::ELB | models', ['aws', 'elb']) do
 
       tests("specifying attributes") do
         attributes = {:instance_port => 2000, :lb_port => 2001, :protocol => 'SSL', :policy_names => ['fake'] }
-        listener = AWS[:elb].listeners.new(attributes)
+        listener = Fog::AWS[:elb].listeners.new(attributes)
         tests('instance_port is 2000').returns(2000) { listener.instance_port }
         tests('lb_port is 2001').returns(2001) { listener.lb_port }
         tests('protocol is SSL').returns('SSL') { listener.protocol }
@@ -33,27 +33,27 @@ Shindo.tests('AWS::ELB | models', ['aws', 'elb']) do
 
     tests('create') do
       tests('without availability zones') do
-        elb = AWS[:elb].load_balancers.create(:id => elb_id)
+        elb = Fog::AWS[:elb].load_balancers.create(:id => elb_id)
         tests("availability zones are correct").returns(@availability_zones.sort) { elb.availability_zones.sort }
         tests("dns names is set").returns(true) { elb.dns_name.is_a?(String) }
         tests("created_at is set").returns(true) { Time === elb.created_at }
         tests("policies is empty").returns([]) { elb.policies }
         tests("default listener") do
           tests("1 listener").returns(1) { elb.listeners.size }
-          tests("params").returns(AWS[:elb].listeners.new.to_params) { elb.listeners.first.to_params }
+          tests("params").returns(Fog::AWS[:elb].listeners.new.to_params) { elb.listeners.first.to_params }
         end
       end
 
       tests('with availability zones') do
         azs = @availability_zones[1..-1]
-        elb2 = AWS[:elb].load_balancers.create(:id => "#{elb_id}-2", :availability_zones => azs)
+        elb2 = Fog::AWS[:elb].load_balancers.create(:id => "#{elb_id}-2", :availability_zones => azs)
         tests("availability zones are correct").returns(azs.sort) { elb2.availability_zones.sort }
         elb2.destroy
       end
 
       # Need to sleep here for IAM changes to propgate
       tests('with ListenerDescriptions') do
-        @certificate = AWS[:iam].upload_server_certificate(AWS::IAM::SERVER_CERT_PUBLIC_KEY, AWS::IAM::SERVER_CERT_PRIVATE_KEY, @key_name).body['Certificate']
+        @certificate = Fog::AWS[:iam].upload_server_certificate(AWS::IAM::SERVER_CERT_PUBLIC_KEY, AWS::IAM::SERVER_CERT_PRIVATE_KEY, @key_name).body['Certificate']
         sleep(8) unless Fog.mocking?
         listeners = [{
             'Listener' => {
@@ -67,7 +67,7 @@ Shindo.tests('AWS::ELB | models', ['aws', 'elb']) do
             },
             'PolicyNames' => []
           }]
-        elb3 = AWS[:elb].load_balancers.create(:id => "#{elb_id}-3", 'ListenerDescriptions' => listeners)
+        elb3 = Fog::AWS[:elb].load_balancers.create(:id => "#{elb_id}-3", 'ListenerDescriptions' => listeners)
         tests('there are 2 listeners').returns(2) { elb3.listeners.count }
         tests('instance_port is 2030').returns(2030) { elb3.listeners.first.instance_port }
         tests('lb_port is 2030').returns(2030) { elb3.listeners.first.lb_port }
@@ -81,23 +81,23 @@ Shindo.tests('AWS::ELB | models', ['aws', 'elb']) do
           'Listener' => {
           'LoadBalancerPort' => 443, 'InstancePort' => 80, 'Protocol' => 'HTTPS', "SSLCertificateId" => "fakecert"}
         }]
-        AWS[:elb].load_balancers.create(:id => "#{elb_id}-4", "ListenerDescriptions" => listeners)
+        Fog::AWS[:elb].load_balancers.create(:id => "#{elb_id}-4", "ListenerDescriptions" => listeners)
       end
     end
 
     tests('all') do
-      elb_ids = AWS[:elb].load_balancers.all.map{|e| e.id}
+      elb_ids = Fog::AWS[:elb].load_balancers.all.map{|e| e.id}
       tests("contains elb").returns(true) { elb_ids.include? elb_id }
     end
 
     tests('get') do
-      elb_get = AWS[:elb].load_balancers.get(elb_id)
+      elb_get = Fog::AWS[:elb].load_balancers.get(elb_id)
       tests('ids match').returns(elb_id) { elb_get.id }
     end
 
     tests('creating a duplicate elb') do
       raises(Fog::AWS::ELB::IdentifierTaken) do
-        AWS[:elb].load_balancers.create(:id => elb_id, :availability_zones => ['us-east-1d'])
+        Fog::AWS[:elb].load_balancers.create(:id => elb_id, :availability_zones => ['us-east-1d'])
       end
     end
 
@@ -110,6 +110,8 @@ Shindo.tests('AWS::ELB | models', ['aws', 'elb']) do
     end
 
     server = Fog::Compute[:aws].servers.create
+    server.wait_for { ready? }
+
     tests('register instance') do
       begin
         elb.register_instances(server.id)
@@ -246,6 +248,6 @@ Shindo.tests('AWS::ELB | models', ['aws', 'elb']) do
       elb.destroy
     end
 
-    AWS[:iam].delete_server_certificate(@key_name)
+    Fog::AWS[:iam].delete_server_certificate(@key_name)
   end
 end

data/tests/aws/models/rds/parameter_group_tests.rb

@@ -4,7 +4,7 @@ Shindo.tests("AWS::RDS | parameter_group", ['aws', 'rds']) do
   params = {:id => group_name, :family => 'mysql5.1', :description => group_name}
 
   pending if Fog.mocking?
-  model_tests(AWS[:rds].parameter_groups, params, false) do
+  model_tests(Fog::AWS[:rds].parameter_groups, params, false) do
     tests('#parameters') do
       #search for a sample parameter
       tests 'contains parameters' do