stockboy 1.1.0 → 1.1.1

data/spec/stockboy/providers/ftp_spec.rb

@@ -23,21 +23,21 @@ module Stockboy
       ftp.file_dir = "files/here"
       ftp.file_name = %r{import_20[1-9][0-9]-(0[1-9]|1[0-2])-([0-2][1-9]|3[0-1]).csv}
 
-      ftp.host.should == "localhost.test"
-      ftp.username.should == "uuu"
-      ftp.password.should == "ppp"
-      ftp.file_dir.should == "files/here"
-      ftp.file_name.should == %r{import_20[1-9][0-9]-(0[1-9]|1[0-2])-([0-2][1-9]|3[0-1]).csv}
+      expect(ftp.host).to eq "localhost.test"
+      expect(ftp.username).to eq "uuu"
+      expect(ftp.password).to eq "ppp"
+      expect(ftp.file_dir).to eq "files/here"
+      expect(ftp.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}
     end
 
     describe ".new" do
       it "has no errors" do
-        subject.errors.should be_empty
+        expect(subject.errors).to be_empty
       end
 
       it "accepts block initialization" do
         ftp = Providers::FTP.new{ |f| f.host 'test2.local' }
-        ftp.host.should == 'test2.local'
+        expect(ftp.host).to eq 'test2.local'
       end
     end
 
@@ -48,9 +48,9 @@ module Stockboy
         connection = false
         provider.client { |f| connection = f }
 
-        connection.should be_a Net::FTP
-        connection.binary.should be true
-        connection.passive.should be true
+        expect(connection).to be_a Net::FTP
+        expect(connection.binary).to be true
+        expect(connection.passive).to be true
       end
 
       it "should return yielded result" do
@@ -58,7 +58,7 @@ module Stockboy
 
         result = provider.client { |_| "a_file_name.csv" }
 
-        result.should == "a_file_name.csv"
+        expect(result).to eq "a_file_name.csv"
       end
     end
 
@@ -67,14 +67,14 @@ module Stockboy
         provider.host = nil
         provider.data
 
-        provider.errors.first.should match /host/
+        expect(provider.errors.first).to match /host/
       end
 
       it "adds an error on missing file_name" do
         provider.file_name = nil
         provider.data
 
-        provider.errors.first.should match /file_name/
+        expect(provider.errors.first).to match /file_name/
       end
 
       it "downloads the last matching file" do
@@ -83,7 +83,7 @@ module Stockboy
         expect(net_ftp).to receive(:get).with('20120102.csv', nil).and_return "DATA"
         expect(provider).to receive(:validate_file).and_return true
 
-        provider.data.should == "DATA"
+        expect(provider.data).to eq "DATA"
       end
 
       it "skips old files" do
@@ -94,7 +94,7 @@ module Stockboy
 
         provider.file_newer = Time.new(2010,1,1)
 
-        provider.data.should be nil
+        expect(provider.data).to be nil
       end
     end
 
@@ -103,14 +103,14 @@ module Stockboy
         net_ftp = expect_connection
         expect(net_ftp).to receive(:nlst).and_return ["1.csv", "2.csv"]
 
-        provider.matching_file.should == "2.csv"
+        expect(provider.matching_file).to eq "2.csv"
 
         net_ftp = expect_connection
         expect(net_ftp).to receive(:nlst).and_return ["1.csv", "2.csv", "3.csv"]
 
-        provider.matching_file.should == "2.csv"
+        expect(provider.matching_file).to eq "2.csv"
         provider.clear
-        provider.matching_file.should == "3.csv"
+        expect(provider.matching_file).to eq "3.csv"
       end
     end
 
@@ -124,12 +124,12 @@ module Stockboy
         net_ftp = expect_connection
         expect(net_ftp).to receive(:nlst).and_return ["1.csv", "2.csv"]
 
