koala 0.9.0 → 1.1.0

data/spec/cases/realtime_updates_spec.rb

@@ -0,0 +1,184 @@
+require 'spec_helper'
+
+describe "Koala::Facebook::RealtimeUpdates" do
+  before :all do
+    # get oauth data
+    @oauth_data = $testing_data["oauth_test_data"]
+    @app_id = @oauth_data["app_id"]
+    @secret = @oauth_data["secret"]
+    @callback_url = @oauth_data["callback_url"]
+    @app_access_token = @oauth_data["app_access_token"]
+    
+    # check OAuth data
+    unless @app_id && @secret && @callback_url && @app_access_token
+      raise Exception, "Must supply OAuth app id, secret, app_access_token, and callback to run live subscription tests!" 
+    end
+    
+    # get subscription data
+    @subscription_data = $testing_data["subscription_test_data"]
+    @verify_token = @subscription_data["verify_token"]
+    @challenge_data = @subscription_data["challenge_data"]
+    @subscription_path = @subscription_data["subscription_path"]
+    
+    # check subscription data
+    unless @verify_token && @challenge_data && @subscription_path
+      raise Exception, "Must supply verify_token and equivalent challenge_data to run live subscription tests!" 
+    end
+  end
+
+  describe "when initializing" do
+    # basic initialization
+    it "should initialize properly with an app_id and an app_access_token" do
+      updates = Koala::Facebook::RealtimeUpdates.new(:app_id => @app_id, :app_access_token => @app_access_token)
+      updates.should be_a(Koala::Facebook::RealtimeUpdates)
+    end
+    
+    # attributes
+    it "should allow read access to app_id, app_access_token, and secret" do
+      updates = Koala::Facebook::RealtimeUpdates.new(:app_id => @app_id, :app_access_token => @app_access_token)
+      # this should not throw errors
+      updates.app_id && updates.app_access_token && updates.secret
+    end
+    
+    it "should not allow write access to app_id" do
+      updates = Koala::Facebook::RealtimeUpdates.new(:app_id => @app_id, :app_access_token => @app_access_token)
+      # this should not throw errors
+      updates.methods.map(&:to_sym).should_not include(:app_id=)
+    end
+
+    it "should not allow write access to app_access_token" do
+      updates = Koala::Facebook::RealtimeUpdates.new(:app_id => @app_id, :app_access_token => @app_access_token)
+      # this should not throw errors
+      updates.methods.map(&:to_sym).should_not include(:app_access_token=)
+    end
+  
+    it "should not allow write access to secret" do
+      updates = Koala::Facebook::RealtimeUpdates.new(:app_id => @app_id, :app_access_token => @app_access_token)
+      # this should not throw errors
+      updates.methods.map(&:to_sym).should_not include(:secret=)
+    end
+    
+    # init with secret / fetching the token
+    it "should initialize properly with an app_id and a secret" do 
+      updates = Koala::Facebook::RealtimeUpdates.new(:app_id => @app_id, :secret => @secret)
+      updates.should be_a(Koala::Facebook::RealtimeUpdates)      
+    end
+
+    it "should fetch an app_token from Facebook when provided an app_id and a secret" do 
+      updates = Koala::Facebook::RealtimeUpdates.new(:app_id => @app_id, :secret => @secret)
+      updates.app_access_token.should_not be_nil
+    end
+    
+    it "should use the OAuth class to fetch a token when provided an app_id and a secret" do
+      oauth = Koala::Facebook::OAuth.new(@app_id, @secret)
+      token = oauth.get_app_access_token
+      oauth.should_receive(:get_app_access_token).and_return(token)
+      Koala::Facebook::OAuth.should_receive(:new).with(@app_id, @secret).and_return(oauth) 
+      updates = Koala::Facebook::RealtimeUpdates.new(:app_id => @app_id, :secret => @secret)
+    end
+  end
+
+  describe "when used" do
+    before :each do 
+      @updates = Koala::Facebook::RealtimeUpdates.new(:app_id => @app_id, :secret => @secret)
+    end
+    
+    it "should send a subscription request to a valid server" do
+      result = @updates.subscribe("user", "name", @subscription_path, @verify_token)
+      result.should be_true
+    end
+    
+    it "should send a subscription request to a valid server" do
+      result = @updates.subscribe("user", "name", @subscription_path, @verify_token)
+      result.should be_true
+    end
+    
+    it "should send a subscription request to an invalid path on a valid server" do
+      lambda { result = @updates.subscribe("user", "name", @subscription_path + "foo", @verify_token) }.should raise_exception(Koala::Facebook::APIError)
+    end
+    
+    it "should fail to send a subscription request to an invalid server" do
+      lambda { @updates.subscribe("user", "name", "foo", @verify_token) }.should raise_exception(Koala::Facebook::APIError)
+    end
+  
+    it "should unsubscribe a valid individual object successfully" do 
+      @updates.unsubscribe("user").should be_true
+    end
+
+    it "should unsubscribe all subscriptions successfully" do 
+      @updates.unsubscribe.should be_true
+    end
+
+    it "should fail when an invalid object is provided to unsubscribe" do 
+      lambda { @updates.unsubscribe("kittens") }.should raise_error(Koala::Facebook::APIError)
+    end
+    
+    it "should is subscriptions properly" do
+      @updates.list_subscriptions.should be_a(Array)
+    end
+  end # describe "when used"
+  
+  describe "when meeting challenge" do
+    it "should return false if hub.mode isn't subscribe" do
+      params = {'hub.mode' => 'not subscribe'}
+      Koala::Facebook::RealtimeUpdates.meet_challenge(params).should be_false
+    end
+    
+    it "should return false if not given a verify_token or block" do
+      params = {'hub.mode' => 'subscribe'}
+      Koala::Facebook::RealtimeUpdates.meet_challenge(params).should be_false
+    end
+    
+    describe "and mode is 'subscribe'" do
+      before(:each) do 
+        @params = {'hub.mode' => 'subscribe'}
+      end
+      
+      describe "and a token is given" do
+        before(:each) do
+          @token = 'token'
+          @params['hub.verify_token'] = @token
+        end
+        
+        it "should return false if the given verify token doesn't match" do
+          Koala::Facebook::RealtimeUpdates.meet_challenge(@params, @token + '1').should be_false
+        end
+        
+        it "should return the challenge if the given verify token matches" do
+          @params['hub.challenge'] = 'challenge val'
+          Koala::Facebook::RealtimeUpdates.meet_challenge(@params, @token).should == @params['hub.challenge']
+        end
+      end
+      
+      describe "and a block is given" do
+        it "should give the block the token as a parameter" do
+          Koala::Facebook::RealtimeUpdates.meet_challenge(@params)do |token|
+            token.should == @token
+          end
+        end
+        
+        it "should return false if the given block return false" do
+          Koala::Facebook::RealtimeUpdates.meet_challenge(@params)do |token|
+            false
+          end.should be_false
+        end
+        
+        it "should return false if the given block returns nil" do
+          Koala::Facebook::RealtimeUpdates.meet_challenge(@params)do |token|
+            nil
+          end.should be_false
+        end
+        
+        it "should return the challenge if the given block returns true" do
+          @params['hub.challenge'] = 'challenge val'
+          Koala::Facebook::RealtimeUpdates.meet_challenge(@params) do |token|
+            true
+          end.should be_true
+        end
+      end
+    
+    end # describe "and mode is subscribe"
+    
+  end # describe "when meeting challenge"
+  
+end # describe

