akamai_api 0.2.0 → 0.3.0

data/lib/akamai_api/eccu_request.rb

@@ -1,6 +1,18 @@
+require "savon"
+require "active_support"
+require "active_support/core_ext/array"
+require "active_support/core_ext/object/blank"
+
+require "akamai_api/eccu/soap_body"
+require "akamai_api/eccu/update_attribute_request"
+require "akamai_api/eccu/destroy_request"
+require "akamai_api/eccu/find_request"
+require "akamai_api/eccu/publish_request"
+require "akamai_api/eccu/list_request"
+
 module AkamaiApi
-  class EccuRequest
-    attr_accessor :file, :status, :code, :notes, :property, :email, :upload_date, :uploaded_by, :version_string
+  class ECCURequest
+    attr_accessor :file, :status, :code, :notes, :property, :email, :upload_date, :uploaded_by, :version
 
     def initialize attributes = {}
       attributes.each do |key, value|
@@ -8,57 +20,28 @@ module AkamaiApi
       end
     end
 
-    def update_notes! notes
-      code = self.code.to_i
-      body = SoapBody.new do
-        integer :fileId, code
-        string  :notes,  notes
-      end
-      resp = client.call :set_notes, :message => body.to_s
-      self.notes = notes
-      resp.body[:set_notes_response][:success]
-    rescue Savon::HTTPError => e
-      raise ::AkamaiApi::Unauthorized if e.http.code == 401
-      raise
-    end
-
-    def update_email! email
-      code = self.code.to_i
-      body = SoapBody.new do
-        integer :fileId, code
-        string  :statusChangeEmail, email
+    {
+      notes: :notes,
+      email: :status_change_email
+    }.each do |name, attribute|
+      define_method "update_#{name}!" do |value|
+        successful = AkamaiApi::ECCU::UpdateAttributeRequest.new(code, attribute).execute(value)
+        send "#{name}=", value if successful
+        successful
       end
-      response = client.call :set_status_change_email, :message => body.to_s
-      successful = response.body[:set_status_change_email_response][:success]
-      self.email = email if successful
-      successful
-    rescue Savon::HTTPError => e
-      raise ::AkamaiApi::Unauthorized if e.http.code == 401
-      raise
     end
 
     def destroy
-      code = self.code.to_i
-      body = SoapBody.new do
-        integer :fileId, code
-      end
-      response = client.call :delete, :message => body.to_s
-      response.body[:delete_response][:success]
-    rescue Savon::HTTPError => e
-      raise ::AkamaiApi::Unauthorized if e.http.code == 401
-      raise
+      AkamaiApi::ECCU::DestroyRequest.new(code).execute
     end
 
     class << self
       def all_ids
-        client.call(:get_ids).body[:get_ids_response][:file_ids][:file_ids]
-      rescue Savon::HTTPError => e
-        raise ::AkamaiApi::Unauthorized if e.http.code == 401
-        raise
+        AkamaiApi::ECCU::ListRequest.new.execute
       end
 
       def all args = {}
-        Array.wrap(all_ids).map { |v| EccuRequest.find v, args }
+        all_ids.map { |v| ECCURequest.find v, args }
       end
 
       def last args = {}
@@ -70,40 +53,16 @@ module AkamaiApi
       end
 
       def find code, args = {}
