akamai_api 0.2.0 → 0.3.0

data/spec/lib/akamai_api/eccu_request_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 module AkamaiApi
-  describe EccuRequest do
+  describe ECCURequest do
     include Savon::SpecHelper
 
     before(:all) { savon.mock! }
@@ -14,69 +14,68 @@ module AkamaiApi
       end
 
       it 'returns the id list of all available requests' do
-        EccuRequest.all_ids.should =~ ['42994282', '43000154']
+        expect(ECCURequest.all_ids).to match_array ['42994282', '43000154']
       end
     end
 
     describe '::find' do
-      let(:fixture) { File.read 'spec/fixtures/eccu/get_info/successful.xml' }
+      subject { ECCURequest }
 
-      def soap_body id, verbose
-        SoapBody.new do
-          integer :fileId, id
-          boolean :retrieveContents, verbose
-        end
+      it 'delegates to FindRequest' do
+        fake_request = double
+        expect(fake_request).to receive(:execute).with(true).and_return AkamaiApi::ECCU::FindResponse.new({})
+        expect(AkamaiApi::ECCU::FindRequest).to receive(:new).with('1234').and_return fake_request
+        subject.find '1234'
       end
 
-      context 'when calling the ECCU service' do
-        it 'sets the specified code and verbosity' do
-          body = soap_body(1234567, false).to_s
-          savon.expects(:get_info).with(:message => body).returns(fixture)
-          EccuRequest.find('1234567')
-        end
-
-        it 'sets to return file content if verbose is specified' do
-          body = soap_body(1234567, true).to_s
-          savon.expects(:get_info).with(:message => body).returns(fixture)
-          EccuRequest.find('1234567', :verbose => true)
-        end
+      it "returns an ECCURequest" do
+        response = AkamaiApi::ECCU::FindResponse.new({})
+        expect_any_instance_of(AkamaiApi::ECCU::FindRequest).to receive(:execute).and_return response
+        subject.find '1234'
       end
 
-      it 'correctly assign the exact match' do
-        body = soap_body(1234567, false).to_s
-        savon.expects(:get_info).with(:message => body).returns(fixture)
-        r = EccuRequest.find('1234567')
-        r.property[:exact_match].should be_true
+      {
+        file:        :file,
+        status:      :status,
+        code:        :code,
+        notes:       :notes,
+        property:    :property,
+        email:       :email,
+        upload_date: :uploaded_at,
+        uploaded_by: :uploaded_by,
+        version:     :version
+      }.each do |local_name, remote_name|
+        it "maps response '#{remote_name}' to '#{local_name}'" do
+          response = AkamaiApi::ECCU::FindResponse.new({})
+          allow(response).to receive(remote_name) { "foobarbaz" }
+          expect_any_instance_of(AkamaiApi::ECCU::FindRequest).to receive(:execute).and_return response
+          expect(subject.find('1234').send local_name).to eq "foobarbaz"
+        end
       end
     end
 
     describe '::last' do
       it 'find the most recent entry' do
-        EccuRequest.stub :all_ids => %w(a b)
-        EccuRequest.should_receive(:find).with('b', anything()).and_return :a
-        EccuRequest.last.should == :a
+        allow(ECCURequest).to receive(:all_ids) { %w(a b) }
+        allow(ECCURequest).to receive(:find).with('b', anything()).and_return :a
+        expect(ECCURequest.last).to eq :a
       end
     end
 
     describe '::first' do
       it 'find the oldest entry' do
-        EccuRequest.stub :all_ids => %w(a b)
-        EccuRequest.should_receive(:find).with('a', anything()).and_return :a
-        EccuRequest.first.should == :a
+        allow(ECCURequest).to receive(:all_ids) { %w(a b) }
+        allow(ECCURequest).to receive(:find).with('a', anything()).and_return :a
+        expect(ECCURequest.first).to eq :a
       end
     end
 
     describe '::all' do
       it 'returns the detail for each enlisted id' do
-        EccuRequest.stub :all_ids => %w(a b)
-        EccuRequest.should_receive(:find).with('a', anything()).and_return(:a)
-        EccuRequest.should_receive(:find).with('b', anything()).and_return(:b)
-        EccuRequest.all.should =~ [:a, :b]
-      end
-      it 'returns the detail for each enlisted id even if only one id is returned' do
-        EccuRequest.stub :all_ids => "a"
-        EccuRequest.should_receive(:find).with('a', anything()).and_return(:a)
-        EccuRequest.all.should =~ [:a]
+        allow(ECCURequest).to receive(:all_ids) { %w(a b) }
+        allow(ECCURequest).to receive(:find).with('a', anything()).and_return(:a)
+        allow(ECCURequest).to receive(:find).with('b', anything()).and_return(:b)
+        expect(ECCURequest.all).to match_array [:a, :b]
       end
     end
 
