fog 0.0.40 → 0.0.41

data/spec/aws/requests/s3/get_bucket_location_spec.rb

@@ -4,15 +4,15 @@ describe 'S3.get_bucket_location' do
   describe 'success' do
 
     before(:each) do
-      s3.put_bucket('foggetlocation', 'LocationConstraint' => 'EU')
+      AWS[:s3].put_bucket('foggetlocation', 'LocationConstraint' => 'EU')
     end
 
     after(:each) do
-      eu_s3.delete_bucket('foggetlocation')
+      AWS[:eu_s3].delete_bucket('foggetlocation')
     end
 
     it 'should return proper attributes' do
-      actual = s3.get_bucket_location('foggetlocation')
+      actual = AWS[:s3].get_bucket_location('foggetlocation')
       actual.status.should == 200
       actual.body['LocationConstraint'].should == 'EU'
     end
@@ -22,7 +22,7 @@ describe 'S3.get_bucket_location' do
 
     it 'should raise NotFound error if bucket does not exist' do
       lambda {
-        s3.get_bucket_location('fognotabucket')
+        AWS[:s3].get_bucket_location('fognotabucket')
       }.should raise_error(Excon::Errors::NotFound)
     end
 

data/spec/aws/requests/s3/get_bucket_spec.rb

@@ -4,19 +4,19 @@ describe 'S3.get_bucket' do
   describe 'success' do
 
     before(:each) do
-      s3.put_bucket('foggetbucket')
-      s3.put_object('foggetbucket', 'fog_object', lorem_file)
-      s3.put_object('foggetbucket', 'fog_other_object', lorem_file)
+      AWS[:s3].put_bucket('foggetbucket')
+      AWS[:s3].put_object('foggetbucket', 'fog_object', lorem_file)
+      AWS[:s3].put_object('foggetbucket', 'fog_other_object', lorem_file)
     end
 
     after(:each) do
-      s3.delete_object('foggetbucket', 'fog_object')
-      s3.delete_object('foggetbucket', 'fog_other_object')
-      s3.delete_bucket('foggetbucket')
+      AWS[:s3].delete_object('foggetbucket', 'fog_object')
+      AWS[:s3].delete_object('foggetbucket', 'fog_other_object')
+      AWS[:s3].delete_bucket('foggetbucket')
     end
 
     it 'should return proper attributes' do
-      actual = s3.get_bucket('foggetbucket')
+      actual = AWS[:s3].get_bucket('foggetbucket')
       actual.body['IsTruncated'].should == false
       actual.body['Marker'].should be_a(String)
       actual.body['MaxKeys'].should be_an(Integer)
@@ -36,7 +36,7 @@ describe 'S3.get_bucket' do
     end
 
     it 'should accept marker option' do
-      actual = s3.get_bucket('foggetbucket', 'marker' => 'fog_object')
+      actual = AWS[:s3].get_bucket('foggetbucket', 'marker' => 'fog_object')
       actual.body['IsTruncated'].should == false
       actual.body['Marker'].should be_a(String)
       actual.body['MaxKeys'].should be_an(Integer)
@@ -56,7 +56,7 @@ describe 'S3.get_bucket' do
     end
 
     it 'should respect max-keys option' do
-      actual = s3.get_bucket('foggetbucket', 'max-keys' => 1)
+      actual = AWS[:s3].get_bucket('foggetbucket', 'max-keys' => 1)
       actual.body['IsTruncated'].should == true
       actual.body['Marker'].should be_a(String)
       actual.body['MaxKeys'].should be_an(Integer)
@@ -76,7 +76,7 @@ describe 'S3.get_bucket' do
     end
 
     it 'should accept prefix option' do
-      actual = s3.get_bucket('foggetbucket', 'prefix' => 'fog_ob')
+      actual = AWS[:s3].get_bucket('foggetbucket', 'prefix' => 'fog_ob')
       actual.body['IsTruncated'].should == false
       actual.body['Marker'].should be_a(String)
       actual.body['MaxKeys'].should be_an(Integer)
