fuelsdk 0.1.0 → 0.1.1

data/ChangeLog.md

@@ -0,0 +1,13 @@
+FuelSDK-Ruby
+============
+
+2013-09-11: Version 0.1.1  
+```
+ Added ChangeLog
+ 
+ soap_configure, soap_perform with supporting tests
+ 
+ make soap_cud more rubular and easier to read and support
+ 
+ fixed some issues when trying to make requests after being passed a jwt
+```

data/fuelsdk.gemspec

@@ -27,4 +27,5 @@ Gem::Specification.new do |spec|
   spec.add_dependency "savon", "~> 2.0"
   spec.add_dependency "json", "~> 1.7.0"
   spec.add_dependency "jwt", "~> 0.1.6"
+  spec.add_dependency "activesupport", "~> 3.2.8"
 end

data/lib/fuelsdk.rb

@@ -3,6 +3,7 @@ require "fuelsdk/version"
 require 'rubygems'
 require 'date'
 require 'jwt'
+require 'active_support/inflector'
 
 module FuelSDK
   require 'fuelsdk/utils'

data/lib/fuelsdk/client.rb

@@ -3,7 +3,7 @@ module FuelSDK
     # not doing accessor so user, can't update these values from response.
     # You will see in the code some of these
     # items are being updated via back doors and such.
-    attr_reader :code, :message, :results, :request_id, :body, :raw
+    attr_reader :code, :message, :results, :request_id, :body, :raw, :decoded_jwt
 
     # some defaults
     def success
@@ -17,11 +17,11 @@ module FuelSDK
     end
     alias :more? :more
 
-    def initialize raw, client
+    def initialize raw=nil, client=nil
       @client = client # keep connection with client in case we request more
       @results = []
       @raw = raw
-      unpack raw
+      unpack raw if raw
     rescue => ex # all else fails return raw
       puts ex.message
       raw
@@ -38,16 +38,26 @@ module FuelSDK
   end
 
   class Client
-    attr_accessor :debug, :access_token, :auth_token, :internal_token, :refresh_token,
+    attr_accessor :debug, :auth_token, :internal_token, :refresh_token,
       :id, :secret, :signature
 
     include FuelSDK::Soap
     include FuelSDK::Rest
 
+    def cache
+      @cache ||= {
+        :retrievable => {},
+        :editable => {}
+      }
+    end
+
     def jwt= encoded_jwt
       raise 'Require app signature to decode JWT' unless self.signature
-      decoded_jwt = JWT.decode(encoded_jwt, self.signature, true)
+      self.decoded_jwt=JWT.decode(encoded_jwt, self.signature, true)
+    end
 
+    def decoded_jwt= decoded_jwt
+      @decoded_jwt = decoded_jwt
       self.auth_token = decoded_jwt['request']['user']['oauthToken']
       self.internal_token = decoded_jwt['request']['user']['internalOauthToken']
       self.refresh_token = decoded_jwt['request']['user']['refreshToken']
@@ -69,29 +79,32 @@ module FuelSDK
       self.wsdl = params["defaultwsdl"] if params["defaultwsdl"]
     end
 
-    def refresh force=false
+    def request_token_data
       raise 'Require Client Id and Client Secret to refresh tokens' unless (id && secret)
+      Hash.new.tap do |h|
+        h['clientId']= id
+        h['clientSecret'] = secret
+        h['refreshToken'] = refresh_token if refresh_token
+        h['accessType'] = 'offline'
+      end
+    end
 
-      if (self.access_token.nil? || force)
-        payload = Hash.new.tap do |h|
-          h['clientId']= id
-          h['clientSecret'] = secret
-          h['refreshToken'] = refresh_token if refresh_token
-          h['accessType'] = 'offline'
-        end
-
-        options = Hash.new.tap do |h|
-          h['data'] = payload
-          h['content_type'] = 'application/json'
-          h['params'] = {'legacy' => 1}
-        end
+    def request_token_options data
+      Hash.new.tap do |h|
+        h['data'] = data
+        h['content_type'] = 'application/json'
+        h['params'] = {'legacy' => 1}
+      end
+    end
 
+    def refresh force=false
+      if (self.auth_token.nil? || force)
+        options =  request_token_options(request_token_data)
         response = post("https://auth.exacttargetapis.com/v1/requestToken", options)
         raise "Unable to refresh token: #{response['message']}" unless response.has_key?('accessToken')
 
-        self.access_token = response['accessToken']
+        self.auth_token = response['accessToken']
         self.internal_token = response['legacyToken']
-        #@authTokenExpiration = Time.new + tokenResponse['expiresIn']
         self.refresh_token = response['refreshToken'] if response.has_key?("refreshToken")
       end
     end

data/lib/fuelsdk/rest.rb

@@ -67,7 +67,7 @@ module FuelSDK
       def rest_request action, url, options={}
         retried = false
         begin
