stockboy 1.1.0 → 1.1.1

data/spec/stockboy/filter_chain_spec.rb

@@ -9,8 +9,8 @@ module Stockboy
 
     it "initializes keys and values from a hash" do
       chain = FilterChain.new(no_angels: filter1, no_daleks: filter2)
-      chain.keys.should == [:no_angels, :no_daleks]
-      chain.values.should == [filter1, filter2]
+      expect(chain.keys).to eq [:no_angels, :no_daleks]
+      expect(chain.values).to eq [filter1, filter2]
     end
 
     describe "#reset" do
@@ -23,7 +23,7 @@ module Stockboy
 
       it "returns a hash of filter keys to empty arrays" do
         empty_records = chain.reset
-        empty_records.should == {no_angels: [], no_daleks: []}
+        expect(empty_records).to eq({no_angels: [], no_daleks: []})
       end
     end
 
@@ -31,7 +31,7 @@ module Stockboy
       it "adds filters to the front of the chain" do
         chain = FilterChain.new(filter1: double)
         chain.prepend(filter0: double)
-        chain.keys.should == [:filter0, :filter1]
+        expect(chain.keys).to eq [:filter0, :filter1]
       end
     end
 

data/spec/stockboy/filter_spec.rb

@@ -21,21 +21,21 @@ module Stockboy
 
       context "matching raw value" do
         it "returns true for match" do
-          filter.call(double(species:"babylichtus"), empty_values).should be true
+          expect(filter.call(double(species:"babylichtus"), empty_values)).to be true
         end
 
         it "returns false for no match" do
-          filter.call(double(species:"triceratops"), empty_values).should be false
+          expect(filter.call(double(species:"triceratops"), empty_values)).to be false
         end
       end
 
       context "matching translated value" do
         it "returns true for match" do
-          filter.call(empty_values, double(species:"babelfish")).should be true
+          expect(filter.call(empty_values, double(species:"babelfish"))).to be true
         end
 
         it "returns false for no match" do
-          filter.call(empty_values, double(species:"rhinoceros")).should be false
+          expect(filter.call(empty_values, double(species:"rhinoceros"))).to be false
         end
       end
     end

data/spec/stockboy/filters/missing_email_spec.rb

@@ -5,22 +5,22 @@ describe Stockboy::Filters::MissingEmail do
   subject(:filter) { described_class.new(:e) }
   it 'allows email addresses' do
     record = OpenStruct.new(e: 'me@example.com')
-    filter.call(record, record).should be false
+    expect(filter.call(record, record)).to be false
   end
 
   it 'catches empty strings' do
     record = OpenStruct.new(e: '')
-    filter.call(record, record).should be true
+    expect(filter.call(record, record)).to be true
   end
 
   it 'catches hyphen placeholders' do
     record = OpenStruct.new(e: '-')
-    filter.call(record, record).should be true
+    expect(filter.call(record, record)).to be true
   end
 
   it 'uses translated output value' do
     input = OpenStruct.new(e: '', other: 'me@example.com')
     output = OpenStruct.new(e: input.other)
-    filter.call(input, output).should be false
+    expect(filter.call(input, output)).to be false
   end
 end

data/spec/stockboy/filters_spec.rb

@@ -8,21 +8,21 @@ module Stockboy
 
     describe ".register" do
       it "registers a key and class" do
-        Filters.register(:invalid, filter).should === filter
+        expect(Filters.register(:invalid, filter)).to be === filter
       end
     end
 
     describe ".find" do
       it "returns a filter class" do
         Filters.register(:invalid, filter)
-        Filters.find(:invalid).should === filter
+        expect(Filters.find(:invalid)).to be === filter
       end
     end
 
     describe ".[]" do
       it "returns a filter class" do
         Filters.register(:invalid, filter)
-        Filters[:invalid].should === filter
+        expect(Filters[:invalid]).to be === filter
       end
     end
 
@@ -30,7 +30,7 @@ module Stockboy
       it "returns all registered filters" do
         Filters.register(:invalid, filter)
         Filters.register(:semivalid, filter)
