fog 0.0.39 → 0.0.40

data/spec/aws/models/ec2/instance_spec.rb

@@ -1,161 +0,0 @@
-require File.dirname(__FILE__) + '/../../../spec_helper'
-
-describe 'Fog::AWS::EC2::Instance' do
-
-  describe "#initialize" do
-
-    it "should remap attributes from parser" do
-      instance = ec2.instances.new({
-        'amiLaunchIndex'    => 'ami_launch_index',
-        'dnsName'           => 'dns_name',
-        'groupId'           => 'group_id',
-        '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'
-      })
-      instance.ami_launch_index.should == 'ami_launch_index'
-      instance.dns_name.should == 'dns_name'
-      instance.group_id.should == 'group_id'
-      instance.image_id.should == 'image_id'
-      instance.id.should == 'instance_id'
-      instance.type.should == 'instance_type'
-      instance.kernel_id.should == 'kernel_id'
-      instance.key_name.should == 'key_name'
-      instance.launch_time.should == 'launch_time'
-      instance.product_codes.should == 'product_codes'
-      instance.private_dns_name.should == 'private_dns_name'
-      instance.ramdisk_id.should == 'ramdisk_id'
-    end
-
-  end
-
-  describe "#addresses" do
-
-    it "should return a Fog::AWS::EC2::Addresses" do
-      instance = ec2.instances.create(:image_id => GENTOO_AMI)
-      instance.addresses.should be_a(Fog::AWS::EC2::Addresses)
-      instance.destroy
-    end
-
-  end
-
-  describe "#destroy" do
-
-    it "should return true if the instance is deleted" do
-      instance = ec2.instances.create(:image_id => GENTOO_AMI)
-      instance.destroy.should be_true
-    end
-
-  end
-
-  describe "#state" do
-    it "should remap values out of hash" do
-      instance = Fog::AWS::EC2::Instance.new({
-        'instanceState' => { 'name' => 'instance_state' },
-      })
-      instance.state.should == 'instance_state'
-    end
-  end
-
-  describe "#collection" do
-
-    it "should return a Fog::AWS::EC2::Instances" do
-      ec2.instances.new.collection.should be_a(Fog::AWS::EC2::Instances)
-    end
-
-    it "should be the instances the instance is related to" do
-      instances = ec2.instances
-      instances.new.collection.should == instances
-    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
-      instance = Fog::AWS::EC2::Instance.new({
-        'monitoring' => { 'state' => true }
-      })
-      instance.monitoring.should == true
-    end
-  end
-
-  describe "#placement=" do
-
-    it "should remap values into availability_zone" do
-      instance = Fog::AWS::EC2::Instance.new({
-        'placement' => { 'availabilityZone' => 'availability_zone' }
-      })
-      instance.availability_zone.should == 'availability_zone'
-    end
-
-  end
-
-  describe "#reload" do
-
-    before(:each) do
-      @instance = ec2.instances.create(:image_id => GENTOO_AMI)
-      @reloaded = @instance.reload
-    end
-
-    after(:each) do
-      @instance.destroy
-    end
-
-    it "should return a Fog::AWS::EC2::Instance" do
-      @reloaded.should be_a(Fog::AWS::EC2::Instance)
-    end
-
-    it "should reset attributes to remote state" do
-      @instance.attributes.should == @reloaded.attributes
-    end
-
-  end
-
-  describe "#save" do
-
-    before(:each) do
-      @instance = ec2.instances.new(:image_id => GENTOO_AMI)
-    end
-
-    it "should return true when it succeeds" do
-      @instance.save.should be_true
-      @instance.destroy
-    end
-
-    it "should not exist in instances before save" do
-      ec2.instances.get(@instance.id).should be_nil
-    end
-
-    it "should exist in buckets after save" do
-      @instance.save
-      ec2.instances.get(@instance.id).should_not be_nil
-      @instance.destroy
-    end
-
-  end
-
-  describe "#volumes" do
-
-    it "should return a Fog::AWS::EC2::Volumes" do
-      instance = ec2.instances.create(:image_id => GENTOO_AMI)
-      instance.volumes.should be_a(Fog::AWS::EC2::Volumes)
-      instance.destroy
-    end
-
-  end
-
-end

