akamai_api 0.2.0 → 0.3.0

data/spec/lib/akamai_api/ccu/purge/request_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe AkamaiApi::Ccu::Purge::Request do
+describe AkamaiApi::CCU::Purge::Request do
   it "includes httparty" do
     expect(subject.class.included_modules).to include HTTParty
   end
@@ -14,8 +14,8 @@ describe AkamaiApi::Ccu::Purge::Request do
   end
 
   describe "#action" do
-    it "is 'remove' by default" do
-      expect(subject.action).to eq 'remove'
+    it "is :remove by default" do
+      expect(subject.action).to eq :remove
     end
 
     it "can be changed" do
@@ -23,13 +23,13 @@ describe AkamaiApi::Ccu::Purge::Request do
     end
 
     it "raises an error if an invalid value is set" do
-      expect { subject.action = 'foobar' }.to raise_error AkamaiApi::Ccu::UnrecognizedOption
+      expect { subject.action = 'foobar' }.to raise_error AkamaiApi::CCU::UnrecognizedOption
     end
   end
 
   describe "#type" do
-    it "is 'arl' by default" do
-      expect(subject.type).to eq 'arl'
+    it "is :arl by default" do
+      expect(subject.type).to eq :arl
     end
 
     it "can be changed" do
@@ -37,13 +37,13 @@ describe AkamaiApi::Ccu::Purge::Request do
     end
 
     it "raises an error if an invalid value is set" do
-      expect { subject.type = 'foobar' }.to raise_error AkamaiApi::Ccu::UnrecognizedOption
+      expect { subject.type = 'foobar' }.to raise_error AkamaiApi::CCU::UnrecognizedOption
     end
   end
 
   describe "#domain" do
-    it "is 'production' by default" do
-      expect(subject.domain).to eq 'production'
+    it "is :production by default" do
+      expect(subject.domain).to eq :production
     end
 
     it "can be changed" do
@@ -51,12 +51,12 @@ describe AkamaiApi::Ccu::Purge::Request do
     end
 
     it "raises an error if an invalid value is set" do
-      expect { subject.domain = 'foobar' }.to raise_error AkamaiApi::Ccu::UnrecognizedOption
+      expect { subject.domain = 'foobar' }.to raise_error AkamaiApi::CCU::UnrecognizedOption
     end
   end
 
   describe "#execute" do
-    let(:fake_response) { double code: 201, parsed_response: {} }
+    let(:fake_response) { double code: 201, parsed_response: { 'httpStatus' => 201, 'submissionTime' => 1 } }
     let(:sample_arl) { 'http://www.foo.bar/t.txt' }
 
     it "executes a post on the base url" do
@@ -68,7 +68,7 @@ describe AkamaiApi::Ccu::Purge::Request do
     end
 
     it "sets the auth in the post" do
-      subject.stub auth: 'foo'
+      allow(AkamaiApi).to receive(:auth) { 'foo' }
       expect(subject.class).to receive :post do |path, args|
         expect(args[:basic_auth]).to eq 'foo'
         fake_response
@@ -78,25 +78,25 @@ describe AkamaiApi::Ccu::Purge::Request do
 
     it "accepts a single element" do
       expect(subject).to receive(:request_body).with([sample_arl])
-      subject.class.stub post: fake_response
+      allow(subject.class).to receive(:post) { fake_response }
       subject.execute sample_arl
     end
 
     it "accepts a collection with a single element" do
       expect(subject).to receive(:request_body).with([sample_arl])
-      subject.class.stub post: fake_response
+      allow(subject.class).to receive(:post) { fake_response }
       subject.execute sample_arl
     end
 
     it "accepts a collection" do
       expect(subject).to receive(:request_body).with(['a', 'b'])
-      subject.class.stub post: fake_response
+      allow(subject.class).to receive(:post) { fake_response }
       subject.execute ['a', 'b']
     end
 
     it "works with splatting" do
       expect(subject).to receive(:request_body).with(['a', 'b'])
