attune 1.0.3 → 1.0.5

data/lib/attune/models/rankedentities.rb

@@ -0,0 +1,60 @@
+module Attune
+  module Model
+    # 
+    class RankedEntities
+      attr_accessor :message
+      
+
+      attr_accessor :status
+      
+
+      attr_accessor :ranking
+      
+
+      # :internal => :external
+      def self.attribute_map
+        {
+          :message => :message,
+          :status => :status,
+          :ranking => :ranking
+
+        }
+      end
+
+      def initialize(attributes = {})
+        return if attributes.empty?
+        # Morph attribute keys into undescored rubyish style
+        if self.class.attribute_map[:"message"]
+          # Workaround since JSON.parse has accessors as strings rather than symbols
+            @message = attributes["message"] || attributes[:"message"]
+        end
+        if self.class.attribute_map[:"status"]
+          # Workaround since JSON.parse has accessors as strings rather than symbols
+            @status = attributes["status"] || attributes[:"status"]
+        end
+        if self.class.attribute_map[:"ranking"]
+          value = attributes["ranking"] || attributes[:"ranking"]
+            if value.is_a?(Array)
+              @ranking = value
+
+            end
+          end
+        
+
+      end
+
+      def to_body
+        body = {}
+        self.class.attribute_map.each_pair do |key, value|
+          body[value] = self.send(key) unless self.send(key).nil?
+        end
+        body
+      end
+
+      def to_json(options = {})
+        to_body.to_json
+      end
+    end
+  end
+end
+

data/lib/attune/models/rankingparams.rb

@@ -0,0 +1,103 @@
+module Attune
+  module Model
+    # 
+    class RankingParams
+      attr_accessor :view
+      
+
+      attr_accessor :entity_type
+      
+
+      attr_accessor :ids
+      
+
+      attr_accessor :scope
+      
+
+      attr_accessor :ip
+      
+
+      attr_accessor :user_agent
+      
+
+      attr_accessor :customer
+      
+
+      attr_accessor :anonymous
+      
+
+      # :internal => :external
+      def self.attribute_map
+        {
+          :view => :view,
+          :entity_type => :entityType,
+          :ids => :ids,
+          :scope => :scope,
+          :ip => :ip,
+          :user_agent => :userAgent,
+          :customer => :customer,
+          :anonymous => :anonymous
+
+        }
+      end
+
+      def initialize(attributes = {})
+        return if attributes.empty?
+        # Morph attribute keys into undescored rubyish style
+        if self.class.attribute_map[:"view"]
+          # Workaround since JSON.parse has accessors as strings rather than symbols
+            @view = attributes["view"] || attributes[:"view"]
+        end
+        if self.class.attribute_map[:"entity_type"]
+          # Workaround since JSON.parse has accessors as strings rather than symbols
+            @entity_type = attributes["entityType"] || attributes[:"entity_type"]
+        end
+        if self.class.attribute_map[:"ids"]
+          value = attributes["ids"] || attributes[:"ids"]
+            if value.is_a?(Array)
+              @ids = value
+
+            end
+          end
+        if self.class.attribute_map[:"scope"]
+          value = attributes["scope"] || attributes[:"scope"]
+            if value.is_a?(Array)
+              @scope = value.map{ |v| ScopeEntry.new(v) }
+
+            end
+          end
+        if self.class.attribute_map[:"ip"]
+          # Workaround since JSON.parse has accessors as strings rather than symbols
+            @ip = attributes["ip"] || attributes[:"ip"]
+        end
+        if self.class.attribute_map[:"user_agent"]
+          # Workaround since JSON.parse has accessors as strings rather than symbols
+            @user_agent = attributes["userAgent"] || attributes[:"user_agent"]
+        end
+        if self.class.attribute_map[:"customer"]
+          # Workaround since JSON.parse has accessors as strings rather than symbols
+            @customer = attributes["customer"] || attributes[:"customer"]
+        end
+        if self.class.attribute_map[:"anonymous"]
+          # Workaround since JSON.parse has accessors as strings rather than symbols
+            @anonymous = attributes["anonymous"] || attributes[:"anonymous"]
+        end
+        
+
+      end
+
+      def to_body
+        body = {}
+        self.class.attribute_map.each_pair do |key, value|
+          body[value] = self.send(key) unless self.send(key).nil?
+        end
+        body
+      end
+
+      def to_json(options = {})
+        to_body.to_json
+      end
+    end
+  end
+end
+