@@ -100,13 +100,13 @@ describe 'S3.get_bucket' do
 
     it 'should raise a NotFound error if the bucket does not exist' do
       lambda {
-        s3.get_bucket('fognotabucket')
+        AWS[:s3].get_bucket('fognotabucket')
       }.should raise_error(Excon::Errors::NotFound)
     end
 
     it 'should request non-subdomain buckets and raise a NotFound error' do
       lambda {
-        s3.get_bucket('A-invalid--name')
+        AWS[:s3].get_bucket('A-invalid--name')
       }.should raise_error(Excon::Errors::NotFound)
     end
 

data/spec/aws/requests/s3/get_object_spec.rb

@@ -4,17 +4,17 @@ describe 'S3.get_object' do
   describe 'success' do
 
     before(:each) do
-      s3.put_bucket('foggetobject')
-      s3.put_object('foggetobject', 'fog_get_object', lorem_file)
+      AWS[:s3].put_bucket('foggetobject')
+      AWS[:s3].put_object('foggetobject', 'fog_get_object', lorem_file)
     end
 
     after(:each) do
-      s3.delete_object('foggetobject', 'fog_get_object')
-      s3.delete_bucket('foggetobject')
+      AWS[:s3].delete_object('foggetobject', 'fog_get_object')
+      AWS[:s3].delete_bucket('foggetobject')
     end
 
     it 'should return proper attributes' do
-      actual = s3.get_object('foggetobject', 'fog_get_object')
+      actual = AWS[:s3].get_object('foggetobject', 'fog_get_object')
       actual.status.should == 200
       data = lorem_file.read
       actual.body.should == data
@@ -26,14 +26,14 @@ describe 'S3.get_object' do
 
     it 'should return chunks with optional block' do
       data = ''
-      s3.get_object('foggetobject', 'fog_get_object') do |chunk|
+      AWS[:s3].get_object('foggetobject', 'fog_get_object') do |chunk|
         data << chunk
       end
       data.should == lorem_file.read
     end
 
     it 'should return a signed expiring url' do
-      url = s3.get_object_url('foggetobject', 'fog_get_object', Time.now + 60 * 10)
+      url = AWS[:s3].get_object_url('foggetobject', 'fog_get_object', Time.now + 60 * 10)
       unless Fog.mocking?
         open(url).read.should == lorem_file.read
       end
@@ -44,13 +44,13 @@ describe 'S3.get_object' do
 
     it 'should raise a NotFound error if the bucket does not exist' do
       lambda {
-        s3.get_object('fognotabucket', 'fog_get_object')
+        AWS[:s3].get_object('fognotabucket', 'fog_get_object')
       }.should raise_error(Excon::Errors::NotFound)
     end
 
     it 'should raise a NotFound error if the object does not exist' do
       lambda {
-        s3.get_object('foggetobject', 'fog_not_an_object')
+        AWS[:s3].get_object('foggetobject', 'fog_not_an_object')
       }.should raise_error(Excon::Errors::NotFound)
     end
 

data/spec/aws/requests/s3/get_request_payment_spec.rb

@@ -4,15 +4,15 @@ describe 'S3.get_request_payment' do
   describe 'success' do
 
     before(:each) do
-      s3.put_bucket('foggetrequestpayment')
+      AWS[:s3].put_bucket('foggetrequestpayment')
     end
 
     after(:each) do
-      s3.delete_bucket('foggetrequestpayment')
+      AWS[:s3].delete_bucket('foggetrequestpayment')
     end
 
     it 'should return proper attributes' do
-      actual = s3.get_request_payment('foggetrequestpayment')
+      actual = AWS[:s3].get_request_payment('foggetrequestpayment')
       actual.status.should == 200
       actual.body['Payer'].should == 'BucketOwner'
     end