-        provider.matching_file.should == "2.csv"
+        expect(provider.matching_file).to eq "2.csv"
 
         net_ftp = expect_connection
         expect(net_ftp).to receive(:delete).with("2.csv")
 
-        provider.delete_data.should == "2.csv"
+        expect(provider.delete_data).to eq "2.csv"
       end
     end
 

data/spec/stockboy/providers/http_spec.rb

@@ -10,47 +10,47 @@ module Stockboy
       provider.query  = {user: 'u'}
       provider.method = :get
 
-      provider.uri.should    == URI("http://www.example.com/?user=u")
-      provider.query.should  == {user: 'u'}
-      provider.method.should == :get
+      expect(provider.uri).to    eq URI("http://www.example.com/?user=u")
+      expect(provider.query).to  eq({user: 'u'})
+      expect(provider.method).to eq :get
     end
 
     it "should assign parameters from :get" do
       provider.get    = "http://www.example.com/"
       provider.query  = {user: 'u'}
 
-      provider.uri.should    == URI("http://www.example.com/?user=u")
-      provider.query.should  == {user: 'u'}
-      provider.method.should == :get
+      expect(provider.uri).to    eq URI("http://www.example.com/?user=u")
+      expect(provider.query).to  eq({user: 'u'})
+      expect(provider.method).to eq :get
     end
 
     it "should assign parameters from :post" do
       provider.post   = "http://www.example.com/"
       provider.query  = {user: 'u'}
 
-      provider.uri.should    == URI("http://www.example.com/?user=u")
-      provider.query.should  == {user: 'u'}
-      provider.method.should == :post
+      expect(provider.uri).to    eq URI("http://www.example.com/?user=u")
+      expect(provider.query).to  eq({user: 'u'})
+      expect(provider.method).to eq :post
     end
 
     it "should assign parameters from :headers" do
       provider.headers = {"Content-Type" => "test/xml"}
 
-      provider.headers["Content-Type"].should == "test/xml"
+      expect(provider.headers["Content-Type"]).to eq "test/xml"
     end
 
     it "should assign parameters from :body" do
       provider.body = "<somexml></somexml>"
 
-      provider.body.should == "<somexml></somexml>"
+      expect(provider.body).to eq "<somexml></somexml>"
     end
 
     it "should assign basic auth parameters" do
       provider.username = "username"
       provider.password = "password"
 
-      provider.username.should == "username"
-      provider.password.should == "password"
+      expect(provider.username).to eq "username"
+      expect(provider.password).to eq "password"
     end
 
     describe ".new" do
@@ -62,9 +62,9 @@ module Stockboy
           query  user: 'u'
         end
 
-        provider.uri.should    == URI("http://www.example.com/?user=u")
-        provider.query.should  == { user: 'u' }
-        provider.method.should == :get
+        expect(provider.uri).to    eq URI("http://www.example.com/?user=u")
+        expect(provider.query).to  eq({ user: 'u' })
+        expect(provider.method).to eq :get
       end
     end
 
@@ -72,35 +72,35 @@ module Stockboy
       it "should be valid with minimal GET params" do
         provider.uri = "http://example.com"
         provider.method = :get
-        provider.should be_valid
+        expect(provider).to be_valid
       end
 
       it "should be valid with minimal POST params" do
         provider.uri = "http://example.com"
         provider.method = :post
         provider.body = "<somexml></somexml>"
-        provider.should be_valid
+        expect(provider).to be_valid
       end
 
       it "should not be valid without a method" do
         provider.uri = "http://example.com"
         provider.method = nil
-        provider.should_not be_valid
-        provider.errors.first.should match /method/
+        expect(provider).not_to be_valid
+        expect(provider.errors.first).to match /method/
       end
 
       it "should not be valid without a uri" do
         provider.uri = ""
         provider.method = :get
-        provider.should_not be_valid
-        provider.errors.first.should match /uri/
+        expect(provider).not_to be_valid
+        expect(provider.errors.first).to match /uri/
       end
 
       it "should require a body for post" do
         provider.uri = "http://example.com"
         provider.method = :post