-        body = SoapBody.new do
-          integer :fileId, code.to_i
-          boolean :retrieveContents, args[:verbose] == true
-        end
-        response = client.call(:get_info, :message => body.to_s)
-        response_body = response.body[:get_info_response][:eccu_info]
-        EccuRequest.new({
-          :file => {
-            :content    => Base64.decode64(get_if_kind(response_body[:contents], String) || ''),
-            :file_size  => response_body[:file_size].to_i,
-            :file_name  => get_if_kind(response_body[:filename], String),
-            :md5_digest => get_if_kind(response_body[:md5_digest], String)
-          },
-          :status => {
-            :extended    => get_if_kind(response_body[:extended_status_message], String),
-            :code        => response_body[:status_code].to_i,
-            :message     => get_if_kind(response_body[:status_message], String),
-            :update_date => get_if_kind(response_body[:status_update_date], String)
-          },
-          :code  => response_body[:file_id],
-          :notes => get_if_kind(response_body[:notes], String),
-          :property => {
-            :name => get_if_kind(response_body[:property_name], String),
-            :exact_match => (response_body[:property_name_exact_match] == true),
-            :type => get_if_kind(response_body[:property_type], String)
-          },
-          :email => get_if_kind(response_body[:status_change_email], String),
-          :upload_date => get_if_kind(response_body[:upload_date], String),
-          :uploaded_by => get_if_kind(response_body[:uploaded_by], String),
-          :version_string => get_if_kind(response_body[:version_string], String)
-        })
-      rescue Savon::HTTPError => e
-        raise ::AkamaiApi::Unauthorized if e.http.code == 401
-        raise
+        response = AkamaiApi::ECCU::FindRequest.new(code).execute args.fetch(:verbose, true)
+        new :file        => response.file,
+            :status      => response.status,
+            :code        => response.code,
+            :notes       => response.notes,
+            :property    => response.property,
+            :email       => response.email,
+            :upload_date => response.uploaded_at,
+            :uploaded_by => response.uploaded_by,
+            :version     => response.version
       end
 
       def publish_file property, file_name, args = {}
@@ -112,52 +71,15 @@ module AkamaiApi
       end
 
       def publish property, content, args = {}
-        body = build_publish_soap_body property, content, args
-        resp = client.call :upload, :message_tag => 'upload', :message => body.to_s
-        resp.body[:upload_response][:file_id].to_i
-      rescue Savon::HTTPError => e
-        raise ::AkamaiApi::Unauthorized if e.http.code == 401
-        raise
+        args = args.dup
+        AkamaiApi::ECCU::PublishRequest.new(property, extract_property_arguments(args)).execute content, args
       end
 
       private
 
-      def build_publish_soap_body property, content, args
-        SoapBody.new do
-          string :filename,                args[:file_name] || ''
-          text   :contents,                content
-          string :notes,                   args[:notes] || 'ECCU Request using AkamaiApi gem'
-          string :versionString,           args[:version] || ''
-          if args[:emails]
-            string :statusChangeEmail,     Array.wrap(args[:emails]).join(' ')
-          end
-          string :propertyName,            property
-          string :propertyType,            args[:property_type] || 'hostheader'
-          boolean :propertyNameExactMatch, args[:property_exact_match].nil? && true || args[:property_exact_match]
-        end
-      end
-
-      # This method is used because, for nil values, savon will respond with an hash containing all other attributes.
-      # If we check that the expected type is matched, we can
-      # prevent to retrieve wrong values
-      def get_if_kind value, kind
-        value.kind_of?(kind) && value || nil
-      end
-
-      def client
-        savon_args = {
-          :wsdl       => File.expand_path('../../../wsdls/eccu.wsdl', __FILE__),
-          :basic_auth => AkamaiApi.config[:auth],
-          :log        => AkamaiApi.config[:log]
-        }
-        Savon.client savon_args
+      def extract_property_arguments args
+        { type: args.delete(:property_type), exact_match: args.delete(:property_exact_match) }.reject { |k, v| v.nil? }
       end
     end
-
-    private
-
-    def client
-      self.class.send(:client)
-    end
   end
 end

data/lib/akamai_api/error.rb

@@ -0,0 +1,5 @@
+module AkamaiApi
+  # Generic superclass for all specific errors that can be raised by AkamaiApi
+  class Error < StandardError
+  end
+end

data/lib/akamai_api/unauthorized.rb

@@ -0,0 +1,6 @@
+require "akamai_api/error"
+
+module AkamaiApi
+  # A simple subclass of {AkamaiApi::Error} representing the "invalid login credentials" error
+  class Unauthorized < AkamaiApi::Error; end
+end