@@ -22,7 +22,7 @@ describe 'S3.get_request_payment' do
 
     it 'should raise a NotFound error if the bucket does not exist' do
       lambda {
-        s3.get_request_payment('fognotabucket')
+        AWS[:s3].get_request_payment('fognotabucket')
       }.should raise_error(Excon::Errors::NotFound)
     end
 

data/spec/aws/requests/s3/get_service_spec.rb

@@ -4,15 +4,15 @@ describe 'S3.get_service' do
   describe 'success' do
 
     before(:each) do
-      s3.put_bucket('foggetservice')
+      AWS[:s3].put_bucket('foggetservice')
     end
 
     after(:each) do
-      s3.delete_bucket('foggetservice')
+      AWS[:s3].delete_bucket('foggetservice')
     end
 
     it 'should return proper_attributes' do
-      actual = s3.get_service
+      actual = AWS[:s3].get_service
       actual.body['Buckets'].should be_an(Array)
       bucket = actual.body['Buckets'].select {|bucket| bucket['Name'] == 'foggetservice'}.first
       bucket['CreationDate'].should be_a(Time)
@@ -24,7 +24,7 @@ describe 'S3.get_service' do
 
     it 'should include foggetservice in get_service' do
       eventually do
-        actual = s3.get_service
+        actual = AWS[:s3].get_service
         actual.body['Buckets'].collect { |bucket| bucket['Name'] }.should include('foggetservice')
       end
     end

data/spec/aws/requests/s3/head_object_spec.rb

@@ -4,17 +4,17 @@ describe 'S3.head_object' do
   describe 'success' do
 
     before(:each) do
-      s3.put_bucket('fogheadobject')
-      s3.put_object('fogheadobject', 'fog_head_object', lorem_file)
+      AWS[:s3].put_bucket('fogheadobject')
+      AWS[:s3].put_object('fogheadobject', 'fog_head_object', lorem_file)
     end
 
     after(:each) do
-      s3.delete_object('fogheadobject', 'fog_head_object')
-      s3.delete_bucket('fogheadobject')
+      AWS[:s3].delete_object('fogheadobject', 'fog_head_object')
+      AWS[:s3].delete_bucket('fogheadobject')
     end
 
     it 'should return proper attributes' do
-      actual = s3.head_object('fogheadobject', 'fog_head_object')
+      actual = AWS[:s3].head_object('fogheadobject', 'fog_head_object')
       actual.status.should == 200
       data = lorem_file.read
       actual.headers['Content-Length'].should == data.length.to_s

data/spec/aws/requests/s3/put_bucket_spec.rb

@@ -4,15 +4,15 @@ describe 'S3.put_bucket' do
   describe 'success' do
 
     before(:each) do
-      @response = s3.put_bucket('fogputbucket')
+      @response = AWS[:s3].put_bucket('fogputbucket')
     end
 
     after(:each) do
-      s3.delete_bucket('fogputbucket')
+      AWS[:s3].delete_bucket('fogputbucket')
     end
 
     it 'should not raise an error if the bucket already exists' do
-      s3.put_bucket('fogputbucket')
+      AWS[:s3].put_bucket('fogputbucket')
     end
 
   end

data/spec/aws/requests/s3/put_object_spec.rb

@@ -4,13 +4,13 @@ describe 'S3.put_object' do
   describe 'success' do
 
     before(:each) do
-      s3.put_bucket('fogputobject')
-      @response = s3.put_object('fogputobject', 'fog_put_object', lorem_file)
+      AWS[:s3].put_bucket('fogputobject')
+      @response = AWS[:s3].put_object('fogputobject', 'fog_put_object', lorem_file)
     end
 
     after(:each) do
-      s3.delete_object('fogputobject', 'fog_put_object')
-      s3.delete_bucket('fogputobject')
+      AWS[:s3].delete_object('fogputobject', 'fog_put_object')
+      AWS[:s3].delete_bucket('fogputobject')
     end
 
     it 'should return proper attributes' do
@@ -18,7 +18,7 @@ describe 'S3.put_object' do
     end
 
     it 'should not raise an error if the object already exists' do