data/spec/cases/rest_api_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe "Koala::Facebook::RestAPI" do
+  
+  context "without an access token" do
+    before :each do
+      @api = Koala::Facebook::RestAPI.new
+    end
+
+    it_should_behave_like "Koala RestAPI"
+    it_should_behave_like "Koala RestAPI without an access token"
+  end
+  
+  context "with an access token" do
+    include LiveTestingDataHelper
+
+    before :each do
+      @api = Koala::Facebook::RestAPI.new(@token)
+    end
+
+    it_should_behave_like "Koala RestAPI"
+    it_should_behave_like "Koala RestAPI with an access token"
+  end
+  
+end

data/spec/cases/test_users_spec.rb

@@ -0,0 +1,221 @@
+require 'spec_helper'
+
+describe "Koala::Facebook::TestUsers" do
+  context "with access token" do
+    include LiveTestingDataHelper
+
+    before :all do
+      # get oauth data
+      @oauth_data = $testing_data["oauth_test_data"]
+      @app_id = @oauth_data["app_id"]
+      @secret = @oauth_data["secret"]
+      @app_access_token = @oauth_data["app_access_token"]
+
+      # check OAuth data
+      unless @app_id && @secret && @app_access_token
+        raise Exception, "Must supply OAuth app id, secret, app_access_token, and callback to run live subscription tests!"
+      end
+
+      @is_mock = Koala.http_service.respond_to?(:mock?) && Koala.http_service.mock?
+    end
+
+    describe "when initializing" do
+      # basic initialization
+      it "should initialize properly with an app_id and an app_access_token" do
+        test_users = Koala::Facebook::TestUsers.new(:app_id => @app_id, :app_access_token => @app_access_token)
+        test_users.should be_a(Koala::Facebook::TestUsers)
+      end
+
+      # init with secret / fetching the token
+      it "should initialize properly with an app_id and a secret" do
+        test_users = Koala::Facebook::TestUsers.new(:app_id => @app_id, :secret => @secret)
+        test_users.should be_a(Koala::Facebook::TestUsers)
+      end
+
+      it "should use the OAuth class to fetch a token when provided an app_id and a secret" do
+        oauth = Koala::Facebook::OAuth.new(@app_id, @secret)
+        token = oauth.get_app_access_token
+        oauth.should_receive(:get_app_access_token).and_return(token)
+        Koala::Facebook::OAuth.should_receive(:new).with(@app_id, @secret).and_return(oauth)
+        test_users = Koala::Facebook::TestUsers.new(:app_id => @app_id, :secret => @secret)
+      end
+    end
+
+    describe "when used without network" do
+      before :each do
+        @test_users = Koala::Facebook::TestUsers.new({:app_access_token => @app_access_token, :app_id => @app_id})
+      end
+
+      # TEST USER MANAGEMENT
+      it "should create a test user when not given installed" do
+        result = @test_users.create(false)
+        @temporary_object_id = result["id"]
+        result.should be_a(Hash)
+        (result["id"] && result["access_token"] && result["login_url"]).should
+      end
+
+      it "should create a test user when not given installed, ignoring permissions" do
+        result = @test_users.create(false, "read_stream")
+        @temporary_object_id = result["id"]
+        result.should be_a(Hash)
+        (result["id"] && result["access_token"] && result["login_url"]).should
+      end
+
+      it "should accept permissions as a string" do
+        @test_users.graph_api.should_receive(:graph_call).with(anything, hash_including("permissions" => "read_stream,publish_stream"), anything, anything)
+        result = @test_users.create(true, "read_stream,publish_stream")
+      end
+
+      it "should accept permissions as an array" do
+        @test_users.graph_api.should_receive(:graph_call).with(anything, hash_including("permissions" => "read_stream,publish_stream"), anything, anything)
+        result = @test_users.create(true, ["read_stream", "publish_stream"])
+      end
+
+      it "should create a test user when given installed and a permission" do
+        result = @test_users.create(true, "read_stream")
+        @temporary_object_id = result["id"]
+        result.should be_a(Hash)
+        (result["id"] && result["access_token"] && result["login_url"]).should
+      end
+
+      it "lets you specify other graph arguments, like uid and access token" do
+        args = {:uid => "some test user ID", :owner_access_token => "some owner access token"}
+        @test_users.graph_api.should_receive(:graph_call).with(anything, hash_including(args), anything, anything)
+        @test_users.create(true, nil, args)
+      end
+      
+      it "lets you specify http options that get passed through to the graph call" do
+        options = {:some_http_option => true}
+        @test_users.graph_api.should_receive(:graph_call).with(anything, anything, anything, options)
+        @test_users.create(true, nil, {}, options)
+      end
+
+      describe "with a user to delete" do
+        before :each do
+          @user1 = @test_users.create(true, "read_stream")
+          @user2 = @test_users.create(true, "read_stream,user_interests")
+        end
+
+        after :each do
+          @test_users.delete(@user1) if @user1
+          @test_users.delete(@user2) if @user2
+        end
+
+        it "should delete a user by id" do
+          @test_users.delete(@user1['id']).should be_true
+          @user1 = nil
+        end
+
+        it "should delete a user by hash" do
+          @test_users.delete(@user2).should be_true
+          @user2 = nil
+        end
+
+        it "should not delete users when provided a false ID" do
+          lambda { @test_users.delete("#{@user1['id']}1") }.should raise_exception(Koala::Facebook::APIError)
+        end
+      end
+
+      describe "with delete_all" do
+        it "should delete all users found by the list commnand" do
+          array = [1, 2, 3]
+          @test_users.should_receive(:list).and_return(array)
+          array.each {|i| @test_users.should_receive(:delete).with(i) }
+          @test_users.delete_all
+        end
+      end
+
+      describe "with existing users" do
+        before :each do
+          @user1 = @test_users.create(true, "read_stream")
+          @user2 = @test_users.create(true, "read_stream,user_interests")
+        end
+
+        after :each do
+          @test_users.delete(@user1)
+          @test_users.delete(@user2)
+        end
+
+        it "should list test users" do
+          result = @test_users.list
+          result.should be_an(Array)
+          first_user, second_user = result[0], result[1]
+          (first_user["id"] && first_user["access_token"] && first_user["login_url"]).should
+          (second_user["id"] && second_user["access_token"] && second_user["login_url"]).should
+        end
+      
+        it "should make two users into friends with string hashes" do
+          result = @test_users.befriend(@user1, @user2)
+          result.should be_true
+        end
+      
+        it "should make two users into friends with symbol hashes" do
+          new_user_1 = {}
+          @user1.each_pair {|k, v| new_user_1[k.to_sym] = v}
+          new_user_2 = {}
+          @user2.each_pair {|k, v| new_user_2[k.to_sym] = v}
+        
+          result = @test_users.befriend(new_user_1, new_user_2)
+          result.should be_true
+        end        
+      
+        it "should not accept user IDs anymore" do
+          lambda { @test_users.befriend(@user1["id"], @user2["id"]) }.should raise_exception
+        end
+      end # with existing users
+
+    end # when used without network
+
+    describe "when creating a network of friends" do
+      before :each do
+        @test_users = Koala::Facebook::TestUsers.new({:app_access_token => @app_access_token, :app_id => @app_id})
+        @network = []
+
+        if @is_mock
+          id_counter = 999999900
+          @test_users.stub!(:create).and_return do
+            id_counter += 1
+            {"id" => id_counter, "access_token" => @token, "login_url" => "https://www.facebook.com/platform/test_account.."}
+          end
+          @test_users.stub!(:befriend).and_return(true)
+          @test_users.stub!(:delete).and_return(true)
+        end
+      end
+
+      describe "tests that create users" do
+        before :each do
+          test_users = Koala::Facebook::TestUsers.new({:app_access_token => @app_access_token, :app_id => @app_id})
+          test_users.delete_all
+        end
+
+        after :each do
+          test_users = Koala::Facebook::TestUsers.new({:app_access_token => @app_access_token, :app_id => @app_id})
+          test_users.delete_all
+        end
+
+        it "should create a 5 person network" do
+          size = 5
+          @network = @test_users.create_network(size)
+          @network.should be_a(Array)
+          @network.size.should == size
+        end
+      end
+
+      it "should limit to a 50 person network" do
+        @test_users.should_receive(:create).exactly(50).times
+        @test_users.stub!(:befriend)
+        @network = @test_users.create_network(51)
+      end
+
+      it "should pass on the installed and permissions parameters to create" do
+        perms = ["read_stream", "offline_access"]
+        installed = false
+        count = 25
+        @test_users.should_receive(:create).exactly(count).times.with(installed, perms)
+        @test_users.stub!(:befriend)
+        @network = @test_users.create_network(count, installed, perms)
+      end
+
+    end # when creating network
+  end
+end  # describe Koala TestUsers