-      subject.class.stub post: fake_response
+      allow(subject.class).to receive(:post) { fake_response }
       subject.execute 'a', 'b'
     end
 
@@ -111,14 +111,20 @@ describe AkamaiApi::Ccu::Purge::Request do
 
     it "raises an exception when the response code is 401" do
       fake_response = double code: 401
-      subject.class.stub post: fake_response
+      allow(subject.class).to receive(:post) { fake_response }
       expect { subject.execute sample_arl }.to raise_error AkamaiApi::Unauthorized
     end
 
     it "returns a response built with the resulted json" do
-      fake_response = double code: 201, parsed_response: { a: 'b' }
-      subject.class.stub post: fake_response
-      expect(subject.execute(sample_arl).raw).to eq a: 'b'
+      fake_response = double code: 201, parsed_response: { 'httpStatus' => 201 }
+      allow(subject.class).to receive(:post) { fake_response }
+      expect(subject.execute(sample_arl).raw).to eq 'httpStatus' => 201
+    end
+
+    it "raises an error when json code in response is not successful" do
+      fake_response = double code: 201, parsed_response: { 'httpStatus' => 403 }
+      allow(subject.class).to receive(:post) { fake_response }
+      expect { subject.execute sample_arl }.to raise_error AkamaiApi::CCU::Error
     end
   end
 end

data/spec/lib/akamai_api/ccu/purge/response_spec.rb

@@ -1,43 +1,33 @@
 require 'spec_helper'
 
-describe AkamaiApi::Ccu::Purge::Response do
+describe AkamaiApi::CCU::Purge::Response do
   let(:raw) do
     {
-      'describedBy' => 'foo',
-      'title' => 'bar',
-      'pingAfterSeconds' => 100,
-      'purgeId' => '120',
-      'supportId' => '130',
-      'detail' => 'baz',
-      'httpStatus' => 201,
-      'estimatedSeconds' => 90,
-      'progressUri' => 'http://asd.com'
+      "httpStatus" => 201,
+      "detail"     => "Request accepted.",
+      "estimatedSeconds" => 420,
+      "purgeId" => "95b5a092-043f-4af0-843f-aaf0043faaf0",
+      "progressUri" => "/ccu/v2/purges/95b5a092-043f-4af0-843f-aaf0043faaf0",
+      "pingAfterSeconds" => 420,
+      "supportId" => "17PY1321286429616716-211907680"
     }
   end
-  subject { AkamaiApi::Ccu::Purge::Response.new raw }
+  subject { AkamaiApi::CCU::Purge::Response.new raw }
 
-  it '#described_by returns the describedBy attribute' do
-    expect(subject.described_by).to eq 'foo'
-  end
-
-  it '#title returns the title attribute' do
-    expect(subject.title).to eq 'bar'
+  it '#detail returns the title attribute' do
+    expect(subject.detail).to eq 'Request accepted.'
   end
 
   it '#time_to_wait returns the pingAfterSeconds attribute' do
-    expect(subject.time_to_wait).to eq 100
+    expect(subject.time_to_wait).to eq 420
   end
 
   it '#purge_id returns the purgeId attribute' do
-    expect(subject.purge_id).to eq '120'
+    expect(subject.purge_id).to eq "95b5a092-043f-4af0-843f-aaf0043faaf0"
   end
 
   it '#support_id returns the supportId attribute' do
-    expect(subject.support_id).to eq '130'
-  end
-
-  it '#message returns the detail attribute' do
-    expect(subject.message).to eq 'baz'
+    expect(subject.support_id).to eq "17PY1321286429616716-211907680"
   end
 
   it '#code returns the httpStatus attribute' do
@@ -45,10 +35,10 @@ describe AkamaiApi::Ccu::Purge::Response do
   end
 
   it '#estimated_time returns the estimatedSeconds attribute' do
-    expect(subject.estimated_time).to eq 90
+    expect(subject.estimated_time).to eq 420
   end
 
   it '#uri returns the progressUri attribute' do
