koala 1.1.0 → 1.2.0

data/spec/support/graph_api_shared_examples.rb

@@ -16,17 +16,36 @@ shared_examples_for "Koala GraphAPI" do
   # GRAPH CALL
   describe "graph_call" do
     it "should pass all arguments to the api method" do
-      args = ["koppel", {}, "get", {:a => :b}]
-
+      args = [KoalaTest.user1, {}, "get", {:a => :b}]
       @api.should_receive(:api).with(*args)
-
       @api.graph_call(*args)
     end
 
     it "should throw an APIError if the result hash has an error key" do
       Koala.stub(:make_request).and_return(Koala::Response.new(500, {"error" => "An error occurred!"}, {}))
-      lambda { @api.graph_call("koppel", {}) }.should raise_exception(Koala::Facebook::APIError)
+      lambda { @api.graph_call(KoalaTest.user1, {}) }.should raise_exception(Koala::Facebook::APIError)
+    end
+    
+    it "passes the results through GraphCollection.evaluate" do
+      result = {}
+      @api.stub(:api).and_return(result)
+      Koala::Facebook::GraphCollection.should_receive(:evaluate).with(result, @api)
+      @api.graph_call("/me")
     end
+    
+    it "returns the results of GraphCollection.evaluate" do
+      expected = {}
+      @api.stub(:api).and_return([])
+      Koala::Facebook::GraphCollection.should_receive(:evaluate).and_return(expected)
+      @api.graph_call("/me").should == expected
+    end
+    
+    it "returns the post_processing block's results if one is supplied" do
+      other_result = [:a, 2, :three]
+      block = Proc.new {|r| other_result}
+      @api.stub(:api).and_return({})
+      @api.graph_call("/me", {}, "get", {}, &block).should == other_result
+    end 
   end
 
   # SEARCH
@@ -40,13 +59,13 @@ shared_examples_for "Koala GraphAPI" do
 
   # get_object
   it "should get public data about a user" do
-    result = @api.get_object("koppel")
+    result = @api.get_object(KoalaTest.user1)
     # the results should have an ID and a name, among other things
     (result["id"] && result["name"]).should_not be_nil
   end
 
   it "should get public data about a Page" do
-    result = @api.get_object("contextoptional")
+    result = @api.get_object(KoalaTest.page)
     # the results should have an ID and a name, among other things
     (result["id"] && result["name"]).should
   end
@@ -55,14 +74,14 @@ shared_examples_for "Koala GraphAPI" do
     results = @api.get_objects([])
     results.should == []
   end
-  
+
   it "should be able to get multiple objects" do
-    results = @api.get_objects(["contextoptional", "naitik"])
+    results = @api.get_objects([KoalaTest.page, KoalaTest.user1])
     results.should have(2).items
   end
 
   it "should be able to get multiple objects if they're a string" do
-    results = @api.get_objects("contextoptional,naitik")
+    results = @api.get_objects("contextoptional,#{KoalaTest.user1}")
     results.should have(2).items
   end
 
@@ -71,11 +90,11 @@ shared_examples_for "Koala GraphAPI" do
   end
 
   it "should be able to access a user's picture, given a picture type"  do
-    @api.get_picture("lukeshepard", {:type => 'large'}).should =~ /^http[s]*\:\/\//
+    @api.get_picture(KoalaTest.user2, {:type => 'large'}).should =~ /^http[s]*\:\/\//
   end
 
   it "should be able to access connections from public Pages" do
-    result = @api.get_connections("contextoptional", "photos")
+    result = @api.get_connections(KoalaTest.page, "photos")
     result.should be_a(Array)
   end
 
@@ -107,7 +126,7 @@ end
 
 shared_examples_for "Koala GraphAPI with an access token" do
   it "should get private data about a user" do
-    result = @api.get_object("koppel")
+    result = @api.get_object(KoalaTest.user1)
     # updated_time should be a pretty fixed test case
     result["updated_time"].should_not be_nil
   end
@@ -118,11 +137,11 @@ shared_examples_for "Koala GraphAPI with an access token" do
   end
 
   it "should be able to get multiple objects" do
-    result = @api.get_objects(["contextoptional", "naitik"])
+    result = @api.get_objects([KoalaTest.page, KoalaTest.user1])
     result.length.should == 2
   end
   it "should be able to access connections from users" do