@@ -87,80 +86,44 @@ module AkamaiApi
       describe '::publish_file' do
         it 'calls publish with the content of the specified file' do
           args = {}
-          EccuRequest.should_receive(:publish).with('foo', xml_request_content, args)
-          EccuRequest.publish_file('foo', xml_request, args)
+          allow(ECCURequest).to receive(:publish).with('foo', xml_request_content, args)
+          ECCURequest.publish_file('foo', xml_request, args)
         end
       end
 
       describe '::publish' do
-        context 'when there is an error' do
-          before do
-            fixture = File.read 'spec/fixtures/eccu/upload/fault.xml'
-            savon.expects(:upload).with(:message => :any).returns(fixture)
-          end
+        let(:subject) { ECCURequest }
 
-          it 'raises an error' do
-            expect { EccuRequest.publish '', xml_request_content }.to raise_error Savon::SOAPFault
-          end
+        it 'does not alter given arguments' do
+          expect_any_instance_of(AkamaiApi::ECCU::PublishRequest).to receive :execute
+          args = { property_type: 'asd' }
+          expect { subject.publish 'foo.com', 'asd', args }.to_not change args, :count
         end
 
-        context 'when there are no errors' do
-          let(:fixture) { File.read 'spec/fixtures/eccu/upload/successful.xml' }
-
-          it 'returns an EccuRequest instance' do
-            savon.expects(:upload).with(:message => :any).returns(fixture)
-            EccuRequest.publish('', xml_request_content).should be_a Fixnum
-          end
-
-          it 'assigns the fields correctly' do
-            content = xml_request_content
-            body = SoapBody.new do
-              string  :filename,          'eccu_request.xml'
-              text    :contents,          content
-              string  :notes,             'sample notes'
-              string  :versionString,     'v2'
-              string  :statusChangeEmail, 'foo@foo.com bar@bar.com'
-              string  :propertyName,      'foo.com'
-              string  :propertyType,      'prop'
-              boolean :propertyNameExactMatch, false
-            end
-            savon.expects(:upload).with(:message => body.to_s).returns(fixture)
-            EccuRequest.publish('foo.com', xml_request_content, {
-              :file_name => 'eccu_request.xml',
-              :notes     => 'sample notes',
-              :version   => 'v2',
-              :emails    => %w(foo@foo.com bar@bar.com),
-              :property_type => 'prop',
-              :property_exact_match => false
-            })
-          end
+        it 'correctly builds a PublishRequest' do
+          expected_args = ['foo.com', { type: 'hostheader', exact_match: true }]
+          expect(AkamaiApi::ECCU::PublishRequest).to receive(:new).with(*expected_args).and_return double(execute: nil)
+          subject.publish 'foo.com', 'asd', property_type: 'hostheader', property_exact_match: true
+        end
 
-          it 'assigns a default notes field if no notes are specified' do
-            SoapBody.any_instance.stub :string => nil
-            SoapBody.any_instance.should_receive(:string).with(:notes, kind_of(String))
-            savon.expects(:upload).with(:message => :any).returns(fixture)
-            EccuRequest.publish '', xml_request_content
-          end
+        it 'does not pass nil values to constructor arguments' do
+          expect(AkamaiApi::ECCU::PublishRequest).to receive(:new).with('foo.com', {}).and_return double(execute: nil)
+          subject.publish 'foo.com', 'asd', property_type: nil, property_exact_match: nil
+        end
 
-          it 'assigns emails field if specified' do
-            SoapBody.any_instance.should_not_receive(:string).with(:statusChangeEmail, anything())
-            savon.expects(:upload).with(:message => :any).returns(fixture)
-            EccuRequest.publish '', xml_request_content
-          end
+        it 'delegates to PublishRequest#execute' do
+          expect_any_instance_of(AkamaiApi::ECCU::PublishRequest).to receive(:execute).and_return 1
+          expect(subject.publish 'foo.com', 'asd').to eq 1
+        end
 
-          it 'assigns the property type to hostheader by default' do
-            SoapBody.any_instance.stub :string => nil
-            SoapBody.any_instance.should_receive(:string).with(:propertyType, 'hostheader')
-            savon.expects(:upload).with(:message => :any).returns(fixture)
-            EccuRequest.publish '', xml_request_content
-          end
+        it 'pass content and given arguments to execute' do
+          expect_any_instance_of(AkamaiApi::ECCU::PublishRequest).to receive(:execute).with 'asd', emails: 'foo@bar.com'
+          subject.publish 'foo.com', 'asd', emails: 'foo@bar.com'
+        end
 