-    expect(subject.uri).to eq 'http://asd.com'
+    expect(subject.uri).to eq "/ccu/v2/purges/95b5a092-043f-4af0-843f-aaf0043faaf0"
   end
 end

data/spec/lib/akamai_api/ccu/purge_status/not_found_response_spec.rb

@@ -1,41 +1,41 @@
-require 'spec_helper'
+# require 'spec_helper'
 
-describe AkamaiApi::Ccu::PurgeStatus::NotFoundResponse do
-  let(:raw) do
-    {
-      'progressUri'              => '/ccu/v2/purges/12345678-1234-5678-1234-123456789012',
-      'purgeId'                  => '12345678-1234-5678-1234-123456789012',
-      'supportId'                => '12345678901234567890-123456789',
-      'httpStatus'               => 200,
-      'purgeStatus'              => 'Unknown',
-      'pingAfterSeconds'         => 60,
-      'detail'                   => 'foobarbaz'
-    }
-  end
-  subject { AkamaiApi::Ccu::PurgeStatus::NotFoundResponse.new raw }
+# describe AkamaiApi::CCU::PurgeStatus::NotFoundResponse do
+#   let(:raw) do
+#     {
+#       'progressUri'              => '/CCU/v2/purges/12345678-1234-5678-1234-123456789012',
+#       'purgeId'                  => '12345678-1234-5678-1234-123456789012',
+#       'supportId'                => '12345678901234567890-123456789',
+#       'httpStatus'               => 200,
+#       'purgeStatus'              => 'Unknown',
+#       'pingAfterSeconds'         => 60,
+#       'detail'                   => 'foobarbaz'
+#     }
+#   end
+#   subject { AkamaiApi::CCU::PurgeStatus::NotFoundResponse.new raw }
 
-  it '#progress_uri returns progressUri attribute' do
-    expect(subject.progress_uri).to eq '/ccu/v2/purges/12345678-1234-5678-1234-123456789012'
-  end
+#   it '#progress_uri returns progressUri attribute' do
+#     expect(subject.progress_uri).to eq '/CCU/v2/purges/12345678-1234-5678-1234-123456789012'
+#   end
 
-  it '#purge_id returns purgeId attribute' do
-    expect(subject.purge_id).to eq '12345678-1234-5678-1234-123456789012'
-  end
+#   it '#purge_id returns purgeId attribute' do
+#     expect(subject.purge_id).to eq '12345678-1234-5678-1234-123456789012'
+#   end
 
-  it '#support_id returns supportId attribute' do
-    expect(subject.support_id).to eq '12345678901234567890-123456789'
-  end
+#   it '#support_id returns supportId attribute' do
+#     expect(subject.support_id).to eq '12345678901234567890-123456789'
+#   end
 
-  it '#code returns httpStatus attribute' do
-    expect(subject.code).to eq 200
-  end
+#   it '#code returns httpStatus attribute' do
+#     expect(subject.code).to eq 200
+#   end
 
-  it '#status returns purgeStatus attribute' do
-    expect(subject.status).to eq 'Unknown'
-  end
+#   it '#status returns purgeStatus attribute' do
+#     expect(subject.status).to eq 'Unknown'
+#   end
 
-  it '#message returns detail attribute' do
-    raw['detail'] = 'asd'
-    expect(subject.message).to eq 'asd'
-  end
-end
+#   it '#message returns detail attribute' do
+#     raw['detail'] = 'asd'
+#     expect(subject.message).to eq 'asd'
+#   end
+# end

data/spec/lib/akamai_api/ccu/purge_status/request_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe AkamaiApi::Ccu::PurgeStatus::Request do
+describe AkamaiApi::CCU::PurgeStatus::Request do
   it "includes httparty" do
     expect(subject.class.included_modules).to include HTTParty
   end
@@ -10,10 +10,10 @@ describe AkamaiApi::Ccu::PurgeStatus::Request do
   end
 
   describe "#execute" do