data/lib/akamai_api/version.rb

@@ -1,3 +1,3 @@
 module AkamaiApi
-  VERSION = "0.2.0"
+  VERSION = "0.3.0"
 end

data/lib/akamai_api.rb

@@ -1,11 +1,25 @@
-require 'savon'
+require "active_support/core_ext/object/blank"
 
-%w(version soap_body ccu eccu_request).each do |file|
+%w(version ccu eccu eccu_request).each do |file|
   require "akamai_api/#{file}"
 end
 
 module AkamaiApi
-  class Unauthorized < StandardError; end
+  def self.config
+    @config ||= {
+      :auth => [
+        ENV.fetch('AKAMAI_USERNAME', ''),
+        ENV.fetch('AKAMAI_PASSWORD', '')
+      ],
+      :log => false
+    }
+  end
 
-  def self.config; @config ||= { :auth => ['', ''], :log => false }; end
+  def self.auth_empty?
+    config[:auth].select { |v| v.blank? }.any?
+  end
+
+  def self.auth
+    { username: config[:auth].first, password: config[:auth].last }
+  end
 end

data/spec/features/ccu/purge_request_spec.rb

@@ -1,60 +1,58 @@
 require 'spec_helper'
 
 describe 'Given I request to purge an asset' do
-  subject { AkamaiApi::Ccu }
+  subject { AkamaiApi::CCU }
 
   shared_examples 'purge helper' do
     let(:method) { "#{action}_#{type}" }
 
     it 'responds with a PurgeResponse object' do
       VCR.use_cassette "akamai_api_ccu_#{type}_#{action}/single_item" do
-        subject.send(method, items).should be_a AkamaiApi::Ccu::Purge::Response
+        expect(subject.send method, items).to be_a AkamaiApi::CCU::Purge::Response
       end
     end
 
     it 'raises error when user is not authorized' do
       VCR.use_cassette "akamai_api_ccu_#{type}_#{action}/invalid_credentials" do
-        AkamaiApi::Ccu.stub auth: { username: 'foo', password: 'bar' }
+        allow(AkamaiApi).to receive(:auth) { { username: 'foo', password: 'bar' } }
         expect { subject.send(method, items) }.to raise_error AkamaiApi::Unauthorized
       end
     end
 
-    it 'returns a different response when data are invalid' do
+    it 'raises an error when data request is invalid' do
       VCR.use_cassette "akamai_api_ccu_#{type}_#{action}/invalid_item" do
-        response = subject.send(method, items)
-        expect(response).to be_a AkamaiApi::Ccu::Purge::Response
-        expect(response.code).to eq 403
+        expect { subject.send method, items }.to raise_error AkamaiApi::CCU::Error
       end
     end
 
     describe 'when data are correct' do
       it 'returns the expected response code' do
         VCR.use_cassette "akamai_api_ccu_#{type}_#{action}/single_item" do
-          subject.send(method, items).code.should == 201
+          expect(subject.send(method, items).code).to eq 201
         end
       end
 
       it 'returns a successful message' do
         VCR.use_cassette "akamai_api_ccu_#{type}_#{action}/single_item" do
-          subject.send(method, items).message.should == 'Request accepted.'
+          expect(subject.send(method, items).message).to eq 'Request accepted.'
         end
       end
 
       it 'returns a unique purge id' do
         VCR.use_cassette "akamai_api_ccu_#{type}_#{action}/single_item" do
-          subject.send(method, items).purge_id.should == '12345678-1234-1234-1234-123456789012'
+          expect(subject.send(method, items).purge_id).to eq '12345678-1234-1234-1234-123456789012'
         end
       end
 
       it 'returns a unique support id' do
         VCR.use_cassette "akamai_api_ccu_#{type}_#{action}/single_item" do