-    result = @api.get_connections("lukeshepard", "likes")
+    result = @api.get_connections(KoalaTest.user2, "friends")
     result.length.should > 0
   end
 
@@ -168,52 +187,63 @@ shared_examples_for "Koala GraphAPI with an access token" do
 
   describe ".put_picture" do
     it "should be able to post photos to the user's wall with an open file object" do
-      content_type = "image/jpg"      
+      content_type = "image/jpg"
       file = File.open(File.join(File.dirname(__FILE__), "..", "fixtures", "beach.jpg"))
-  
+
       result = @api.put_picture(file, content_type)
-      @temporary_object_id = result["id"] 
+      @temporary_object_id = result["id"]
       @temporary_object_id.should_not be_nil
     end
 
-    it "uses the base HTTP service if the upload is a StringIO or similar" do
-      source = stub("UploadIO")
-      Koala::UploadableIO.stub(:new).and_return(source)
-      source.stub(:requires_base_http_service).and_return(true)
-      Koala.should_receive(:make_request).with(anything, anything, anything, hash_including(:http_service => Koala.base_http_service)).and_return(Koala::Response.new(200, "[]", {}))
-      @api.put_picture(StringIO.new)
-    end
-
     it "should be able to post photos to the user's wall without an open file object" do
       content_type = "image/jpg",
       file_path = File.join(File.dirname(__FILE__), "..", "fixtures", "beach.jpg")
-  
+
       result = @api.put_picture(file_path, content_type)
-      @temporary_object_id = result["id"] 
+      @temporary_object_id = result["id"]
       @temporary_object_id.should_not be_nil
     end
-  
+
     it "should be able to verify a photo posted to a user's wall" do
       content_type = "image/jpg",
       file_path = File.join(File.dirname(__FILE__), "..", "fixtures", "beach.jpg")
-  
+
       expected_message = "This is the test message"
-  
+
       result = @api.put_picture(file_path, content_type, :message => expected_message)
-      @temporary_object_id = result["id"] 
+      @temporary_object_id = result["id"]
       @temporary_object_id.should_not be_nil
-  
+
       get_result = @api.get_object(@temporary_object_id)
       get_result["name"].should == expected_message
     end
+
+
+    describe "using a URL instead of a file" do
+      before :each do
+        @url = "http://img.slate.com/images/redesign2008/slate_logo.gif"
+      end
+
+      it "should be able to post photo to the user's wall using a URL" do
+        result = @api.put_picture(@url)
+        @temporary_object_id = result["id"]
+        @temporary_object_id.should_not be_nil
+      end
+
+      it "should be able to post photo to the user's wall using a URL and an additional param" do
+        result = @api.put_picture(@url, :message => "my message")
+        @temporary_object_id = result["id"]
+        @temporary_object_id.should_not be_nil
+      end
+    end
   end
-  
+
   describe ".put_video" do
     before :each do
-      @cat_movie = File.join(File.dirname(__FILE__), "..", "fixtures", "cat.m4v")      
-      @content_type = "video/mpeg4"      
+      @cat_movie = File.join(File.dirname(__FILE__), "..", "fixtures", "cat.m4v")
+      @content_type = "video/mpeg4"
     end
-    
+
     it "should set options[:video] to true" do
       source = stub("UploadIO")
       Koala::UploadableIO.stub(:new).and_return(source)
@@ -221,26 +251,19 @@ shared_examples_for "Koala GraphAPI with an access token" do
       Koala.should_receive(:make_request).with(anything, anything, anything, hash_including(:video => true)).and_return(Koala::Response.new(200, "[]", {}))
       @api.put_video("foo")
     end
-    
+
     it "should be able to post videos to the user's wall with an open file object" do
       file = File.open(@cat_movie)
 
       result = @api.put_video(file, @content_type)
-      @temporary_object_id = result["id"] 
+      @temporary_object_id = result["id"]
       @temporary_object_id.should_not be_nil
     end
 
-    it "uses the base HTTP service if the upload is a StringIO or similar" do
-      source = stub("UploadIO")
-      Koala::UploadableIO.stub(:new).and_return(source)
-      source.stub(:requires_base_http_service).and_return(true)
-      Koala.should_receive(:make_request).with(anything, anything, anything, hash_including(:http_service => Koala.base_http_service)).and_return(Koala::Response.new(200, "[]", {}))
-      @api.put_video(StringIO.new)
-    end
 
     it "should be able to post videos to the user's wall without an open file object" do
       result = @api.put_video(@cat_movie, @content_type)