-          it 'assigns the property exact match to true by default' do
-            SoapBody.any_instance.stub :boolean => nil
-            SoapBody.any_instance.should_receive(:boolean).with(:propertyNameExactMatch, true)
-            savon.expects(:upload).with(:message => :any).returns(fixture)
-            EccuRequest.publish '', xml_request_content
-          end
+        it 'removed unnecessary arguments when calling execute' do
+          expect_any_instance_of(AkamaiApi::ECCU::PublishRequest).to receive(:execute).with 'asd', emails: 'foo@bar.com'
+          subject.publish 'foo.com', 'asd', emails: 'foo@bar.com', property_exact_match: false
         end
       end
     end
@@ -168,90 +131,118 @@ module AkamaiApi
     describe 'instance' do
       describe 'constructor' do
         it 'assigns the attributes hash to the accessors' do
-          req = EccuRequest.new :status => 'foo', :notes => 'bar'
-          req.status.should == 'foo'
-          req.notes.should == 'bar'
+          req = ECCURequest.new :status => 'foo', :notes => 'bar'
+          expect(req.status).to eq 'foo'
+          expect(req.notes).to eq 'bar'
         end
       end
 
       describe '#update_notes!' do
-        let(:fixture) { File.read 'spec/fixtures/eccu/set_notes/successful.xml' }
-
-        it 'updates the notes field' do
-          savon.expects(:set_notes).with(:message => :any).returns(fixture)
-          req = EccuRequest.new :code => '1234'
-          expect {
-            req.update_notes! 'foo'
-          }.to change(req, :notes).to 'foo'
+        subject { ECCURequest.new code: '1234' }
+
+        it 'delegates to UpdateAttributeRequest' do
+          fake_request = double
+          expect(fake_request).to receive(:execute).with('foo').and_return true
+          expect(AkamaiApi::ECCU::UpdateAttributeRequest).to receive(:new).with('1234', :notes).and_return fake_request
+          subject.update_notes! 'foo'
         end
 
-        it 'calls the ECCU service using code and notes' do
-          body = SoapBody.new do
-            integer :fileId, 1234
-            string  :notes,  'foo'
+        context 'when the update is successful' do
+          before do
+            expect_any_instance_of(AkamaiApi::ECCU::UpdateAttributeRequest).to receive(:execute).and_return true
+          end
+
+          it "returns true" do
+            expect(subject.update_notes! 'foo').to be_truthy
+          end
+
+          it "updates notes attribute" do
+            expect { subject.update_notes! 'foo' }.to change(subject, :notes).to 'foo'
           end
-          savon.expects(:set_notes).with(:message => body.to_s).returns(fixture)
-          EccuRequest.new(:code => '1234').update_notes! 'foo'
         end
 
-        it 'calls the ECCU service and return the service boolean response' do
-          savon.expects(:set_notes).with(:message => :any).returns(fixture)
-          EccuRequest.new(:code => '1234').update_notes!('foo').should be_true
+        context 'when the update is not successful' do
+          before do
+            expect_any_instance_of(AkamaiApi::ECCU::UpdateAttributeRequest).to receive(:execute).and_return false
+          end
+
+          it "returns false" do
+            expect(subject.update_notes! 'foo').to be_falsy
+          end
+
+          it "does not update the notes attribute" do
+            expect { subject.update_notes! 'foo' }.to_not change { subject.notes }
+          end
         end
       end
 
-      describe '#update_email' do
-        let(:fixture) { File.read 'spec/fixtures/eccu/set_status_change_email/successful.xml' }
+      describe '#update_email!' do
+        subject { ECCURequest.new code: '1234' }
 
-        it 'updates the email field' do
-          savon.expects(:set_status_change_email).with(:message => :any).returns(fixture)
-          req = EccuRequest.new :code => '1234'
-          expect {
-            req.update_email! 'foo'
-          }.to change(req, :email).to 'foo'
+        it 'delegates to UpdateEmailRequest' do
+          fake_request = double
+          expect(fake_request).to receive(:execute).with('foo').and_return true
+          expect(AkamaiApi::ECCU::UpdateAttributeRequest).to receive(:new).with('1234', :status_change_email).and_return fake_request
+          subject.update_email! 'foo'
         end
 
-        it 'calls the ECCU service using code and email' do
-          body = SoapBody.new do
-            integer :fileId,            1234
-            string  :statusChangeEmail, 'foo'
+        context 'when the update is successful' do
+          before do
+            expect_any_instance_of(AkamaiApi::ECCU::UpdateAttributeRequest).to receive(:execute).and_return true
+          end
+
+          it "returns true" do
+            expect(subject.update_email! 'foo').to be_truthy
           end
