stockboy 0.5.0

data/spec/stockboy/filter_chain_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+require 'stockboy/filter_chain'
+
+module Stockboy
+  describe FilterChain do
+
+    let(:filter1) { double("Filter") }
+    let(:filter2) { double("Filter", reset: true) }
+
+    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]
+    end
+
+    describe "#reset" do
+      let(:chain) { FilterChain.new(no_angels: filter1, no_daleks: filter2) }
+
+      it "calls reset on all members" do
+        filter2.should_receive(:reset)
+        chain.reset
+      end
+
+      it "returns a hash of filter keys to empty arrays" do
+        empty_records = chain.reset
+        empty_records.should == {no_angels: [], no_daleks: []}
+      end
+    end
+
+    describe "#prepend" do
+      it "adds filters to the front of the chain" do
+        chain = FilterChain.new(filter1: double)
+        chain.prepend(filter0: double)
+        chain.keys.should == [:filter0, :filter1]
+      end
+    end
+
+  end
+end
+

data/spec/stockboy/filter_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+require 'stockboy/filter'
+
+class FishFilter < Stockboy::Filter
+  def filter(raw, translated)
+    return true if raw.species =~ /ichtus/
+    return true if translated.species =~ /fish/
+    return nil
+  end
+end
+
+module Stockboy
+  describe Filter do
+
+    describe "#call" do
+      let(:empty_values) { double.as_null_object }
+      subject(:filter) { FishFilter.new }
+
+      context "matching raw value" do
+        it "returns true for match" do
+          filter.call(double(species:"babylichtus"), empty_values).should be_true
+        end
+
+        it "returns false for no match" do
+          filter.call(double(species:"triceratops"), empty_values).should 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
+        end
+
+        it "returns false for no match" do
+          filter.call(empty_values, double(species:"rhinoceros")).should be_false
+        end
+      end
+    end
+
+  end
+end

data/spec/stockboy/filters/missing_email_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+require 'stockboy/filters/missing_email'
+
+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
+  end
+
+  it 'catches empty strings' do
+    record = OpenStruct.new(e: '')
+    filter.call(record, record).should be_true
+  end
+
+  it 'catches hyphen placeholders' do
+    record = OpenStruct.new(e: '-')
+    filter.call(record, record).should 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
+  end
+end

data/spec/stockboy/filters_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+require 'stockboy/filters'
+
+module Stockboy
+  describe Filters do
+
+    let(:filter) { double("filter") }
+
+    describe ".register" do
+      it "registers a key and class" do
+        Filters.register(:invalid, filter).should === filter
+      end
+    end
+
+    describe ".find" do
+      it "returns a filter class" do
+        Filters.register(:invalid, filter)
+        Filters.find(:invalid).should === filter
+      end
+    end
+
+    describe ".[]" do
+      it "returns a filter class" do
+        Filters.register(:invalid, filter)
+        Filters[:invalid].should === filter
+      end
+    end
+
+    describe ".all" do
+      it "returns all registered filters" do
+        Filters.register(:invalid, filter)
+        Filters.register(:semivalid, filter)
+        Filters.all.should include(invalid: filter, semivalid: filter)
+      end
+    end
+
+  end
+end

data/spec/stockboy/job_spec.rb