-          subject.send(method, items).support_id.should == '12345678901234567890-123456789'
+          expect(subject.send(method, items).support_id).to eq '12345678901234567890-123456789'
         end
       end
 
       it 'returns the estimated time in seconds' do
         VCR.use_cassette "akamai_api_ccu_#{type}_#{action}/single_item" do
-          subject.send(method, items).estimated_time.should == 420
+          expect(subject.send(method, items).estimated_time).to eq 420
         end
       end
     end

data/spec/features/ccu/purge_status_request_spec.rb

@@ -1,13 +1,13 @@
 require 'spec_helper'
 
 describe "Given I request a purge status" do
-  subject { AkamaiApi::Ccu }
+  subject { AkamaiApi::CCU }
 
   context "when login credentials are ok and progress uri is valid", vcr: { cassette_name: "akamai_api_ccu_purge_status/completed_request" } do
     let(:progress_uri) { '/ccu/v2/purges/12345678-1234-5678-1234-123456789012' }
 
     it "responds with a PurgeStatusResponse object" do
-      expect(subject.status progress_uri).to be_a AkamaiApi::Ccu::PurgeStatus::SuccessfulResponse
+      expect(subject.status progress_uri).to be_a AkamaiApi::CCU::PurgeStatus::Response
     end
   end
 
@@ -15,7 +15,7 @@ describe "Given I request a purge status" do
     let(:progress_uri) { '/ccu/v2/purges/12345678-1234-5678-1234-123456789012' }
 
     before do
-      AkamaiApi::Ccu.stub auth: { username: 'foo', password: 'bar' }
+      allow(AkamaiApi).to receive(:auth) { { username: 'foo', password: 'bar' } }
     end
 
     it "raises an error" do
@@ -24,8 +24,8 @@ describe "Given I request a purge status" do
   end
 
   context "when the given progress uri is invalid", vcr: { cassette_name: "akamai_api_ccu_purge_status/not_found_request" } do
-    it "returns a correct response" do
-      expect(subject.status 'foobarbaz').to be_a AkamaiApi::Ccu::PurgeStatus::NotFoundResponse
+    it "raises a NotFound error" do
+      expect { subject.status 'foobarbaz' }.to raise_error AkamaiApi::CCU::PurgeStatus::NotFound
     end
   end
 end

data/spec/features/ccu/status_request_spec.rb

@@ -3,15 +3,15 @@ require 'spec_helper'
 describe 'Given I request the current status' do
   context 'and given my login credentials are correct', vcr: { cassette_name: 'akamai_api_ccu_status/valid_credentials' } do
     it 'I receive a successful response object' do
-      expect(AkamaiApi::Ccu.status).to be_a AkamaiApi::Ccu::Status::Response
+      expect(AkamaiApi::CCU.status).to be_a AkamaiApi::CCU::Status::Response
     end
   end
 
   context 'and given my login credentials are wrong', vcr: { cassette_name: 'akamai_api_ccu_status/invalid_credentials' } do
-    before { AkamaiApi::Ccu.stub auth: { username: 'foo', password: 'bar' } }
+    before { allow(AkamaiApi).to receive(:auth) { { username: 'foo', password: 'bar' } } }
 
     it 'an error is raised' do
-      expect { AkamaiApi::Ccu.status }.to raise_error AkamaiApi::Unauthorized
+      expect { AkamaiApi::CCU.status }.to raise_error AkamaiApi::Unauthorized
     end
   end
 end