-          (options['params'] ||= {}).merge! 'access_token' => access_token
+          (options['params'] ||= {}).merge! 'access_token' => auth_token
           rsp = rest_client.send(action, url, options)
           raise 'Unauthorized' if rsp.message == 'Unauthorized'
         rescue

data/lib/fuelsdk/soap.rb

@@ -1,6 +1,15 @@
 require 'savon'
 module FuelSDK
 
+  class DescribeError < StandardError
+    attr_reader :response
+    def initialize response=nil, message=nil
+      response.instance_variable_set(:@message, message) # back door update
+      @response = response
+      super message
+    end
+  end
+
   class SoapResponse < FuelSDK::Response
 
     def continue
@@ -124,37 +133,112 @@ module FuelSDK
       soap_request :describe, message
     end
 
-    def soap_get object_type, properties=nil, filter=nil
-      if properties.nil? or properties.empty?
-        rsp = soap_describe object_type
-        if rsp.success?
-          properties = rsp.retrievable
-        else
-          rsp.instance_variable_set(:@message, "Unable to get #{object_type}") # back door update
-          return rsp
-        end
+    def get_all_object_properties object_type
+      rsp = soap_describe object_type
+      raise DescribeError.new(rsp, "Unable to get #{object_type}") unless rsp.success?
+      rsp
+    end
+
+    def cache_properties action, object_type, properties
+      raise 'Properties should be in cache as a list' unless properties.kind_of? Array
+      cache[action][object_type] = properties
+    end
+
+    def cached_properties? action, object_type
+      cache[action][object_type] rescue nil
+    end
+
+    def retrievable_properties_cached? object_type
+      cached_properties? :retrievable, object_type
+    end
+
+    def cache_retrievable object_type, properties
+      cache_properties :retrievable, object_type, properties
+    end
+
+    def get_retrievable_properties object_type
+      if props=retrievable_properties_cached?(object_type)
+        props
+      else
+        cache_retrievable object_type, get_all_object_properties(object_type).retrievable
+      end
+    end
+
+    def editable_properties_cached? object_type
+      cached_properties? :editable, object_type
+    end
+
+    def cache_editable object_type, properties
+      cache_properties :editable, object_type, properties
+    end
+
+    def get_editable_properties object_type
+      if props=editable_properties_cached?(object_type)
+        props
+      else
+        cache_editable object_type, get_all_object_properties(object_type).editable
+      end
+    end
+
+    def normalize_properties_for_retrieve object_type, properties
+      if properties.nil? or properties.blank?
+        get_retrievable_properties object_type
       elsif properties.kind_of? Hash
-        properties = properties.keys
+        properties.keys
       elsif properties.kind_of? String
-        properties = [properties]
+        [properties]
+      elsif properties.kind_of? Symbol
+        [properties.to_s]
+      else
+        properties
       end
+    end
 
-      message = {'ObjectType' => object_type, 'Properties' => properties}
+    def add_simple_filter_part filter
+      {
+        'Filter' => filter,
+        :attributes! => { 'Filter' => { 'xsi:type' => 'tns:SimpleFilterPart' }}
+      }
+    end
 
-      if filter and filter.kind_of? Hash
-        message['Filter'] = filter
-        message[:attributes!] = { 'Filter' => { 'xsi:type' => 'tns:SimpleFilterPart' } }
+    def add_complex_filter_part filter
+      filter[:attributes!] = {
+        'LeftOperand' => { 'xsi:type' => 'tns:SimpleFilterPart' },
+        'RightOperand' => { 'xsi:type' => 'tns:SimpleFilterPart' }
+      }
 
+      {
+        'Filter' => filter,
+        :attributes! => { 'Filter' => { 'xsi:type' => 'tns:ComplexFilterPart' }}
+      }
+    end
+
+    def normalize_filter filter
+      if filter and filter.kind_of? Hash
         if filter.has_key?('LogicalOperator')
-          message[:attributes!] = { 'Filter' => { 'xsi:type' => 'tns:ComplexFilterPart' }}
-          message['Filter'][:attributes!] = {
-            'LeftOperand' => { 'xsi:type' => 'tns:SimpleFilterPart' },
-            'RightOperand' => { 'xsi:type' => 'tns:SimpleFilterPart' }}
+          add_complex_filter_part filter
+        else
+          add_simple_filter_part filter
         end
+      else
+        {}
       end
-      message = {'RetrieveRequest' => message}
+    end
+
+    def create_object_type_message object_type, properties, filter
+      {'ObjectType' => object_type, 'Properties' => properties}.merge filter
+    end
+
+    def soap_get object_type, properties=nil, filter=nil
+
+      properties = normalize_properties_for_retrieve object_type, properties
+      filter = normalize_filter filter
+      message = create_object_type_message(object_type,  properties, filter)
+
+      soap_request :retrieve, 'RetrieveRequest' => message
 
-      soap_request :retrieve, message
+    rescue DescribeError => err
+      return err.response
     end
 
     def soap_post object_type, properties
