vkontakte_api 1.2 → 1.3

data/spec/vkontakte_api/client_spec.rb

@@ -2,40 +2,48 @@ require 'spec_helper'
 
 describe VkontakteApi::Client do
   before(:each) do
-    @user_id      = double("User id")
-    @string_token = double("Access token as a String")
-    @expires_at   = Time.now - 2 * 60 * 60 # 2.hours.ago
-    
-    @oauth2_token = double("Access token as an OAuth2::AccessToken")
-    @oauth2_token.stub(:token).and_return(@string_token)
-    @oauth2_token.stub(:params).and_return('user_id' => @user_id)
-    @oauth2_token.stub(:expires_at).and_return(@expires_at)
+    @user_id = double("User id")
+  end
+  
+  def oauth2_token(expires_at = Time.now)
+    token = double("Access token as an OAuth2::AccessToken").tap do |token|
+      token.stub(:token).and_return(string_token)
+      token.stub(:params).and_return('user_id' => @user_id)
+      token.stub(:expires_at).and_return(expires_at)
+    end
   end
   
+  let(:string_token)  { double("Access token as a String") }
+  let(:expired_token) { oauth2_token(Time.now - 2 * 60 * 60) }
+  let(:actual_token)  { oauth2_token(Time.now + 2 * 60 * 60) }
+  
   describe "#initialize" do
     context "without arguments" do
+      let(:client) { VkontakteApi::Client.new }
+      
       it "creates a client with a nil access_token" do
-        client = VkontakteApi::Client.new
-        client.token.should be_nil
+        expect(client.token).to be_nil
       end
     end
     
     context "with a token argument" do
       context "with a string value" do
+        let(:client) { VkontakteApi::Client.new(string_token) }
+        
         it "creates a client with a given access_token" do
-          client = VkontakteApi::Client.new(@string_token)
-          client.token.should == @string_token
+          expect(client.token).to eq(string_token)
         end
       end
       
       context "with an OAuth2::AccessToken value" do
+        let(:client) { VkontakteApi::Client.new(oauth2_token) }
+        
         it "extracts the string token and uses it" do
-          client = VkontakteApi::Client.new(@oauth2_token)
-          client.token.should == @string_token
-          client.user_id.should == @user_id
+          expect(client.token).to eq(string_token)
+          expect(client.user_id).to eq(@user_id)
           
-          client.expires_at.should be_a(Time)
-          client.expires_at.should be < Time.now
+          expect(client.expires_at).to be_a(Time)
+          expect(client.expires_at).to be < Time.now
         end
       end
     end
@@ -43,60 +51,57 @@ describe VkontakteApi::Client do
   
   describe "#authorized?" do
     context "with an unauthorized client" do
+      let(:client) { VkontakteApi::Client.new }
+      
       it "returns false" do
-        VkontakteApi::Client.new.should_not be_authorized
+        expect(client).not_to be_authorized
       end
     end
     
     context "with an authorized client" do
+      let(:client) { VkontakteApi::Client.new(string_token) }
+      
       it "returns true" do
-        VkontakteApi::Client.new(@string_token).should be_authorized
+        expect(client).to be_authorized
       end
     end
   end
   
   describe "#expired?" do
     context "with an expired token" do
-      before(:each) do
-        @client = VkontakteApi::Client.new(@oauth2_token)
-      end
+      let(:client) { VkontakteApi::Client.new(expired_token) }
       
       it "returns true" do
-        @client.should be_expired
+        expect(client).to be_expired
       end
     end
     
     context "with an actual token" do
-      before(:each) do
-        @oauth2_token.stub(:expires_at).and_return(Time.now + 2 * 24 * 60 * 60) # 2.days.from_now
-        @client = VkontakteApi::Client.new(@oauth2_token)
-      end
+      let(:client) { VkontakteApi::Client.new(actual_token) }
       
       it "returns false" do
-        @client.should_not be_expired
+        expect(client).not_to be_expired
       end
     end
     
     context "with a String token" do
-      before(:each) do
-        @client = VkontakteApi::Client.new(@string_token)
-      end
+      let(:client) { VkontakteApi::Client.new(string_token) }
       
       it "returns false" do
-        @client.should_not be_expired
+        expect(client).not_to be_expired
       end
     end
   end
   
   describe "#scope" do
-    before(:each) do
-      @client = VkontakteApi::Client.new
-      @client.stub(:get_user_settings).and_return(865310)
+    let(:client) do
+      VkontakteApi::Client.new.tap do |client|
+        client.stub(:get_user_settings).and_return(865310)
+      end
     end
+    let(:scope) { client.scope }
     
     it "returns an array of access rights" do
-      scopes_array = @client.scope
-      
       [
         :friends,
         :photos,
@@ -108,7 +113,38 @@ describe VkontakteApi::Client do
         :groups,
         :notifications
       ].each do |access_scope|