data/spec/features/eccu/destroy_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+describe "Given I want to destroy a request" do
+  subject { AkamaiApi::ECCURequest.new code: '1234' }
+
+  context "when login credentials are invalid", vcr: { cassette_name: "akamai_api_eccu_destroy/invalid_credentials" } do
+    before do
+      allow(AkamaiApi).to receive(:config) { { auth: ['foo', 'bar'] } }
+      allow(AkamaiApi::ECCU).to receive(:client) { AkamaiApi::ECCU.send(:build_client) }
+    end
+
+    it "raises Unauthorized" do
+      expect { subject.destroy }.to raise_error AkamaiApi::Unauthorized
+    end
+  end
+
+  context "when request id cannot be found", vcr: { cassette_name: "akamai_api_eccu_destroy/not_found_request" } do
+    it "raises NotFound" do
+      expect { subject.destroy }.to raise_error AkamaiApi::ECCU::NotFound
+    end
+  end
+
+  context "when request id is found", vcr: { cassette_name: "akamai_api_eccu_destroy/successful" } do
+    it "returns true" do
+      expect(subject.destroy).to be_truthy
+    end
+  end
+end

data/spec/features/eccu/find_request_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+describe "Given I want to retrieve a request" do
+  subject { AkamaiApi::ECCURequest }
+
+  context "when login credentials are invalid", vcr: { cassette_name: "akamai_api_eccu_find/invalid_credentials" } do
+    before do
+      allow(AkamaiApi).to receive(:config) { { auth: ['foo', 'bar'] } }
+      allow(AkamaiApi::ECCU).to receive(:client) { AkamaiApi::ECCU.send(:build_client) }
+    end
+
+    it "raises Unauthorized" do
+      expect { subject.find '1234' }.to raise_error AkamaiApi::Unauthorized
+    end
+  end
+
+  context "when request id cannot be found", vcr: { cassette_name: "akamai_api_eccu_find/not_found_request" } do
+    it "raises NotFound" do
+      expect { subject.find '1234' }.to raise_error AkamaiApi::ECCU::NotFound
+    end
+  end
+
+  context "when request id is found", vcr: { cassette_name: "akamai_api_eccu_find/successful" } do
+    it "returns an ECCURequest" do
+      expect(subject.find '1234').to be_a AkamaiApi::ECCURequest
+    end
+  end
+
+  context "when request id is found but verbose is false", vcr: { cassette_name: "akamai_api_eccu_find/successful_without_content" } do
+    it "returns an ECCURequest without file content" do
+      expect(subject.find('1234', verbose: false).file).to_not have_key :content
+    end
+  end
+end

data/spec/features/eccu/list_request_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+describe "Given I want to retrieve all submitted request ids" do
+  subject { AkamaiApi::ECCURequest }
+
+  context "when login credentials are invalid", vcr: { cassette_name: "akamai_api_eccu_all_ids/invalid_credentials" } do
+    before do
+      allow(AkamaiApi).to receive(:config) { { auth: ['foo', 'bar'] } }
+      allow(AkamaiApi::ECCU).to receive(:client) { AkamaiApi::ECCU.send(:build_client) }
+    end
+
+    it "raises Unauthorized" do
+      expect { subject.all_ids }.to raise_error AkamaiApi::Unauthorized
+    end
+  end
+
+  context "when credentials are valid", vcr: { cassette_name: "akamai_api_eccu_all_ids/successful" } do
+    it "returns a list of ids" do
+      expect(subject.all_ids).to eq ["12341", "12342", "12343", "12344", "12345", "12346", "12347", "12348", "12349", "12350", "12351", "12352", "12353", "12354", "12355", "12356", "12357", "12358", "12359", "12360", "12361", "12362", "12363", "12364", "12365", "12366", "12367", "12368", "12369", "12370", "12371"]
+    end
+  end
+end