-      @temporary_object_id = result["id"] 
+      @temporary_object_id = result["id"]
       @temporary_object_id.should_not be_nil
     end
 
@@ -290,6 +313,12 @@ shared_examples_for "Koala GraphAPI with an access token" do
     like_result.should be_true
   end
 
+  # Page Access Token Support
+  it "gets a page's access token" do
+    # we can't test this live since test users (or random real users) can't be guaranteed to have pages to manage
+    @api.should_receive(:api).with("my_page", {:fields => "access_token"}, "get", anything)
+    @api.get_page_access_token("my_page")
+  end
 
   # test all methods to make sure they pass data through to the API
   # we run the tests here (rather than in the common shared example group)
@@ -339,23 +368,17 @@ end
 
 # GraphCollection
 shared_examples_for "Koala GraphAPI with GraphCollection" do
-
-  it "should create an array-like object" do
-    call = @api.graph_call("contextoptional/photos")
-    Koala::Facebook::GraphCollection.new(call, @api).should be_an(Array)
-  end
-
   describe "when getting a collection" do
     # GraphCollection methods
     it "should get a GraphCollection when getting connections" do
-      @result = @api.get_connections("contextoptional", "photos")
+      @result = @api.get_connections(KoalaTest.page, "photos")
       @result.should be_a(Koala::Facebook::GraphCollection)
     end
 
     it "should return nil if the get_collections call fails with nil" do
       # this happens sometimes
       @api.should_receive(:graph_call).and_return(nil)
-      @api.get_connections("contextoptional", "photos").should be_nil
+      @api.get_connections(KoalaTest.page, "photos").should be_nil
     end
 
     it "should get a GraphCollection when searching" do
@@ -370,74 +393,14 @@ shared_examples_for "Koala GraphAPI with GraphCollection" do
     end
 
     it "should get a GraphCollection when paging through results" do
-      @results = @api.get_page(["search", {"q"=>"facebook", "limit"=>"25", "until"=>"2010-09-23T21:17:33+0000"}])
+      @results = @api.get_page(["search", {"q"=>"facebook", "limit"=>"25", "until"=> KoalaTest.search_time}])
       @results.should be_a(Koala::Facebook::GraphCollection)
     end
 
     it "should return nil if the page call fails with nil" do
       # this happens sometimes
       @api.should_receive(:graph_call).and_return(nil)