data/spec/aws/models/ec2/instances_spec.rb

@@ -1,70 +0,0 @@
-require File.dirname(__FILE__) + '/../../../spec_helper'
-
-describe 'Fog::AWS::EC2::Instances' do
-
-  describe "#all" do
-
-    it "should return a Fog::AWS::EC2::Instances" do
-      ec2.instances.all.should be_a(Fog::AWS::EC2::Instances)
-    end
-
-    it "should include persisted instances" do
-      instance = ec2.instances.create(:image_id => GENTOO_AMI)
-      ec2.instances.get(instance.id).should_not be_nil
-      instance.destroy
-    end
-
-  end
-
-  describe "#create" do
-
-    before(:each) do
-      @instance = ec2.instances.create(:image_id => GENTOO_AMI)
-    end
-
-    after(:each) do
-      @instance.destroy
-    end
-
-    it "should return a Fog::AWS::EC2::Instance" do
-      @instance.should be_a(Fog::AWS::EC2::Instance)
-    end
-
-    it "should exist on ec2" do
-      ec2.instances.get(@instance.id).should_not be_nil
-    end
-
-  end
-
-  describe "#get" do
-
-    it "should return a Fog::AWS::EC2::Instance if a matching instance exists" do
-      instance = ec2.instances.create(:image_id => GENTOO_AMI)
-      get = ec2.instances.get(instance.id)
-      instance.attributes.should == get.attributes
-      instance.destroy
-    end
-
-    it "should return nil if no matching instance exists" do
-      ec2.instances.get('i-00000000').should be_nil
-    end
-
-  end
-
-  describe "#new" do
-
-    it "should return a Fog::AWS::EC2::Instance" do
-      ec2.instances.new(:image_id => GENTOO_AMI).should be_a(Fog::AWS::EC2::Instance)
-    end
-
-  end
-
-  describe "#reload" do
-
-    it "should return a Fog::AWS::EC2::Instances" do
-      ec2.instances.all.reload.should be_a(Fog::AWS::EC2::Instances)
-    end
-
-  end
-
-end

data/spec/aws/models/s3/bucket_spec.rb