-        Filters.all.should include(invalid: filter, semivalid: filter)
+        expect(Filters.all).to include(invalid: filter, semivalid: filter)
       end
     end
 

data/spec/stockboy/job_spec.rb

@@ -74,14 +74,14 @@ module Stockboy
       end
 
       it "returns an instance of Job" do
-        Job.define("test_job").should be_a Job
+        expect(Job.define("test_job")).to be_a Job
       end
 
       it "yields the defined job" do
         yielded = nil
         job = Job.define("test_job") { |j| yielded = j }
-        job.should be_a Job
-        job.should be yielded
+        expect(job).to be_a Job
+        expect(job).to be yielded
       end
 
       it "should read a file from a path" do
@@ -94,7 +94,7 @@ module Stockboy
                                        .with(:ftp)
                                        .and_return(TestProvider)
         job = Job.define("test_job")
-        job.provider.should be_a TestProvider
+        expect(job.provider).to be_a TestProvider
       end
 
       it "assigns a registered reader from a symbol" do
@@ -102,18 +102,18 @@ module Stockboy
                                      .with(:csv)
                                      .and_return(TestReader)
         job = Job.define("test_job")
-        job.reader.should be_a TestReader
+        expect(job.reader).to be_a TestReader
       end
 
       it "assigns attributes from a block" do
         job = Job.define("test_job")
-        job.attributes.map(&:to).should == [:name, :email, :updated_at]
+        expect(job.attributes.map(&:to)).to eq [:name, :email, :updated_at]
       end
 
       it "assigns triggers into their associated array from a block" do
         job = Job.define("test_job")
-        job.triggers[:cleanup].size.should == 2
-        job.triggers[:cleanup].each { |t| t.should be_a Proc }
+        expect(job.triggers[:cleanup].size).to eq 2
+        job.triggers[:cleanup].each { |t| expect(t).to be_a Proc }
       end
     end
 
@@ -126,12 +126,12 @@ module Stockboy
 
       it "replaces the attribute map" do
         job.attributes = AttributeMap.new do last_name end
-        job.attributes.map(&:to).should == [:last_name]
+        expect(job.attributes.map(&:to)).to eq [:last_name]
       end
 
       it "resets the job" do
         job.attributes = AttributeMap.new do last_name end
-        job.all_records.should be_empty
+        expect(job.all_records).to be_empty
       end
 
     end
@@ -147,7 +147,7 @@ module Stockboy
         job.reader = reader_double(parse: [{"name"=>"A"},{"name"=>"B"}])
 
         job.process
-        job.total_records.should == 2
+        expect(job.total_records).to eq 2
       end
 
       it "partitions records by filter" do
@@ -155,7 +155,7 @@ module Stockboy
         job.filters = {alpha: proc{ |r| r.name =~ /A/ }}
 
         job.process
-        job.records[:alpha].length.should == 1
+        expect(job.records[:alpha].length).to eq 1
       end
 
       it "keeps unfiltered_records" do
@@ -163,7 +163,7 @@ module Stockboy
         job.filters = {zeta: proc{ |r| r.name =~ /Z/ }}
 
         job.process
-        job.unfiltered_records.length.should == 1
+        expect(job.unfiltered_records.length).to eq 1
       end
 
       it "keeps all_records" do
@@ -171,7 +171,7 @@ module Stockboy
         job.filters = {alpha: proc{ |r| r.name =~ /A/ }}
 
         job.process
-        job.all_records.length.should == 2
+        expect(job.all_records.length).to eq 2
       end
 
       it "resets filters between runs" do
@@ -186,14 +186,14 @@ module Stockboy
         job.reader = double(parse: [{"name"=>"A"},{"name"=>"Z"}])
         job.filters = {alpha: counter = CountingFilter.new(/A/)}
 
-        counter.matches.should == 0
+        expect(counter.matches).to eq 0
         2.times { job.process }