data/spec/cases/uploadable_io_spec.rb

@@ -0,0 +1,193 @@
+# fake MIME::Types
+module Koala::MIME
+  module Types
+    def self.type_for(type)
+      # this should be faked out in tests
+      nil
+    end
+  end
+end
+
+describe "Koala::UploadableIO" do
+  def rails_3_mocks
+    tempfile = stub('Tempfile', :path => "foo")
+    uploaded_file = stub('ActionDispatch::Http::UploadedFile',
+      :content_type => true,
+      :tempfile => tempfile
+    )
+    tempfile.stub!(:respond_to?).with(:path).and_return(true)
+
+    [tempfile, uploaded_file]
+  end
+  
+  def sinatra_mocks
+    {:type => "type", :tempfile => "Tempfile"}
+  end
+  
+  describe "the constructor" do
+    describe "when given a file path" do
+      before(:each) do
+        @koala_io_params = [File.open(BEACH_BALL_PATH)]
+      end
+
+      describe "and a content type" do
+        before :each do
+          @koala_io_params.concat([stub("image/jpg")])
+        end
+
+        it "should return an UploadIO with the same file path" do
+          stub_path = @koala_io_params[0] = "/stub/path/to/file"
+          Koala::UploadableIO.new(*@koala_io_params).io_or_path.should == stub_path
+        end
+
+        it "should return an UploadIO with the same content type" do
+          stub_type = @koala_io_params[1] = stub('Content Type')
+          Koala::UploadableIO.new(*@koala_io_params).content_type.should == stub_type
+        end
+
+        it "should detect that NetHTTPService must be used" do
+          @koala_io_params[0] = mock
+          @koala_io_params[0].stub!(:read)
+          Koala::UploadableIO.new(*@koala_io_params).requires_base_http_service.should be_true
+        end
+      end
+
+      describe "and no content type" do
+        it_should_behave_like "determining a mime type"
+      end
+    end
+
+    describe "when given a File object" do
+      before(:each) do
+        @koala_io_params = [File.open(BEACH_BALL_PATH)]
+      end
+
+      describe "and a content type" do
+        before :each do
+          @koala_io_params.concat(["image/jpg"])
+        end
+
+        it "should return an UploadIO with the same io" do
+          Koala::UploadableIO.new(*@koala_io_params).io_or_path.should == @koala_io_params[0]
+        end
+
+        it "should return an UplaodIO with the same content_type" do
+          content_stub = @koala_io_params[1] = stub('Content Type')
+          Koala::UploadableIO.new(*@koala_io_params).content_type.should == content_stub
+        end
+      end
+
+      describe "and no content type" do
+        it_should_behave_like "determining a mime type"
+      end
+    end
+
+    describe "when given a Rails 3 ActionDispatch::Http::UploadedFile" do
+      before(:each) do
+        @tempfile, @uploaded_file = rails_3_mocks
+      end
+
+      it "should get the content type via the content_type method" do
+        expected_content_type = stub('Content Type')
+        @uploaded_file.should_receive(:content_type).and_return(expected_content_type)
+        Koala::UploadableIO.new(@uploaded_file).content_type.should == expected_content_type
+      end
+
+      it "should get the path from the tempfile associated with the UploadedFile" do
+        expected_path = stub('Tempfile')
+        @tempfile.should_receive(:path).and_return(expected_path)
+        Koala::UploadableIO.new(@uploaded_file).io_or_path.should == expected_path
+      end
+    end
+
+    describe "when given a Sinatra file parameter hash" do
+      before(:each) do
+        @file_hash = sinatra_mocks
+      end
+
+      it "should get the content type from the :type key" do
+        expected_content_type = stub('Content Type')
+        @file_hash[:type] = expected_content_type
+
+        uploadable = Koala::UploadableIO.new(@file_hash)
+        uploadable.content_type.should == expected_content_type
+      end
+
+      it "should get the io_or_path from the :tempfile key" do
+        expected_file = stub('File')
+        @file_hash[:tempfile] = expected_file
+
+        uploadable = Koala::UploadableIO.new(@file_hash)
+        uploadable.io_or_path.should == expected_file
+      end
+    end
+
+    describe "for files with with recognizable MIME types" do
+      # what that means is tested below
+      it "should accept a file object alone" do
+        params = [BEACH_BALL_PATH]
+        lambda { Koala::UploadableIO.new(*params) }.should_not raise_exception(Koala::KoalaError)
+      end
+
+      it "should accept a file path alone" do
+        params = [BEACH_BALL_PATH]
+        lambda { Koala::UploadableIO.new(*params) }.should_not raise_exception(Koala::KoalaError)
+      end
+    end
+  end
+
+  describe "getting an UploadableIO" do
+    before(:each) do
+      @upload_io = stub("UploadIO")
+      UploadIO.stub!(:new).with(anything, anything, anything).and_return(@upload_io)
+    end
+
+    context "if no filename was provided" do
+      it "should call the constructor with the content type, file name, and a dummy file name" do
+        UploadIO.should_receive(:new).with(BEACH_BALL_PATH, "content/type", anything).and_return(@upload_io)
+        Koala::UploadableIO.new(BEACH_BALL_PATH, "content/type").to_upload_io.should == @upload_io
+      end
+    end
+    
+    context "if a filename was provided" do
+      it "should call the constructor with the content type, file name, and the filename" do
+        filename = "file"
+        UploadIO.should_receive(:new).with(BEACH_BALL_PATH, "content/type", filename).and_return(@upload_io)
+        Koala::UploadableIO.new(BEACH_BALL_PATH, "content/type", filename).to_upload_io
+      end
+    end
+  end
+
+  describe "getting a file" do
+    it "should return the File if initialized with a file" do
+      f = File.new(BEACH_BALL_PATH)
+      Koala::UploadableIO.new(f).to_file.should == f
+    end
+
+    it "should open up and return a file corresponding to the path if io_or_path is a path" do
+      result = stub("File")
+      File.should_receive(:open).with(BEACH_BALL_PATH).and_return(result)
+      Koala::UploadableIO.new(BEACH_BALL_PATH).to_file.should == result
+    end
+  end
+
+  describe "#binary_content?" do
+    it "returns true for Rails 3 file uploads" do
+      Koala::UploadableIO.binary_content?(rails_3_mocks.last).should be_true
+    end
+    
+    it "returns true for Sinatra file uploads" do
+      Koala::UploadableIO.binary_content?(rails_3_mocks.last).should be_true
+    end
+    
+    it "returns true for File objects" do
+      Koala::UploadableIO.binary_content?(File.open(BEACH_BALL_PATH)).should be_true
+    end
+    
+    it "returns false for everything else" do
+      Koala::UploadableIO.binary_content?(StringIO.new).should be_false
+      Koala::UploadableIO.binary_content?(BEACH_BALL_PATH).should be_false
+      Koala::UploadableIO.binary_content?(nil).should be_false
+    end
+  end
+end  # describe UploadableIO