-      @api.get_page(["search", {"q"=>"facebook", "limit"=>"25", "until"=>"2010-09-23T21:17:33+0000"}]).should be_nil
-    end
-
-    # GraphCollection attributes
-    describe "the GraphCollection" do
-      before(:each) do
-        @result = @api.get_connections("contextoptional", "photos")
-      end
-
-      it "should have a read-only paging attribute" do
-        @result.methods.map(&:to_sym).should include(:paging)
-        @result.methods.map(&:to_sym).should_not include(:paging=)
-      end
-
-      describe "when getting a whole page" do
-        before(:each) do
-          @second_page = stub("page of Fb graph results")
-          @base = stub("base")
-          @args = stub("args")
-          @page_of_results = stub("page of results")
-        end
-
-        it "should return the previous page of results" do
-          @result.should_receive(:previous_page_params).and_return([@base, @args])
-          @api.should_receive(:graph_call).with(@base, @args).and_yield(@second_page)
-          Koala::Facebook::GraphCollection.should_receive(:new).with(@second_page, @api).and_return(@page_of_results)
-
-          @result.previous_page#.should == @page_of_results
-        end
-
-        it "should return the next page of results" do
-          @result.should_receive(:next_page_params).and_return([@base, @args])
-          @api.should_receive(:graph_call).with(@base, @args).and_yield(@second_page)
-          Koala::Facebook::GraphCollection.should_receive(:new).with(@second_page, @api).and_return(@page_of_results)
-
-          @result.next_page#.should == @page_of_results
-        end
-
-        it "should return nil it there are no other pages" do
-          %w{next previous}.each do |this|
-            @result.should_receive("#{this}_page_params".to_sym).and_return(nil)
-            @result.send("#{this}_page").should == nil
-          end
-        end
-      end
-
-      describe "when parsing page paramters" do
-        before(:each) do
-          @graph_collection = Koala::Facebook::GraphCollection.new({"data" => []}, Koala::Facebook::GraphAPI.new)
-        end
-
-        it "should return the base as the first array entry" do
-          base = "url_path"
-          @graph_collection.parse_page_url("anything.com/#{base}?anything").first.should == base
-        end
-
-        it "should return the arguments as a hash as the last array entry" do
-          args_hash = {"one" => "val_one", "two" => "val_two"}
-          @graph_collection.parse_page_url("anything.com/anything?#{args_hash.map {|k,v| "#{k}=#{v}" }.join("&")}").last.should == args_hash
-        end
-      end
+      @api.get_page(["search", {"q"=>"facebook", "limit"=>"25", "until"=> KoalaTest.search_time}]).should be_nil
     end
   end
 end
@@ -456,12 +419,11 @@ shared_examples_for "Koala GraphAPI without an access token" do
   end
 
   it "shouldn't be able to access connections from users" do
-    lambda { @api.get_connections("lukeshepard", "likes") }.should raise_error(Koala::Facebook::APIError)
+    lambda { @api.get_connections("lukeshepard", "friends") }.should raise_error(Koala::Facebook::APIError)
   end
 
   it "should not be able to put an object" do
     lambda { @result = @api.put_object("lukeshepard", "feed", :message => "Hello, world") }.should raise_error(Koala::Facebook::APIError)
-    puts "Error!  Object #{@result.inspect} somehow put onto Luke Shepard's wall!" if @result
   end
 
   # these are not strictly necessary as the other put methods resolve to put_object, but are here for completeness
@@ -470,13 +432,11 @@ shared_examples_for "Koala GraphAPI without an access token" do
       attachment = {:name => "OAuth Playground", :link => "http://oauth.twoalex.com/"}
       @result = @api.put_wall_post("Hello, world", attachment, "contextoptional")
     end).should raise_error(Koala::Facebook::APIError)
-    puts "Error!  Object #{@result.inspect} somehow put onto Context Optional's wall!" if @result
   end
 
   it "should not be able to comment on an object" do
     # random public post on the ContextOptional wall
     lambda { @result = @api.put_comment("7204941866_119776748033392", "The hackathon was great!") }.should raise_error(Koala::Facebook::APIError)
-    puts "Error!  Object #{@result.inspect} somehow commented on post 7204941866_119776748033392!" if @result
   end
 
   it "should not be able to like an object" do

data/spec/support/json_testing_fix.rb

@@ -1,18 +1,42 @@
 # when testing across Ruby versions, we found that JSON string creation inconsistently ordered keys
 # which is a problem because our mock testing service ultimately matches strings to see if requests are mocked
 # this fix solves that problem by ensuring all hashes are created with a consistent key order every time
-
 module MultiJson
   self.engine = :ok_json
+
+  class << self
+    def encode_with_ordering(object)
+      # if it's a hash, recreate it with k/v pairs inserted in sorted-by-key order
+      # (for some reason, REE fails if we don't assign the ternary result as a local variable
+      # separately from calling encode_original)
+      encode_original(sort_object(object))
+    end
+
+    alias_method :encode_original, :encode
+    alias_method :encode, :encode_with_ordering
   
-  def encode_with_ordering(object)
-    # if it's a hash, recreate it with k/v pairs inserted in sorted-by-key order
-    # (for some reason, REE 1.8.7 fails if we don't assign the ternary result as a local variable 
-    # separate from calling encode_original)
-    new_object = object.is_a?(Hash) ? object.keys.sort.inject({}) {|hash, k| hash[k] = object[k]; hash} : object
-    encode_original(new_object)
-  end
+    def decode_with_ordering(string)
+      sort_object(decode_original(string))
+    end
+
+    alias_method :decode_original, :decode
+    alias_method :decode, :decode_with_ordering
+    
+    private 
+  
+    def sort_object(object)
+      if object.is_a?(Hash)
+        sort_hash(object)
+      elsif object.is_a?(Array)
+        object.collect {|item| item.is_a?(Hash) ? sort_hash(item) : item}
+      else
+        object
+      end
+    end
   