-        counter.matches.should == 1
+        expect(counter.matches).to eq 1
       end
 
       it "has empty partitions" do
         job.filters = {alpha: proc{ |r| r.name =~ /A/ }, beta: proc{ |r| r.name =~ /B/ }}
-        job.records.should == {alpha: [], beta: []}
+        expect(job.records).to eq({alpha: [], beta: []})
       end
 
       context "with a repeating provider" do
@@ -209,7 +209,7 @@ module Stockboy
 
         it "it loads all records into a set" do
           job.process
-          job.all_records.size.should == 3
+          expect(job.all_records.size).to eq 3
         end
       end
 
@@ -224,7 +224,7 @@ module Stockboy
 
       context "before processing" do
         it "should be empty" do
-          job.record_counts.should == {}
+          expect(job.record_counts).to eq({})
         end
       end
 
@@ -237,7 +237,7 @@ module Stockboy
         job.reader = double(parse: [{"name"=>"Arthur"}, {"name"=>"Abc"}, {"name"=>"Zaphod"}])
         job.process
 
-        job.record_counts.should == {alpha: 2, zeta: 1}
+        expect(job.record_counts).to eq({alpha: 2, zeta: 1})
       end
     end
 
@@ -247,9 +247,9 @@ module Stockboy
       end
 
       it "indicates if the job has been processed" do
-        job.processed?.should be false
+        expect(job.processed?).to be false
         job.process
-        job.processed?.should be true
+        expect(job.processed?).to be true
       end
     end
 
@@ -274,7 +274,7 @@ module Stockboy
         expect(job.provider).to receive(:delete_data).once
         stats = {}
         job.trigger(:success, stats)
-        stats[:count].should == 1
+        expect(stats[:count]).to eq 1
       end
 
     end
@@ -284,7 +284,7 @@ module Stockboy
       it "replaces existing triggers" do
         job.triggers = {breakfast: double}
         job.triggers = {lunch: double}
-        job.triggers.keys.should == [:lunch]
+        expect(job.triggers.keys).to eq [:lunch]
       end
 
     end

data/spec/stockboy/mapped_record_spec.rb

@@ -8,23 +8,24 @@ module Stockboy
     end
 
     it "accesses initialized fields from hash" do
-      record.full_name.should == 'Arthur Dent'
+      expect(record.full_name).to eq 'Arthur Dent'
     end
 
     it "does not redefine accessor methods" do
       record1 = MappedRecord.new(:full_name => 'Arthur Dent')
       record2 = MappedRecord.new(:full_name => 'Arthur Dent')
 
-      record1.method(:full_name).owner.should ==
+      expect(record1.method(:full_name).owner).to eq(
       record2.method(:full_name).owner
+      )
     end
 
     it "only has its own accessor methods" do
       record1 = MappedRecord.new(:first_name => 'Arthur')
       record2 = MappedRecord.new(:last_name => 'Dent')
 
-      record1.should_not respond_to(:last_name)
-      record2.should_not respond_to(:first_name)
+      expect(record1).not_to respond_to(:last_name)
+      expect(record2).not_to respond_to(:first_name)
     end
   end
 end

data/spec/stockboy/provider_repeater_spec.rb

@@ -27,7 +27,7 @@ module Stockboy
       it "yields each data set" do
         calls = []
         repeater.data { |data| calls << data.split(",").last }
-        calls.should == ["1", "2", "3"]
+        expect(calls).to eq ["1", "2", "3"]
       end
 
     end
@@ -43,7 +43,7 @@ module Stockboy
           repeater.each do |nth_provider|
             calls << nth_provider
           end
-          calls.map(&:page).should == [42]
+          expect(calls.map(&:page)).to eq [42]
         end
       end
 

data/spec/stockboy/provider_spec.rb

@@ -41,13 +41,13 @@ module Stockboy
       it "fetches data when there is none" do
         expect(provider).to receive(:fetch_data).once.and_call_original
         2.times do
-          provider.data.should == "TEST,DATA"
+          expect(provider.data).to eq "TEST,DATA"
         end
       end
 
       it "yields data to a block" do
         provider.data do |data|