data/spec/{facebook_data.yml → fixtures/facebook_data.yml}

@@ -4,19 +4,19 @@
 # Just remember to update all fields!
  
 # You must supply this value yourself to test the GraphAPI class.
-# Your OAuth token should have publish_stream and read_stream permissions.
-oauth_token: 119908831367602|2.K0IVdhrRngS7VQM4Z_s6_g__.3600.1285844400-2905623|Q3VNUb9haS3s29X4SYPk6VL1f9A 
+# Your OAuth token should have publish_stream, read_stream, and user_photos permissions.
+oauth_token: 
 
 # for testing the OAuth class    
 # baseline app
 oauth_test_data: 
   # You must supply this value yourself, since they will expire.
-  code: 2.K0IVdhrRngS7VQM4Z_s6_g__.3600.1285844400-2905623|b5PCXOhEMe2FJXPHAg_mY3Psl6M
+  code: 
   # easiest way to get session keys: use multiple test accounts with the Javascript login at http://oauth.twoalex.com
-  session_key: 2.K0IVdhrRngS7VQM4Z_s6_g__.3600.1285844400-2905623
+  session_key: 
   multiple_session_keys:
-    - 2.K0IVdhrRngS7VQM4Z_s6_g__.3600.1285844400-2905623
-    - 2.K0IVdhrRngS7VQM4Z_s6_g__.3600.1285844400-2905623
+    - 
+    - 
   
   # These values will work out of the box
   app_id: 119908831367602