-        provider.should_not be_valid
-        provider.errors.first.should match /body/
+        expect(provider).not_to be_valid
+        expect(provider.errors.first).to match /body/
       end
     end
 
@@ -110,11 +110,11 @@ module Stockboy
       before { provider.uri = "http://example.com/" }
 
       it "should configure the base url" do
-        client.url.host.should == "example.com"
+        expect(client.url.host).to eq "example.com"
       end
 
       it "returns the value of the passed block" do
-        provider.client { |http| "DATA" }.should == "DATA"
+        expect(provider.client { |http| "DATA" }).to eq "DATA"
       end
     end
 
@@ -132,7 +132,7 @@ module Stockboy
       it "returns string body on success" do
         expect(HTTPI).to receive(:request) { response }
 
-        provider.data.should == '{"success":true}'
+        expect(provider.data).to eq '{"success":true}'
       end
 
       it "should setup basic auth if a username and password are supplied" do
@@ -142,7 +142,7 @@ module Stockboy
         expect(HTTPI).to receive(:request) { response }
         expect_any_instance_of(HTTPI::Auth::Config).to receive(:basic).with("username", "password")
 
-        provider.data.should == '{"success":true}'
+        expect(provider.data).to eq '{"success":true}'
       end
     end
 

data/spec/stockboy/providers/imap/search_options_spec.rb

@@ -6,8 +6,8 @@ module Stockboy::Providers
 
     describe "to_hash" do
       it "converts keys to uppercase" do
-        options(subject: "Improbability")
-          .to_hash.should == {"SUBJECT" => "Improbability"}
+        expect(options(subject: "Improbability")
+          .to_hash).to eq({"SUBJECT" => "Improbability"})
       end
     end
 
@@ -15,8 +15,8 @@ module Stockboy::Providers
     describe "to_imap" do
 
       it "converts to a flat array of options" do
