vkontakte_api 0.2.1 → 1.0.rc

data/spec/vkontakte_api/authorization_spec.rb

@@ -0,0 +1,111 @@
+require 'spec_helper'
+
+describe VkontakteApi::Authorization do
+  before(:each) do
+    @app_id = stub("App id")
+    VkontakteApi.stub(:app_id).and_return(@app_id)
+    @app_secret = stub("App secret")
+    VkontakteApi.stub(:app_secret).and_return(@app_secret)
+    @redirect_uri = stub("Redirect uri")
+    VkontakteApi.stub(:redirect_uri).and_return(@redirect_uri)
+    
+    @url   = stub("Authorization url")
+    @token = stub("Token")
+    
+    @auth_code          = stub("Authorization code strategy", :get_token => @token, :authorize_url => @url)
+    @implicit           = stub("Implicit strategy",            :authorize_url => @url)
+    @client_credentials = stub("Client credentials strategy",  :get_token => @token)
+    
+    @client = stub("OAuth2::Client instance", :auth_code => @auth_code, :implicit => @implicit, :client_credentials => @client_credentials)
+    OAuth2::Client.stub(:new).and_return(@client)
+    
+    @auth = Object.new
+    @auth.extend VkontakteApi::Authorization
+  end
+  
+  describe "#authorization_url" do
+    before(:each) do
+      @auth.stub(:client).and_return(@client)
+    end
+    
+    context "with a site type" do
+      it "returns a valid authorization url" do
+        @auth_code.should_receive(:authorize_url).with(:redirect_uri => @redirect_uri)
+        @auth.authorization_url(:type => :site).should == @url
+      end
+    end
+    
+    context "with a client type" do
+      it "returns a valid authorization url" do
+        @implicit.should_receive(:authorize_url).with(:redirect_uri => @redirect_uri)
+        @auth.authorization_url(:type => :client).should == @url
+      end
+    end
+    
+    context "given a redirect_uri" do
+      it "prefers the given uri over VkontakteApi.redirect_uri" do
+        redirect_uri = 'http://example.com/oauth/callback'
+        @auth_code.should_receive(:authorize_url).with(:redirect_uri => redirect_uri)
+        @auth.authorization_url(:redirect_uri => redirect_uri)
+      end
+    end
+    
+    context "given a scope" do
+      it "sends it to VkontakteApi::Utils.flatten_argument" do
+        scope = stub("Scope")
+        flat_scope = stub("Flat scope")
+        
+        VkontakteApi::Utils.should_receive(:flatten_argument).with(scope).and_return(flat_scope)
+        @auth_code.should_receive(:authorize_url).with(:redirect_uri => @redirect_uri, :scope => flat_scope)
+        @auth.authorization_url(:scope => scope)
+      end
+    end
+  end
+  
+  describe "#authorize" do
+    context "with a site type" do
+      before(:each) do
+        @code = stub("Authorization code")
+        @auth_code.stub(:get_token).and_return(@token)
+      end
+      
+      it "gets the token" do
+        @auth_code.should_receive(:get_token).with(@code)
+        @auth.authorize(:type => :site, :code => @code)
+      end
+    end
+    
+    context "with an app_server type" do
+      it "gets the token" do
+        @client_credentials.should_receive(:get_token).with({}, subject::OPTIONS[:client_credentials])
+        @auth.authorize(:type => :app_server)
+      end
+    end
+    
+    context "with an unknown type" do
+      it "raises an ArgumentError" do
+        expect {
+          @auth.authorize(:type => :unknown)
+        }.to raise_error(ArgumentError)
+      end
+    end
+    
+    it "builds a VkontakteApi::Client instance with the received token" do
+      client = stub("VkontakteApi::Client instance")
+      VkontakteApi::Client.should_receive(:new).with(@token).and_return(client)
+      @auth.authorize.should == client
+    end
+  end
+  
+  describe "#client" do
+    it "creates and returns an OAuth2::Client instance" do
+      OAuth2::Client.should_receive(:new).with(@app_id, @app_secret, subject::OPTIONS[:client])
+      @auth.send(:client).should == @client
+    end
+    
+    it "caches the result" do
+      OAuth2::Client.should_receive(:new).once
+      5.times { @auth.send(:client) }
+    end
+  end
+end

data/spec/vkontakte_api/client_spec.rb

@@ -2,20 +2,31 @@ require 'spec_helper'
 
 describe VkontakteApi::Client do
   before(:each) do