-    let(:fake_response) { double code: 200, parsed_response: {} }
+    let(:fake_response) { double code: 200, parsed_response: { 'httpStatus' => 200, 'submissionTime' => 1 } }
 
     it "executes a GET request on the given progress_uri" do
-      expect(AkamaiApi::Ccu::PurgeStatus::Request).to receive :get do |uri, args|
+      expect(AkamaiApi::CCU::PurgeStatus::Request).to receive :get do |uri, args|
         expect(uri).to eq '/ccu/v2/purges/foo'
         fake_response
       end
@@ -21,8 +21,8 @@ describe AkamaiApi::Ccu::PurgeStatus::Request do
     end
 
     it "sets the auth in the request" do
-      AkamaiApi::Ccu.stub auth: 'foo'
-      expect(AkamaiApi::Ccu::PurgeStatus::Request).to receive :get do |uri, args|
+      allow(AkamaiApi).to receive(:auth) { 'foo' }
+      expect(AkamaiApi::CCU::PurgeStatus::Request).to receive :get do |uri, args|
         expect(args).to eq basic_auth: 'foo'
         fake_response
       end
@@ -30,20 +30,32 @@ describe AkamaiApi::Ccu::PurgeStatus::Request do
     end
 
     it "raises an exception when the response code is 401" do
-      fake_response.stub code: 401
-      expect(AkamaiApi::Ccu::PurgeStatus::Request).to receive(:get).and_return fake_response
+      allow(fake_response).to receive(:code) { 401 }
+      expect(AkamaiApi::CCU::PurgeStatus::Request).to receive(:get).and_return fake_response
       expect { subject.execute '/ccu/v2/purges/foo' }.to raise_error AkamaiApi::Unauthorized
     end
 
     it "returns a response built with the received json" do
-      fake_response.stub parsed_response: {a: 'b'}
-      expect(AkamaiApi::Ccu::PurgeStatus::Request).to receive(:get).and_return fake_response
-      expect(subject.execute '/ccu/v2/purges/foo' ).to be_a AkamaiApi::Ccu::PurgeStatus::Response
+      allow(fake_response).to receive(:parsed_response) { { 'httpStatus' => 201, 'submissionTime' => 1 } }
+      expect(AkamaiApi::CCU::PurgeStatus::Request).to receive(:get).and_return fake_response
+      expect(subject.execute '/ccu/v2/purges/foo' ).to be_a AkamaiApi::CCU::PurgeStatus::Response
+    end
+
+    it "raises an error if json code in response is not valid" do
+      allow(fake_response).to receive(:parsed_response) { { 'httpStatus' => 400, 'submissionTime' => 1 } }
+      expect(AkamaiApi::CCU::PurgeStatus::Request).to receive(:get).and_return fake_response
+      expect { subject.execute '/ccu/v2/purges/foo' }.to raise_error AkamaiApi::CCU::Error
+    end
+
+    it "raises an error when json code in response has no submissionTime" do
+      fake_response = double code: 201, parsed_response: { 'httpStatus' => 201 }
+      expect(AkamaiApi::CCU::PurgeStatus::Request).to receive(:get).and_return fake_response
+      expect { subject.execute '/ccu/v2/purges/foo' }.to raise_error AkamaiApi::CCU::PurgeStatus::NotFound
     end
 
     context "when the given progressUri is the purgeId" do
       it "the progressUri prefix is appended" do
-        expect(AkamaiApi::Ccu::PurgeStatus::Request).to receive :get do |uri, args|
+        expect(AkamaiApi::CCU::PurgeStatus::Request).to receive :get do |uri, args|
           expect(uri).to eq '/ccu/v2/purges/foo'
           fake_response
         end
@@ -53,7 +65,7 @@ describe AkamaiApi::Ccu::PurgeStatus::Request do
 
     context "when the given progressUri isn't prefixed by a slash" do
       it "a slash is prefixed" do
-        expect(AkamaiApi::Ccu::PurgeStatus::Request).to receive :get do |uri, args|
+        expect(AkamaiApi::CCU::PurgeStatus::Request).to receive :get do |uri, args|
           expect(uri).to eq '/ccu/v2/purges/foo'
           fake_response
         end

