vkontakte_api 1.2 → 1.3

data/spec/vkontakte_api/namespace_spec.rb

@@ -1,5 +1,51 @@
 require 'spec_helper'
 
 describe VkontakteApi::Namespace do
-  # nothing to spec here yet
+  describe ".names" do
+    before(:each) do
+      VkontakteApi::Namespace.instance_variable_set(:@names, nil)
+    end
+    
+    context "on first call" do
+      it "loads namespaces from a file" do
+        filename = double("Filename")
+        expect(File).to receive(:expand_path).and_return(filename)
+        namespaces = double("Namespaces list")
+        expect(YAML).to receive(:load_file).with(filename).and_return(namespaces)
+        
+        VkontakteApi::Namespace.names
+      end
+    end
+    
+    context "on subsequent calls" do
+      before(:each) do
+        VkontakteApi::Namespace.names
+      end
+      
+      it "returns the cached list" do
+        expect(YAML).not_to receive(:load_file)
+        VkontakteApi::Namespace.names
+      end
+    end
+  end
+  
+  describe ".exists?" do
+    context "with an existing namespace" do
+      it "returns true" do
+        expect(VkontakteApi::Namespace).to exist('users')
+      end
+    end
+    
+    context "with a non-existent namespace" do
+      it "returns false" do
+        expect(VkontakteApi::Namespace).not_to exist('admins')
+      end
+    end
+    
+    context "with an existing symbol namespace" do
+      it "returns true" do
+        expect(VkontakteApi::Namespace).to exist(:users)
+      end
+    end
+  end
 end

data/spec/vkontakte_api/resolvable_spec.rb

@@ -8,14 +8,12 @@ describe VkontakteApi::Resolvable do
   end
   
   describe "#initialize" do
-    it "should save name and resolver" do
-      name     = double("Name")
-      token    = double("Token")
-      resolver = Hashie::Mash.new(token: token)
+    it "saves the name and the resolver" do
+      resolver   = Hashie::Mash.new(token: 'token')
+      resolvable = @class.new(:name, resolver: resolver)
       
-      resolvable = @class.new(name, resolver: resolver)
-      resolvable.name.should  == name
-      resolvable.token.should == token
+      expect(resolvable.name).to  eq('name')
+      expect(resolvable.token).to eq('token')
     end
   end
 end

data/spec/vkontakte_api/resolver_spec.rb

@@ -11,39 +11,6 @@ describe VkontakteApi::Resolver do
     end
   end
   
-  describe "#method_missing" do
-    before(:each) do
-      @resolver = @class.new(:trololo)
-      @token = double("Token")
-      @resolver.stub(:token).and_return(@token)
-    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 "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
-        VkontakteApi::Method.should_receive(:new).with('get', resolver: @resolver.resolver)
-        @resolver.get(id: 1)
-      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 "#send" do
     before(:each) do
       @resolver = @class.new('trololo')
@@ -53,7 +20,7 @@ describe VkontakteApi::Resolver do
     
     it "gets into #method_missing" do
       method = double("Method", call: nil)
-      VkontakteApi::Method.should_receive(:new).with('send', resolver: @resolver.resolver).and_return(method)
+      expect(@resolver).to receive(:method_missing).with(:send, message: 'hello')
       @resolver.send(message: 'hello')
     end
   end
@@ -66,44 +33,17 @@ describe VkontakteApi::Resolver do
       @resolver.stub(:token).and_return(@token)
     end
     
+    let(:resolver) { @resolver.resolver }
+    
     it "returns a Hashie::Mash with a name and a token" do
-      r = @resolver.resolver
-      r.name.should  == @name
-      r.token.should == @token
+      expect(resolver.name).to  eq(@name)
+      expect(resolver.token).to eq(@token)
     end
     
     it "caches the result" do
       @mash = double("Mash", name: @name, token: @token)
-      Hashie::Mash.should_receive(:new).once.and_return(@mash)
+      expect(Hashie::Mash).to receive(:new).once.and_return(@mash)
       5.times { @resolver.resolver }
     end
   end
-  
-  describe ".namespaces" do
-    before(:each) do
-      VkontakteApi::Resolver.instance_variable_set(:@namespaces, nil)
-    end
-    
-    context "on first call" do
-      it "loads namespaces from a file" do
-        filename = double("Filename")
-        File.should_receive(:expand_path).and_return(filename)
-        namespaces = double("Namespaces list")
-        YAML.should_receive(:load_file).with(filename).and_return(namespaces)
-        
-        VkontakteApi::Resolver.namespaces
-      end
-    end
-    
-    context "on subsequent calls" do
-      before(:each) do
-        VkontakteApi::Resolver.namespaces
-      end
-      
-      it "returns the cached list" do
-        YAML.should_not_receive(:load_file)
-        VkontakteApi::Resolver.namespaces
-      end
-    end
-  end
 end

data/spec/vkontakte_api/result_spec.rb

@@ -2,90 +2,99 @@ require 'spec_helper'
 
 describe VkontakteApi::Result do
   describe ".process" do