-  alias_method :encode_original, :encode
-  alias_method :encode, :encode_with_ordering
-end
+    def sort_hash(unsorted_hash)
+      sorted_hash = KoalaTest::OrderedHash.new(sorted_hash)
+      unsorted_hash.keys.sort {|a, b| a.to_s <=> b.to_s}.inject(sorted_hash) {|hash, k| hash[k] = unsorted_hash[k]; hash}
+    end
+  end
+end

data/spec/support/koala_test.rb

@@ -0,0 +1,187 @@
+# small helper method for live testing
+module KoalaTest
+
+  class << self
+    attr_accessor :oauth_token, :app_id, :secret, :app_access_token, :code, :session_key
+    attr_accessor :oauth_test_data, :subscription_test_data, :search_time
+  end
+    
+  # Test setup
+  
+  def self.setup_test_environment!
+    setup_rspec
+    
+    unless ENV['LIVE']
+      # By default the Koala specs are run using stubs for HTTP requests,
+      # so they won't fail due to Facebook-imposed rate limits or server timeouts.
+      #
+      # However as a result they are more brittle since
+      # we are not testing the latest responses from the Facebook servers.
+      # To be certain all specs pass with the current Facebook services, 
+      # run LIVE=true bundle exec rake spec.
+      Koala.http_service = Koala::MockHTTPService
+      KoalaTest.setup_test_data(Koala::MockHTTPService::TEST_DATA)
+    else
+      # Runs Koala specs through the Facebook servers
+      # using data for a real app
+      live_data = YAML.load_file(File.join(File.dirname(__FILE__), '../fixtures/facebook_data.yml'))
+      KoalaTest.setup_test_data(live_data)
+
+      # allow live tests with different adapters
+      adapter = ENV['ADAPTER'] || "typhoeus"# use Typhoeus by default if available
+      begin
+        require adapter
+        Faraday.default_adapter = adapter.to_sym
+      rescue LoadError
+        puts "Unable to load adapter #{adapter}, using Net::HTTP."
+      end
+      
+      Koala.http_service.http_options[:beta] = true if ENV["beta"] || ENV["BETA"]
+
+      # use a test user unless the developer wants to test against a real profile
+      unless token = KoalaTest.oauth_token
+        KoalaTest.setup_test_users
+      else
+        KoalaTest.validate_user_info(token)
+      end
+    end
+  end
+  
+  def self.setup_rspec
+    # set up a global before block to set the token for tests
+    # set the token up for
+    RSpec.configure do |config|
+      config.before :each do
+        @token = KoalaTest.oauth_token
+        Koala::Utils.stub(:deprecate) # never fire deprecation warnings
+      end
+
+      config.after :each do
+        # clean up any objects posted to Facebook
+        if @temporary_object_id && !KoalaTest.mock_interface?
+          api = @api || (@test_users ? @test_users.graph_api : nil)
+          raise "Unable to locate API when passed temporary object to delete!" unless api
+
+          # wait 10ms to allow Facebook to propagate data so we can delete it
+          sleep(0.01)
+
+          # clean up any objects we've posted
+          result = (api.delete_object(@temporary_object_id) rescue false)
+          # if we errored out or Facebook returned false, track that
+          puts "Unable to delete #{@temporary_object_id}: #{result} (probably a photo or video, which can't be deleted through the API)" unless result
+        end
+      end
+    end
+  end
+
+  def self.setup_test_data(data)
+    # make data accessible to all our tests
+    self.oauth_test_data = data["oauth_test_data"]
+    self.subscription_test_data = data["subscription_test_data"]
+    self.oauth_token = data["oauth_token"]
+    self.app_id = data["oauth_test_data"]["app_id"]
+    self.app_access_token = data["oauth_test_data"]["app_access_token"]
+    self.secret = data["oauth_test_data"]["secret"]
+    self.code = data["oauth_test_data"]["code"]
+    self.session_key = data["oauth_test_data"]["session_key"]
+    
+    # fix the search time so it can be used in the mock responses
+    self.search_time = data["search_time"] || (Time.now - 3600).to_s
+  end
+
+  def self.testing_permissions
+    "read_stream, publish_stream, user_photos, user_videos, read_insights"
+  end
+  
+  def self.setup_test_users
+    # note: we don't have to delete the two test users explicitly, since the test user specs do that for us
+    # technically, this is a point of brittleness and would break if the tests were run out of order
+    # however, for now we can live with it since it would slow tests way too much to constantly recreate our test users
+    print "Setting up test users..."
+    @test_user_api = Koala::Facebook::TestUsers.new(:app_id => self.app_id, :secret => self.secret)
+
+    RSpec.configure do |config|
+      config.before :all do
+        # before each test module, create two test users with specific names and befriend them
+        KoalaTest.create_test_users
+      end
+      
+      config.after :all do
+        # after each test module, delete the test users to avoid cluttering up the application
+        KoalaTest.destroy_test_users
+      end
+    end
+
+    puts "done."
+  end
+
+  def self.create_test_users
+    @live_testing_user = @test_user_api.create(true, KoalaTest.testing_permissions, :name => KoalaTest.user1_name)
+    @live_testing_friend = @test_user_api.create(true, KoalaTest.testing_permissions, :name => KoalaTest.user2_name)
+    @test_user_api.befriend(@live_testing_user, @live_testing_friend)
+    self.oauth_token = @live_testing_user["access_token"]
+  end
+  
+  def self.destroy_test_users
+    [@live_testing_user, @live_testing_friend].each do |u|
+      puts "Unable to delete test user #{u.inspect}" if u && !(@test_user_api.delete(u) rescue false)
+    end
+  end
+
+  def self.validate_user_info(token)
+    print "Validating permissions for live testing..."
+    # make sure we have the necessary permissions
+    api = Koala::Facebook::API.new(token)
+    perms = api.fql_query("select #{testing_permissions} from permissions where uid = me()")[0]
+    perms.each_pair do |perm, value|
+      if value == (perm == "read_insights" ? 1 : 0) # live testing depends on insights calls failing
+        puts "failed!\n" # put a new line after the print above
+        raise ArgumentError, "Your access token must have the read_stream, publish_stream, and user_photos permissions, and lack read_insights.  You have: #{perms.inspect}"
+      end
+    end
+    puts "done!"
+  end
+  
+  # Info about the testing environment
+  def self.real_user?
+    !(mock_interface? || @test_user)
+  end
+
+  def self.test_user?
+    !!@test_user_api
+  end
+
+  def self.mock_interface?
+    Koala.http_service == Koala::MockHTTPService
+  end
+
+  # Data for testing
+  def self.user1
+    test_user? ? @live_testing_user["id"] : "koppel"
+  end
+
+  def self.user1_id
+    test_user? ? @live_testing_user["id"] : 2905623
+  end
+
+  def self.user1_name
+    "Alex"
+  end
+
+  def self.user2
+    test_user? ? @live_testing_friend["id"] : "lukeshepard"
+  end
+
+  def self.user2_id
+    test_user? ? @live_testing_friend["id"] : 2901279
+  end
+
+  def self.user2_name
+    "Luke"
+  end
+
+  def self.page
+    "contextoptional"
+  end
+
+end