data/spec/lib/akamai_api/ccu/purge_status/{successful_response_spec.rb → response_spec.rb}

@@ -1,10 +1,10 @@
 require 'spec_helper'
 
-describe AkamaiApi::Ccu::PurgeStatus::SuccessfulResponse do
+describe AkamaiApi::CCU::PurgeStatus::Response do
   let(:raw) do
     {
       'originalEstimatedSeconds' => 480,
-      'progressUri'              => '/ccu/v2/purges/12345678-1234-5678-1234-123456789012',
+      'progressUri'              => '/CCU/v2/purges/12345678-1234-5678-1234-123456789012',
       'originalQueueLength'      => 6,
       'purgeId'                  => '12345678-1234-5678-1234-123456789012',
       'supportId'                => '12345678901234567890-123456789',
@@ -16,18 +16,18 @@ describe AkamaiApi::Ccu::PurgeStatus::SuccessfulResponse do
       'pingAfterSeconds'         => 60
     }
   end
-  subject { AkamaiApi::Ccu::PurgeStatus::SuccessfulResponse.new raw }
+  subject { AkamaiApi::CCU::PurgeStatus::Response.new raw }
 
-  it '#estimated_time returns estimatedSeconds attribute' do
-    expect(subject.estimated_time).to eq 480
+  it '#original_estimated_time returns originalEstimatedSeconds attribute' do
+    expect(subject.original_estimated_time).to eq 480
   end
 
   it '#progress_uri returns progressUri attribute' do
-    expect(subject.progress_uri).to eq '/ccu/v2/purges/12345678-1234-5678-1234-123456789012'
+    expect(subject.progress_uri).to eq '/CCU/v2/purges/12345678-1234-5678-1234-123456789012'
   end
 
-  it '#queue_length returns originalQueueLength attribute' do
-    expect(subject.queue_length).to eq 6
+  it '#original_queue_length returns originalQueueLength attribute' do
+    expect(subject.original_queue_length).to eq 6
   end
 
   it '#purge_id returns purgeId attribute' do

data/spec/lib/akamai_api/ccu/status/request_spec.rb

@@ -1,22 +1,22 @@
 require 'spec_helper'
 
-describe AkamaiApi::Ccu::Status::Request do
+describe AkamaiApi::CCU::Status::Request do
   it 'executes a get upon base url passing the basic auth' do
     fake_response = double code: 200, parsed_response: {}
-    AkamaiApi::Ccu.stub auth: 'foo'
-    expect(AkamaiApi::Ccu::Status::Request).to receive(:get).with('/', basic_auth: 'foo').and_return fake_response
+    allow(AkamaiApi).to receive(:auth) { 'foo' }
+    expect(AkamaiApi::CCU::Status::Request).to receive(:get).with('/', basic_auth: 'foo').and_return fake_response
     subject.execute
   end
 
   it 'raises an unauthorized error if code is 401' do
     fake_response = double code: 401, parsed_response: {}
-    expect(AkamaiApi::Ccu::Status::Request).to receive(:get).and_return fake_response
+    expect(AkamaiApi::CCU::Status::Request).to receive(:get).and_return fake_response
     expect { subject.execute }.to raise_error AkamaiApi::Unauthorized
   end
 
   it 'returns a StatusResponse' do
     fake_response = double code: 200, parsed_response: {}
-    expect(AkamaiApi::Ccu::Status::Request).to receive(:get).and_return fake_response
-    expect(subject.execute).to be_a AkamaiApi::Ccu::Status::Response
+    expect(AkamaiApi::CCU::Status::Request).to receive(:get).and_return fake_response
+    expect(subject.execute).to be_a AkamaiApi::CCU::Status::Response
   end
 end

data/spec/lib/akamai_api/ccu/status/response_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe AkamaiApi::Ccu::Status::Response do
+describe AkamaiApi::CCU::Status::Response do
   let(:raw) do
     {
       'httpStatus' => 201,
@@ -9,7 +9,7 @@ describe AkamaiApi::Ccu::Status::Response do
       'supportId' => '21'
     }
   end
