stockboy 1.1.0 → 1.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7f65df7318f49c88b008b2ee6539b4c32d5bd444
-  data.tar.gz: ad26b53bcd6f495a5674708922ed41c6fc7a8b69
+  metadata.gz: b618c2bafb9061a14b04ae6d571e42a119aa2a90
+  data.tar.gz: 8772582062024383ea452a5f20d2e4975b7b810e
 SHA512:
-  metadata.gz: 97195c3f0d8b9b98b00657fdd035e5b4e3d9804bad40c186103a54dd6344472723a1c9703e259ba57e030a4560f8888513efc8079d6724648c60ff7178035d2f
-  data.tar.gz: ff23c429b975eba2c558aa376debe315f9e771e9af087aa15200335905ed5ceaff4363bed0acfd5b7c4b37caf5bfa1792a833db1bbd7dfbed3c8f78df560a660
+  metadata.gz: 7d55abefd7dbeb962d641ec9639823406f180da9d55196b85f6383be5e67f39fb9827f1df485d24f9aa68d80ade1364b697b497745f7c99a03b29cb66a3c9317
+  data.tar.gz: 23f36e47763251d1f98351b339d3121d7ea6d322fc5b64e2d6943116c38f2e48d2edab20841ac569d192ff594ef07942be02d9a784a963ec0b78427d718c8559

data/CHANGELOG.md

@@ -1,5 +1,9 @@
 # Changelog
 
+## 1.1.1 / 2016-03-08
+
+* [BUGFIX]      Timeouts on SOAP connections were ignored
+
 ## 1.1.0 / 2016-02-19
 
 * [ENHANCEMENT] Allow `:read_timeout` and `:open_timeout` on SOAP connections

data/lib/stockboy/providers/soap.rb

@@ -165,6 +165,8 @@ module Stockboy::Providers
     #
     def client
       @client ||= Savon.client(client_options)
+      @client.globals.open_timeout(open_timeout) if open_timeout
+      @client.globals.read_timeout(read_timeout) if read_timeout
       yield @client if block_given?
       @client
     end

data/lib/stockboy/version.rb

@@ -1,3 +1,3 @@
 module Stockboy
-  VERSION = "1.1.0"
+  VERSION = "1.1.1"
 end

data/spec/stockboy/attribute_map_spec.rb

@@ -17,31 +17,31 @@ module Stockboy
 
       it "initializes from hash attribute" do
         map = AttributeMap.new(:email => row)
-        map[:email].should == row
+        expect(map[:email]).to eq row
       end
     end
 
     it "sets same destination as default" do
-      subject[:email].should == Attribute.new(:email, "email", [])
+      expect(subject[:email]).to eq Attribute.new(:email, "email", [])
     end
 
     it "sets source from string to string" do
       map = AttributeMap.new { updated_at from: "statusDate" }
-      map[:updated_at].from.should == "statusDate"
+      expect(map[:updated_at].from).to eq "statusDate"
     end
 
     it "sets source from symbol to string" do
       map = AttributeMap.new { updated_at from: :statusDate }
-      map[:updated_at].from.should == "statusDate"
+      expect(map[:updated_at].from).to eq "statusDate"
     end
 
     it "sets source from number to number" do
       map = AttributeMap.new { email from: 12 }
-      map[:email].from.should == 12
+      expect(map[:email].from).to eq 12
     end
 
     it "sets callable translators" do
-      subject[:updated_at].translators.first.call("2012-01-01").should == Date.new(2012,1,1)
+      expect(subject[:updated_at].translators.first.call("2012-01-01")).to eq Date.new(2012,1,1)
     end
 
     it "sets ignore conditions" do
@@ -49,7 +49,7 @@ module Stockboy
     end
 
     it "has attr accessors" do
-      subject.email.should be_a Attribute
+      expect(subject.email).to be_a Attribute
     end
 
     it "raises error for undefined attrs" do
@@ -57,8 +57,8 @@ module Stockboy
     end
 
     it "is enumerable" do
-      subject.map(&:from).should == ["email", "score", "statusDate"]
-      subject.map(&:to).should == [:email, :score, :updated_at]
+      expect(subject.map(&:from)).to eq ["email", "score", "statusDate"]
+      expect(subject.map(&:to)).to eq [:email, :score, :updated_at]
     end
 
     describe "#insert" do
@@ -67,7 +67,7 @@ module Stockboy
       it "sets options from hash" do
         upcase = ->(r) { r.upcase }
         map.insert :test, from: "Test", as: upcase
-        map[:test].should == Attribute.new(:test, "Test", [upcase])
+        expect(map[:test]).to eq Attribute.new(:test, "Test", [upcase])
       end
     end
 

