vend 0.0.8 → 0.0.9

data/spec/vend/resource/register_sale_spec.rb

@@ -1,7 +1,6 @@
 require 'spec_helper'
 
 describe Vend::Resource::RegisterSale do
-
   subject { described_class.new(nil, {}) }
 
   describe "#register_sale_products" do
@@ -9,16 +8,16 @@ describe Vend::Resource::RegisterSale do
     let(:raw_register_sale_product) { double("raw register sale prodcut") }
 
     before do
-      subject.stub(:attrs) { 
-        { "register_sale_products" => [raw_register_sale_product] } 
-      }
-      Vend::Resource::RegisterSaleProduct.stub(:new).with(raw_register_sale_product) {
-        register_sale_product 
-      }
+      subject.stub(:attrs) do
+        { "register_sale_products" => [raw_register_sale_product] }
+      end
+      Vend::Resource::RegisterSaleProduct.stub(:new).with(raw_register_sale_product) do
+        register_sale_product
+      end
     end
 
     it "returns all the register sale products" do
-      subject.register_sale_products.should == [register_sale_product]
+      expect(subject.register_sale_products).to eq [register_sale_product]
     end
   end
 end

data/spec/vend/resource_collection_spec.rb

@@ -1,66 +1,77 @@
 require 'spec_helper'
 
 describe Vend::ResourceCollection do
-
   let(:client)        { double("client") }
-  let(:target_class)  {
+  let(:target_class)  do
     double("target_class", default_collection_request_args: {})
-  }
+  end
   let(:endpoint)      { "endpoint" }
   let(:request_args)  { {} }
 
   subject { described_class.new(client, target_class, endpoint, request_args) }
 
-  its(:client)        { should == client }
-  its(:target_class)  { should == target_class }
-  its(:endpoint)      { should == endpoint }
-  its(:scopes)        { should == [] }
+  specify :client do
+    expect(subject.client).to eq client
+  end
 
-  describe "#request_args" do
+  specify :target_class do
+    expect(subject.target_class).to eq target_class
+  end
+
+  specify :endpoint do
+    expect(subject.endpoint).to eq endpoint
+  end
+
+  specify :scopes do
+    expect(subject.scopes).to eq []
+  end
 
-    its(:request_args)  { should == request_args }
+  describe "#request_args" do
+    specify :request_args  do
+      expect(subject.request_args).to eq request_args
+    end
 
     context "when not set in initialize" do
-      subject {
-        described_class.new(client, target_class, endpoint)
-      }
-      its(:request_args)  { should == {} }
+      subject { described_class.new(client, target_class, endpoint) }
+      specify :request_args  do
+        expect(subject.request_args).to eq({})
+      end
     end
 
     context "when target class has default request args" do
-      subject {
+      subject do
         described_class.new(client, target_class, endpoint)
-      }
-      before { target_class.stub(:default_collection_request_args => {:foo => :bar}) }
-      its(:request_args)  { should == {:foo => :bar}}
-    end
+      end
+
+      before { target_class.stub(default_collection_request_args: {foo: :bar}) }
 
+      specify :request_args  do
+        expect(subject.request_args).to eq({ foo: :bar })
+      end
+    end
   end
 
   describe "#each" do
-
     let(:member_one)  { double("member_one") }
     let(:member_two)  { double("member_two") }
     let(:json)        { double("json") }
     let(:next_page)   { double("next_page") }
 
     before do