@@ -1,129 +0,0 @@
-require File.dirname(__FILE__) + '/../../../spec_helper'
-
-describe 'Fog::AWS::S3::Bucket' do
-
-  describe "#initialize" do
-
-    it "should remap attributes from parser" do
-      now = Time.now
-      bucket = Fog::AWS::S3::Bucket.new(
-        'CreationDate' => now,
-        'Name'         => 'bucketname'
-      )
-      bucket.creation_date.should == now
-      bucket.name.should == 'bucketname'
-    end
-
-  end
-
-  describe "#collection" do
-
-    it "should return a Fog::AWS::S3::Buckets" do
-      s3.buckets.new.collection.should be_a(Fog::AWS::S3::Buckets)
-    end
-
-    it "should be the buckets the bucket is related to" do
-      buckets = s3.buckets
-      buckets.new.collection.should == buckets
-    end
-
-  end
-
-  describe "#destroy" do
-
-    it "should return true if the bucket is deleted" do
-      bucket = s3.buckets.create(:name => 'fogmodelbucket')
-      bucket.destroy.should be_true
-    end
-
-    it "should return false if the bucket does not exist" do
-      bucket = s3.buckets.new(:name => 'fogmodelbucket')
-      bucket.destroy.should be_false
-    end
-
-  end
-
-  describe "#location" do
-
-    it "should return the location constraint" do
-      bucket = s3.buckets.create(:name => 'fogmodeleubucket', :location => 'EU')
-      bucket.location.should == 'EU'
-      eu_s3.buckets.new(:name => 'fogmodeleubucket').destroy
-    end
-
-  end
-
-  describe "#objects" do
-
-    it "should return a Fog::AWS::S3::Objects" do
-      bucket = s3.buckets.new(:name => 'fogmodelbucket')
-      bucket.objects.should be_an(Fog::AWS::S3::Objects)
-    end
-
-  end
-
-  describe "#payer" do
-
-    it "should return the request payment value" do
-      bucket = s3.buckets.create(:name => 'fogmodelbucket')
-      bucket.payer.should == 'BucketOwner'
-      bucket.destroy.should be_true
-    end
-
-  end
-
-  describe "#payer=" do
-
-    it "should set the request payment value" do
-      bucket = s3.buckets.create(:name => 'fogmodelbucket')
-      (bucket.payer = 'Requester').should == 'Requester'
-      bucket.destroy.should
-    end
-
-  end
-
-  describe "#reload" do
-
-    before(:each) do
-      @bucket = s3.buckets.create(:name => 'fogmodelbucket')
-      @reloaded = @bucket.reload
-    end
-
-    after(:each) do
-      @bucket.destroy
-    end
-
-    it "should return a Fog::AWS::S3::Bucket" do
-      @reloaded.should be_a(Fog::AWS::S3::Bucket)
-    end
-
-    it "should reset attributes to remote state" do
-      @bucket.attributes.should == @reloaded.attributes
-    end
-
-  end
-
-  describe "#save" do
-
-    before(:each) do
-      @bucket = s3.buckets.new(:name => 'fogmodelbucket')
-    end
-
-    it "should return true when it succeeds" do
-      @bucket.save.should be_true
-      @bucket.destroy
-    end
-
-    it "should not exist in buckets before save" do
-      s3.buckets.all.map {|bucket| bucket.name}.include?(@bucket.name).should be_false
-    end
-
-    it "should exist in buckets after save" do
-      @bucket.save
-      s3.buckets.all.map {|bucket| bucket.name}.include?(@bucket.name).should be_true
-      @bucket.destroy
-    end
-
-  end
-
-end

data/spec/aws/models/s3/buckets_spec.rb

@@ -1,70 +0,0 @@
-require File.dirname(__FILE__) + '/../../../spec_helper'
-
-describe 'Fog::AWS::S3::Buckets' do
-
-  describe "#all" do
-
-    it "should return a Fog::AWS::S3::Buckets" do
-      s3.buckets.all.should be_a(Fog::AWS::S3::Buckets)
-    end
-
-    it "should include persisted buckets" do
-      bucket = s3.buckets.create(:name => 'fogbucketname')
-      s3.buckets.all.map {|bucket| bucket.name}.should include('fogbucketname')
-      bucket.destroy
-    end
-
-  end
-
-  describe "#create" do
-
-    before(:each) do
-      @bucket = s3.buckets.create(:name => 'fogbucketname')
-    end
-
-    after(:each) do
-      @bucket.destroy
-    end
-
-    it "should return a Fog::AWS::S3::Bucket" do
-      @bucket.should be_a(Fog::AWS::S3::Bucket)
-    end
-
-    it "should exist on s3" do
-      s3.buckets.get(@bucket.name).should_not be_nil
-    end
-
-  end
-
-  describe "#get" do
-
-    it "should return a Fog::AWS::S3::Bucket if a matching bucket exists" do
-      bucket = s3.buckets.create(:name => 'fogbucketname')
-      get = s3.buckets.get('fogbucketname')
-      bucket.attributes.should == get.attributes
-      bucket.destroy
-    end
-
-    it "should return nil if no matching bucket exists" do
-      s3.buckets.get('fogbucketname').should be_nil
-    end
-
-  end
-
-  describe "#new" do
-
-    it "should return a Fog::AWS::S3::Bucket" do
-      s3.buckets.new.should be_a(Fog::AWS::S3::Bucket)
-    end
-
-  end
-
-  describe "#reload" do
-
-    it "should return a Fog::AWS::S3::Buckets" do
-      s3.buckets.all.should be_a(Fog::AWS::S3::Buckets)
-    end
-
-  end
-
-end