@@ -169,43 +253,65 @@ module FuelSDK
       soap_cud :delete, object_type, properties
     end
 
-    def soap_perform object_type, properties, action
-      message = {
+    def create_action_message message_type, object_type, properties, action
+      properties = [properties] unless properties.kind_of? Array
+      {
         'Action' => action,
-        'Definitions' => {
-          'Definition' => properties,
+        message_type => {
+          message_type.singularize => properties,
           :attributes! => {
-            'Definition' => {'xsi:type' => ('tns:' + object_type)}
+            message_type.singularize => { 'xsi:type' => ('tns:' + object_type) }
           }
         }
       }
+    end
+
+    def soap_perform object_type, properties, action
+      message = create_action_message 'Definitions', object_type, properties, action
       soap_request :perform, message
     end
 
-    private
+    def soap_configure object_type, properties, action
+      message = create_action_message 'Configurations', object_type, properties, action
+      soap_request :configure, message
+    end
 
-      def soap_cud action, object_type, properties
-        # get a list of attributes so we can seperate
-        # them from standard object properties
-        type_attrs = soap_describe(object_type).editable
-
-        properties = [properties] unless properties.kind_of? Array
-        properties.each do |p|
-          formated_attrs = []
-          p.each do |k, v|
-            if type_attrs.include? k
-              p.delete k
-              attrs = FuelSDK.format_name_value_pairs k => v
-              formated_attrs.concat attrs
-            end
+    def create_objects_message object_type, object_properties
+      raise 'Object properties must be a List' unless object_properties.kind_of? Array
+      raise 'Object properties must be a List of Hashes' unless object_properties.first.kind_of? Hash
+
+      {
+        'Objects' => object_properties,
+        :attributes! => {'Objects' => { 'xsi:type' => ('tns:' + object_type) }}
+      }
+    end
+
+    def normalize_properties_for_cud object_type, properties
+      properties = [properties] unless properties.kind_of? Array
+      raise 'Object properties must be a Hash' unless properties.first.kind_of? Hash
+
+      # get a list of attributes so we can seperate
+      # them from standard object properties
+      type_attrs = get_editable_properties object_type
+
+      properties.each do |p|
+        formated_attrs = []
+        p.each do |k, v|
+          if type_attrs.include? k
+            p.delete k
+            attrs = FuelSDK.format_name_value_pairs k => v
+            formated_attrs.concat attrs
           end
-          (p['Attributes'] ||= []).concat formated_attrs unless formated_attrs.empty?
         end
+        (p['Attributes'] ||= []).concat formated_attrs unless formated_attrs.blank?
+      end
+    end
 
-        message = {
-          'Objects' => properties,
-          :attributes! => { 'Objects' => { 'xsi:type' => ('tns:' + object_type) } }
-        }
+    private
+
+      def soap_cud action, object_type, properties
+        properties = normalize_properties_for_cud object_type, properties
+        message = create_objects_message object_type, properties
         soap_request action, message
       end
 

data/lib/fuelsdk/targeting.rb

@@ -1,22 +1,23 @@
 module FuelSDK::Targeting
-  attr_accessor :access_token
+  attr_accessor :auth_token
   attr_reader :endpoint
 
   include FuelSDK::HTTPRequest
 
+  def refresh
+    raise NotImplementedError
+  end
+
   def endpoint
-    unless @endpoint
-      determine_stack
-    end
-    @endpoint
+    @endpoint ||= determine_stack
   end
 
   protected
     def determine_stack
-      options = {'params' => {'access_token' => self.access_token}}
+      refresh unless self.auth_token
+      options = {'params' => {'access_token' => self.auth_token}}
       response = get("https://www.exacttargetapis.com/platform/v1/endpoints/soap", options)
-      @endpoint = response['url']
-    rescue => e
-      raise 'Unable to determine stack using: ' + e.message
+      raise 'Unable to determine stack' unless response.success?
+      response['url']
     end
 end

data/lib/fuelsdk/version.rb

@@ -1,3 +1,3 @@
 module FuelSDK
-  VERSION = "0.1.0"
+  VERSION = "0.1.1"
 end

data/spec/client_spec.rb

@@ -2,6 +2,16 @@ require 'spec_helper.rb'
 
 describe FuelSDK::Client do
 
+  it { should respond_to :cache }
+
+  describe '#cache' do
+    let(:client) { FuelSDK::Client.new }
+
+    it 'its default keys are retrievable and editable' do
+      expect(client.cache).to eq({:retrievable => {}, :editable => {}})
+    end
+  end
+
   context 'initialized' do
 
     it 'with client parameters' do

data/spec/fuelsdk_response_spec.rb

@@ -0,0 +1,5 @@
+require 'spec_helper'
+
+describe FuelSDK::Response do
+  it_behaves_like 'Response Object'
+end

data/spec/objects_spec.rb

@@ -1,5 +1,4 @@
 require 'spec_helper.rb'
-require 'objects_helper_spec.rb'
 
 describe FuelSDK::Objects::Base do
 

data/spec/soap/configure_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+describe FuelSDK::Soap do
+
+  let(:client) { FuelSDK::Client.new }
+  subject {client}
+
+  it 'has inflector support' do
+    expect('Configurations'.singularize).to eq 'Configuration'
+  end
+
+  describe '#soap_configure' do
+    it 'makes a soap configure request with message' do
+      subject.should_receive(:create_action_message).with('Configurations', 'Subscriber', [], 'Do it').and_return({})
+      subject.should_receive(:soap_request).with(:configure, {})
+      subject.soap_configure 'Subscriber', [], 'Do it'
+    end
+  end
+end

data/spec/soap/cud_spec.rb

@@ -0,0 +1,132 @@
+require 'spec_helper'
+
+describe FuelSDK::Soap do
+
+  let(:client) { FuelSDK::Client.new }
+
+  subject { client }
+
+  describe '#editable_properties_cached?' do
+    it 'returns a list of editable properties for the object' do
+      subject.should_receive(:cached_properties?)
+        .with(:editable, 'item')
+        .and_return(['prop'])
+
+      expect(subject.editable_properties_cached? 'item').to eq(['prop'])
+    end
+
+    it 'returns nil if not cached' do
+      expect(subject.editable_properties_cached? 'missing').to be_nil
+    end
+  end
+
+  describe '#get_editable_properties' do
+    it 'returns cached properties' do
+      subject.should_receive(:editable_properties_cached?)
+        .with('object')
+        .and_return(['prop'])
+
+      subject.should_not_receive(:get_all_object_properties)
+      subject.should_not_receive(:cache_editable)
+
+      expect(subject.get_editable_properties('object')).to eq ['prop']
+    end
+
+    it 'requests and caches properties when not in cache' do
+      subject.should_receive(:editable_properties_cached?)
+        .with('object')
+        .and_return(nil)
+
+      response = double(FuelSDK::DescribeResponse)
+      response.stub(:editable).and_return(['prop'])
+      subject.should_receive(:get_all_object_properties)
+        .and_return(response)
+
+      subject.should_receive(:cache_editable)
+        .with('object', ['prop'])
+        .and_return(['prop'])
+
+      expect(subject.get_editable_properties('object')).to eq ['prop']
+    end
+  end
+
+  describe '#cache_editable' do
+    it 'caches object properties to :editable' do
+      subject.cache_editable('Subscriber', ['Email'])
+      expect(subject.cache[:editable]).to eq 'Subscriber' => ['Email']
+    end
+  end
+
+  describe '#normalize_properties_for_cud' do
+
+    it 'creates soap objects properties hash putting ' \
+      'custom attributes into name value pairs' do
+
+      subject.should_receive(:get_editable_properties)
+        .with('Subscriber')
+        .and_return(['FirstName'])
+
+      expect(subject.normalize_properties_for_cud(
+        'Subscriber',
+        [{'Email' => 'dev@exacttarget.com', 'FirstName' => 'Devy'}]
+      )).to eq(
+          [{
+            'Email' => 'dev@exacttarget.com',
+            'Attributes' => [{'Name' => 'FirstName', 'Value' => 'Devy'}]
+          }]
+      )
+    end
+
+    it 'converts properties into an array' do
+      subject.should_receive(:get_editable_properties)
+        .with('Subscriber')
+        .and_return(['FirstName'])
+
+      expect(subject.normalize_properties_for_cud(
+        'Subscriber',
+        {'Email' => 'dev@exacttarget.com', 'FirstName' => 'Devy'}
+      )).to eq(
+          [{
+            'Email' => 'dev@exacttarget.com',
+            'Attributes' => [{'Name' => 'FirstName', 'Value' => 'Devy'}]
+          }]
+      )
+    end
+
+    it 'raises an exception if properties are not a hash' do
+      expect { subject.normalize_properties_for_cud('Subscriber', 'Email') }
+        .to raise_error
+    end
+  end
+
+  describe '#create_objects_message' do
+    it 'creates hash for soap message' do
+      obj_attributes = [{'Name' => 'First Name', 'Value' => 'Justin'}]
+      expect(subject.create_objects_message('object', obj_attributes)).to eq(
+          {
+            'Objects' => [{'Name' => 'First Name', 'Value' => 'Justin'}],
+            :attributes! => {'Objects' => { 'xsi:type' => 'tns:object' }}
+          }
+      )
+    end
+
+    it 'raises an exception if object attributes is not an Array' do
+      expect{ subject.create_objects_message('object', '1') }.to raise_error
+    end
+
+    it 'raises an exception if object attributes are not stored in a hash' do
+      expect{ subject.create_objects_message('object', ['1']) }.to raise_error
+    end
+  end
+
+  describe '#soap_cud' do
+    it 'request with message created with normalized properties' do
+
+      subject.should_receive(:normalize_properties_for_cud)
+      subject.should_receive(:create_objects_message)
+      subject.should_receive(:soap_request)
+
+      subject.send :soap_cud, :post, 'Subscriber', [{'EmailAddress' => 'dev@exacttarget.com'}]
+    end
+  end
+end

data/spec/soap/describe_error_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe FuelSDK::DescribeError do
+
+  it { should respond_to(:response) }
+
+  let (:triggering) { FuelSDK::SoapResponse.new }
+
+  it 'has passed message as error' do
+    error = FuelSDK::DescribeError.new(triggering, 'i am an error message')
+    expect(error.message).to eq 'i am an error message'
+  end
+
+  it 'triggering response is available' do
+    error = FuelSDK::DescribeError.new(triggering, 'i am an error message')
+    expect(error.response).to eq triggering
+  end
+
+  it 'sets message on response' do
+    expect(triggering.message).to be_nil
+    error = FuelSDK::DescribeError.new(triggering, 'i am an error message')
+    expect(triggering.message).to eq 'i am an error message'
+  end
+
+end

data/spec/soap/get_spec.rb

@@ -0,0 +1,257 @@
+require 'spec_helper'
+
+describe FuelSDK::Soap do
+
+  let(:client) { FuelSDK::Client.new }
+  subject { client }
+
+  describe '#get_all_object_properties' do
+
+    it 'returns properties for object_type' do
+      response = mock(FuelSDK::DescribeResponse)
+      response.should_receive(:success?).and_return(true)
+
+      subject.should_receive(:soap_describe)
+        .with('some object')
+        .and_return(response)
+
+      expect(subject.get_all_object_properties('some object'))
+        .to eq response
+    end
+
+    it 'raises an DescribeError when describe is unsuccessful' do
+      response = mock(FuelSDK::DescribeResponse)
+      response.should_receive(:success?).and_return(false)
+      response.stub(:status).and_return('ERROR')
+
+      subject.should_receive(:soap_describe)
+        .with('some object')
+        .and_return(response)
+
+      expect { subject.get_all_object_properties('some object') }
+        .to raise_error FuelSDK::DescribeError
+    end
+  end
+
+  describe '#normalize_properties_for_retrieve' do
+    it 'when properties are nil gets_all_object_properties' do
+      subject.should_receive(:get_retrievable_properties)
+        .with('object').and_return('called all')
+
+      expect(subject.normalize_properties_for_retrieve('object', nil)).to eq 'called all'
+    end
+
+    describe 'when properties is a' do
+      subject {
+        client.should_not_receive(:get_retrievable_properties)
+        client
+      }
+
+      it 'Hash returns keys' do
+        expect(subject.normalize_properties_for_retrieve('object', {'Prop1' => 'a', 'Prop2' => 'b'}))
+          .to eq ['Prop1', 'Prop2']
+      end
+
+      it 'String returns Array' do
+        expect(subject.normalize_properties_for_retrieve('object', 'Prop1'))
+          .to eq ['Prop1']
+      end
+
+      it 'Symbol returns Array' do
+        expect(subject.normalize_properties_for_retrieve('object', :Prop1))
+          .to eq ['Prop1']
+      end
+
+      it 'Array returns Array' do
+        expect(subject.normalize_properties_for_retrieve('object', ['Prop1']))
+          .to eq ['Prop1']
+      end
+    end
+  end
+
+  describe '#normalize_filter' do
+    it 'returns complex filter part when filter contains LogicalOperator key' do
+      expect(subject.normalize_filter({'LogicalOperator' => 'AND'}))
+        .to eq(
+          {
+            'Filter' => {
+              'LogicalOperator' => 'AND',
+              :attributes! => {
+                'LeftOperand' => { 'xsi:type' => 'tns:SimpleFilterPart' },
+                'RightOperand' => { 'xsi:type' => 'tns:SimpleFilterPart' }
+              },
+            },
+            :attributes! => { 'Filter' => { 'xsi:type' => 'tns:ComplexFilterPart' }}
+          }
+        )
+    end
+
+    it 'returns simple filter part by default' do
+      expect(subject.normalize_filter({'SimpleOperator' => 'equals'}))
+        .to eq(
+          {
+            'Filter' => {
+              'SimpleOperator' => 'equals',
+            },
+            :attributes! => { 'Filter' => { 'xsi:type' => 'tns:SimpleFilterPart' }}
+          }
+        )
+    end
+
+    it 'returns empty hash when no filter' do
+      expect(subject.normalize_filter(nil)).to eq({})
+    end
+
+    it 'returns empty hash when filter is unparsable' do
+      expect(subject.normalize_filter(['unparsable'])).to eq({})
+    end
+  end
+
+  describe '#cache_properties' do
+    it 'raise an error if properties is not an Array' do
+
+      subject.should_not_receive(:cache)
+      expect { subject.cache_properties :retrievable, 'Subscriber', 'EmailAddress' }
+        .to raise_error
+    end
+
+    it 'caches properties' do
+      subject.should_receive(:cache).and_return({:retrievable => {}})
+      expect(subject.cache_properties :retrievable, 'Subscriber', ['EmailAddress'])
+        .to eq(['EmailAddress'])
+    end
+  end
+
+  describe '#cached_properties?' do
+    it 'returns cached properties' do
+      subject.should_receive(:cache).and_return(
+        {
+          :retrievable => {
+          'Subscriber' => ['EmailAddress']}
+        }
+      )
+
+      expect(subject.cached_properties?(:retrievable, 'Subscriber'))
+        .to eq ['EmailAddress']
+    end
+
+    it 'returns nil on error access cache' do
+      subject.should_receive(:cache).and_return(1)
+      expect(subject.cached_properties?(:retrievable, 'Subscriber'))
+        .to be_nil
+    end
+  end
+
+  describe '#retrievable_properties_cached?' do
+    it 'returns a list of retrievable properties for the object' do
+      subject.should_receive(:cached_properties?)
+        .with(:retrievable, 'item')
+        .and_return(['prop'])
+
+      expect(subject.retrievable_properties_cached? 'item').to eq(['prop'])
+    end
+
+    it 'returns nil if not cached' do
+      expect(subject.retrievable_properties_cached? 'missing').to be_nil
+    end
+  end
+
+  describe '#get_retrievable_properties' do
+    it 'returns cached properties' do
+      subject.should_receive(:retrievable_properties_cached?)
+        .with('object')
+        .and_return(['prop'])
+
+      subject.should_not_receive(:get_all_object_properties)
+      subject.should_not_receive(:cache_retrievable)
+
+      expect(subject.get_retrievable_properties('object')).to eq ['prop']
+    end
+
+    it 'requests and caches properties when not in cache' do
+      subject.should_receive(:retrievable_properties_cached?)
+        .with('object')
+        .and_return(nil)
+
+      response = mock(FuelSDK::DescribeResponse)
+      response.stub(:retrievable).and_return(['prop'])
+      subject.should_receive(:get_all_object_properties)
+        .and_return(response)
+
+      subject.should_receive(:cache_retrievable)
+        .with('object', ['prop'])
+        .and_return(['prop'])
+
+      expect(subject.get_retrievable_properties('object')).to eq ['prop']
+    end
+  end
+
+  describe '#cache_retrievable' do
+    it 'caches object properties to :retrievable' do
+      subject.cache_retrievable('Subscriber', ['Email'])
+      expect(subject.cache[:retrievable]).to eq 'Subscriber' => ['Email']
+    end
+  end
+
+  describe '#soap_get' do
+    it 'request with message created with normalized properties, filters' do
+
+      subject.should_receive(:normalize_properties_for_retrieve)
+        .with('end to end', nil).and_return([])
+
+      subject.should_receive(:normalize_filter)
+        .with(nil).and_return({})
+
+      subject.should_receive(:create_object_type_message)
+        .with('end to end', [], {}).and_return('message')
+
+      subject.should_receive(:soap_request)
+        .with(:retrieve, 'RetrieveRequest' => 'message')
+
+      subject.soap_get 'end to end'
+    end
+
+    it 'request an object without passing properties or a filter' do
+
+      subject.should_receive(:get_retrievable_properties)
+        .with('no criteria').and_return(['Props1'])
+
+      subject.should_not_receive(:add_complex_filter_part)
+      subject.should_not_receive(:add_simple_filter_part)
+
+      subject.should_receive(:soap_request).with(:retrieve, 'RetrieveRequest' => {
+          'ObjectType' => 'no criteria',
+          'Properties' => ['Props1']
+        }
+      )
+
+      subject.soap_get 'no criteria'
+    end
+
+    it 'request an object with limited properties' do
+
+      subject.should_not_receive(:get_retrievable_properties)
+      subject.should_not_receive(:add_complex_fitler_part)
+      subject.should_not_receive(:add_simple_fitler_part)
+
+      subject.should_receive(:soap_request).with(:retrieve, 'RetrieveRequest' => {
+          'ObjectType' => 'limited',
+          'Properties' => ['Props1']
+        }
+      )
+
+      subject.soap_get('limited', ['Props1'])
+    end
+
+    it 'request an invalid object without properties' do
+      subject.should_receive(:get_retrievable_properties) { raise FuelSDK::DescribeError.new(
+          FuelSDK::DescribeResponse.new,  "Unable to get invalid"
+        )
+      }
+
+      rsp = subject.soap_get('invalid')
+      expect(rsp.success?).to be_false
+    end
+  end
+
+end

data/spec/soap/perform_spec.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+
+describe FuelSDK::Soap do
+
+  let(:client) { FuelSDK::Client.new }
+  subject {client}
+
+  it 'has inflector support' do
+    expect('Definitions'.singularize).to eq 'Definition'
+  end
+
+  describe '#create_action_message' do
+    it 'returns message' do
+      expect(subject.create_action_message('Definitions', 'QueryDefinition', [{'ObjectID' => 1}], 'start'))
+        .to eq(
+        {
+          'Action' => 'start',
+          'Definitions' => {
+            'Definition' => [{'ObjectID' => 1}],
+            :attributes! => {
+              'Definition' => { 'xsi:type' => 'tns:QueryDefinition'}
+            }
+          }
+        }
+      )
+    end
+
+    it 'standardizes properties to an array' do
+      expect(subject.create_action_message('Definitions', 'QueryDefinition', {'ObjectID' => 1}, 'start'))
+        .to eq(
+        {
+          'Action' => 'start',
+          'Definitions' => {
+            'Definition' => [{'ObjectID' => 1}],
+            :attributes! => {
+              'Definition' => { 'xsi:type' => 'tns:QueryDefinition'}
+            }
+          }
+        }
+      )
+    end
+  end
+
+  describe '#soap_perform' do
+    it 'starts a defined query' do
+      subject.should_receive(:create_action_message)
+        .with('Definitions', 'QueryDefinition', [{'ObjectID' => 1}], 'start')
+        .and_return 'Do It'
+      subject.should_receive(:soap_request).with(:perform, 'Do It')
+      subject.soap_perform 'QueryDefinition', [{'ObjectID' => 1}], 'start'
+    end
+  end
+end

data/spec/{soap_spec.rb → soap/soap_spec.rb}

@@ -6,11 +6,11 @@ describe FuelSDK::Soap do
 
   subject { client }
 
-  it { should respond_to(:soap_get) }
   it { should respond_to(:soap_post) }
   it { should respond_to(:soap_patch) }
   it { should respond_to(:soap_delete) }
   it { should respond_to(:soap_describe) }
+  it { should respond_to(:soap_perform) }
 
   it { should respond_to(:header) }
   it { should_not respond_to(:header=) }
@@ -62,8 +62,7 @@ describe FuelSDK::Soap do
         client.stub(:soap_request) do |action, message|
           [action, message]
         end
-
-        client.stub_chain(:soap_describe,:editable)
+        client.should_receive(:get_editable_properties)
           .and_return(['First Name', 'Last Name', 'Gender'])
         client
       }

data/spec/spec_helper.rb

@@ -12,3 +12,51 @@ RSpec.configure do |config|
   # Use the specified formatter
   config.formatter = :documentation
 end
+
+shared_examples_for 'Response Object' do
+  it { should respond_to(:code) }
+  it { should respond_to(:message) }
+  it { should respond_to(:results) }
+  it { should respond_to(:request_id) }
+  it { should respond_to(:body) }
+  it { should respond_to(:raw) }
+  it { should respond_to(:more) }
+  it { should respond_to(:more?) }
+  it { should respond_to(:success) }
+  it { should respond_to(:success?) }
+  it { should respond_to(:status) }
+  it { should respond_to(:continue) }
+end
+
+# Everything will be readable so test for shared from Read behavior
+shared_examples_for 'Soap Read Object' do
+  # begin backwards compat
+  it { should respond_to :props= }
+  it { should respond_to :authStub= }
+  # end
+  it { should respond_to :id }
+  it { should respond_to :properties }
+  it { should respond_to :client }
+  it { should respond_to :filter }
+  it { should respond_to :info }
+  it { should respond_to :get }
+end
+
+shared_examples_for 'Soap CUD Object' do
+  it { should respond_to :post }
+  it { should respond_to :patch }
+  it { should respond_to :delete }
+end
+
+shared_examples_for 'Soap Object' do
+  it_behaves_like 'Soap Read Object'
+  it_behaves_like 'Soap CUD Object'
+end
+
+shared_examples_for 'Soap Read Only Object' do
+  it_behaves_like 'Soap Read Object'
+  it { should_not respond_to :post }
+  it { should_not respond_to :patch }
+  it { should_not respond_to :delete }
+end
+

data/spec/targeting_spec.rb

@@ -11,28 +11,59 @@ describe FuelSDK::Targeting do
   it { should respond_to(:post) }
   it { should respond_to(:patch) }
   it { should respond_to(:delete) }
-  it { should respond_to(:access_token) }
+  it { should respond_to(:auth_token) }
+
+  let(:response) {
+    rsp = double(FuelSDK::HTTPResponse)
+    rsp.stub(:success?).and_return(true)
+    rsp.stub(:[]).with('url').and_return('S#.authentication.target')
+    rsp
+  }
+
+  let(:client) {
+    Class.new.new.extend(FuelSDK::Targeting)
+  }
 
   describe '#determine_stack' do
-    let(:client) { c = Class.new.new.extend(FuelSDK::Targeting)
-      c.stub(:access_token).and_return('open_sesame')
-      c.stub(:get)
-        .with('https://www.exacttargetapis.com/platform/v1/endpoints/soap',{'params'=>{'access_token'=>'open_sesame'}})
-        .and_return({'url' => 'S#.authentication.target'})
-      c
-    }
-    it 'sets @endpoint' do
-      expect(client.send(:determine_stack)).to eq 'S#.authentication.target'
+    describe 'without auth_token' do
+      it 'calls refresh' do
+        client.stub(:refresh) {
+          client.instance_variable_set('@auth_token', 'open_sesame')
+        }
+        client.stub(:get)
+          .with('https://www.exacttargetapis.com/platform/v1/endpoints/soap',
+            {'params'=>{'access_token'=>'open_sesame'}})
+          .and_return(response)
+      end
+    end
+
+    describe 'with valid auth_token' do
+      before :each do
+        client.should_receive(:auth_token).twice.and_return('open_sesame')
+      end
+
+      it 'when successful returns endpoint' do
+        client.stub(:get)
+          .with('https://www.exacttargetapis.com/platform/v1/endpoints/soap',
+            {'params'=>{'access_token'=>'open_sesame'}})
+          .and_return(response)
+        expect(client.send(:determine_stack)).to eq 'S#.authentication.target'
+      end
+
+      it 'raises error on unsuccessful responses' do
+        client.stub(:get).and_return{
+          rsp = double(FuelSDK::HTTPResponse)
+          rsp.stub(:success?).and_return(false)
+          rsp
+        }
+        expect{ client.send(:determine_stack) }.to raise_error 'Unable to determine stack'
+      end
     end
   end
 
   describe '#endpoint' do
-    let(:client) { c = Class.new.new.extend(FuelSDK::Targeting)
-      c.stub(:get).and_return({'url' => 'S#.authentication.target'})
-      c
-    }
-
     it 'calls determine_stack to find target' do
+      client.should_receive(:determine_stack).and_return('S#.authentication.target')
       expect(client.endpoint).to eq 'S#.authentication.target'
     end
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: fuelsdk
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
   prerelease: 
 platform: ruby
 authors:
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-08-29 00:00:00.000000000 Z
+date: 2013-09-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -140,6 +140,22 @@ dependencies:
     - - ~>
       - !ruby/object:Gem::Version
         version: 0.1.6
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.2.8
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.2.8
 description: Fuel SDK for Ruby
 email: []
 executables: []
@@ -147,6 +163,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - .gitignore
+- ChangeLog.md
 - Gemfile
 - Guardfile
 - README.md
@@ -180,12 +197,17 @@ files:
 - samples/sample-unsubevent.rb
 - samples/sample_helper.rb
 - spec/client_spec.rb
+- spec/fuelsdk_response_spec.rb
 - spec/helper_funcs_spec.rb
 - spec/http_request_spec.rb
-- spec/objects_helper_spec.rb
 - spec/objects_spec.rb
 - spec/rest_spec.rb
-- spec/soap_spec.rb
+- spec/soap/configure_spec.rb
+- spec/soap/cud_spec.rb
+- spec/soap/describe_error_spec.rb
+- spec/soap/get_spec.rb
+- spec/soap/perform_spec.rb
+- spec/soap/soap_spec.rb
 - spec/spec_helper.rb
 - spec/targeting_spec.rb
 homepage: https://code.exacttarget.com/sdks
@@ -233,11 +255,16 @@ test_files:
 - samples/sample-unsubevent.rb
 - samples/sample_helper.rb
 - spec/client_spec.rb
+- spec/fuelsdk_response_spec.rb
 - spec/helper_funcs_spec.rb
 - spec/http_request_spec.rb
-- spec/objects_helper_spec.rb
 - spec/objects_spec.rb
 - spec/rest_spec.rb
-- spec/soap_spec.rb
+- spec/soap/configure_spec.rb
+- spec/soap/cud_spec.rb
+- spec/soap/describe_error_spec.rb
+- spec/soap/get_spec.rb
+- spec/soap/perform_spec.rb
+- spec/soap/soap_spec.rb
 - spec/spec_helper.rb
 - spec/targeting_spec.rb

data/spec/objects_helper_spec.rb

@@ -1,32 +0,0 @@
-
-# Everything will be readable so test for shared from Read behavior
-shared_examples_for 'Soap Read Object' do
-  # begin backwards compat
-  it { should respond_to :props= }
-  it { should respond_to :authStub= }
-  # end
-  it { should respond_to :id }
-  it { should respond_to :properties }
-  it { should respond_to :client }
-  it { should respond_to :filter }
-  it { should respond_to :info }
-  it { should respond_to :get }
-end
-
-shared_examples_for 'Soap CUD Object' do
-  it { should respond_to :post }
-  it { should respond_to :patch }
-  it { should respond_to :delete }
-end
-
-shared_examples_for 'Soap Object' do
-  it_behaves_like 'Soap Read Object'
-  it_behaves_like 'Soap CUD Object'
-end
-
-shared_examples_for 'Soap Read Only Object' do
-  it_behaves_like 'Soap Read Object'
-  it { should_not respond_to :post }
-  it { should_not respond_to :patch }
-  it { should_not respond_to :delete }
-end