-  subject { AkamaiApi::Ccu::Status::Response.new raw }
+  subject { AkamaiApi::CCU::Status::Response.new raw }
 
   it '#code returns the httpStatus property' do
     expect(subject.code).to eq 201

data/spec/lib/akamai_api/ccu_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
-describe AkamaiApi::Ccu do
-  subject { AkamaiApi::Ccu }
+describe AkamaiApi::CCU do
+  subject { AkamaiApi::CCU }
 
   %w(invalidate remove).each do |action|
     describe "##{action}" do
@@ -35,18 +35,18 @@ describe AkamaiApi::Ccu do
     it 'delegates to Purge::Request' do
       fake_request = double
       expect(fake_request).to receive(:execute).with('baz').and_return 'quiz'
-      expect(AkamaiApi::Ccu::Purge::Request).to receive(:new).with('foo', 'bar', domain: 'asd').
+      expect(AkamaiApi::CCU::Purge::Request).to receive(:new).with('foo', 'bar', domain: 'asd').
                                                and_return fake_request
       expect(subject.purge 'foo', 'bar', 'baz', domain: 'asd').to eq 'quiz'
     end
 
     describe 'raises an error when' do
       it 'action is not allowed' do
-        expect { subject.purge :sss, :cpcode, '12345' }.to raise_error AkamaiApi::Ccu::UnrecognizedOption
+        expect { subject.purge :sss, :cpcode, '12345' }.to raise_error AkamaiApi::CCU::UnrecognizedOption
       end
 
       it 'type is not allowed' do
-        expect { subject.purge :remove, :foo, '12345' }.to raise_error AkamaiApi::Ccu::UnrecognizedOption
+        expect { subject.purge :remove, :foo, '12345' }.to raise_error AkamaiApi::CCU::UnrecognizedOption
       end
 
       it 'domain is specified and not allowed' do
@@ -58,7 +58,7 @@ describe AkamaiApi::Ccu do
   describe '#status' do
     context "when no argument is given" do
       it "delegates to Status request instance" do
-        expect(AkamaiApi::Ccu::Status::Request).to receive(:new).and_return double execute: 'foo'
+        expect(AkamaiApi::CCU::Status::Request).to receive(:new).and_return double execute: 'foo'
         expect(subject.status).to eq 'foo'
       end
     end
@@ -66,7 +66,7 @@ describe AkamaiApi::Ccu do
     context "when a progress uri is passed as argument" do
       it "delegates to PurgeStatus request instance" do
         fake_instance = double
-        expect(AkamaiApi::Ccu::PurgeStatus::Request).to receive(:new).and_return fake_instance
+        expect(AkamaiApi::CCU::PurgeStatus::Request).to receive(:new).and_return fake_instance
         expect(fake_instance).to receive(:execute).with('foo').and_return 'asd'
         expect(subject.status 'foo').to eq 'asd'
       end

data/spec/lib/akamai_api/cli/ccu/status_renderer_spec.rb

@@ -1,8 +1,8 @@
 require 'spec_helper'
 
 module AkamaiApi
-  describe Cli::Ccu::StatusRenderer do
-    subject { Cli::Ccu::StatusRenderer.new Ccu::Status::Response.new({}) }
+  describe CLI::CCU::StatusRenderer do
+    subject { CLI::CCU::StatusRenderer.new CCU::Status::Response.new({}) }
 
     describe '#render' do
       it 'returns a string' do
@@ -10,27 +10,15 @@ module AkamaiApi
       end
 
       it 'delegates to #render_status if response is a Status::Response' do
-        expect(subject).to receive(:render_status)
+        expect(subject).to receive(:queue_status)
         subject.render
       end
 
       it 'delegates to #render_purge_status if response is a PurgeStatus::Response' do
