partigirb 0.2.7

data/lib/partigirb/transport.rb

@@ -0,0 +1,160 @@
+module Partigirb
+  
+  class Response #:nodoc:
+    attr_accessor :method, :request_uri, :status, :body
+    
+    def initialize(method,request_uri,status,body)
+      self.method = method
+      self.request_uri = request_uri
+      self.status = status
+      self.body = body
+    end
+  end
+  
+  class Transport
+    
+    attr_accessor :debug
+  
+    CRLF = "\r\n"
+    
+    def req_class(method)
+      case method
+        when :get then Net::HTTP::Get
+        when :post then Net::HTTP::Post
+        when :put then Net::HTTP::Put
+        when :delete then Net::HTTP::Delete
+      end
+    end
+    
+    # Options are one of
+    # - :params - a hash of parameters to be sent with the request. If a File is a parameter value, \
+    #             a multipart request will be sent. If a Time is included, .httpdate will be called on it.
+    # - :headers - a hash of headers to send with the request
+    def request(method, string_url, options={})
+      params = stringify_params(options[:params])
+      if method == :get && params
+        string_url << query_string(params)
+      end
+      url = URI.parse(string_url)
+      begin
+        execute_request(method,url,options)
+      rescue Timeout::Error
+        raise "Timeout while #{method}ing #{url.to_s}"
+      end
+    end
+    
+    def execute_request(method,url,options={})
+      conn = Net::HTTP.new(url.host, url.port)
+      #conn.use_ssl = (url.scheme == 'https')
+      conn.start do |http|
+        req = req_class(method).new(url.request_uri)
+        
+        add_headers(req,options[:headers])
+        if file_param?(options[:params])
+          add_multipart_data(req,options[:params])
+        else
+          add_form_data(req,options[:params])
+        end
+        
+        dump_request(req) if debug
+        res = http.request(req)
+        dump_response(res) if debug
+        res
+      end
+    end
+
+    def query_string(params)
+      query = case params
+        when Hash then params.map{|key,value| url_encode_param(key,value) }.join("&")
+        else url_encode(params.to_s)
+      end
+      if !(query == nil || query.length == 0) && query[0,1] != '?'
+        query = "?#{query}"
+      end
+      query
+    end      
+  
+    private
+      def stringify_params(params)
+        return nil unless params
+        params.inject({}) do |h, pair|
+          key, value = pair
+          if value.respond_to? :httpdate
+            value = value.httpdate
+          end
+          h[key] = value
+          h
+        end
+      end
+      
+      def file_param?(params)
+        return false unless params
+        params.any? {|key,value| value.respond_to? :read }
+      end
+      
+      def url_encode(value)
+        require 'cgi' unless defined?(CGI) && defined?(CGI::escape)
+        CGI.escape(value.to_s)
+      end
+      
+      def url_encode_param(key,value)
+        "#{url_encode(key)}=#{url_encode(value)}"
+      end
+      
+      def add_headers(req,headers)
+        if headers
+          headers.each do |header, value|
+            req[header] = value
+          end
+        end        
+      end
+    
+      def add_form_data(req,params)
+        if req.request_body_permitted? && params
+          req.set_form_data(params)
+        end
+      end
+    
+      def add_multipart_data(req,params)
+        boundary = Time.now.to_i.to_s(16)
+        req["Content-Type"] = "multipart/form-data; boundary=#{boundary}"
+        body = ""
+        params.each do |key,value|
+          esc_key = url_encode(key)
+          body << "--#{boundary}#{CRLF}"
+          if value.respond_to?(:read)
+            mime_type = MIME::Types.type_for(value.path)[0] || MIME::Types["application/octet-stream"][0]
+            body << "Content-Disposition: form-data; name=\"#{esc_key}\"; filename=\"#{File.basename(value.path)}\"#{CRLF}"
+            body << "Content-Type: #{mime_type.simplified}#{CRLF*2}"
+            body << value.read
+          else
+            body << "Content-Disposition: form-data; name=\"#{esc_key}\"#{CRLF*2}#{value}"
+          end
+          body << CRLF
+        end
+        body << "--#{boundary}--#{CRLF*2}"
+        req.body = body
+        req["Content-Length"] = req.body.size
+      end
+
+      private
+        
+        def dump_request(req)
+          puts "Sending Request"
+          puts"#{req.method} #{req.path}"
+          dump_headers(req)
+        end
+      
+        def dump_response(res)
+          puts "Received Response"
+          dump_headers(res)
+          puts res.body
+        end
+      
+        def dump_headers(msg)
+          msg.each_header do |key, value|
+            puts "\t#{key}=#{value}"
+          end
+        end
+  end
+end