-          data.should == "TEST,DATA"
+          expect(data).to eq "TEST,DATA"
         end
       end
     end
@@ -58,7 +58,7 @@ module Stockboy
       it "clears and reloads the data" do
         data = provider.data
         expect(provider).to receive(:fetch_data).once.and_call_original
-        provider.reload.should == data
+        expect(provider.reload).to eq data
       end
     end
 

data/spec/stockboy/providers/file_spec.rb

@@ -13,22 +13,22 @@ module Stockboy
       provider.file_larger = 1024
       provider.pick = :first
 
-      provider.file_dir.should == "fixtures/files"
-      provider.file_name.should == %r{import_20[1-9][0-9]-(0[1-9]|1[0-2])-([0-2][1-9]|3[0-1]).csv}
-      provider.file_newer.should == Date.today
-      provider.file_smaller.should == 1024**2
-      provider.file_larger.should == 1024
-      provider.pick.should == :first
+      expect(provider.file_dir).to eq "fixtures/files"
+      expect(provider.file_name).to eq %r{import_20[1-9][0-9]-(0[1-9]|1[0-2])-([0-2][1-9]|3[0-1]).csv}
+      expect(provider.file_newer).to eq Date.today
+      expect(provider.file_smaller).to eq 1024**2
+      expect(provider.file_larger).to eq 1024
+      expect(provider.pick).to eq :first
     end
 
     describe ".new" do
       it "has no errors" do
-        provider.errors.should be_empty
+        expect(provider.errors).to be_empty
       end
 
       it "accepts block initialization" do
         provider = Providers::File.new{ |f| f.file_dir 'fixtures/files' }
-        provider.file_dir.should == 'fixtures/files'
+        expect(provider.file_dir).to eq 'fixtures/files'
       end
     end
 
@@ -61,25 +61,25 @@ module Stockboy
 
       it "fails with an error if the file doesn't exist" do
         provider.file_name = "missing-file.csv"
-        provider.data.should be nil
-        provider.valid?.should be false
-        provider.errors.first.should match /not found/
+        expect(provider.data).to be nil
+        expect(provider.valid?).to be false
+        expect(provider.errors.first).to match /not found/
       end
 
       it "finds last matching file from string glob" do
         provider.file_name = "test_data-*.csv"
-        provider.data.should == "2012-02-02\n"
+        expect(provider.data).to eq "2012-02-02\n"
       end
 
       it "finds first matching file from string glob" do
         provider.file_name = "test_data-*.csv"
         provider.pick = :first
-        provider.data.should == "2012-01-01\n"
+        expect(provider.data).to eq "2012-01-01\n"
       end
 
       it "finds last matching file from regex" do
         provider.file_name = /test_data/
-        provider.data.should == "2012-02-02\n"
+        expect(provider.data).to eq "2012-02-02\n"
       end
 
       context "metadata validation" do
@@ -90,22 +90,22 @@ module Stockboy
         it "skips old files with :since" do
           expect_any_instance_of(::File).to receive(:mtime).and_return last_week
           provider.since = recently
-          provider.data.should be nil
-          provider.errors.first.should == "no new files since #{recently}"
+          expect(provider.data).to be nil
+          expect(provider.errors.first).to eq "no new files since #{recently}"
         end
 
         it "skips large files with :file_smaller" do
           expect_any_instance_of(::File).to receive(:size).and_return 1001
           provider.file_smaller = 1000
-          provider.data.should be nil
-          provider.errors.first.should == "file size larger than 1000"
+          expect(provider.data).to be nil
+          expect(provider.errors.first).to eq "file size larger than 1000"
         end
 
         it "skips small files with :file_larger" do
           expect_any_instance_of(::File).to receive(:size).and_return 999
           provider.file_larger = 1000
-          provider.data.should be nil
-          provider.errors.first.should == "file size smaller than 1000"
+          expect(provider.data).to be nil
+          expect(provider.errors.first).to eq "file size smaller than 1000"
         end
       end
     end