data/spec/features/eccu/publish_request_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+describe "Given I want to publish a request" do
+  subject { AkamaiApi::ECCURequest }
+  let(:fixture_content) { File.read 'spec/fixtures/eccu_request.xml' }
+
+  context "when login credentials are invalid", vcr: { cassette_name: "akamai_api_eccu_publish/invalid_credentials" } do
+    before do
+      allow(AkamaiApi).to receive(:config) { { auth: ['foo', 'bar'] } }
+      allow(AkamaiApi::ECCU).to receive(:client) { AkamaiApi::ECCU.send(:build_client) }
+    end
+
+    it "raises Unauthorized" do
+      expect { subject.publish 'foo.com', fixture_content, file_name: './publish.xml' }.to raise_error AkamaiApi::Unauthorized
+    end
+  end
+
+  context "when property name is not found", vcr: { cassette_name: "akamai_api_eccu_publish/invalid_domain" } do
+    it "raises InvalidDomain" do
+      expect { subject.publish 'foobarbaz.com', fixture_content, file_name: './publish.xml' }.to raise_error AkamaiApi::ECCU::InvalidDomain
+    end
+  end
+
+  context "when data is correct", vcr: { cassette_name: "akamai_api_eccu_publish/successful" } do
+    it "returns the request id" do
+      expect(subject.publish 'foo.com', fixture_content, file_name: './publish.xml').to be_a Fixnum
+    end
+  end
+end

data/spec/features/eccu/update_email_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+describe "Given I want to update the email of a request" do
+  subject { AkamaiApi::ECCURequest.new code: '1234' }
+
+  context "when login credentials are invalid", vcr: { cassette_name: "akamai_api_eccu_update_email/invalid_credentials" } do
+    before do
+      allow(AkamaiApi).to receive(:config) { { auth: ['foo', 'bar'] } }
+      allow(AkamaiApi::ECCU).to receive(:client) { AkamaiApi::ECCU.send(:build_client) }
+    end
+
+    it "raises Unauthorized" do
+      expect { subject.update_email! 'guest@mikamai.com' }.to raise_error AkamaiApi::Unauthorized
+    end
+  end
+
+  context "when request id cannot be found", vcr: { cassette_name: "akamai_api_eccu_update_email/not_found_request" } do
+    it "raises NotFound" do
+      expect { subject.update_email! 'guest@mikamai.com' }.to raise_error AkamaiApi::ECCU::NotFound
+    end
+  end
+
+  context "when request id is found", vcr: { cassette_name: "akamai_api_eccu_update_email/successful" } do
+    it "returns true" do
+      expect(subject.update_notes! 'guest@mikamai.com').to be_truthy
+    end
+  end
+end

data/spec/features/eccu/update_notes_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+describe "Given I want to update the notes of a request" do
+  subject { AkamaiApi::ECCURequest.new code: '1234' }
+
+  context "when login credentials are invalid", vcr: { cassette_name: "akamai_api_eccu_update_notes/invalid_credentials" } do
+    before do
+      allow(AkamaiApi).to receive(:config) { { auth: ['foo', 'bar'] } }
+      allow(AkamaiApi::ECCU).to receive(:client) { AkamaiApi::ECCU.send(:build_client) }
+    end
+
+    it "raises Unauthorized" do
+      expect { subject.update_notes! 'request updated using AkamaiApi' }.to raise_error AkamaiApi::Unauthorized
+    end
+  end
+
+  context "when request id cannot be found", vcr: { cassette_name: "akamai_api_eccu_update_notes/not_found_request" } do
+    it "raises NotFound" do
+      expect { subject.update_notes! 'request updated using AkamaiApi' }.to raise_error AkamaiApi::ECCU::NotFound
+    end
+  end
+
+  context "when request id is found", vcr: { cassette_name: "akamai_api_eccu_update_notes/successful" } do
+    it "returns true" do
+      expect(subject.update_notes! 'request updated using AkamaiApi').to be_truthy
+    end
+  end
+end

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

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
-describe AkamaiApi::Ccu::Response do
-  subject { AkamaiApi::Ccu::Response.new 'supportId' => 'foo', 'httpStatus' => 201 }
+describe AkamaiApi::CCU::BaseResponse do
+  subject { AkamaiApi::CCU::BaseResponse.new 'supportId' => 'foo', 'httpStatus' => 201 }
 
   it '#support_id returns the supportId attribute' do
     expect(subject.support_id).to eq 'foo'