-        scopes_array.should include(access_scope)
+        expect(scope).to include(access_scope)
+      end
+    end
+  end
+  
+  describe "#method_missing" do
+    let(:client) do
+      token = double("Token")
+      VkontakteApi::Client.new(token)
+    end
+    
+    context "called with a namespace" do
+      it "returns a Namespace instance" do
+        expect(client.users).to be_a(VkontakteApi::Namespace)
+      end
+    end
+    
+    context "called with a method" do
+      before(:each) do
+        @result = double("Result")
+        @method = double("Method", call: @result)
+        VkontakteApi::Method.stub(:new).and_return(@method)
+      end
+      
+      it "creates a Method instance" do
+        expect(VkontakteApi::Method).to receive(:new).with(:get, resolver: client.resolver)
+        client.get(id: 1)
+      end
+      
+      it "calls Method#call and returns the result" do
+        expect(@method).to receive(:call).with(id: 1)
+        expect(client.get(id: 1)).to eq(@result)
       end
     end
   end

data/spec/vkontakte_api/configuration_spec.rb

@@ -7,30 +7,31 @@ end
 describe VkontakteApi::Configuration do
   describe "#configure" do
     it "yields self" do
-      Configurable.should_receive(:some_method)
+      expect(Configurable).to receive(:some_method)
       Configurable.configure do |config|
         config.some_method
       end
     end
     
     it "returns self" do
-      Configurable.configure.should == Configurable
+      expect(Configurable.configure).to eq(Configurable)
     end
   end
   
   describe "#reset" do
     it "sets all options to their default values" do
       Configurable.reset
-      Configurable.app_id.should be_nil
-      Configurable.app_secret.should be_nil
-      Configurable.adapter.should == VkontakteApi::Configuration::DEFAULT_ADAPTER
-      Configurable.http_verb.should == VkontakteApi::Configuration::DEFAULT_HTTP_VERB
-      Configurable.faraday_options.should == {}
       
-      Configurable.logger.should be_a(Logger)
-      Configurable.should log_requests
-      Configurable.should log_errors
-      Configurable.should_not log_responses
+      expect(Configurable.app_id).to be_nil
+      expect(Configurable.app_secret).to be_nil
+      expect(Configurable.adapter).to eq(VkontakteApi::Configuration::DEFAULT_ADAPTER)
+      expect(Configurable.http_verb).to eq(VkontakteApi::Configuration::DEFAULT_HTTP_VERB)
+      expect(Configurable.faraday_options).to eq(Hash.new)
+      
+      expect(Configurable.logger).to be_a(Logger)
+      expect(Configurable).to log_requests
+      expect(Configurable).to log_errors
+      expect(Configurable).not_to log_responses
     end
   end
 end

data/spec/vkontakte_api/error_spec.rb

@@ -1,8 +1,8 @@
 require 'spec_helper'
 
 describe VkontakteApi::Error do
-  before(:each) do
-    @error_data = Hashie::Mash.new(
+  let(:error_data) do
+    Hashie::Mash.new(
       error_code:     5,
       error_msg:      'User authorization failed: invalid access_token.',
       request_params: [
@@ -24,24 +24,22 @@ describe VkontakteApi::Error do
   
   describe "#message" do
     context "without parameters" do
-      before(:each) do
-        @e = VkontakteApi::Error.new(@error_data)
-      end
+      let(:error) { VkontakteApi::Error.new(error_data) }
       
       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)
+          raise error
+        }.to raise_error(error.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)
+      let(:error) do
+        error_data[:request_params] << Hashie::Mash.new(key: 'some', value: 'params')
+        VkontakteApi::Error.new(error_data)
       end
       
       it "returns all needed data about an error" do
@@ -49,8 +47,8 @@ describe VkontakteApi::Error do
         message << ' after calling method \'unknownMethod\' with parameters {"some"=>"params"}.'
         
         expect {
-          raise @e
-        }.to raise_error(@e.class, message)
+          raise error
+        }.to raise_error(error.class, message)
       end
     end
   end

data/spec/vkontakte_api/logger_spec.rb

@@ -2,10 +2,18 @@ require 'spec_helper'
 
 describe VkontakteApi::Logger do
   before(:each) do
-    @success_response = Oj.dump('a' => 1, 'b' => 2)
-    @fail_response    = Oj.dump('error' => 404)
+    VkontakteApi.logger = double("Logger").as_null_object
     