data/spec/support/mock_http_service.rb

@@ -18,7 +18,8 @@ module Koala
     TEST_DATA = YAML.load_file(File.join(File.dirname(__FILE__), '..', 'fixtures', 'facebook_data.yml'))
     TEST_DATA.merge!('oauth_token' => Koala::MockHTTPService::ACCESS_TOKEN)
     TEST_DATA['oauth_test_data'].merge!('code' => Koala::MockHTTPService::OAUTH_CODE)
-
+    TEST_DATA['search_time'] = (Time.now - 3600).to_s
+    
     # Useful in mock_facebook_responses.yml
     OAUTH_DATA = TEST_DATA['oauth_test_data']
     OAUTH_DATA.merge!({
@@ -38,7 +39,7 @@ module Koala
       path = 'root' if path == '' || path == '/'
       verb ||= 'get'
       server = options[:rest_api] ? 'rest_api' : 'graph_api'
-      token = args.delete('access_token') 
+      token = args.delete('access_token')
       with_token = (token == ACCESS_TOKEN || token == APP_ACCESS_TOKEN) ? 'with_token' : 'no_token'
 
       # Assume format is always JSON
@@ -77,11 +78,13 @@ module Koala
       response_object
     end
 
-    def self.mock?
-      true
+    def self.encode_params(*args)
+      # use HTTPService's encode_params
+      HTTPService.encode_params(*args)
     end
 
     protected
+
     def self.create_params_key(params_hash)
       if params_hash.empty?
         'no_args'
@@ -93,4 +96,4 @@ module Koala
       end
     end
   end
-end
+end