data/lib/attune/models/scopeentry.rb

@@ -0,0 +1,49 @@
+module Attune
+  module Model
+    # 
+    class ScopeEntry
+      attr_accessor :name
+      
+
+      attr_accessor :value
+      
+
+      # :internal => :external
+      def self.attribute_map
+        {
+          :name => :name,
+          :value => :value
+
+        }
+      end
+
+      def initialize(attributes = {})
+        return if attributes.empty?
+        # Morph attribute keys into undescored rubyish style
+        if self.class.attribute_map[:"name"]
+          # Workaround since JSON.parse has accessors as strings rather than symbols
+            @name = attributes["name"] || attributes[:"name"]
+        end
+        if self.class.attribute_map[:"value"]
+          # Workaround since JSON.parse has accessors as strings rather than symbols
+            @value = attributes["value"] || attributes[:"value"]
+        end
+        
+
+      end
+
+      def to_body
+        body = {}
+        self.class.attribute_map.each_pair do |key, value|
+          body[value] = self.send(key) unless self.send(key).nil?
+        end
+        body
+      end
+
+      def to_json(options = {})
+        to_body.to_json
+      end
+    end
+  end
+end
+

data/lib/attune/net_http_persistent.rb

@@ -13,3 +13,4 @@ module Attune
 
   end
 end
+

data/lib/attune/param_flattener.rb

@@ -15,3 +15,4 @@ module Attune
     end
   end
 end
+

data/lib/attune/version.rb

@@ -1,3 +1,4 @@
 module Attune
-  VERSION = "1.0.3"
+  VERSION = "1.0.5"
 end
+

data/spec/attune/client_spec.rb

@@ -26,23 +26,23 @@ describe Attune::Client do
 
   describe "API errors" do
     it "will raise timeout" do
-      stubs.post("anonymous", %[{"user_agent":"Mozilla/5.0"}]){ raise Faraday::Error::TimeoutError.new("test") }
+      stubs.post("anonymous", nil){ raise Faraday::Error::TimeoutError.new("test") }
       expect {
-        client.create_anonymous(user_agent: 'Mozilla/5.0')
+        client.anonymous.create
       }.to raise_exception(Faraday::Error::TimeoutError)
       stubs.verify_stubbed_calls
     end
     it "will raise ConnectionFailed" do
-      stubs.post("anonymous", %[{"user_agent":"Mozilla/5.0"}]){ raise Faraday::Error::ConnectionFailed.new("test") }
+      stubs.post("anonymous", nil){ raise Faraday::Error::ConnectionFailed.new("test") }
       expect {
-        client.create_anonymous(user_agent: 'Mozilla/5.0')
+        client.anonymous.create
       }.to raise_exception(Faraday::Error::ConnectionFailed)
       stubs.verify_stubbed_calls
     end
     it "will raise ConnectionFailed on Errno::ENOENT" do
-      stubs.post("anonymous", %[{"user_agent":"Mozilla/5.0"}]){ raise Errno::ENOENT.new("test") }
+      stubs.post("anonymous", nil){ raise Errno::ENOENT.new("test") }
       expect {
-        client.create_anonymous(user_agent: 'Mozilla/5.0')
+        client.anonymous.create
       }.to raise_exception(Faraday::Error::ConnectionFailed)
     end
     it "will raise AuthenticationException" do