@@ -0,0 +1,238 @@
+require 'spec_helper'
+require 'stockboy/job'
+
+module Stockboy
+  describe Job do
+    let(:jobs_path) { RSpec.configuration.fixture_path.join('jobs') }
+    let(:provider_stub) { double(:ftp).as_null_object }
+    let(:reader_stub)   { double(:csv).as_null_object }
+
+    let(:job_template) {
+      <<-END.gsub(/^ {6}/,'')
+      provider :ftp do
+        username 'foo'
+        password 'bar'
+        host 'ftp.example.com'
+      end
+      format   :csv
+      filter :blank_name do |r|
+        false if r.name.blank?
+      end
+      attributes do
+        name from: 'userName'
+        email from: 'email'
+        updated_at from: 'statusDate', as: [:date]
+      end
+      on :cleanup do |job|
+        job.provider.delete_data
+      end
+      on :cleanup do |job|
+        "log: " << job.all_records.size
+      end
+      END
+    }
+
+    before do
+      Stockboy.configuration.template_load_paths = [jobs_path]
+
+      allow(Stockboy::Providers).to receive(:find) { provider_stub }
+      allow(Stockboy::Readers).to receive(:find) { reader_stub }
+    end
+
+    its(:filters) { should be_a Hash }
+
+    describe "#define" do
+      before do
+        allow(File).to receive(:read)
+            .with("#{jobs_path}/test_job.rb")
+            .and_return job_template
+      end
+
+      it "returns an instance of Job" do
+        Job.define("test_job").should 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
+      end
+
+      it "should read a file from a path" do
+        File.should_receive(:read).with("#{jobs_path}/test_job.rb")
+        Job.define("test_job")
+      end
+
+      it "assigns a registered provider from a symbol" do
+        job = Job.define("test_job")
+        job.provider.should == provider_stub
+      end
+
+      it "assigns a registered reader from a symbol" do
+        Stockboy::Readers.should_receive(:find)
+                         .with(:csv)
+                         .and_return(reader_stub)
+        job = Job.define("test_job")
+        job.reader.should == reader_stub
+      end
+
+      it "assigns attributes from a block" do
+        job = Job.define("test_job")
+        job.attributes.map(&:to).should == [: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 }
+      end
+    end
+
+    describe "#process" do
+      let(:attribute_map) { AttributeMap.new { name } }
+
+      subject(:job) do
+        Job.new(provider: double(:provider, data:"", errors:[]),
+                attributes: attribute_map)
+      end
+
+      it "records total received record count" do
+        job.reader = double(parse: [{"name"=>"A"},{"name"=>"B"}])
+
+        job.process
+        job.total_records.should == 2
+      end
+
+      it "partitions records by filter" do
+        job.reader = double(parse: [{"name"=>"A"},{"name"=>"B"}])
+        job.filters = {alpha: proc{ |r| r.name =~ /A/ }}
+
+        job.process
+        job.records[:alpha].length.should == 1
+      end
+
+      it "keeps unfiltered_records" do
+        job.reader = double(parse: [{"name"=>"A"}])
+        job.filters = {zeta: proc{ |r| r.name =~ /Z/ }}
+
+        job.process
+        job.unfiltered_records.length.should == 1
+      end
+
+      it "keeps all_records" do
+        job.reader = double(parse: [{"name"=>"A"},{"name"=>"Z"}])
+        job.filters = {alpha: proc{ |r| r.name =~ /A/ }}
+
+        job.process
+        job.all_records.length.should == 2
+      end
+
+      it "resets filters between runs" do
+
+        class CountingFilter
+          attr_reader :matches
+          define_method(:initialize) { |pattern| @pattern, @matches = /A/, 0 }
+          define_method(:call)       { |_, output| @matches += 1 if output.name =~ @pattern }
+          define_method(:reset)      { @matches = 0 }
+        end
+
+        job.reader = double(parse: [{"name"=>"A"},{"name"=>"Z"}])
+        job.filters = {alpha: counter = CountingFilter.new(/A/)}
+
+        counter.matches.should == 0
+        2.times { job.process }
+        counter.matches.should == 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: []}
+      end
+    end
+
+    describe "#record_counts" do
+      let(:attribute_map) { AttributeMap.new { name } }
+
+      subject(:job) do
+        Job.new(provider: double(:provider, data:"", errors:[]),
+                attributes: attribute_map)
+      end
+
+      context "before processing" do
+        it "should be empty" do
+          job.record_counts.should == {}
+        end
+      end
+
+      it "returns a hash of counts by filtered record partition" do
+        job.filters = {
+          alpha: proc{ |r| r.name =~ /^A/ },
+          zeta:  proc{ |r| r.name =~ /^Z/ }
+        }
+
+        job.reader = double(parse: [{"name"=>"Arthur"}, {"name"=>"Abc"}, {"name"=>"Zaphod"}])
+        job.process
+
+        job.record_counts.should == {alpha: 2, zeta: 1}
+      end
+    end
+
+    describe "#processed?" do
+      subject(:job) do
+        Job.new(provider: provider_stub,
+                reader: reader_stub,
+                attributes: AttributeMap.new)
+      end
+
+      it "indicates if the job has been processed" do
+        job.processed?.should be_false
+        job.process
+        job.processed?.should be_true
+      end
+    end
+
+    describe "#trigger" do
+
+      let(:provider_stub) { double(delete_data: true) }
+
+      subject(:job) do
+        Job.new(
+          provider: provider_stub,
+          triggers: {
+            success: [proc { |j| j.provider.delete_data },
+                      proc { |j, stats| stats[:count] = 1 if stats }]
+          }
+        )
+      end
+
+      it "should yield itself to each trigger" do
+        provider_stub.should_receive(:delete_data).once
+        job.trigger(:success)
+      end
+
+      it "should yield args to each trigger" do
+        stats = {}
+        job.trigger(:success, stats)
+        stats[:count].should == 1
+      end
+
+    end
+
+    describe "#method_missing" do
+
+      subject(:job) { Job.new(triggers: {cleanup: proc{|_|}})}
+
+      it "should call a named trigger" do
+        expect(job).to receive(:trigger).with(:cleanup, "trash")
+        job.cleanup("trash")
+      end
+
+      it "should raise an error for unknown trigger keys" do
+        expect { job.wobble }.to raise_error NoMethodError
+      end
+
+    end
+
+  end
+end

data/spec/stockboy/mapped_record_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+require 'stockboy/mapped_record'
+
+module Stockboy
+  describe MappedRecord do
+    subject(:record) do
+      MappedRecord.new(:full_name => 'Arthur Dent')
+    end
+
+    it "accesses initialized fields from hash" do
+      record.full_name.should == '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 ==
+      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)
+    end
+  end
+end

data/spec/stockboy/provider_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+require 'stockboy/provider'
+
+class ProviderSubclass < Stockboy::Provider
+  attr_accessor :foo
+  def validate
+    errors.add_on_empty(:foo, "Foo is empty")
+  end
+end
+
+module Stockboy
+  describe Provider do
+
+    describe "#errors" do
+      its(:errors) { should be_empty }
+    end
+
+    describe "#logger" do
+      its(:logger) { should respond_to :error }
+    end
+
+    describe "abstract method" do
+      subject { Class.new(Provider).new }
+
+      it "raises error for unimplemented #validate" do
+        expect{ subject.send :validate }.to raise_error(NoMethodError)
+      end
+
+      it "raises error for unimplemented #fetch_data" do
+        expect{ subject.send :fetch_data }.to raise_error(NoMethodError)
+      end
+    end
+  end
+end