-    @token = stub("Access token")
+    @string_token = stub("Access token as a String")
+    @oauth2_token = stub("Access token as an OAuth2::AccessToken", :token => @string_token)
   end
   
   describe "#initialize" do
     context "without arguments" do
       it "creates a client with a nil access_token" do
-        VkontakteApi::Client.new.access_token.should be_nil
+        client = VkontakteApi::Client.new
+        client.token.should be_nil
       end
     end
     
     context "with a token argument" do
-      it "creates a client with a given access_token" do
-        client = VkontakteApi::Client.new(@token)
-        client.access_token.should == @token
+      context "with a string value" do
+        it "creates a client with a given access_token" do
+          client = VkontakteApi::Client.new(@string_token)
+          client.token.should == @string_token
+        end
+      end
+      
+      context "with an OAuth2::AccessToken value" do
+        it "extracts the string token and uses it" do
+          client = VkontakteApi::Client.new(@oauth2_token)
+          client.token.should == @string_token
+        end
       end
     end
   end
@@ -29,26 +40,8 @@ describe VkontakteApi::Client do
     
     context "with an authorized client" do
       it "returns true" do
-        VkontakteApi::Client.new(@token).should be_authorized
+        VkontakteApi::Client.new(@string_token).should be_authorized
       end
     end
   end
-  
-  describe "#method_missing" do
-    before(:each) do
-      @resolver = stub("Resolver").as_null_object
-      VkontakteApi::Resolver.stub(:new).and_return(@resolver)
-      @args = {:field => 'value'}
-    end
-    
-    it "creates a resolver, passing it the access_token" do
-      VkontakteApi::Resolver.should_receive(:new).with(:access_token => @token)
-      VkontakteApi::Client.new(@token).api_method(@args)
-    end
-    
-    it "delegates to VkontakteApi::Resolver" do
-      @resolver.should_receive(:api_method).with(@args)
-      VkontakteApi::Client.new(@token).api_method(@args)
-    end
-  end
 end

data/spec/vkontakte_api/configuration_spec.rb

@@ -24,6 +24,11 @@ describe VkontakteApi::Configuration do
       Configurable.app_id.should be_nil
       Configurable.app_secret.should be_nil
       Configurable.adapter.should == VkontakteApi::Configuration::DEFAULT_ADAPTER
+      
+      Configurable.logger.should be_a(Logger)
+      Configurable.should log_requests
+      Configurable.should log_errors
+      Configurable.should_not log_responses
     end
   end
 end

data/spec/vkontakte_api/error_spec.rb

@@ -2,7 +2,7 @@ require 'spec_helper'
 
 describe VkontakteApi::Error do
   before(:each) do