-      target_class.should_receive(:build_from_json).with(client, next_page) {
+      expect(target_class).to receive(:build_from_json).with(client, next_page) {
         [member_one, member_two]
       }
+
       client.stub(:request).with(endpoint, request_args) { json }
       subject.stub(:get_next_page) { next_page }
       subject.stub(:last_page?).and_return(false, true)
     end
 
     it "yields each member and returns self" do
-      member_one.should_receive(:ping!)
-      member_two.should_receive(:ping!)
-      subject.each do |member|
-        member.ping!
-      end.should == subject
+      expect(member_one).to receive(:ping!)
+      expect(member_two).to receive(:ping!)
+      expect(subject.each(&:ping!)).to eq subject
     end
-
   end
 
   describe "#last_page?" do
@@ -84,9 +95,9 @@ describe Vend::ResourceCollection do
   describe "#paged?" do
     context "when pagination is set" do
       let(:value)       { double("value") }
-      let(:pagination)  { double("pagination", :paged? => value) }
+      let(:pagination)  { double("pagination", paged?: value) }
       before do
-        subject.stub(:pagination => pagination)
+        subject.stub(pagination: pagination)
       end
 
       it "delegates to #pagination" do
@@ -101,20 +112,18 @@ describe Vend::ResourceCollection do
     end
   end
 
-=begin
-  [:pages, :page].each do |method|
-    describe method do
-      let(:value)       { double("value") }
-      let(:pagination)  { double("pagination", method => value) }
-      before do
-        subject.stub(:pagination => pagination)
-      end
-      it "delegates to #pagination" do
-        subject.send(method).should == value
-      end
-    end
-  end
-=end
+  #   [:pages, :page].each do |method|
+  #     describe method do
+  #       let(:value)       { double("value") }
+  #       let(:pagination)  { double("pagination", method => value) }
+  #       before do
+  #         subject.stub(pagination: pagination)
+  #       end
+  #       it "delegates to #pagination" do
+  #         expect(subject.send(method)).to eq value
+  #       end
+  #     end
+  #   end
 
   describe "#scope" do
     let(:value)   { double("value") }
@@ -124,12 +133,13 @@ describe Vend::ResourceCollection do
     context "when scope is not already present" do
       before do
         subject.stub(:has_scope?).with(:name) { false }
-        subject.stub(:scopes => scopes)
+        subject.stub(scopes: scopes)
         Vend::Scope.stub(:new).with(:name, value) { scope }
-        scopes.should_receive(:<<).with(scope)
+        expect(scopes).to receive(:<<).with(scope)
       end
+
       it "returns self" do
-        subject.scope(:name, value).should == subject
+        expect(subject.scope(:name, value)).to eq subject
       end
     end
 
@@ -137,10 +147,11 @@ describe Vend::ResourceCollection do
       before do
         subject.stub(:has_scope?).with(:name) { true }
       end
+
       it "raises and AlreadyScopedError" do
-        lambda do
+        expect do
           subject.scope(:name, value)
-        end.should raise_exception(Vend::ResourceCollection::AlreadyScopedError)
+        end.to raise_exception(Vend::ResourceCollection::AlreadyScopedError)
       end
     end
   end
@@ -168,28 +179,27 @@ describe Vend::ResourceCollection do
     before do
       target_class.stub(:accepts_scope?).with(:name)  { value }
     end
+
     it "delegates to target_class" do
-      subject.accepts_scope?(:name).should == value
+      expect(subject.accepts_scope?(:name)).to eq value
     end
   end
 
   describe "#method_missing" do
-
     let(:value) { double("value") }
-
     context "when the method name is a valid scope name" do
-
       before do
         subject.stub(:accepts_scope?).with(:foo) { true }
       end
 
-      it { should respond_to(:foo) }
+      specify :responds_to_foo do
+        expect(subject).to respond_to(:foo)
+      end
 
       it "adds the relevant scope if it accepts a scope for the method name" do
-        subject.should_receive(:scope).with(:foo, value) { subject }
-        subject.foo(value).should == subject
+        expect(subject).to receive(:scope).with(:foo, value) { subject }
+        expect(subject.foo(value)).to eq subject
       end
-
     end
 
     context "when the method name is not a valid scope name" do
@@ -202,29 +212,31 @@ describe Vend::ResourceCollection do
       end
 
       it "raises method missing" do
-        lambda do
+        expect do
           subject.foo(value)
-        end.should raise_exception(NoMethodError)
+        end.to raise_exception(NoMethodError)
       end
     end
   end
 
   describe "#url" do
-
     let(:endpoint_with_scopes) { "endpoint_with_scopes" }
 
     before do
-      subject.stub(:endpoint_with_scopes => endpoint_with_scopes)
-      subject.should_receive(:increment_page)
+      subject.stub(endpoint_with_scopes: endpoint_with_scopes)
+      expect(subject).to receive(:increment_page)
     end
 
-    its(:url) { should == endpoint_with_scopes }
+    specify :url do
+      expect(subject.url).to eq endpoint_with_scopes
+    end
   end
 
   describe "#endpoint_with_scopes" do
-
     context "when there are no scopes" do
-      its(:endpoint_with_scopes) { should == endpoint }
+      specify :endpoint_with_scopes do
+        expect(subject.endpoint_with_scopes).to eq endpoint
+      end
     end
 
     context "when there are scopes" do
@@ -232,95 +244,96 @@ describe Vend::ResourceCollection do
       let(:scope2) { "scope2" }
       let(:scopes) { [scope1, scope2] }
       before do
-        subject.stub(:scopes => scopes)
+        subject.stub(scopes: scopes)
       end
 
-      its(:endpoint_with_scopes) { should == endpoint + scopes.join}
+      specify :endpoint_with_scopes do
+        expect(subject.endpoint_with_scopes).to eq endpoint + scopes.join
+      end
     end
   end
 
   describe "#increment_page" do
-
     context "when not paged" do
-
       before do
-        subject.stub(:paged? => false)
+        subject.stub(paged?: false)
       end
 
-      its(:increment_page) { should be_nil }
-
+      specify :increment_page do
+        expect(subject.increment_page).to be_nil
+      end
     end
 
     context "when paged" do
-
-      let(:page_scope)  { double("page_scope", :value => 1) }
+      let(:page_scope)  { double("page_scope", value: 1) }
 
       before do
-        subject.stub(:paged? => true)
-        subject.stub(:page => 1)
-        subject.should_receive(:get_or_create_page_scope) { page_scope }
-        page_scope.should_receive(:value=).with(2) { 2 }
+        subject.stub(paged?: true)
+        subject.stub(page: 1)
+        expect(subject).to receive(:get_or_create_page_scope) { page_scope }
+        expect(page_scope).to receive(:value=).with(2) { 2 }
       end
 
-      its(:increment_page) { should == 2 }
-
+      specify :increment_page do
+        expect(subject.increment_page).to eq 2
+      end
     end
-
   end
 
   describe "#get_or_create_page_scope" do
-
     let(:page_scope)  { double("page_scope") }
     let(:page)        { 1 }
 
     before do
-      subject.stub(:page => page)
-      subject.should_receive(:get_scope).with(:page) { page_scope }
+      subject.stub(page: page)
+      expect(subject).to receive(:get_scope).with(:page) { page_scope }
     end
 
     context "when scope is not present" do
       before do
         subject.stub(:has_scope?).with(:page) { false }
-        subject.should_receive(:scope).with(:page, page) { page_scope }
+        expect(subject).to receive(:scope).with(:page, page) { page_scope }
+      end
+
+      specify :get_or_create_page_scope  do
+        expect(subject.get_or_create_page_scope).to eq page_scope
       end
-      its(:get_or_create_page_scope)  { should == page_scope }
     end
 
     context "when scope is already present" do
       before do
         subject.stub(:has_scope?).with(:page) { true }
       end
-      its(:get_or_create_page_scope)  { should == page_scope }
+      specify :get_or_create_page_scope  do
+        expect(subject.get_or_create_page_scope).to eq page_scope
+      end
     end
   end
 
   describe "#get_scope" do
-
     let(:scope_name)  { :scope_name }
-    let(:scope)       { double("scope", :name => scope_name) }
+    let(:scope)       { double("scope", name: scope_name) }
 
     context "when scope is present" do
-
       before do
-        subject.stub(:scopes => [scope])
+        subject.stub(scopes: [scope])
       end
 
       specify do
-        subject.get_scope(scope_name).should == scope
+        expect(subject.get_scope(scope_name)).to eq scope
       end
-
     end
 
     context "when scope is not present" do
       before do
-        subject.stub(:scopes => [])
+        subject.stub(scopes: [])
       end
+
       specify do
-        lambda do
+        expect do
           subject.get_scope(scope_name)
-        end.should raise_exception(Vend::ResourceCollection::ScopeNotFoundError)
+        end.to raise_exception(Vend::ResourceCollection::ScopeNotFoundError)
       end
     end
-
   end
 end

data/spec/vend/scope_spec.rb

@@ -1,41 +1,49 @@
 require 'spec_helper'
 
 describe Vend::Scope do
-
   let(:name)    { :name }
   let(:value)   { "value" }
 
   subject { described_class.new(name, value) }
 
-  its(:name)    { should == name }
-  its(:value)   { should == value }
+  specify :name do
+    expect(subject.name).to eq name
+  end
 
+  specify :value do
+    expect(subject.value).to eq value
+  end
 
   describe "#to_s" do
-
     let(:escaped_value) { "escaped_value" }
 
     before do
-      subject.stub(:escaped_value => escaped_value)
+      subject.stub(escaped_value: escaped_value)
     end
 
-    its(:to_s)    { should == "/#{name}/#{escaped_value}" }
-
+    specify :to_s do
+      expect(subject.to_s).to eq "/#{name}/#{escaped_value}"
+    end
   end
 
   describe "#escaped_value" do
     let(:value) { "value with spaces" }
-    its(:escaped_value) { should == "value+with+spaces" }
+    specify :escaped_value do
+      expect(subject.escaped_value).to eq "value+with+spaces"
+    end
 
     context "when value is a Fixnum" do
       let(:value) { 42 }
-      its(:escaped_value) { should == "42" }
+      specify :escaped_value do
+        expect(subject.escaped_value).to eq "42"
+      end
     end
 
     context "when value is a timestamp" do
-      let(:value) { Time.new(2012,7,11,10,40,29) }
-      its(:escaped_value) { should == "2012-07-11+10%3A40%3A29" }
+      let(:value) { Time.new(2012, 7, 11, 10, 40, 29) }
+      specify :escaped_value do
+        expect(subject.escaped_value).to eq "2012-07-11+10%3A40%3A29"
+      end
     end
   end
-
 end