-      actual = s3.put_object('fogputobject', 'fog_put_object', lorem_file)
+      actual = AWS[:s3].put_object('fogputobject', 'fog_put_object', lorem_file)
       actual.status.should == 200
     end
 
@@ -27,16 +27,16 @@ describe 'S3.put_object' do
 
     it 'should raise a NotFound error if the bucket does not exist' do
       lambda {
-        s3.put_object('fognotabucket', 'fog_put_object', lorem_file)
+        AWS[:s3].put_object('fognotabucket', 'fog_put_object', lorem_file)
       }.should raise_error(Excon::Errors::NotFound)
     end
 
     it 'should not raise an error if the object already exists' do
-      s3.put_bucket('fogputobject')
-      s3.put_object('fogputobject', 'fog_put_object', lorem_file)
-      s3.put_object('fogputobject', 'fog_put_object', lorem_file)
-      s3.delete_object('fogputobject', 'fog_put_object')
-      s3.delete_bucket('fogputobject')
+      AWS[:s3].put_bucket('fogputobject')
+      AWS[:s3].put_object('fogputobject', 'fog_put_object', lorem_file)
+      AWS[:s3].put_object('fogputobject', 'fog_put_object', lorem_file)
+      AWS[:s3].delete_object('fogputobject', 'fog_put_object')
+      AWS[:s3].delete_bucket('fogputobject')
     end
 
   end

data/spec/aws/requests/s3/put_request_payment_spec.rb

@@ -4,15 +4,15 @@ describe 'S3.put_request_payment' do
   describe 'success' do
 
     before(:each) do
-      s3.put_bucket('fogputrequestpayment')
+      AWS[:s3].put_bucket('fogputrequestpayment')
     end
 
     after(:each) do
-      s3.delete_bucket('fogputrequestpayment')
+      AWS[:s3].delete_bucket('fogputrequestpayment')
     end
 
     it 'should return proper attributes' do
-      actual = s3.put_request_payment('fogputrequestpayment', 'Requester')
+      actual = AWS[:s3].put_request_payment('fogputrequestpayment', 'Requester')
       actual.status.should == 200
     end
 
@@ -21,7 +21,7 @@ describe 'S3.put_request_payment' do
 
     it 'should raise a NotFound error if bucket does not exist' do
       lambda {
-        s3.put_request_payment('fognotabucket', 'Requester')
+        AWS[:s3].put_request_payment('fognotabucket', 'Requester')
       }.should raise_error(Excon::Errors::NotFound)
     end
 

data/spec/aws/requests/simpledb/batch_put_attributes_spec.rb

@@ -5,15 +5,15 @@ describe 'SimpleDB.batch_put_attributes' do
 
     before(:all) do
       @domain_name = "fog_domain_#{Time.now.to_i}"
-      sdb.create_domain(@domain_name)
+      AWS[:sdb].create_domain(@domain_name)
     end
 
     after(:all) do
-      sdb.delete_domain(@domain_name)
+      AWS[:sdb].delete_domain(@domain_name)
     end
 
     it 'should return proper attributes' do
-      actual = sdb.batch_put_attributes(@domain_name, { 'a' => { 'b' => 'c' }, 'x' => { 'y' => 'z' } })
+      actual = AWS[:sdb].batch_put_attributes(@domain_name, { 'a' => { 'b' => 'c' }, 'x' => { 'y' => 'z' } })
       actual.body['RequestId'].should be_a(String)
       actual.body['BoxUsage'].should be_a(Float)
     end
@@ -23,7 +23,7 @@ describe 'SimpleDB.batch_put_attributes' do
 
     it 'should raise a BadRequest error if the domain does not exist' do
       lambda {
-        sdb.batch_put_attributes('notadomain', { 'a' => { 'b' => 'c' }, 'x' => { 'y' => 'z' } })
+        AWS[:sdb].batch_put_attributes('notadomain', { 'a' => { 'b' => 'c' }, 'x' => { 'y' => 'z' } })
       }.should raise_error(Excon::Errors::BadRequest)
     end
 