data/spec/stockboy/attribute_spec.rb

@@ -5,30 +5,30 @@ module Stockboy
   describe Attribute do
     it "describes its attrs" do
       attr = Attribute.new :outfield, "infield", [:one, :two], :nil?
-      attr.inspect.should == %{#<Stockboy::Attribute to=:outfield, from="infield", translators=[:one, :two], ignore=:nil?>}
+      expect(attr.inspect).to eq %{#<Stockboy::Attribute to=:outfield, from="infield", translators=[:one, :two], ignore=:nil?>}
     end
 
     describe :ignore? do
       it "is false by default" do
         attr = Attribute.new :email, "email", []
-        attr.ignore?(double email: "").should be false
+        expect(attr.ignore?(double email: "")).to be false
       end
 
       it "extracts symbols from a record" do
         attr = Attribute.new :email, "email", [], :blank?
-        attr.ignore?(double email: "").should be true
-        attr.ignore?(double email: "@").should be false
+        expect(attr.ignore?(double email: "")).to be true
+        expect(attr.ignore?(double email: "@")).to be false
       end
 
       it "is true with a truthy value" do
         attr = Attribute.new :email, "email", [], 1
-        attr.ignore?(double email: "").should be true
+        expect(attr.ignore?(double email: "")).to be true
       end
 
       it "yields records to a proc" do
         attr = Attribute.new :email, "email", [], ->(r) { not r.email.include? "@" }
-        attr.ignore?(double email: "").should be true
-        attr.ignore?(double email: "@").should be false
+        expect(attr.ignore?(double email: "")).to be true
+        expect(attr.ignore?(double email: "@")).to be false
       end
 
     end

data/spec/stockboy/candidate_record_spec.rb

@@ -23,7 +23,7 @@ module Stockboy
       it "remaps attributes" do
         map = AttributeMap.new { name from: 'full_name' }
         subject = CandidateRecord.new(hash_attrs, map).to_hash
-        subject.should == { :name => 'Arthur Dent' }
+        expect(subject).to eq({ :name => 'Arthur Dent' })
       end
 
       it "converts String subclasses to clean strings" do
@@ -31,14 +31,14 @@ module Stockboy
         map = AttributeMap.new { full_name }
         hash_attrs['full_name'] = Nori::StringWithAttributes.new('Arthur')
         subject = CandidateRecord.new(hash_attrs, map).to_hash
-        subject[:full_name].class.should == String
+        expect(subject[:full_name].class).to eq String
       end
 
       it "omits ignored attributes" do
         invalid_email = ->(r) { r.email.include?('example.com') }
         map = AttributeMap.new { id ; email ignore: invalid_email }
         subject = CandidateRecord.new(hash_attrs, map).to_hash
-        subject.should == { :id => '1' }
+        expect(subject).to eq({ :id => '1' })
       end
     end
 
@@ -46,13 +46,13 @@ module Stockboy
       it "remaps attributes" do
         map = AttributeMap.new { name from: 'full_name' }
         subject = CandidateRecord.new(hash_attrs, map).raw_hash
-        subject.should == { :name => 'Arthur Dent' }
+        expect(subject).to eq({ :name => 'Arthur Dent' })
       end
 
       it "does not translate attributes" do
         map = AttributeMap.new { birthday as: ->(r) { Date.parse(r.birthday) } }
         subject = CandidateRecord.new(hash_attrs, map).raw_hash
-        subject.should == { :birthday => "1980-01-01" }
+        expect(subject).to eq({ :birthday => "1980-01-01" })
       end
     end
 
@@ -61,28 +61,28 @@ module Stockboy
 
       context "from lambda" do
         let(:map) { AttributeMap.new{ birthday as: ->(r){ Date.parse(r.birthday) } } }
-        it { should == {birthday: Date.new(1980,1,1)} }
+        it { should eq({birthday: Date.new(1980,1,1)}) }
       end
 
       context "from symbol lookup" do
         before    { Stockboy::Translations.register :date, ->(r){ Date.parse(r.birthday) } }
         let(:map) { AttributeMap.new{ birthday :as => :date } }
-        it { should == {birthday: Date.new(1980,1,1)} }
+        it { should eq({birthday: Date.new(1980,1,1)}) }
       end
 
       context "chaining" do
         let(:map) { AttributeMap.new{ id as: [->(r){r.id.next}, ->(r){r.id.next}] } }
-        it { should == {id: '3'} }
+        it { should eq({id: '3'}) }
       end
 
       context "with exception" do
         let(:map) { AttributeMap.new{ id as: [->(r){r.id.to_i}, ->(r){r.id / 0}] } }
-        it { should == {id: nil} }
+        it { should eq({id: nil}) }
       end
 
       context "dynamic without an input field" do
         let(:map) { AttributeMap.new{ generated as: [->(r){ "from lambda" }] } }
-        it { should == {generated: "from lambda"} }
+        it { should eq({generated: "from lambda"}) }
       end
     end
 
@@ -102,14 +102,14 @@ module Stockboy
         it "fetches raw values for raw input keys" do
           map = AttributeMap.new { name from: 'full_name' }
           subject = CandidateRecord.new(hash_attrs, map)
-          subject.input['full_name'].should == 'Arthur Dent'
+          expect(subject.input['full_name']).to eq 'Arthur Dent'
         end
       end
 
       it "accesses fields by mapped name before translation" do
         map = AttributeMap.new { name from: 'full_name', as: ->(r){ r.name.upcase } }
         subject = CandidateRecord.new(hash_attrs, map)
-        subject.input.name.should == 'Arthur Dent'
+        expect(subject.input.name).to eq 'Arthur Dent'
       end
     end
 
@@ -118,13 +118,13 @@ module Stockboy
         it "fetches translated values for raw input keys" do
           map = AttributeMap.new { name from: 'full_name' }
           subject = CandidateRecord.new(hash_attrs, map)
-          subject.output.name.should == 'Arthur Dent'
+          expect(subject.output.name).to eq 'Arthur Dent'
         end
 
         it "returns translated values for ignored keys" do
           map = AttributeMap.new { email ignore: ->(r){ r.email.include?("example.com") } }
           subject = CandidateRecord.new(hash_attrs, map)
-          subject.output.email.should == "adent@example.com"
+          expect(subject.output.email).to eq "adent@example.com"
         end
       end
     end
@@ -137,7 +137,7 @@ module Stockboy
       it "returns first matched filter key" do
         key = subject.partition(zeta:  proc{ |raw| raw.name =~ /Z/ },
                                 alpha: proc{ |raw| raw.name =~ /A/ })
-        key.should == :alpha
+        expect(key).to eq :alpha
       end
 
       it "returns a match for translated block argument" do
@@ -145,17 +145,17 @@ module Stockboy
         subject = CandidateRecord.new({'name' =>'Arthur'}, map)
 
         key = subject.partition(down: proc{ |raw,out| out.name[0] == "a" })
-        key.should == :down
+        expect(key).to eq :down
       end
 
       it "returns nil when raw field is unmatched" do
         key = subject.partition({beta: proc{ |raw| raw.name =~ /B/ }})
-        key.should be nil
+        expect(key).to be nil
       end
 
       it "returns nil when translated field is unmatched" do
         key = subject.partition({beta: proc{ |raw,out| out.name =~ /B/ }})
-        key.should be nil
+        expect(key).to be nil
       end
     end
 

data/spec/stockboy/configuration_spec.rb

@@ -8,20 +8,20 @@ module Stockboy
 
     it "yields a config block" do
       Stockboy::Configuration.new do |c|
-        c.should be_a Stockboy::Configuration
+        expect(c).to be_a Stockboy::Configuration
       end
     end
 
     it "is accessible from top namespace" do
-      Stockboy.configuration.should be_a Stockboy::Configuration
+      expect(Stockboy.configuration).to be_a Stockboy::Configuration
     end
 
     specify "#template_load_paths" do
       config.template_load_paths.clear
       config.template_load_paths << "/some_path"
-      config.template_load_paths.should == ["/some_path"]
+      expect(config.template_load_paths).to eq ["/some_path"]
       config.template_load_paths = ["/other_path"]
-      config.template_load_paths.should == ["/other_path"]
+      expect(config.template_load_paths).to eq ["/other_path"]
     end
 
   end

data/spec/stockboy/configurator_spec.rb

@@ -28,12 +28,12 @@ module Stockboy
 
       it "registers with a symbol" do
         subject.provider :ftp
-        subject.config[:provider].should be_a(provider_class)
+        expect(subject.config[:provider]).to be_a(provider_class)
       end
 
       it "registers with a class" do
         subject.provider provider_class
-        subject.config[:provider].should be_a(provider_class)
+        expect(subject.config[:provider]).to be_a(provider_class)
       end
 
       it "initializes arguments" do
@@ -58,19 +58,19 @@ module Stockboy
 
       it "registers with a symbol" do
         subject.reader :csv
-        subject.config[:reader].should be_a(reader_class)
+        expect(subject.config[:reader]).to be_a(reader_class)
       end
 
       it "registers with a class" do
         subject.reader reader_class
-        subject.config[:reader].should be_a(reader_class)
+        expect(subject.config[:reader]).to be_a(reader_class)
       end
 
       it "initializes arguments" do
         reader_stub = double(:reader)
         expect(reader_class).to receive(:new).with(col_sep: '|').and_return(reader_stub)
         subject.reader reader_class, col_sep: '|'
-        subject.config[:reader].should == reader_stub
+        expect(subject.config[:reader]).to eq reader_stub
       end
     end
 
@@ -79,28 +79,28 @@ module Stockboy
         attribute_map = double
         expect(AttributeMap).to receive(:new).and_return(attribute_map)
         subject.attributes &proc{}
-        subject.config[:attributes].should be attribute_map
+        expect(subject.config[:attributes]).to be attribute_map
       end
 
       it "replaces existing attributes" do
         subject.attribute :first_name
         subject.attributes do last_name end
-        subject.config[:attributes][:first_name].should be nil
-        subject.config[:attributes][:last_name].should be_an Attribute
+        expect(subject.config[:attributes][:first_name]).to be nil
+        expect(subject.config[:attributes][:last_name]).to be_an Attribute
       end
     end
 
     describe "#attribute" do
       it "inserts a single attribute" do
         subject.attribute :test, from: "Test"
-        subject.config[:attributes][:test].should == Attribute.new(:test, "Test", [])
+        expect(subject.config[:attributes][:test]).to eq Attribute.new(:test, "Test", [])
       end
 
       it "respects existing attributes added first" do
         subject.attributes do first_name end
         subject.attribute :last_name
-        subject.config[:attributes][:first_name].should be_an Attribute
-        subject.config[:attributes][:last_name].should be_an Attribute
+        expect(subject.config[:attributes][:first_name]).to be_an Attribute
+        expect(subject.config[:attributes][:last_name]).to be_an Attribute
       end
     end
 
@@ -114,7 +114,7 @@ module Stockboy
           job.process
         end
 
-        subject.config[:triggers][:reprocess][0].should be_a Proc
+        expect(subject.config[:triggers][:reprocess][0]).to be_a Proc
       end
 
     end
@@ -123,14 +123,14 @@ module Stockboy
       it "initializes a callable" do
         filter_stub = double(call: true)
         subject.filter :pass, filter_stub
-        subject.config[:filters][:pass].should == filter_stub
+        expect(subject.config[:filters][:pass]).to eq filter_stub
       end
 
       it "initializes a block" do
         subject.filter :pass do |r|
           true if r == 42
         end
-        subject.config[:filters][:pass].call(42).should == true
+        expect(subject.config[:filters][:pass].call(42)).to eq true
       end
 
       context "with a class" do
@@ -144,22 +144,22 @@ module Stockboy
 
         it "passes arguments to a registered class symbol" do
           subject.filter :pass, :test, 42
-          subject.config[:filters][:pass].args.should == [42]
+          expect(subject.config[:filters][:pass].args).to eq [42]
         end
 
         it "passes a block to a registered class symbol" do
           subject.filter :pass, :test do 42 end
-          subject.config[:filters][:pass].block[].should == 42
+          expect(subject.config[:filters][:pass].block[]).to eq 42
         end
 
         it "passes arguments to a given class" do
           subject.filter :pass, TestFilter, 42
-          subject.config[:filters][:pass].args.should == [42]
+          expect(subject.config[:filters][:pass].args).to eq [42]
         end
 
         it "uses an instance directly" do
           subject.filter :pass, TestFilter.new(42)
-          subject.config[:filters][:pass].args.should == [42]
+          expect(subject.config[:filters][:pass].args).to eq [42]
         end
       end
 
@@ -176,10 +176,10 @@ module Stockboy
 
       it "returns a Job instance" do
         job = subject.to_job
-        job.should be_a(Job)
-        job.provider.should be_a(provider_class)
-        job.reader.should be_a(reader_class)
-        job.attributes.should be_a(AttributeMap)
+        expect(job).to be_a(Job)
+        expect(job.provider).to be_a(provider_class)
+        expect(job.reader).to be_a(reader_class)
+        expect(job.attributes).to be_a(AttributeMap)
       end
 
       context "with a repeat block" do
@@ -189,8 +189,8 @@ module Stockboy
 
         it "adds a repeater to the provider" do
           job = subject.to_job
-          job.provider.should be_a ProviderRepeater
-          job.provider.base_provider.should be_a provider_class
+          expect(job.provider).to be_a ProviderRepeater
+          expect(job.provider.base_provider).to be_a provider_class
         end
       end
     end