+    let(:response) { double("Response") }
+    let(:result) { double("Result") }
+    
     before(:each) do
-      @response = double("Response")
-      @result = double("Result")
-      subject.stub(:extract_result).and_return(@result)
+      subject.stub(:extract_result).and_return(result)
     end
     
     it "calls .extract_result passing it the response" do
-      subject.should_receive(:extract_result).with(@response)
-      subject.process(@response, @type, nil)
+      expect(subject).to receive(:extract_result).with(response)
+      subject.process(response, :anything, nil)
     end
     
     context "with a non-enumerable result" do
+      let(:type) { double("Type") }
+      let(:typecasted_value) { double("Typecasted value") }
+      
       before(:each) do
-        @type = double("Type")
-        @typecasted_value = double("Typecasted value")
-        subject.stub(:typecast).and_return(@typecasted_value)
+        subject.stub(:typecast).and_return(typecasted_value)
       end
       
       it "returns #typecast-ed value" do
-        subject.should_receive(:typecast).with(@result, @type).and_return(@typecasted_value)
-        subject.send(:process, @result, @type, nil).should == @typecasted_value
+        expect(subject).to receive(:typecast).with(result, type).and_return(typecasted_value)
+        expect(subject.process(result, type, nil)).to eq(typecasted_value)
       end
       
       context "when block_given?" do
         it "yields the #typecast-ed value and returns the result of the block" do
           block_result = double("Block result")
-          @typecasted_value.should_receive(:result_method).and_return(block_result)
+          expect(typecasted_value).to receive(:result_method).and_return(block_result)
           block = proc(&:result_method)
           
-          subject.send(:process, @response, @type, block).should == block_result
+          expect(subject.process(response, type, block)).to eq(block_result)
         end
       end
     end
     
     context "with an enumerable result" do
+      let(:element1) { double("First element") }
+      let(:element2) { double("Second element") }
+      let(:enumerable_result) { [element1, element2] }
+      
       before(:each) do
-        @element1 = double("First element")
-        @element2 = double("Second element")
-        @enumerable_result = [@element1, @element2]
-        subject.stub(:extract_result).and_return(@enumerable_result)
+        subject.stub(:extract_result).and_return(enumerable_result)
       end
       
       it "returns the untouched value" do
-        subject.send(:process, @enumerable_result, :anything, nil).should == @enumerable_result
+        expect(subject.process(enumerable_result, :anything, nil)).to eq(enumerable_result)
       end
       
       context "when block_given?" do
         it "yields each element untouched to the block" do
           result1 = double("First element after result_method")
           result2 = double("Second element after result_method")
-          @element1.should_receive(:result_method).and_return(result1)
-          @element2.should_receive(:result_method).and_return(result2)
+          expect(element1).to receive(:result_method).and_return(result1)
+          expect(element2).to receive(:result_method).and_return(result2)
           block = proc(&:result_method)
           
-          subject.send(:process, @enumerable_result, :anything, block).should == [result1, result2]
+          expect(subject.process(enumerable_result, :anything, block)).to eq([result1, result2])
         end
       end
     end
   end
   
   describe ".extract_result" do
-    before(:each) do
-      @result_response  = { 'key' => 'value' }
-      @result_error     = { 'request_params' => [{ 'key' => 'error', 'value' => 'description' }] }
+    let(:result_response) do
+      { 'key' => 'value' }
+    end
+    
+    let(:result_error) do
+      {
+        'request_params' => [
+          {
+            'key'   => 'error',
+            'value' => 'description'
+          }
+        ]
+      }
     end
     
     context "with a successful response" do
-      before(:each) do
-        @result = Hashie::Mash.new(response: @result_response)
-      end
+      let(:result) { Hashie::Mash.new(response: result_response) }
       
       it "returns the response part" do
-        subject.send(:extract_result, @result).should == @result_response
+        expect(subject.send(:extract_result, result)).to eq(result_response)
       end
     end
     
     context "with an error response" do
-      before(:each) do
-        @result = Hashie::Mash.new(error: @result_error)
-      end
+      let(:result) { Hashie::Mash.new(error: result_error) }
       
       it "raises a VkontakteApi::Error" do
         expect {
-          subject.send(:extract_result, @result)
+          subject.send(:extract_result, result)
         }.to raise_error(VkontakteApi::Error)
       end
     end
@@ -94,20 +103,20 @@ describe VkontakteApi::Result do
   describe ".typecast" do
     context "with an :anything type" do
       it "returns it's argument untouched" do
-        subject.send(:typecast, :some_arg, :anything).should == :some_arg
+        expect(subject.send(:typecast, :some_arg, :anything)).to eq(:some_arg)
       end
     end
     
     context "with a :boolean type" do
       context "and zero result" do
         it "returns false" do
-          subject.send(:typecast, '0', :boolean).should == false
+          expect(subject.send(:typecast, '0', :boolean)).to eq(false)
         end
       end
       
       context "and non-zero parameter" do
         it "returns true" do