-        subject = Cli::Ccu::StatusRenderer.new Ccu::PurgeStatus::SuccessfulResponse.new({})
-        expect(subject).to receive(:render_purge_status)
+        subject = CLI::CCU::StatusRenderer.new CCU::PurgeStatus::Response.new({})
+        expect(subject).to receive(:purge_status)
         subject.render
       end
     end
-
-    it '#render_purge_status delegates to #render_successful_purge_status for success response' do
-      subject = Cli::Ccu::StatusRenderer.new Ccu::PurgeStatus::SuccessfulResponse.new({})
-      expect(subject).to receive :render_successful_purge_status
-      subject.render_purge_status
-    end
-
-    it '#render_purge_status delegates to #render_not_found_purge_status for not foundresponse' do
-      subject = Cli::Ccu::StatusRenderer.new Ccu::PurgeStatus::NotFoundResponse.new({})
-      expect(subject).to receive :render_not_found_purge_status
-      subject.render_purge_status
-    end
   end
 end

data/spec/lib/akamai_api/eccu/destroy_request_spec.rb

@@ -0,0 +1,75 @@
+require 'spec_helper'
+
+describe AkamaiApi::ECCU::DestroyRequest do
+  subject { AkamaiApi::ECCU::DestroyRequest.new '1234' }
+
+  describe "#execute" do
+    let(:fake_client) { double call: nil }
+
+    before do
+      allow(AkamaiApi::ECCU).to receive(:client) { fake_client }
+    end
+
+    it "calls 'delete' via savon with a message" do
+      fake_response = double body: { delete_response: { success: true } }
+      expect(subject).to receive(:request_body).and_return double(to_s: 'asd')
+      expect(fake_client).to receive(:call).with(:delete, message: 'asd').and_return fake_response
+      subject.execute
+    end
+
+    it "returns 'true' if response hash reports to be successful" do
+      allow(subject).to receive(:request_body) { 'example' }
+      allow(fake_client).to receive(:call) { double(body: { delete_response: { success: true } }) }
+      expect(subject.execute).to be_truthy
+    end
+
+    it "returns 'false' if response hash reports to be unsuccessful" do
+      allow(subject).to receive(:request_body) { 'example' }
+      allow(fake_client).to receive(:call) { double(body: { delete_response: { success: false } }) }
+      expect(subject.execute).to be_falsy
+    end
+
+    it "raises NotFound if request raises a Savon::SOAPFault with particular message" do
+      expect(fake_client).to receive :call do
+        exc = Savon::SOAPFault.new({}, {})
+        allow(exc).to receive(:to_hash) { { fault: { faultstring: 'asdasd fileId xsxx does not exist' } } }
+        allow(exc).to receive(:to_s) { '' }
+        raise exc
+      end
+      expect { subject.execute }.to raise_error AkamaiApi::ECCU::NotFound
+    end
+
+    it "raises unauthorized if request raises a Savon::HTTPError with code 401" do
+      expect(fake_client).to receive :call do
+        raise Savon::HTTPError, double(code: 401)
+      end
+      expect { subject.execute }.to raise_error AkamaiApi::Unauthorized
+    end
+
+    it "raises Savon:HTTPError if request raises this exception and its code differs from 401" do
+      expect(fake_client).to receive :call do
+        raise Savon::HTTPError, double(code: 402)
+      end
+      expect { subject.execute }.to raise_error Savon::HTTPError
+    end
+  end
+
+  describe "#request_body" do
+    def subject_request_body
+      subject.send :request_body
+    end
+
+    it "returns a SoapBody object" do
+      expect(subject_request_body).to be_a AkamaiApi::ECCU::SoapBody
+    end
+
+    it "sets an integer value named 'fileId' with the given code" do
+      expect_any_instance_of(AkamaiApi::ECCU::SoapBody).to receive(:integer).with :fileId, 1234
+      subject_request_body
+    end
+
+    it "sets only fileId" do
+      expect(subject_request_body.to_s).to eq "<fileId xsi:type=\"xsd:int\">1234</fileId>"
+    end
+  end
+end