-          savon.expects(:set_status_change_email).with(:message => body.to_s).returns(fixture)
-          EccuRequest.new(:code => '1234').update_email! 'foo'
-        end
 
-        it 'calls the ECCU service and return the service boolean response' do
-          savon.expects(:set_status_change_email).with(:message => :any).returns(fixture)
-          EccuRequest.new(:code => '1234').update_email!('foo').should be_true
+          it "updates notes attribute" do
+            expect { subject.update_email! 'foo' }.to change(subject, :email).to 'foo'
+          end
         end
 
-        context 'when there is an error' do
-          let(:fixture) { File.read 'spec/fixtures/eccu/set_status_change_email/fault.xml' }
+        context 'when the update is not successful' do
+          before do
+            expect_any_instance_of(AkamaiApi::ECCU::UpdateAttributeRequest).to receive(:execute).and_return false
+          end
+
+          it "returns false" do
+            expect(subject.update_email! 'foo').to be_falsy
+          end
 
-          it 'does not update the mail' do
-            savon.expects(:set_status_change_email).with(:message => :any).returns(fixture)
-            req = EccuRequest.new :code => '1234'
-          expect {
-            req.update_email! 'foo'
-          }.to_not change(req, :email)
+          it "does not update the email attribute" do
+            expect { subject.update_email! 'foo' }.to_not change { subject.email }
           end
         end
       end
 
       describe '#destroy' do
-        let(:fixture) { File.read 'spec/fixtures/eccu/delete/successful.xml' }
+        subject { ECCURequest.new code: '1234' }
+
+        it 'delegates to DestroyRequest' do
+          fake_request = double
+          expect(fake_request).to receive(:execute).and_return true
+          expect(AkamaiApi::ECCU::DestroyRequest).to receive(:new).with('1234').and_return fake_request
+          subject.destroy
+        end
+
+        context 'when the update is successful' do
+          before do
+            expect_any_instance_of(AkamaiApi::ECCU::DestroyRequest).to receive(:execute).and_return true
+          end
 
-        it 'calls the ECCU service using code' do
-          body = SoapBody.new do
-            integer :fileId, 1234
+          it "returns true" do
+            expect(subject.destroy).to be_truthy
           end
-          savon.expects(:delete).with(:message => body.to_s).returns(fixture)
-          EccuRequest.new(:code => '1234').destroy
         end
 
-        it 'calls the ECCU service and return the service boolean response' do
-          savon.expects(:delete).with(:message => :any).returns(fixture)
-          EccuRequest.new(:code => '1234').destroy.should be_true
+        context 'when the update is not successful' do
+          before do
+            expect_any_instance_of(AkamaiApi::ECCU::DestroyRequest).to receive(:execute).and_return false
+          end
+
+          it "returns false" do
+            expect(subject.destroy).to be_falsy
+          end
         end
       end
     end

data/spec/spec_helper.rb

@@ -1,25 +1,34 @@
 require File.expand_path '../../lib/akamai_api', __FILE__
 require File.expand_path '../../lib/akamai_api/cli', __FILE__
-require File.expand_path '../auth.rb', __FILE__
 
+begin
+  require File.expand_path '../auth.rb', __FILE__
+rescue LoadError
+  AkamaiApi.config[:auth] = ['test_username', 'test_password']
+end
 require 'savon/mock/spec_helper'
 require 'webmock/rspec'
 require 'vcr'
+require 'coveralls'
+Coveralls.wear_merged!
 
 VCR.configure do |c|
   c.cassette_library_dir = 'cassettes'
   c.hook_into :webmock
   c.default_cassette_options = {
-    record: :once
+    record: :once,
+    match_requests_on: [:method, :uri, :body]
   }
   c.configure_rspec_metadata!
   c.after_http_request do |request|
     request.uri.gsub! AkamaiApi.config[:auth].first, 'USERNAME'
     request.uri.gsub! AkamaiApi.config[:auth].last, 'PASSWORD'
+    request.body.gsub! "AkamaiApi #{AkamaiApi::VERSION}", "AkamaiApi VERSION"
   end
   c.before_playback do |i|
     i.request.uri.gsub! 'USERNAME', AkamaiApi.config[:auth].first
     i.request.uri.gsub! 'PASSWORD', AkamaiApi.config[:auth].last
+    i.request.body.gsub! "AkamaiApi VERSION", "AkamaiApi #{AkamaiApi::VERSION}"
   end
 end
 
@@ -29,7 +38,6 @@ Dir[File.expand_path '../support/**/*.rb', __FILE__].each do |f|
 end
 
 RSpec.configure do |config|
-  config.treat_symbols_as_metadata_keys_with_true_values = true
   config.run_all_when_everything_filtered = true
   config.filter_run :focus