-          subject.send(:typecast, '1', :boolean).should == true
+          expect(subject.send(:typecast, '1', :boolean)).to eq(true)
         end
       end
     end

data/spec/vkontakte_api/uploading_spec.rb

@@ -1,26 +1,27 @@
 require 'spec_helper'
 
 describe VkontakteApi::Uploading do
-  before(:each) do
-    @uploader = Object.new
-    @uploader.extend VkontakteApi::Uploading
+  let(:uploader) do
+    Object.new.tap do |object|
+      object.extend VkontakteApi::Uploading
+    end
   end
   
   describe "#upload" do
+    let(:upload_io)     { double("Faraday::UploadIO instance") }
+    let(:response_body) { double("Server response body") }
+    let(:response)      { double("Server response", body: response_body) }
+    let(:connection)    { double("Faraday connection", post: response) }
+    
     before(:each) do
-      @upload_io = double("Faraday::UploadIO instance")
-      Faraday::UploadIO.stub(:new).and_return(@upload_io)
-      
-      @response_body = double("Server response body")
-      response       = double("Server response", body: @response_body)
-      @connection    = double("Faraday connection", post: response)
-      VkontakteApi::API.stub(:connection).and_return(@connection)
+      Faraday::UploadIO.stub(:new).and_return(upload_io)
+      VkontakteApi::API.stub(:connection).and_return(connection)
     end
     
     context "without a :url param" do
       it "raises an ArgumentError" do
         expect {
-          @uploader.upload
+          uploader.upload
         }.to raise_error(ArgumentError)
       end
     end
@@ -28,19 +29,22 @@ describe VkontakteApi::Uploading do
     it "creates a Faraday::UploadIO for each file passed in" do
       path = double("File path")
       type = double("File mime type")
-      Faraday::UploadIO.should_receive(:new).with(path, type)
-      @uploader.upload(url: 'http://example.com', file1: [path, type])
+      io = double("File IO")
+      
+      expect(Faraday::UploadIO).to receive(:new).with(path, type, nil)
+      expect(Faraday::UploadIO).to receive(:new).with(io, type, path)
+      uploader.upload(url: 'http://example.com', file1: [path, type], file2: [io, type, path])
     end
     
     it "POSTs the files through the connection to a given URL" do
       url  = double("URL")
       file = double("File")
-      @connection.should_receive(:post).with(url, file1: @upload_io)
-      @uploader.upload(url: url, file1: file)
+      expect(connection).to receive(:post).with(url, file1: upload_io)
+      uploader.upload(url: url, file1: file)
     end
     
     it "returns the server response" do
-      @uploader.upload(url: 'http://example.com').should == @response_body
+      expect(uploader.upload(url: 'http://example.com')).to eq(response_body)
     end
   end
 end

data/spec/vkontakte_api/utils_spec.rb

@@ -2,45 +2,42 @@ require 'spec_helper'
 
 describe VkontakteApi::Utils do
   describe ".flatten_arguments" do
+    let(:arg1) { double("First argument") }
+    let(:arg2) { double("Second argument") }
+    let(:flat_arg1) { double("Flattened first argument") }
+    let(:flat_arg2) { double("Flattened second argument") }
+    
     before(:each) do
-      @arg1 = double("First argument")
-      @arg2 = double("Second argument")
-      @flat_arg1 = double("Flattened first argument")
-      @flat_arg2 = double("Flattened second argument")
-      
       VkontakteApi::Utils.stub(:flatten_argument) do |arg|
         case arg
-        when @arg1 then @flat_arg1
-        when @arg2 then @flat_arg2
+        when arg1 then flat_arg1
+        when arg2 then flat_arg2
         end
       end
     end
     
     it "sends each value to .flatten_argument" do
-      flat_arguments = VkontakteApi::Utils.flatten_arguments(arg1: @arg1, arg2: @arg2)
-      flat_arguments.should == { arg1: @flat_arg1, arg2: @flat_arg2 }
+      flat_arguments = VkontakteApi::Utils.flatten_arguments(arg1: arg1, arg2: arg2)
+      expect(flat_arguments).to eq(arg1: flat_arg1, arg2: flat_arg2)
     end
   end
   
   describe ".flatten_argument" do
     context "with a flat argument" do
-      before(:each) do
-        @argument = :flat
-      end
+      let(:argument) { :flat }
       
       it "leaves it untouched" do
-        subject.send(:flatten_argument, @argument).should == @argument
+        result = subject.send(:flatten_argument, argument)
+        expect(result).to eq(argument)
       end
     end
     
     context "with an array argument" do
-      before(:each) do
-        @array_argument = [1, 2, 3]
-      end
+      let(:array_argument) { [1, 2, 3] }
       
       it "joins the elements with a comma" do
-        flat_argument = subject.send(:flatten_argument, @array_argument)
-        flat_argument.should == '1,2,3'
+        flat_argument = subject.send(:flatten_argument, array_argument)
+        expect(flat_argument).to eq('1,2,3')
       end
     end
   end