data/lib/partigirb.rb

@@ -0,0 +1,27 @@
+module Partigirb
+  VERSION='0.1.0'
+  CURRENT_API_VERSION=1
+end
+
+$:.unshift File.dirname(__FILE__)
+
+require 'rubygems'
+
+require 'open-uri'
+require 'net/http'
+require 'base64'
+require 'digest'
+require 'rexml/document'
+require 'mime/types'
+require 'ostruct'
+
+require 'partigirb/core_ext'
+
+require 'partigirb/handlers/xml_handler'
+require 'partigirb/handlers/atom_handler'
+require 'partigirb/handlers/json_handler'
+require 'partigirb/handlers/string_handler'
+
+require 'partigirb/transport'
+require 'partigirb/client'
+

data/partigirb.gemspec

@@ -0,0 +1,76 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{partigirb}
+  s.version = "0.2.7"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Alvaro Bautista", "Fernando Blat"]
+  s.date = %q{2009-10-28}
+  s.email = ["alvarobp@gmail.com", "ferblape@gmail.com"]
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.markdown"
+  ]
+  s.files = [
+    ".gitignore",
+     "LICENSE",
+     "README.markdown",
+     "Rakefile",
+     "VERSION",
+     "examples/last_reviews_summary.rb",
+     "examples/who_ignores_me.rb",
+     "lib/partigirb.rb",
+     "lib/partigirb/client.rb",
+     "lib/partigirb/core_ext.rb",
+     "lib/partigirb/handlers/atom_handler.rb",
+     "lib/partigirb/handlers/json_handler.rb",
+     "lib/partigirb/handlers/string_handler.rb",
+     "lib/partigirb/handlers/xml_handler.rb",
+     "lib/partigirb/transport.rb",
+     "partigirb.gemspec",
+     "test/atom_handler_test.rb",
+     "test/client_test.rb",
+     "test/fixtures/alvaro_friends.atom.xml",
+     "test/fixtures/pulp_fiction.atom.xml",
+     "test/json_handler_test.rb",
+     "test/mocks/net_http_mock.rb",
+     "test/mocks/response_mock.rb",
+     "test/mocks/transport_mock.rb",
+     "test/test_helper.rb",
+     "test/transport_test.rb",
+     "test/xml_handler_test.rb"
+  ]
+  s.homepage = %q{http://github.com/partigi/partigirb}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.5}
+  s.summary = %q{A Ruby wrapper for the Partigi API}
+  s.test_files = [
+    "test/atom_handler_test.rb",
+     "test/client_test.rb",
+     "test/json_handler_test.rb",
+     "test/mocks/net_http_mock.rb",
+     "test/mocks/response_mock.rb",
+     "test/mocks/transport_mock.rb",
+     "test/test_helper.rb",
+     "test/transport_test.rb",
+     "test/xml_handler_test.rb",
+     "examples/last_reviews_summary.rb",
+     "examples/who_ignores_me.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end
+

data/test/atom_handler_test.rb

@@ -0,0 +1,61 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class AtomHandlerTest < Test::Unit::TestCase
+  def setup
+    @handler = Partigirb::Handlers::AtomHandler.new
+  end
+  
+  should "return a PartigiStruct with entry elements for feeds with just one entry" do
+    xmls = build_xml_string do |xml|
+      xml.instruct!
+      
+      xml.feed "xmlns" => "http://www.w3.org/2005/Atom" do
+        xml.title   "A feed"
+        xml.id      "http://the.feed.url.com"
+        xml.updated "2009-07-24T10:40:22Z"
+      
+        xml.entry({"xmlns:ptUser" => 'http://schemas.partigi.com/v1.0/ptUser'}) do
+          xml.category({:scheme => "http://schemas.partigi.com/v1.0#kind", :term => "http://schemas.partigi.com/v1.0#user"})
+          xml.id          "http://the.feed.url2.com"
+          xml.title       "User entry"
+          xml.ptUser :id, 321
+          xml.ptUser :login, "user_login"
+          xml.ptUser :name, "User Name"
+        end
+      end
+    end
+    
+    res = @handler.decode_response(xmls)
+    assert res.is_a?(Partigirb::PartigiStruct)
+    
+    assert_equal "User entry", res.title
+    assert_equal "http://the.feed.url2.com", res.id
+    assert_equal 321, res.ptUser_id
+    assert_equal "user_login", res.ptUser_login
+    assert_equal "User Name", res.ptUser_name
+    assert_nil res.updated
+  end
+  
+  should "return an array of PartigiStruct with PartigiStruct of each entry in the feed" do
+    xmls = build_xml_string do |xml|
+      xml.instruct!
+      
+      xml.feed "xmlns" => "http://www.w3.org/2005/Atom" do
+        xml.title   "A feed"      
+        xml.entry({"xmlns:ptUser" => 'http://schemas.partigi.com/v1.0/ptUser'}) do
+          xml.ptUser :id, 321
+        end
+        xml.entry({"xmlns:ptUser" => 'http://schemas.partigi.com/v1.0/ptUser'}) do
+          xml.ptUser :id, 123
+        end
+      end
+    end
+    
+    res = @handler.decode_response(xmls)
+    assert res.is_a?(Array)
+    assert_equal 2, res.size
+    
+    assert_equal 321, res[0].ptUser_id
+    assert_equal 123, res[1].ptUser_id
+  end
+end

data/test/client_test.rb

@@ -0,0 +1,209 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class ClientTest < Test::Unit::TestCase
+  def setup
+    @client = new_client
+  end
+  
+  should "use GET method by default" do
+    @client.users.show.xml
+    
+    assert_equal(:get, @client.transport.method)
+  end
+  
+  should "use GET method for methods ending with ?" do
+    @client.users.show.xml?
+    
+    assert_equal(:get, @client.transport.method)
+  end
+  
+  should "not make a request if format is missing" do
+    MockTransport.any_instance.expects(:request).never
+    
+    @client.users.show
+    
+    assert_nil @client.transport.url
+  end
+  
+  should "use POST method for methods ending with !" do
+    @client.users.show.xml!
+    
+    assert_equal(:post, @client.transport.method)
+  end
+  
+  should "use POST method and default format for methods ending with !" do
+    @client.friendships.create!
+    
+    assert_equal(:post, @client.transport.method)
+    assert @client.transport.url.path.include?("/friendships/create.atom")
+  end
+  
+  should "request to the Partigi API host through HTTP protocol" do
+    @client.users.show.xml
+    
+    assert_equal('http', @client.transport.url.scheme)
+    assert_equal(Partigirb::Client::PARTIGI_API_HOST, @client.transport.url.host)
+  end
+  
+  should "use the current API version by default" do
+    @client.users.show.xml
+    
+    assert_equal(Partigirb::CURRENT_API_VERSION, @client.api_version)
+  end
+  
+  should "put the requested API version in the request url" do
+    @client = new_client(200, '', {:api_version => 3})
+    @client.users.show.xml
+    
+    assert_equal '/api/v3/users/show.xml', @client.transport.url.path
+  end
+  
+  should "add paremeters to url on GET" do
+    @client.items.index.xml :type => 'film', :page => 1, :per_page => 20
+    
+    assert_equal 3, request_query.size
+    assert request_query.include?('type=film')
+    assert request_query.include?('page=1')
+    assert request_query.include?('per_page=20')
+  end
+  
+  should "add parameters to request body on POST" do
+    @client.reviews.create! :item_id => 'star-wars', :type => 'film', :status => 2, :text => 'My favorite movie', :rating => '5'
+    
+    assert_equal 5, post_data.size
+    assert post_data.include?('item_id=star-wars')
+    assert post_data.include?('type=film')
+    assert post_data.include?('status=2')
+    assert post_data.include?('text=My%20favorite%20movie')
+    assert post_data.include?('rating=5')
+  end
+  
+  should "add any headers to the HTTP requests" do
+    @client = new_client(200, '', {:headers => {'Useless' => 'void', 'Fake' => 'header'}})
+    @client.user.show.xml
+    
+    assert_not_nil Net::HTTP.request['Useless']
+    assert_equal 'void', Net::HTTP.request['Useless']
+    assert_not_nil Net::HTTP.request['Fake']
+    assert_equal 'header', Net::HTTP.request['Fake']
+  end
+  
+  should "add authentication headers when login and secret are provided" do
+    @client = new_client(200, '', :auth => {:login => 'auser', :api_secret => 'his_api_secret'})
+    
+    @client.friendships.update! :id => 321
+    
+    assert_not_nil Net::HTTP.request['Authorization']
+    assert_equal "WSSE realm=\"#{Partigirb::Client::PARTIGI_API_HOST}\", profile=\"UsernameToken\"", Net::HTTP.request['Authorization']
+    
+    assert_not_nil Net::HTTP.request['X-WSSE']
+    assert_match /UsernameToken Username="auser", PasswordDigest="[^"]+", Nonce="[^"]+", Created="[^"]+"/, Net::HTTP.request['X-WSSE']
+  end
+  
+  should "not add authentication headers if no auth params are provided" do
+    @client.friendships.update! :id => 321
+    
+    assert_nil Net::HTTP.request['Authorization']
+    assert_nil Net::HTTP.request['X-WSSE']
+  end
+  
+  should "use given nonce for authentication" do
+    @client = new_client(200, '', :auth => {:login => 'auser', :api_secret => 'his_api_secret', :nonce => '123456789101112'})
+    @client.friendships.update! :id => 321
+    
+    assert_equal "WSSE realm=\"#{Partigirb::Client::PARTIGI_API_HOST}\", profile=\"UsernameToken\"", Net::HTTP.request['Authorization']
+    assert_match /UsernameToken Username="auser", PasswordDigest="[^"]+", Nonce="123456789101112", Created="[^"]+"/, Net::HTTP.request['X-WSSE']
+  end
+  
+  should "use given timestamp string for authentication" do
+    @client = new_client(200, '', :auth => {:login => 'auser', :api_secret => 'his_api_secret', :timestamp => '2009-07-15T14:43:07Z'})
+    @client.friendships.update! :id => 321
+    
+    assert_equal "WSSE realm=\"#{Partigirb::Client::PARTIGI_API_HOST}\", profile=\"UsernameToken\"", Net::HTTP.request['Authorization']
+    assert_match /UsernameToken Username="auser", PasswordDigest="[^"]+", Nonce="[^"]+", Created="2009-07-15T14:43:07Z"/, Net::HTTP.request['X-WSSE']
+  end
+  
+  should "use given Time object as timestamp for authentication" do
+    timestamp = Time.now
+    @client = new_client(200, '', :auth => {:login => 'auser', :api_secret => 'his_api_secret', :timestamp => timestamp})
+    @client.friendships.update! :id => 321
+    
+    assert_equal "WSSE realm=\"#{Partigirb::Client::PARTIGI_API_HOST}\", profile=\"UsernameToken\"", Net::HTTP.request['Authorization']
+    assert_match /UsernameToken Username="auser", PasswordDigest="[^"]+", Nonce="[^"]+", Created="#{timestamp.strftime(Partigirb::Client::TIMESTAMP_FORMAT)}"/, Net::HTTP.request['X-WSSE']
+  end
+  
+  should "use the PasswordDigest from given parameters" do
+    @client = new_client(200, '', :auth => {:login => 'auser', :api_secret => 'his_api_secret', :nonce => '123456789101112', :timestamp => '2009-07-15T14:43:07Z'})
+    @client.friendships.update! :id => 321
+    
+    pdigest = Base64.encode64(Digest::SHA1.hexdigest("1234567891011122009-07-15T14:43:07Zauserhis_api_secret")).chomp
+    
+    assert_equal "WSSE realm=\"#{Partigirb::Client::PARTIGI_API_HOST}\", profile=\"UsernameToken\"", Net::HTTP.request['Authorization']
+    assert_match /UsernameToken Username="auser", PasswordDigest="#{pdigest}", Nonce="123456789101112", Created="2009-07-15T14:43:07Z"/, Net::HTTP.request['X-WSSE']
+  end
+  
+  context "generate_nonce method" do
+    should "generate random strings" do
+      @client.instance_eval do
+        nonces = []
+        1.upto(25) do
+          assert !nonces.include?(generate_nonce)
+        end
+      end
+    end
+  end
+  
+  should "process XML response by XML handler" do
+    Partigirb::Handlers::XMLHandler.any_instance.expects(:decode_response).once
+    Partigirb::Handlers::AtomHandler.any_instance.expects(:decode_response).never
+    Partigirb::Handlers::JSONHandler.any_instance.expects(:decode_response).never
+    @client.items.xml
+  end
+
+  should "process Atom response by Atom handler" do
+    Partigirb::Handlers::XMLHandler.any_instance.expects(:decode_response).never
+    Partigirb::Handlers::AtomHandler.any_instance.expects(:decode_response).once
+    Partigirb::Handlers::JSONHandler.any_instance.expects(:decode_response).never
+    @client.items.atom
+  end
+
+  should "process JSON response by JSON handler" do
+    Partigirb::Handlers::XMLHandler.any_instance.expects(:decode_response).never
+    Partigirb::Handlers::AtomHandler.any_instance.expects(:decode_response).never
+    Partigirb::Handlers::JSONHandler.any_instance.expects(:decode_response).once
+    @client.items.json
+  end  
+  
+  should "raise a PartigiError with response error text as the message when http response codes are other than 200" do
+   client = new_client(400, "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<error>Partigi::BadAPIRequestRequiredParams</error>\n")
+   
+   begin
+     client.items.show.xml :id => 'madeup'
+   rescue Exception => e
+     assert e.is_a?(Partigirb::PartigiError)
+     assert_equal 'Partigi::BadAPIRequestRequiredParams', e.message
+   end
+  end
+  
+  # Copied from Grackle
+  should "clear the request path on clear" do
+    client = new_client(200,'[{"id":1,"text":"test 1"}]')
+    client.some.url.that.does.not.exist
+    assert_equal('/some/url/that/does/not/exist',client.send(:request).path,"An unexecuted path should be build up")
+    client.clear
+    assert_equal('',client.send(:request).path,"The path shoudl be cleared")
+  end
+  
+  should "use multipart encoding when using a file param" do
+    client = new_client(200,'')
+    client.account.update_profile_image! :image=>File.new(__FILE__)    
+    assert_match(/multipart\/form-data/,Net::HTTP.request['Content-Type'])
+  end
+  
+  should "escape and encode time param" do
+    client = new_client(200,'')
+    time = Time.now-60*60
+    client.statuses.public_timeline? :since=>time  
+    assert_equal("/api/v#{Partigirb::CURRENT_API_VERSION}/statuses/public_timeline.atom?since=#{CGI::escape(time.httpdate)}", Net::HTTP.request.path)
+  end
+end

data/test/fixtures/alvaro_friends.atom.xml

@@ -0,0 +1,80 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<feed xmlns="http://www.w3.org/2005/Atom">
+  <title>user/7/friends &#187; Partigi</title>
+  <id>http://www.partigi.com/api/v1/friends/show/7.atom</id>
+  <updated>2009-07-23T10:08:14Z</updated>
+  <link type="application/atom+xml" href="http://www.partigi.com/api/v1/friends/show/7.atom" rel="self"/>
+  <link type="text/html" href="http://www.partigi.com/alvarobp/friends/follows" rel="alternate"/>
+  <author>
+    <name>Partigi</name>
+  </author>
+  <entry xmlns:ptUser="http://schemas.partigi.com/v1.0/ptUser">
+    <category scheme="http://schemas.partigi.com/v1.0#kind" term="http://schemas.partigi.com/v1.0#user"/>
+    <id>http://www.partigi.com/friend1</id>
+    <title>Friend 1</title>
+    <updated>2009-07-24T19:16:14Z</updated>
+    <published>2009-07-23T10:07:49Z</published>
+    <link type="text/html" href="http://www.partigi.com/friend1" rel="alternate"/>
+    <link type="application/atom+xml" href="http://www.partigi.com/api/v1/users/show.atom?id=friend1" rel="self"/>
+    <ptUser:id>440</ptUser:id>
+    <ptUser:login>friend1</ptUser:login>
+    <ptUser:name>Friend 1</ptUser:name>
+    <ptUser:surname>Surname 1</ptUser:surname>
+    <ptUser:country>ES</ptUser:country>
+  </entry>
+  <entry xmlns:ptUser="http://schemas.partigi.com/v1.0/ptUser">
+    <category scheme="http://schemas.partigi.com/v1.0#kind" term="http://schemas.partigi.com/v1.0#user"/>
+    <id>http://www.partigi.com/friend2</id>
+    <title>Friend 2</title>
+    <updated>2009-07-23T10:15:18Z</updated>
+    <published>2009-07-03T04:20:09Z</published>
+    <link type="text/html" href="http://www.partigi.com/friend2" rel="alternate"/>
+    <link type="application/atom+xml" href="http://www.partigi.com/api/v1/users/show.atom?id=friend2" rel="self"/>
+    <ptUser:id>357</ptUser:id>
+    <ptUser:login>friend2</ptUser:login>
+    <ptUser:name>Friend 2</ptUser:name>
+    <ptUser:surname>Surname 2</ptUser:surname>
+    <ptUser:country>ES</ptUser:country>
+  </entry>
+  <entry xmlns:ptUser="http://schemas.partigi.com/v1.0/ptUser">
+    <category scheme="http://schemas.partigi.com/v1.0#kind" term="http://schemas.partigi.com/v1.0#user"/>
+    <id>http://www.partigi.com/friend3</id>
+    <title>Friend 3</title>
+    <updated>2009-07-18T17:05:42Z</updated>
+    <published>2009-07-18T17:04:43Z</published>
+    <link type="text/html" href="http://www.partigi.com/friend3" rel="alternate"/>
+    <link type="application/atom+xml" href="http://www.partigi.com/api/v1/users/show.atom?id=friend3" rel="self"/>
+    <ptUser:id>408</ptUser:id>
+    <ptUser:login>friend3</ptUser:login>
+    <ptUser:name>Friend 3</ptUser:name>
+    <ptUser:surname>Surname 3</ptUser:surname>
+    <ptUser:country>ES</ptUser:country>
+  </entry>
+  <entry xmlns:ptUser="http://schemas.partigi.com/v1.0/ptUser">
+    <category scheme="http://schemas.partigi.com/v1.0#kind" term="http://schemas.partigi.com/v1.0#user"/>
+    <id>http://www.partigi.com/friend4</id>
+    <title>Friend 4</title>
+    <updated>2009-07-18T12:35:46Z</updated>
+    <published>2009-05-20T13:51:09Z</published>
+    <link type="text/html" href="http://www.partigi.com/friend4" rel="alternate"/>
+    <link type="application/atom+xml" href="http://www.partigi.com/api/v1/users/show.atom?id=friend4" rel="self"/>
+    <ptUser:id>183</ptUser:id>
+    <ptUser:login>friend4</ptUser:login>
+    <ptUser:name>Friend 4</ptUser:name>
+    <ptUser:surname>Surname 4</ptUser:surname>
+  </entry>
+  <entry xmlns:ptUser="http://schemas.partigi.com/v1.0/ptUser">
+    <category scheme="http://schemas.partigi.com/v1.0#kind" term="http://schemas.partigi.com/v1.0#user"/>
+    <id>http://www.partigi.com/friend5</id>
+    <title>Friend 5</title>
+    <updated>2009-07-19T17:27:53Z</updated>
+    <published>2009-06-04T11:37:17Z</published>
+    <link type="text/html" href="http://www.partigi.com/friend5" rel="alternate"/>
+    <link type="application/atom+xml" href="http://www.partigi.com/api/v1/users/show.atom?id=friend5" rel="self"/>
+    <ptUser:id>249</ptUser:id>
+    <ptUser:login>friend5</ptUser:login>
+    <ptUser:name>Friend 5</ptUser:name>
+    <ptUser:surname>Surname 5</ptUser:surname>
+    <ptUser:country>ES</ptUser:country>
+  </entry>
+</feed>