@@ -35,17 +35,21 @@ oauth_test_data:
     # note: I've revoked the offline access for security reasons, so you can't make calls against this :)
     fbs_119908831367602: '"access_token=119908831367602|08170230801eb225068e7a70-2905623|Q3LDCYYF8CX9cstxnZLsxiR0nwg.&expires=0&secret=78abaee300b392e275072a9f2727d436&session_key=08170230801eb225068e7a70-2905623&sig=423b8aa4b6fa1f9a571955f8e929d567&uid=2905623"'
 
-  # These values will work out of the box
-  # They're from Facebook's example at http://developers.facebook.com/docs/authentication/canvas
+  # These values from the OAuth Playground (see above) will work out of the box
   # You can update this to live data if desired
   # request_secret is optional and will fall back to the secret above if absent
-  request_secret: "secret"
-  signed_request: "vlXgu64BQGFSQrY0ZcJBZASMvYvTHu9GQ0YM9rjPSso.eyJhbGdvcml0aG0iOiJITUFDLVNIQTI1NiIsIjAiOiJwYXlsb2FkIn0"
-  signed_request_result:
-      "0": payload
+  signed_params: "zWRm0gd5oHW_jzXP_WA9CirO7c5CLHotn-SKRqH2NmU.eyJhbGdvcml0aG0iOiJITUFDLVNIQTI1NiIsImV4cGlyZXMiOjEzMDE5MjIwMDAsImlzc3VlZF9hdCI6MTMwMTkxNzI5OSwib2F1dGhfdG9rZW4iOiIxMTk5MDg4MzEzNjc2MDJ8Mi56VkZfNk5yTUVMSHVKYTRnSVU5dEt3X18uMzYwMC4xMzAxOTIyMDAwLTI5MDU2MjN8emdxUHNyMkJHOUxvT0s5a2VrR2dSVVJaeDBrIiwidXNlciI6eyJjb3VudHJ5IjoiZGUiLCJsb2NhbGUiOiJkZV9ERSIsImFnZSI6eyJtaW4iOjIxfX0sInVzZXJfaWQiOiIyOTA1NjIzIn0"
+  signed_params_result:
+      expires: 1301922000
       algorithm: HMAC-SHA256
-    
-  
+      user_id: "2905623"
+      oauth_token: 119908831367602|2.zVF_6NrMELHuJa4gIU9tKw__.3600.1301922000-2905623|zgqPsr2BG9LoOK9kekGgRURZx0k
+      user: 
+        country: de
+        locale: de_DE
+        age: 
+          min: 21
+      issued_at: 1301917299
 
 subscription_test_data:
   subscription_path: http://oauth.twoalex.com/subscriptions