data/spec/aws/requests/simpledb/create_domain_spec.rb

@@ -6,13 +6,13 @@ describe 'SimpleDB.create_domain' do
   end
 
   after(:each) do
-    sdb.delete_domain(@domain_name)
+    AWS[:sdb].delete_domain(@domain_name)
   end
 
   describe 'success' do
 
     it 'should return proper attributes' do
-      actual = sdb.create_domain(@domain_name)
+      actual = AWS[:sdb].create_domain(@domain_name)
       actual.body['RequestId'].should be_a(String)
       actual.body['BoxUsage'].should be_a(Float)
     end
@@ -21,8 +21,8 @@ describe 'SimpleDB.create_domain' do
   describe 'failure' do
 
     it 'should not raise an error if the domain already exists' do
-      sdb.create_domain(@domain_name)
-      sdb.create_domain(@domain_name)
+      AWS[:sdb].create_domain(@domain_name)
+      AWS[:sdb].create_domain(@domain_name)
     end
 
   end

data/spec/aws/requests/simpledb/delete_attributes_spec.rb

@@ -5,16 +5,16 @@ describe 'SimpleDB.delete_attributes' do
 
     before(:each) do
       @domain_name = "fog_domain_#{Time.now.to_i}"
-      sdb.create_domain(@domain_name)
-      sdb.put_attributes(@domain_name, 'foo', { :bar => :baz })
+      AWS[:sdb].create_domain(@domain_name)
+      AWS[:sdb].put_attributes(@domain_name, 'foo', { :bar => :baz })
     end
 
     after(:each) do
-      sdb.delete_domain(@domain_name)
+      AWS[:sdb].delete_domain(@domain_name)
     end
 
     it 'should return proper attributes from delete_attributes' do
-      actual = sdb.delete_attributes(@domain_name, 'foo')
+      actual = AWS[:sdb].delete_attributes(@domain_name, 'foo')
       actual.body['RequestId'].should be_a(String)
       actual.body['BoxUsage'].should be_a(Float)
     end
@@ -24,15 +24,15 @@ describe 'SimpleDB.delete_attributes' do
 
     it 'shouild raise a BadRequest error if the domain does not exist' do
       lambda {
-        sdb.delete_attributes('notadomain', 'notanattribute')
+        AWS[:sdb].delete_attributes('notadomain', 'notanattribute')
       }.should raise_error(Excon::Errors::BadRequest)
     end
 
     it 'should not raise an error if the attribute does not exist' do
       @domain_name = "fog_domain_#{Time.now.to_i}"
-      sdb.create_domain(@domain_name)
-      sdb.delete_attributes(@domain_name, 'notanattribute')
-      sdb.delete_domain(@domain_name)
+      AWS[:sdb].create_domain(@domain_name)
+      AWS[:sdb].delete_attributes(@domain_name, 'notanattribute')
+      AWS[:sdb].delete_domain(@domain_name)
     end
 
   end

data/spec/aws/requests/simpledb/delete_domain_spec.rb

@@ -8,11 +8,11 @@ describe 'SimpleDB.delete_domain' do
     end
 
     before(:each) do
-      sdb.create_domain(@domain_name)
+      AWS[:sdb].create_domain(@domain_name)
     end
 
     it 'should return proper attributes' do
-      actual = sdb.delete_domain(@domain_name)
+      actual = AWS[:sdb].delete_domain(@domain_name)
       actual.body['RequestId'].should be_a(String)
       actual.body['BoxUsage'].should be_a(Float)
     end
@@ -21,7 +21,7 @@ describe 'SimpleDB.delete_domain' do
   describe 'failure' do
 
     it 'should not raise an error if the domain does not exist' do
-      sdb.delete_domain('notadomain')
+      AWS[:sdb].delete_domain('notadomain')
     end
 
   end