@@ -61,7 +61,7 @@ describe Attune::Client do
       let(:options){ {disabled: true, exception_handler: :raise} }
       it "will raise DisalbedException" do
         expect {
-          client.create_anonymous(user_agent: 'Mozilla/5.0')
+          client.anonymous.create
         }.to raise_exception(Attune::DisabledException)
       end
     end
@@ -73,11 +73,11 @@ describe Attune::Client do
         expect(result).to match(/^[a-z0-9\-]+$/)
       end
       it "mocks create_anonymous with an id" do
-        result = client.create_anonymous(id: '12345', user_agent: 'Mozilla/5.0')
+        result = client.anonymous.create(id: '12345', user_agent: 'Mozilla/5.0')
         expect(result).to eq('12345')
       end
       it "mocks create_anonymous with no id" do
-        result = client.create_anonymous(user_agent: 'Mozilla/5.0')
+        result = client.anonymous.create(user_agent: 'Mozilla/5.0')
         expect(result).to match(/^[a-z0-9\-]+$/)
       end
       describe "mocks get_rankings" do
@@ -90,7 +90,7 @@ describe Attune::Client do
         end
 
         before(:each) do
-          @result = client.get_rankings(
+          @result = client.entities.get_rankings(
             id: 'abcd123',
             view: 'b/mens-pants',
             collection: 'products',
@@ -157,59 +157,66 @@ describe Attune::Client do
   end
 
   it "can create_anonymous generating an id" do
-    stubs.post("anonymous", %[{"user_agent":"Mozilla/5.0"}]){ [200, {location: 'urn:id:abcd123'}, nil] }
-    id = client.create_anonymous(user_agent: 'Mozilla/5.0')
+    stubs.post("anonymous", nil){ [200, {location: 'urn:id:abcd123'}, %[{"id": "abcd123"}]] }
+    result = client.anonymous.create
     stubs.verify_stubbed_calls
 
-    expect(id).to eq('abcd123')
+    expect(result.id).to eq('abcd123')
   end
 
   it "can bind" do
-    stubs.put("bindings/anonymous=abcd123&customer=foobar"){ [200, {}, nil] }
-    client.bind('abcd123', 'foobar')
+    stubs.put("anonymous/abcd123", %[{"customer":"foobar"}]){ [200, {}, nil] }
+    client.anonymous.update('abcd123', Attune::Model::Customer.new(customer:'foobar'))
     stubs.verify_stubbed_calls
   end
 
-  it "can create_anonymous using existing id" do
-    stubs.put("anonymous/abcd123", %[{"user_agent":"Mozilla/5.0"}]){ [200, {}, nil] }
-    id = client.create_anonymous(id: 'abcd123', user_agent: 'Mozilla/5.0')
+  it "get anonymous using existing id" do
+    stubs.get("anonymous/abcd123"){ [200, {}, %[{"customer":"foobar"}]] }
+    response = client.anonymous.get('abcd123')
     stubs.verify_stubbed_calls
 
-    expect(id).to eq('abcd123')
+    expect(response.customer).to eq('foobar')
   end
 
   describe "get_rankings" do
     before(:each) do
-      stubs.get("rankings/anonymous=abcd123&entities=1001%2C%2C1002%2C%2C1003%2C%2C1004&entity_collection=products&ip=none&view=b%2Fmens-pants"){ [200, {"attune-ranking"=>"test", "attune-cell"=>"test"}, %[{"ranking":["1004","1003","1002","1001"]}]] }
-      @rankings = client.get_rankings(
-        id: 'abcd123',
+      ranking_request = {
+        anonymous: 'abcd123',
         view: 'b/mens-pants',
-        collection: 'products',
-        entities: %w[1001, 1002, 1003, 1004]
-      )
+        entity_type: 'products',
+        ids: %w[1001, 1002, 1003, 1004]
+      }
+      stubs.post("entities/ranking", ranking_request.to_json){ [200, nil, %[{"ranking":["1004","1003","1002","1001"]}]] }
+      @rankings = client.entities.get_rankings(ranking_request)
       stubs.verify_stubbed_calls
     end
 
     it "can get ranked entities" do
-      expect(@rankings[:entities]).to eq(%W[1004 1003 1002 1001])
-    end
-
-    it "can get ranking headers" do
-      expect(@rankings[:headers]).to eq({"attune-ranking"=>"test", "attune-cell"=>"test"})
+      expect(@rankings.ranking).to eq(%W[1004 1003 1002 1001])
     end
   end
 
   describe "multi_get_rankings" do
-    let(:req1){ CGI::escape 'anonymous=0cddbc0-6114-11e3-949a-0800200c9a66&view=b%2Fmens-pants&entity_collection=products&entities=1001%2C%2C1002%2C%2C1003%2C%2C1004&ip=none' }
-    let(:req2){ CGI::escape 'anonymous=0cddbc0-6114-11e3-949a-0800200c9a66&view=b%2Fmens-pants&entity_collection=products&entities=2001%2C%2C2002%2C%2C2003%2C%2C2004&ip=none' }
-
     before(:each) do
-      stubs.get("/rankings?ids=anonymous%3D0cddbc0-6114-11e3-949a-0800200c9a66%26entities%3D1001%252C%252C1002%252C%252C1003%252C%252C1004%26entity_collection%3Dproducts%26ip%3Dnone%26view%3Db%252Fmens-pants&ids=anonymous%3D0cddbc0-6114-11e3-949a-0800200c9a66%26entities%3D2001%252C%252C2002%252C%252C2003%252C%252C2004%26entity_collection%3Dproducts%26ip%3Dnone%26view%3Db%252Fmens-pants") do
-        [200, {"attune-ranking"=>"test", "attune-cell"=>"test"}, <<-JSON]
+      batch_request = {requests: [
+        {
+          anonymous: '0cddbc0-6114-11e3-949a-0800200c9a66',
+          view: 'b/mens-pants',
+          entity_type: 'products',
+          ids: %w[1001, 1002, 1003, 1004]
+        },
+        {
+          anonymous: '0cddbc0-6114-11e3-949a-0800200c9a66',
+          view: 'b/mens-pants',
+          entity_type: 'products',
+          ids: %w[2001, 2002, 2003, 2004]
+        }
+      ]}
+      stubs.post("entities/ranking/many", batch_request.to_json) do
+        [200, nil, <<-JSON]
   {
-      "errors": {},
-      "results": {
-          "anonymous=0cddbc0-6114-11e3-949a-0800200c9a66&entities=1001%2C%2C1002%2C%2C1003%2C%2C1004&entity_collection=products&ip=none&view=b%2Fmens-pants": {
+      "results": [
+          {
               "ranking": [
                   "1004",
                   "1003",
@@ -217,7 +224,7 @@ describe Attune::Client do
                   "1001"
               ]
           },
-          "anonymous=0cddbc0-6114-11e3-949a-0800200c9a66&entities=2001%2C%2C2002%2C%2C2003%2C%2C2004&entity_collection=products&ip=none&view=b%2Fmens-pants": {
+          {
               "ranking": [
                   "2004",
                   "2003",
@@ -225,36 +232,21 @@ describe Attune::Client do
                   "2001"
               ]
           }
-      }
+      ]
   }
         JSON
       end
-      @rankings = client.multi_get_rankings([
-        {
-          id: '0cddbc0-6114-11e3-949a-0800200c9a66',
-          view: 'b/mens-pants',
-          collection: 'products',
-          entities: %w[1001, 1002, 1003, 1004]
-        },
-        {
-          id: '0cddbc0-6114-11e3-949a-0800200c9a66',
-          view: 'b/mens-pants',
-          collection: 'products',
-          entities: %w[2001, 2002, 2003, 2004]
-        }
-      ])
+      @results = client.entities.batch_get_rankings(batch_request)
       stubs.verify_stubbed_calls
     end
 
     it "can get ranked entities" do
-      expect(@rankings[:entities]).to eq [
+      rankings = @results.results.map {|r| r.ranking }
+      expect(rankings).to eq [
         %W[1004 1003 1002 1001],
         %W[2004 2003 2002 2001]
       ]
     end
-
-    it "can get ranking headers" do
-      expect(@rankings[:headers]).to eq({"attune-ranking"=>"test", "attune-cell"=>"test"})
-    end
   end
 end
+

data/spec/remote_spec.rb

@@ -21,49 +21,49 @@ describe "remote requests" do
   end
 
   it "can create an anonymous user" do
-    id = client.create_anonymous(user_agent: 'Mozilla/5.0')
-    id.should =~ /[a-z0-9\-]+/
+    result = client.anonymous.create
+    result.id.should =~ /[a-z0-9\-]+/
   end
 
-  it "can create an anonymous user with an id" do
-    id = client.create_anonymous(id: '123456', user_agent: 'Mozilla/5.0')
-    id.should == '123456'
-  end
-
-  it "can bind an anonymous user" do
-    id = client.create_anonymous(id: '123456', user_agent: 'Mozilla/5.0')
-    client.bind(id, '654321')
+  it "can bind and get an anonymous user" do
+    client.anonymous.update('654321', Attune::Model::Customer.new(customer:'foobar'))
+    customer = client.anonymous.get('654321')
+    customer.customer.should == 'foobar'
   end
 
   let(:entities){ [202875,202876,202874,202900,202902,202898,202905,200182,200181,185940,188447,185932,190589,1238689589] }
   describe "get_rankings" do
     before(:each) do
-      id = client.create_anonymous(id: '123456', user_agent: 'Mozilla/5.0')
-      client.bind(id, '654321')
-      @result = client.get_rankings(id: '123456', view: 'b/mens-pants', collection: 'products', entities: entities)
+      anonymous_result = client.anonymous.create
+      params = Attune::Model::RankingParams.new
+      params.anonymous = anonymous_result.id
+      params.view = 'b/mens-pants'
+      params.entity_type = 'products'
+      params.ids = entities
+      @result = client.entities.get_rankings(params)
     end
     it "can get ranked entities" do
-      @result[:entities].should be_an Array
-      @result[:entities].sort.should == entities.map(&:to_s).sort
+      @result.ranking.should be_an Array
+      @result.ranking.sort.should == entities.map(&:to_s).sort
     end
-    specify { expect(@result[:headers]).to be_a Hash }
-    specify { expect(@result[:headers]).to have_key "attune-ranking" }
-    specify { expect(@result[:headers]).to have_key "attune-cell" }
   end
 
   describe "multi_get_rankings" do
     before(:each) do
-      id = client.create_anonymous(id: '123456', user_agent: 'Mozilla/5.0')
-      client.bind(id, '654321')
-      @results = client.multi_get_rankings([id: '123456', view: 'b/mens-pants', collection: 'products', entities: entities])
+      anonymous_result = client.anonymous.create
+      params = Attune::Model::RankingParams.new
+      params.anonymous = anonymous_result.id
+      params.view = 'b/mens-pants'
+      params.entity_type = 'products'
+      params.ids = entities
+      batch_request = Attune::Model::BatchRankingRequest.new
+      batch_request.requests = [params]
+      @results = client.entities.batch_get_rankings(batch_request)
     end
     it "can batch get rankings" do
-      @results[:entities].should be_an Array
-      result, = *@results[:entities]
-      result.sort.should == entities.map(&:to_s).sort
+      @results.results.should be_an Array
+      ranking = @results.results[0].ranking
+      ranking.sort.should == entities.map(&:to_s).sort
     end
-    specify { expect(@results[:headers]).to be_a Hash }
-    specify { expect(@results[:headers]).to have_key "attune-ranking" }
-    specify { expect(@results[:headers]).to have_key "attune-cell" }
   end
 end