Merge remote-tracking branch 'ariejan/master'

Also replaced test task with RSpec task in Rakefile.

Author: Arjan van der Gaag

Rakefile

@@ -1,10 +1,6 @@
 require 'bundler/gem_tasks'
-require 'rake/testtask'
+require 'rspec/core/rake_task'
 
-Rake::TestTask.new do |t|
-  t.libs << 'spec'
-  t.test_files = FileList['spec/**/*_spec.rb']
-  t.verbose = true
-end
+RSpec::Core::RakeTask.new(:spec)
 
-task default: :test
+task :default => :spec

bol.gemspec

@@ -17,6 +17,6 @@ Gem::Specification.new do |s|
   s.require_paths = ['lib']
 
   s.add_development_dependency 'rake'
+  s.add_development_dependency 'rspec'
   s.add_development_dependency 'fakeweb'
-  s.add_development_dependency 'mocha'
 end

spec/bol/category_spec.rb

@@ -4,57 +4,57 @@
   describe 'combining categories' do
     it 'should add two categories for a combined scope' do
       cat = Bol::Category.new(1) + Bol::Category.new(2)
-      cat.id.must_equal('1+2')
+      cat.id.should == '1+2'
     end
 
     it 'should not duplicate IDs when adding' do
       cat = Bol::Category.new(1) + Bol::Category.new(2) + Bol::Category.new(2)
-      cat.id.must_equal('1+2')
+      cat.id.should == '1+2'
     end
 
     it 'should subtract two categories to reduce scope' do
       a = Bol::Category.new(1) + Bol::Category.new(2)
       b = Bol::Category.new(2)
-      (a - b).id.must_equal('1')
+      (a - b).id.should == '1'
     end
   end
 
   describe '#search' do
     it 'should default to root category from the class' do
       query = Bol::Category.search 'foo'
-      query.must_be_kind_of Bol::ResultProxy
-      query.category_id.must_equal 0
+      query.should be_instance_of Bol::ResultProxy
+      query.category_id.should == 0
     end
 
     it 'should set query term' do
-      Bol::Requests::Search.expects(:new).with('foo', instance_of(Bol::Query)).returns(stub(proxy: nil, query: nil))
+      Bol::Requests::Search.should_receive(:new).with('foo', instance_of(Bol::Query)).and_return(stub(proxy: nil, query: nil))
       Bol::Category.search 'foo'
     end
   end
 
   describe 'default category' do
     it 'should set request category scope to 0' do
-      Bol::Category.new.id.must_equal(0)
+      Bol::Category.new.id.should == 0
     end
   end
 
   describe 'lists' do
     let(:cat) { Bol::Category.new.top_products }
 
     it 'should create a list request' do
-      cat.must_be_instance_of(Bol::ResultProxy)
+      cat.should be_instance_of Bol::ResultProxy
     end
 
     it 'should be scoped to the category' do
-      cat.category_id.must_equal(0)
+      cat.category_id.should == 0
     end
   end
 
   describe 'subcategories' do
     let(:cat) { Bol::Category.new.subcategories }
 
     it 'should create category list request' do
-      cat.must_be_instance_of(Bol::Requests::Category)
+      cat.should be_instance_of Bol::Requests::Category
     end
   end
 end

spec/bol/configuration_spec.rb

@@ -4,17 +4,17 @@
   describe 'as a hash' do
     it 'should should set known keys' do
       c = Bol::Configuration.new access_key: 'foo'
-      c[:access_key].must_equal 'foo'
+      c[:access_key].should == 'foo'
     end
 
     it 'should raise for unknown keys' do
-      proc { Bol::Configuration.new foo: 'bar' }.must_raise ArgumentError
+      expect { Bol::Configuration.new foo: 'bar' }.to raise_error ArgumentError
     end
 
     it 'should set a single key' do
       c = Bol::Configuration.new
       c[:access_key] = 'bar'
-      c[:access_key].must_equal 'bar'
+      c[:access_key].should == 'bar'
     end
   end
 
@@ -23,12 +23,12 @@
 
     it 'should should set known keys' do
       config.access_key = 'bar'
-      config.access_key.must_equal 'bar'
+      config.access_key.should == 'bar'
     end
 
     it 'should raise for unknown keys' do
-      proc { config.foo = 'bar' }.must_raise NoMethodError
-      proc { config.foo }.must_raise NoMethodError
+      expect { config.foo = 'bar' }.to raise_error NoMethodError
+      expect { config.foo }.to raise_error NoMethodError
     end
   end
 end

spec/bol/product_spec.rb

@@ -5,12 +5,12 @@
     let(:r) { Bol::Product.find(1) }
 
     before do
-      Bol.stubs(:configuration).returns({ access_key: 'foo', secret: 'bar' })
+      Bol.stub(:configuration).and_return({ access_key: 'foo', secret: 'bar' })
       FakeWeb.register_uri(:get, 'https://openapi.bol.com/openapi/services/rest/catalog/v3/products/1?categoryId=0', body: fixture('products.xml'))
     end
 
     it 'should return product instance' do
-      r.must_be_instance_of Bol::Product
+      r.should be_instance_of Bol::Product
     end
 
     it 'should raise error when not found'
@@ -20,13 +20,13 @@
     it 'should delegate [] to attributes' do
       product = Bol::Product.new
       product.attributes[:foo] = 'bar'
-      product[:foo].must_equal('bar')
+      product[:foo].should == 'bar'
     end
 
     it 'should expose attributes as methods' do
       product = Bol::Product.new
       product.attributes[:foo] = 'bar'
-      product.foo.must_equal('bar')
+      product.foo.should == 'bar'
     end
 
     describe 'referral_url' do