-    @connection = Faraday.new(url: 'http://example.com') do |builder|
+    VkontakteApi.log_requests  = false
+    VkontakteApi.log_responses = false
+    VkontakteApi.log_errors    = false
+  end
+  
+  let(:success_response) { Oj.dump('a' => 1, 'b' => 2) }
+  let(:fail_response) { Oj.dump('error' => 404) }
+  
+  let(:connection) do
+    Faraday.new(url: 'http://example.com') do |builder|
       builder.request  :url_encoded
       builder.response :vk_logger
       builder.response :mashify
@@ -13,23 +21,18 @@ describe VkontakteApi::Logger do
       
       builder.adapter :test do |stub|
         stub.get('/success') do
-          [200, {}, @success_response]
+          [200, {}, success_response]
         end
+        
         stub.post('/success') do
-          [200, {}, @success_response]
+          [200, {}, success_response]
         end
+        
         stub.get('/fail') do
-          [200, {}, @fail_response]
+          [200, {}, fail_response]
         end
       end
     end
-    
-    @logger = double("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
@@ -38,23 +41,23 @@ describe VkontakteApi::Logger do
     end
     
     it "logs the request URL" do
-      @logger.should_receive(:debug).with('GET http://example.com/success')
-      @connection.get('/success')
+      expect(VkontakteApi.logger).to receive(:debug).with('GET http://example.com/success')
+      connection.get('/success')
     end
     
     context "with a POST request" do
       it "logs the request URL and the request body" do
-        @logger.should_receive(:debug).with('POST http://example.com/success')
-        @logger.should_receive(:debug).with('body: "param=1"')
-        @connection.post('/success', param: 1)
+        expect(VkontakteApi.logger).to receive(:debug).with('POST http://example.com/success')
+        expect(VkontakteApi.logger).to receive(:debug).with('body: "param=1"')
+        connection.post('/success', param: 1)
       end
     end
   end
   
   context "without VkontakteApi.log_requests?" do
     it "doesn't log the request" do
-      @logger.should_not_receive(:debug)
-      @connection.get('/success')
+      expect(VkontakteApi.logger).not_to receive(:debug)
+      connection.get('/success')
     end
   end
   
@@ -65,15 +68,15 @@ describe VkontakteApi::Logger do
       end
       
       it "logs the response body" do
-        @logger.should_receive(:debug).with(@success_response)
-        @connection.get('/success')
+        expect(VkontakteApi.logger).to 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')
+        expect(VkontakteApi.logger).not_to receive(:debug)
+        connection.get('/success')
       end
     end
   end
@@ -85,15 +88,15 @@ describe VkontakteApi::Logger do
       end
       
       it "logs the response body" do
-        @logger.should_receive(:warn).with(@fail_response)
-        @connection.get('/fail')
+        expect(VkontakteApi.logger).to 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')
+        expect(VkontakteApi.logger).not_to receive(:warn)
+        connection.get('/fail')
       end
     end
   end

data/spec/vkontakte_api/method_spec.rb

@@ -2,42 +2,45 @@ require 'spec_helper'
 
 describe VkontakteApi::Method do
   describe "#call" do
+    let(:full_name) { double("Full method name") }
+    let(:args) { double("Method arguments") }
+    let(:token) { double("Access token") }
+    
+    let(:method) do
+      VkontakteApi::Method.new('some_name').tap do |method|
+        method.stub(:full_name).and_return(full_name)
+        method.stub(:token).and_return(token)
+      end
+    end
+    
     before(:each) do
-      @full_name = double("Full method name")
-      @args      = double("Method arguments")
-      @token     = double("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)
+      expect(VkontakteApi::API).to receive(:call).with(full_name, args, token)
+      method.call(args)
     end
     
     it "sends the response to Result.process" do
       response = double("VK response")
       VkontakteApi::API.stub(:call).and_return(response)
       type = double("Type")
-      @method.stub(:type).and_return(type)
+      method.stub(:type).and_return(type)
       
-      VkontakteApi::Result.should_receive(:process).with(response, type, nil)
-      @method.call(@args)
+      expect(VkontakteApi::Result).to receive(:process).with(response, type, nil)
+      method.call(args)
     end
   end
   
   describe "#full_name" do
-    before(:each) do
+    let(:method) do
       resolver = Hashie::Mash.new(name: 'name_space')
-      @name = 'name'
-      @method = VkontakteApi::Method.new(@name, resolver: resolver)
+      VkontakteApi::Method.new('name', resolver: resolver)
     end
     
     it "sends each part to #camelize" do
-      @method.send(:full_name).should == 'nameSpace.name'
+      expect(method.send(:full_name)).to eq('nameSpace.name')
     end
   end
   
@@ -45,14 +48,14 @@ describe VkontakteApi::Method do
     context "with a usual name" do
       it "returns :anything" do
         method = VkontakteApi::Method.new('get')
-        method.send(:type).should == :anything
+        expect(method.send(:type)).to eq(: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
+        expect(method.send(:type)).to eq(:boolean)
       end
     end
   end