data/spec/aws/models/s3/object_spec.rb

@@ -1,121 +0,0 @@
-require File.dirname(__FILE__) + '/../../../spec_helper'
-
-describe 'S3::Object' do
-
-  before(:each) do
-    @bucket = s3.buckets.create(:name => 'fogbucketname')
-  end
-
-  after(:each) do
-    @bucket.destroy
-  end
-
-  describe "#initialize" do
-
-    it "should remap attributes from parser" do
-      now = Time.now
-      bucket = Fog::AWS::S3::Object.new(
-        'Content-Length' => 10,
-        'Content-Type'   => 'contenttype',
-        'Etag'           => 'etag',
-        'Key'            => 'key',
-        'Last-Modified'  => now,
-        'Size'           => 10,
-        'StorageClass'   => 'storageclass'
-      )
-      bucket.content_length == 10
-      bucket.content_type.should == 'contenttype'
-      bucket.etag.should == 'etag'
-      bucket.key.should == 'key'
-      bucket.last_modified.should == now
-      bucket.size.should == 10
-      bucket.storage_class.should == 'storageclass'
-
-      bucket = Fog::AWS::S3::Object.new(
-        'ETag'          => 'etag',
-        'LastModified'  => now
-      )
-      bucket.etag.should == 'etag'
-      bucket.last_modified.should == now
-    end
-
-  end
-
-  describe "#bucket" do
-
-    before(:each) do
-      @object = @bucket.objects.new(:key => 'foo')
-    end
-    
-
-    it "should return an S3::Bucket" do
-      @object.bucket.should be_a(Fog::AWS::S3::Bucket)
-    end
-
-    it "should be the bucket the object is related to" do
-      @object.bucket.should == @bucket
-    end
-
-  end
-
-  describe "#copy" do
-
-    it "should return a Fog::AWS::S3::Object with matching attributes" do
-      other_bucket = s3.buckets.create(:name => 'fogotherbucketname')
-      file = File.open(File.dirname(__FILE__) + '/../../../lorem.txt', 'r')
-      object = @bucket.objects.create(:key => 'fogobjectname', :body => file)
-      other_object = object.copy('fogotherbucketname', 'fogotherobjectname')
-      object.reload.attributes.reject{|key,value| [:key, :last_modified].include?(key)}.should == other_object.reload.attributes.reject{|key,value| [:key, :last_modified].include?(key)}
-      other_object.destroy
-      object.destroy
-      other_bucket.destroy
-    end
-
-  end
-
-  describe "#destroy" do
-
-    it "should return true if the object is deleted" do
-      file = File.open(File.dirname(__FILE__) + '/../../../lorem.txt', 'r')
-      object = @bucket.objects.create(:key => 'fogobjectname', :body => file)
-      object.destroy.should be_true
-    end
-
-    it "should return true if the object does not exist" do
-      object = @bucket.objects.new(:key => 'fogobjectname')
-      object.destroy.should be_true
-    end
-
-  end
-
-  describe "#reload" do
-
-    it "should return a Fog::AWS::S3::Object" do
-      file = File.open(File.dirname(__FILE__) + '/../../../lorem.txt', 'r')
-      object = @bucket.objects.create(:key => 'fogobjectname', :body => file)
-      # object.reload.should be_a(Fog::AWS::S3::Object)
-      object.destroy
-    end
-
-    it "should reset attributes to remote state" do
-      file = File.open(File.dirname(__FILE__) + '/../../../lorem.txt', 'r')
-      object = @bucket.objects.create(:key => 'fogobjectname', :body => file)
-      object.last_modified = Time.now
-      # object.reload.attributes.should == object.attributes
-      object.destroy
-    end
-
-  end
-
-  describe "#save" do
-
-    it "should return the success value" do
-      file = File.open(File.dirname(__FILE__) + '/../../../lorem.txt', 'r')
-      object = @bucket.objects.new(:key => 'fogobjectname', :body => file)
-      object.save.should be_true
-      object.destroy
-    end
-
-  end
-
-end