@@ -39,7 +39,7 @@
       end
 
       it 'should generate referral URL' do
-        product.referral_url('foo').must_equal("http://partnerprogramma.bol.com/click/click?p=1&t=url&s=foo&url=http%3A%2F%2Ffoo.bar&f=API&subid=qux&name=bla")
+        product.referral_url('foo').should == "http://partnerprogramma.bol.com/click/click?p=1&t=url&s=foo&url=http%3A%2F%2Ffoo.bar&f=API&subid=qux&name=bla"
       end
     end
 
@@ -53,15 +53,15 @@
       end
 
       it 'should return medium by default' do
-        product.cover.must_equal('foo')
+        product.cover.should == 'foo'
       end
 
       it 'should take format as argument' do
-        product.cover(:small).must_equal('bar')
+        product.cover(:small).should == 'bar'
       end
 
       it 'should raise on invalid format' do
-        proc { product.cover(:baz) }.must_raise(KeyError)
+        expect { product.cover(:baz) }.to raise_error KeyError
       end
     end
   end

spec/bol/query_spec.rb

@@ -3,129 +3,129 @@
 describe Bol::Query do
   describe 'category scope' do
     it 'should set category scope' do
-      Bol::Query.new(1).category_id.must_equal(1)
+      Bol::Query.new(1).category_id.should == 1
     end
 
     it 'should raise unless given a number' do
-      proc { Bol::Query.new('foo') }.must_raise ArgumentError
+      expect { Bol::Query.new('foo') }.to raise_error ArgumentError
     end
 
     it 'should set category param' do
-      Bol::Query.new(1).params[:categoryId].must_equal(1)
+      Bol::Query.new(1).params[:categoryId].should == 1
     end
   end
 
   describe '#has_param?' do
     let(:q) { Bol::Query.new(0) }
 
     it 'should be true when object' do
-      q.has_param?(:categoryId).must_equal true
+      q.has_param?(:categoryId).should be_true
     end
 
     it 'should be false when nil' do
-      q.has_param?(:term).must_equal false
+      q.has_param?(:term).should be_false
     end
 
     it 'should be false when not set' do
-      q.has_param?(:foo).must_equal false
+      q.has_param?(:foo).should be_false
     end
   end
 
   describe '#limit' do
     let(:q) { Bol::Query.new(0) }
 
     it 'should parse argument to a number' do
-      q.limit('10').limit.must_equal(10)
+      q.limit('10').limit.should == 10
     end
 
     it 'should add parameter to request' do
       q.limit(10)
-      q.params[:nrProducts].must_equal(10)
+      q.params[:nrProducts].should == 10
     end
 
     it 'should not add parameter when not set' do
-      q.params.keys.wont_include(:nrProducts)
+      q.params.keys.should_not include(:nrProducts)
     end
 
     it 'should return query' do
-      q.limit(10).must_equal(q)
+      q.limit(10).should == q
     end
   end
 
   describe '#page' do
     let(:q) { Bol::Query.new(0).page(2) }
 
     it 'should parse to number' do
-      Bol::Query.new(0).page('2').limit.must_equal(10)
+      Bol::Query.new(0).page('2').limit.should == 10
     end
 
     it 'should default to 1' do
       x = Bol::Query.new(0).page(nil)
-      x.limit.must_equal(10)
-      x.offset.must_equal(0)
+      x.limit.should == 10
+      x.offset.should == 0
     end
 
     it 'should add limit param to request' do
-      q.limit.must_equal(10)
+      q.limit.should == 10
     end
 
     it 'should add offset param to request' do
-      q.offset.must_equal(10)
+      q.offset.should == 10
     end
 
     it 'should use per page config to determine offset value' do
       Bol.configuration[:per_page] = 20
       x = Bol::Query.new(0).page(3)
-      x.limit.must_equal(20)
-      x.offset.must_equal(40)
+      x.limit.should == 20
+      x.offset.should == 40
       Bol.configuration[:per_page] = 10
     end
 
     it 'should return query' do
       q = Bol::Query.new(0)
-      q.page(1).must_equal(q)
+      q.page(1).should == q
     end
   end
 
   describe '#offset' do
     let(:q) { Bol::Query.new(0) }
 
     it 'should parse argument to a number' do
-      q.offset('10').offset.must_equal(10)
+      q.offset('10').offset.should == 10
     end
 
     it 'should add parameter to request' do
       q.offset(10)
-      q.params[:offset].must_equal(10)
+      q.params[:offset].should == 10
     end
 
     it 'should not add parameter when not set' do
-      q.params.keys.wont_include(:offset)
+      q.params.keys.should_not include(:offset)
     end
 
     it 'should return query' do
-      q.offset(10).must_equal(q)
+      q.offset(10).should == q
     end
   end
 
   describe '#order' do
     let(:q) { Bol::Query.new(0) }
 
     it 'should raise unless wrong format' do
-      proc { q.order('foo') }.must_raise ArgumentError
+      expect { q.order('foo') }.to raise_error ArgumentError
     end
 
     it 'should add order direction on request' do
-      q.order('price ASC').params[:sortingAscending].must_equal('true')
-      q.order('price DESC').params[:sortingAscending].must_equal('false')
+      q.order('price ASC').params[:sortingAscending].should == 'true'
+      q.order('price DESC').params[:sortingAscending].should == 'false'
     end
 
     it 'should add order key on request' do
-      q.order('price ASC').params[:sortingMethod].must_equal('price')
+      q.order('price ASC').params[:sortingMethod].should == 'price'
     end
 
     it 'should return query' do
-      q.order('price ASC').must_equal(q)
+      q.order('price ASC').should == q
     end
   end
 end