-    @e = VkontakteApi::Error.new(
+    @error_data = Hashie::Mash.new(
       :error_code      => 5,
       :error_msg       => 'User authorization failed: invalid access_token.',
       :request_params  => [
@@ -14,10 +14,6 @@ describe VkontakteApi::Error do
           :key   => 'method',
           :value => 'unknownMethod'
         },
-        {
-          :key   => 'some',
-          :value => 'params'
-        },
         {
           :key   => 'access_token',
           :value => '123'
@@ -27,11 +23,35 @@ describe VkontakteApi::Error do
   end
   
   describe "#message" do
-    it "returns all needed data about an error" do
-      message = 'VKontakte returned an error 5: \'User authorization failed: invalid access_token.\' after calling method \'unknownMethod\' with parameters {"some"=>"params"}.'
-      expect {
-        raise @e
-      }.to raise_error(@e.class, message)
+    context "without parameters" do
+      before(:each) do
+        @e = VkontakteApi::Error.new(@error_data)
+      end
+      
+      it "returns all needed data about an error" do
+        message = 'VKontakte returned an error 5: \'User authorization failed: invalid access_token.\''
+        message << ' after calling method \'unknownMethod\' without parameters.'
+        
+        expect {
+          raise @e
+        }.to raise_error(@e.class, message)
+      end
+    end
+    
+    context "with parameters" do
+      before(:each) do
+        @error_data[:request_params] << Hashie::Mash.new(:key => 'some', :value => 'params')
+        @e = VkontakteApi::Error.new(@error_data)
+      end
+      
+      it "returns all needed data about an error" do
+        message = 'VKontakte returned an error 5: \'User authorization failed: invalid access_token.\''
+        message << ' after calling method \'unknownMethod\' with parameters {"some"=>"params"}.'
+        
+        expect {
+          raise @e
+        }.to raise_error(@e.class, message)
+      end
     end
   end
 end

data/spec/vkontakte_api/logger_spec.rb

@@ -0,0 +1,88 @@
+require 'spec_helper'
+
+describe VkontakteApi::Logger do
+  before(:each) do
+    @success_response = Oj.dump('a' => 1, 'b' => 2)
+    @fail_response    = Oj.dump('error' => 404)
+    
+    @connection = Faraday.new(:url => 'http://example.com') do |builder|
+      builder.response :vk_logger
+      builder.response :mashify
+      builder.response :oj, :preserve_raw => true
+      
+      builder.adapter :test do |stub|
+        stub.get('/success') do
+          [200, {}, @success_response]
+        end
+        stub.get('/fail') do
+          [200, {}, @fail_response]
+        end
+      end
+    end
+    
+    @logger = stub("Logger").as_null_object
+    VkontakteApi.logger = @logger
+    
+    VkontakteApi.log_requests  = false
+    VkontakteApi.log_responses = false
+    VkontakteApi.log_errors    = false
+  end
+  
+  context "with VkontakteApi.log_requests?" do
+    before(:each) do
+      VkontakteApi.log_requests = true
+    end
+    
+    it "logs the request" do
+      @logger.should_receive(:debug).with('GET http://example.com/success')
+      @connection.get('/success')
+    end
+  end
+  
+  context "without VkontakteApi.log_requests?" do
+    it "doesn't log the request" do
+      @logger.should_not_receive(:debug)
+      @connection.get('/success')
+    end
+  end
+  
+  context "with a successful response" do
+    context "with VkontakteApi.log_responses?" do
+      before(:each) do
+        VkontakteApi.log_responses = true
+      end
+      
+      it "logs the response body" do
+        @logger.should_receive(:debug).with(@success_response)
+        @connection.get('/success')
+      end
+    end
+    
+    context "without VkontakteApi.log_responses?" do
+      it "doesn't log the response body" do
+        @logger.should_not_receive(:debug)
+        @connection.get('/success')
+      end
+    end
+  end
+  
+  context "with an error response" do
+    context "with VkontakteApi.log_errors?" do
+      before(:each) do
+        VkontakteApi.log_errors = true
+      end
+      
+      it "logs the response body" do
+        @logger.should_receive(:warn).with(@fail_response)
+        @connection.get('/fail')
+      end
+    end
+    
+    context "without VkontakteApi.log_errors?" do
+      it "doesn't log the response body" do
+        @logger.should_not_receive(:warn)
+        @connection.get('/fail')
+      end
+    end
+  end
+end

data/spec/vkontakte_api/method_spec.rb

@@ -0,0 +1,59 @@
+require 'spec_helper'
+
+describe VkontakteApi::Method do
+  describe "#call" do
+    before(:each) do
+      @full_name = stub("Full method name")
+      @args      = stub("Method arguments")
+      @token     = stub("Access token")
+      
+      @method = VkontakteApi::Method.new('some_name')
+      @method.stub(:full_name).and_return(@full_name)
+      @method.stub(:token).and_return(@token)
+      VkontakteApi::Result.stub(:process)
+    end
+    
+    it "calls API.call with full name, args and token" do
+      VkontakteApi::API.should_receive(:call).with(@full_name, @args, @token)
+      @method.call(@args)
+    end
+    
+    it "sends the response to Result.process" do
+      response = stub("VK response")
+      VkontakteApi::API.stub(:call).and_return(response)
+      type = stub("Type")
+      @method.stub(:type).and_return(type)
+      
+      VkontakteApi::Result.should_receive(:process).with(response, type, nil)
+      @method.call(@args)
+    end
+  end
+  
+  describe "#full_name" do
+    before(:each) do
+      resolver = Hashie::Mash.new(:name => 'name_space')
+      @name = 'name'
+      @method = VkontakteApi::Method.new(@name, :resolver => resolver)
+    end
+    
+    it "sends each part to #camelize" do
+      @method.send(:full_name).should == 'nameSpace.name'
+    end
+  end
+  
+  describe "#type" do
+    context "with a usual name" do
+      it "returns :anything" do
+        method = VkontakteApi::Method.new('get')
+        method.send(:type).should == :anything
+      end
+    end
+    
+    context "with a predicate name" do
+      it "returns :boolean" do
+        method = VkontakteApi::Method.new('is_app_user?')
+        method.send(:type).should == :boolean
+      end
+    end
+  end
+end

data/spec/vkontakte_api/namespace_spec.rb

@@ -0,0 +1,5 @@
+require 'spec_helper'
+
+describe VkontakteApi::Namespace do
+  # nothing to spec here yet
+end

data/spec/vkontakte_api/resolvable_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+describe VkontakteApi::Resolvable do
+  before(:each) do
+    @class = Class.new do
+      include VkontakteApi::Resolvable
+    end
+  end
+  
+  describe "#initialize" do
+    it "should save name and resolver" do
+      name     = stub("Name")
+      token    = stub("Token")
+      resolver = Hashie::Mash.new(:token => token)
+      
+      resolvable = @class.new(name, :resolver => resolver)
+      resolvable.name.should  == name
+      resolvable.token.should == token
+    end
+  end
+end

data/spec/vkontakte_api/resolver_spec.rb

@@ -1,177 +1,94 @@
 require 'spec_helper'
 
 describe VkontakteApi::Resolver do
-  describe "#method_missing" do
-    before(:each) do
-      @result = stub("API result")
-      @result.stub(:respond_to?).and_return(false)
-      
-      VkontakteApi::API.stub(:call).and_return(@result)
-      @args = {:arg_name => 'arg_value'}
-      @token = stub("Access token")
-    end
-    
-    context "with a nil @namespace" do
-      before(:each) do
-        VkontakteApi::Resolver.stub(:vk_method_name).and_return(['apiMethod', :anything])
-        @resolver = VkontakteApi::Resolver.new(:access_token => @token)
-      end
-      
-      context "with method_name not from namespaces" do
-        it "calls #vk_method_name with method name and nil namespace" do
-          VkontakteApi::Resolver.should_receive(:vk_method_name).with('api_method', nil)
-          @resolver.api_method
-        end
-        
-        it "calls #api_call with full VK method name and access_token" do
-          @args.should_receive(:[]=).with(:access_token, @token)
-          VkontakteApi::API.should_receive(:call).with('apiMethod', @args)
-          @resolver.api_method(@args).should == @result
-        end
-      end
-      
-      context "with method_name from namespaces" do
-        it "return a new resolver with the corresponding @namespace" do
-          new_resolver = @resolver.friends
-          new_resolver.should be_a(VkontakteApi::Resolver)
-          new_resolver.namespace.should == 'friends'
-        end
-      end
+  before(:each) do
+    @class = Class.new do
+      include VkontakteApi::Resolver
       
-      context "without a token" do
-        before(:each) do
-          @resolver = VkontakteApi::Resolver.new
-        end
-        
-        it "calls #api_call with full VK method name but without a token" do
-          @args.should_not_receive(:[]=).with(:access_token, anything)
-          VkontakteApi::API.should_receive(:call).with('apiMethod', @args)
-          @resolver.api_method(@args).should == @result
-        end
+      def initialize(name)
+        @name = name
       end
     end
-    
-    context "with a non-nil @namespace" do
-      before(:each) do
-        @resolver = VkontakteApi::Resolver.new(:namespace => 'friends')
-        VkontakteApi::Resolver.stub(:vk_method_name).and_return('friends.apiMethod')
-      end
-      
-      it "calls #vk_method_name with method name and @namespace" do
-        VkontakteApi::Resolver.should_receive(:vk_method_name).with('api_method', 'friends')
-        @resolver.api_method
-      end
+  end
+  
+  describe "#method_missing" do
+    before(:each) do
+      @resolver = @class.new(:trololo)
+      @token = stub("Token")
+      @resolver.stub(:token).and_return(@token)
     end
     
-    context "with a non-enumerable result" do
-      before(:each) do
-        @resolver = VkontakteApi::Resolver.new
-        
-        @type = stub("Type")
-        VkontakteApi::Resolver.stub(:vk_method_name).and_return([:method_name, @type])
-        
-        @typecasted_value = stub("Typecasted value")
-        @resolver.stub(:typecast).and_return(@typecasted_value)
-      end
-      
-      it "returns #typecast-ed value" do
-        @resolver.should_receive(:typecast).with(@result, @type).and_return(@typecasted_value)
-        @resolver.method_name.should == @typecasted_value
-      end
-      
-      context "when block_given?" do
-        it "yields the #typecast-ed value and returns the result of the block" do
-          block_result = stub("Block result")
-          @typecasted_value.should_receive(:result_method).and_return(block_result)
-          
-          @resolver.api_method do |result|
-            result.result_method
-          end.should == block_result
-        end
+    context "called with a namespace" do
+      it "returns a Namespace instance" do
+        namespace = @resolver.users
+        namespace.should be_a(VkontakteApi::Namespace)
       end
     end
     
-    context "with an enumerable result" do
+    context "called with a method" do
       before(:each) do
-        @resolver = VkontakteApi::Resolver.new
-        
-        @element1 = stub("First element")
-        @element2 = stub("Second element")
-        @enumerable_result = [@element1, @element2]
-        VkontakteApi::API.stub(:call).and_return(@enumerable_result)
+        @result = stub("Result")
+        @method = stub("Method", :call => @result)
+        VkontakteApi::Method.stub(:new).and_return(@method)
       end
       
-      it "returns the untouched value" do
-        @resolver.method_name.should == @enumerable_result
+      it "creates a Method instance" do
+        VkontakteApi::Method.should_receive(:new).with('get', :resolver => @resolver.resolver)
+        @resolver.get(:id => 1)
       end
       
-      context "when block_given?" do
-        it "yields each element untouched to the block" do
-          result1 = stub("First element after result_method")
-          result2 = stub("Second element after result_method")
-          @element1.should_receive(:result_method).and_return(result1)
-          @element2.should_receive(:result_method).and_return(result2)
-          
-          @resolver.api_method do |result|
-            result.result_method
-          end.should == [result1, result2]
-        end
+      it "calls Method#call and returns the result" do
+        @method.should_receive(:call).with(:id => 1)
+        @resolver.get(:id => 1).should == @result
       end
     end
   end
   
-  describe ".vk_method_name" do
-    context "with a usual method name" do
-      context "without a namespace" do
-        it "returns 'methodName'" do
-          VkontakteApi::Resolver.vk_method_name(:api_method).first.should == 'apiMethod'
-        end
-      end
-      
-      context "with a namespace" do
-        it "returns 'namespace.methodName'" do
-          VkontakteApi::Resolver.vk_method_name(:api_method, 'namespace').first.should == 'namespace.apiMethod'
-        end
-      end
-      
-      it "returns :anything as a type" do
-        VkontakteApi::Resolver.vk_method_name(:api_method).last.should == :anything
-      end
+  describe "#resolver" do
+    before(:each) do
+      @name     = stub("Name")
+      @resolver = @class.new(@name)
+      @token    = stub("Token")
+      @resolver.stub(:token).and_return(@token)
     end
     
-    context "with a predicate method name" do
-      it "returns method name without '?'" do
-        VkontakteApi::Resolver.vk_method_name(:is_it_working?).first.should == 'isItWorking'
-      end
-      
-      it "returns :boolean as a type" do
-        VkontakteApi::Resolver.vk_method_name(:is_it_working?).last.should == :boolean
-      end
+    it "returns a Hashie::Mash with a name and a token" do
+      r = @resolver.resolver
+      r.name.should  == @name
+      r.token.should == @token
+    end
+    
+    it "caches the result" do
+      @mash = stub("Mash", :name => @name, :token => @token)
+      Hashie::Mash.should_receive(:new).once.and_return(@mash)
+      5.times { @resolver.resolver }
     end
   end
   
-  describe "#typecast" do
+  describe ".namespaces" do
     before(:each) do
-      @resolver = VkontakteApi::Resolver.new
+      VkontakteApi::Resolver.instance_variable_set(:@namespaces, nil)
     end
     
-    context "with an :anything type" do
-      it "returns it's argument untouched" do
-        @resolver.send(:typecast, :some_arg, :anything).should == :some_arg
+    context "on first call" do
+      it "loads namespaces from a file" do
+        filename = stub("Filename")
+        File.should_receive(:expand_path).and_return(filename)
+        namespaces = stub("Namespaces list")
+        YAML.should_receive(:load_file).with(filename).and_return(namespaces)
+        
+        VkontakteApi::Resolver.namespaces
       end
     end
     
-    context "with a :boolean type" do
-      context "and zero result" do
-        it "returns false" do
-          @resolver.send(:typecast, '0', :boolean).should == false
-        end
+    context "on subsequent calls" do
+      before(:each) do
+        VkontakteApi::Resolver.namespaces
       end
       
-      context "and non-zero parameter" do
-        it "returns true" do
-          @resolver.send(:typecast, '1', :boolean).should == true
-        end
+      it "returns the cached list" do
+        YAML.should_not_receive(:load_file)
+        VkontakteApi::Resolver.namespaces
       end
     end
   end