-        options(subject: "Improbability", from: "me@example.com")
-          .to_imap.should == ["SUBJECT", "Improbability", "FROM", "me@example.com"]
+        expect(options(subject: "Improbability", from: "me@example.com")
+          .to_imap).to eq ["SUBJECT", "Improbability", "FROM", "me@example.com"]
       end
 
       DATE_OPTIONS = { before:      "BEFORE",
@@ -28,8 +28,8 @@ module Stockboy::Providers
 
       DATE_OPTIONS.each do |date_option_symbol, date_option_imap|
         it "converts #{date_option_imap.inspect} to IMAP date option" do
-          options(date_option_symbol => TIME_FORMATS.first)
-          .to_imap.should == [date_option_imap, "12-DEC-2012"]
+          expect(options(date_option_symbol => TIME_FORMATS.first)
+          .to_imap).to eq [date_option_imap, "12-DEC-2012"]
         end
       end
 
@@ -39,8 +39,8 @@ module Stockboy::Providers
 
       TIME_FORMATS.each do |time|
         it "converts #{time.class} to IMAP date option" do
-          options(since: time)
-          .to_imap.should == ["SINCE", "12-DEC-2012"]
+          expect(options(since: time)
+          .to_imap).to eq ["SINCE", "12-DEC-2012"]
         end
       end
 
@@ -51,9 +51,9 @@ module Stockboy::Providers
 
       BOOLEAN_OPTIONS.each do |bool_option_symbol, bool_option_imap|
         it "converts #{bool_option_imap.inspect} to IMAP single value option" do
-          options(bool_option_symbol => true).to_imap.should == [bool_option_imap]
-          options(bool_option_symbol => false).to_imap.should == ["NOT", bool_option_imap]
-          options(bool_option_symbol => nil).to_imap.should == []
+          expect(options(bool_option_symbol => true).to_imap).to eq [bool_option_imap]
+          expect(options(bool_option_symbol => false).to_imap).to eq ["NOT", bool_option_imap]
+          expect(options(bool_option_symbol => nil).to_imap).to eq []
         end
       end
 

data/spec/stockboy/providers/imap_spec.rb

@@ -16,30 +16,30 @@ module Stockboy
       provider.file_smaller = 1024**3
       provider.file_larger = 1024
 
-      provider.host.should == "mail.localhost.test"
-      provider.username.should == "uuu"
-      provider.password.should == "ppp"
-      provider.mailbox.should == "INBOX/Data"
-      provider.subject.should == %r{New Records 20[1-9][0-9]-(0[1-9]|1[0-2])-([0-2][1-9]|3[0-1])}
-      provider.attachment.should == %r{data-[0-9]+\.csv}
-      provider.since.should == Date.new(2012,12,1)
-      provider.file_smaller.should == 1024**3
-      provider.file_larger.should == 1024
+      expect(provider.host).to eq "mail.localhost.test"
+      expect(provider.username).to eq "uuu"
+      expect(provider.password).to eq "ppp"
+      expect(provider.mailbox).to eq "INBOX/Data"
+      expect(provider.subject).to eq %r{New Records 20[1-9][0-9]-(0[1-9]|1[0-2])-([0-2][1-9]|3[0-1])}
+      expect(provider.attachment).to eq %r{data-[0-9]+\.csv}
+      expect(provider.since).to eq Date.new(2012,12,1)
+      expect(provider.file_smaller).to eq 1024**3
+      expect(provider.file_larger).to eq 1024
     end
 
     it "aliases since to newer_than" do
       provider = Providers::IMAP.new{ |f| f.newer_than Date.new(2012,12,1) }
-      provider.since.should == Date.new(2012,12,1)
+      expect(provider.since).to eq Date.new(2012,12,1)
     end
 
     it "aliases file_smaller to smaller_than" do
       provider = Providers::IMAP.new{ |f| f.smaller_than 1024**3 }
-      provider.file_smaller.should == 1024**3
+      expect(provider.file_smaller).to eq 1024**3
     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
@@ -49,10 +49,10 @@ module Stockboy
           file_smaller 1024**3
           file_larger 1024
         end
-        provider.host.should == 'mail.test2.local'
-        provider.attachment.should == 'report.csv'
-        provider.file_smaller.should == 1024**3
-        provider.file_larger.should == 1024
+        expect(provider.host).to eq 'mail.test2.local'
+        expect(provider.attachment).to eq 'report.csv'
+        expect(provider.file_smaller).to eq 1024**3
+        expect(provider.file_larger).to eq 1024
       end
     end
 
@@ -186,7 +186,7 @@ module Stockboy
       it "closes connections when catching exceptions" do
         net_imap = expect_connection("hhh", "uuu", "ppp", "UNBOX")
         provider.client { |i| raise Net::IMAP::Error }
-        provider.errors.first.should match /IMAP connection error/
+        expect(provider.errors.first).to match /IMAP connection error/
       end
 
     end
@@ -197,7 +197,7 @@ module Stockboy
         provider.subject = "Earth"
         provider.from = "me@example.com"
 
-        provider.search_keys.should == [
+        expect(provider.search_keys).to eq [
           "SUBJECT", "Earth",
           "FROM", "me@example.com",
           "SINCE", "21-Dec-2012"
@@ -207,28 +207,28 @@ module Stockboy
       it "replaces defaults with given options" do
         provider.since = Date.new(2012, 12, 21)
         provider.subject = "Earth"
-        provider.search_keys(subject: "Improbability").should == ["SUBJECT", "Improbability"]
+        expect(provider.search_keys(subject: "Improbability")).to eq ["SUBJECT", "Improbability"]
       end
 
       it "returns the same array given" do
-        provider.search_keys(["SINCE", "21-DEC-12"]).should == ["SINCE", "21-DEC-12"]
+        expect(provider.search_keys(["SINCE", "21-DEC-12"])).to eq ["SINCE", "21-DEC-12"]
       end
     end
 
     describe "#default_search_options" do
       it "includes configured SUBJECT option" do
         provider.subject = "Life"
-        provider.default_search_options.should == {subject: "Life"}
+        expect(provider.default_search_options).to eq({subject: "Life"})
       end
 
       it "includes configured SINCE option" do
         provider.since = Date.today
-        provider.default_search_options.should == {since: Date.today}
+        expect(provider.default_search_options).to eq({since: Date.today})
       end
 
       it "includes configured FROM option" do
         provider.from = "me@example.com"
-        provider.default_search_options.should == {from: "me@example.com"}
+        expect(provider.default_search_options).to eq({from: "me@example.com"})
       end
     end
 

data/spec/stockboy/providers/soap_spec.rb

@@ -14,11 +14,11 @@ module Stockboy
       provider.message   = {user: 'u', pass: 'p'}
       provider.headers   = {key: 'k'}
 
-      provider.wsdl.should      == "http://api.example.com/?wsdl"
-      provider.request.should   == :get_user
-      provider.namespace.should == "http://api.example.com/"
-      provider.message.should   == {user: 'u', pass: 'p'}
-      provider.headers.should   == {key: 'k'}
+      expect(provider.wsdl).to      eq "http://api.example.com/?wsdl"
+      expect(provider.request).to   eq :get_user
+      expect(provider.namespace).to eq "http://api.example.com/"
+      expect(provider.message).to   eq({user: 'u', pass: 'p'})
+      expect(provider.headers).to   eq({key: 'k'})
     end
 
     describe ".new" do
@@ -36,14 +36,14 @@ module Stockboy
           p.headers   = {key: 'k'}
         end
 
-        provider.request.should   == :get_user
-        provider.endpoint.should  == "http://api.example.com/v1"
-        provider.wsdl.should      == "http://api.example.com/?wsdl"
-        provider.open_timeout.should == 13
-        provider.read_timeout.should == 99
-        provider.namespace.should == "http://api.example.com/namespace"
-        provider.message.should   == {user: 'u', pass: 'p'}
-        provider.headers.should   == {key: 'k'}
+        expect(provider.request).to   eq :get_user
+        expect(provider.endpoint).to  eq "http://api.example.com/v1"
+        expect(provider.wsdl).to      eq "http://api.example.com/?wsdl"
+        expect(provider.client.globals[:open_timeout]).to eq 13
+        expect(provider.client.globals[:read_timeout]).to eq 99
+        expect(provider.namespace).to eq "http://api.example.com/namespace"
+        expect(provider.message).to   eq({user: 'u', pass: 'p'})
+        expect(provider.headers).to   eq({key: 'k'})
       end
     end
 
@@ -56,7 +56,7 @@ module Stockboy
       context "without a WSDL document" do
         it "has error for blank endpoint & WSDL namespace" do
           provider.valid?
-          provider.errors.first.should match /endpoint/
+          expect(provider.errors.first).to match /endpoint/
         end
       end
     end
@@ -66,7 +66,7 @@ module Stockboy
         provider.endpoint = "http://api.example.com/v1"
         provider.namespace = ''
         provider.client do |soap|
-          soap.should be_a Savon::Client
+          expect(soap).to be_a Savon::Client
         end
       end
     end
@@ -102,13 +102,13 @@ module Stockboy
       end
 
       it "uses string keys" do
-        response.keys.each { |k| k.should be_a String }
+        response.keys.each { |k| expect(k).to be_a String }
       end
 
       it "shares key string objects from a common pool" do
         cases = response["MultiNamespacedEntryResponse"]["history"]["case"]
         text_keys = cases.map { |c| c.keys[c.keys.index("logText")] }
-        text_keys[0].should be text_keys[1]
+        expect(text_keys[0]).to be text_keys[1]
       end
 
     end