stockboy 0.5.0

data/spec/stockboy/providers/file_spec.rb

@@ -0,0 +1,116 @@
+require 'spec_helper'
+require 'stockboy/providers/file'
+
+module Stockboy
+  describe Providers::File do
+    subject(:provider) { Stockboy::Providers::File.new }
+
+    it "should assign parameters" do
+      provider.file_dir = "fixtures/files"
+      provider.file_name = %r{import_20[1-9][0-9]-(0[1-9]|1[0-2])-([0-2][1-9]|3[0-1]).csv}
+      provider.file_newer = Date.today
+      provider.file_smaller = 1024**2
+      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
+    end
+
+    describe ".new" do
+      it "has no errors" do
+        provider.errors.messages.should be_empty
+      end
+
+      it "accepts block initialization" do
+        provider = Providers::File.new{ |f| f.file_dir 'fixtures/files' }
+        provider.file_dir.should == 'fixtures/files'
+      end
+    end
+
+    describe "#matching_file" do
+      subject(:provider) do
+        Providers::File.new do |f|
+          f.file_dir = RSpec.configuration.fixture_path.join("files")
+        end
+      end
+
+      it "returns the full path to the matching file name" do
+        provider.file_name = "test_data-*"
+        provider.matching_file.should end_with "fixtures/files/test_data-20120202.csv"
+      end
+    end
+
+    describe "#data" do
+      subject(:provider) do
+        Providers::File.new do |f|
+          f.file_dir = RSpec.configuration.fixture_path.join("files")
+        end
+      end
+
+      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 == false
+        provider.errors[:base].should_not be_empty
+      end
+
+      it "finds last matching file from string glob" do
+        provider.file_name = "test_data-*.csv"
+        provider.data.should == "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"
+      end
+
+      it "finds last matching file from regex" do
+        provider.file_name = /test_data/
+        provider.data.should == "2012-02-02\n"
+      end
+
+      context "with :since validation" do
+        let(:recently) { Time.now - 60 }
+
+        it "skips old files" do
+          expect_any_instance_of(::File).to receive(:mtime).and_return Time.now - 86400
+          provider.file_dir = RSpec.configuration.fixture_path.join("files")
+          provider.file_name = '*.csv'
+          provider.since = recently
+
+          provider.data.should be_nil
+          provider.errors[:response].should include "No new files since #{recently}"
+        end
+      end
+    end
+
+    describe ".delete_data" do
+      let(:target)       { ::Tempfile.new(['delete', '.csv']) }
+      let(:target_dir)   { File.dirname(target) }
+      subject(:provider) { Providers::File.new(file_name: 'delete*.csv', file_dir: target_dir) }
+
+      after do
+        target.unlink
+      end
+
+      it "should raise an error when called blindly" do
+        expect_any_instance_of(::File).to_not receive(:delete)
+        expect { provider.delete_data }.to raise_error Stockboy::OutOfSequence
+      end
+
+      it "should call delete on the matched file" do
+        provider.matching_file
+
+        expect(::File).to receive(:delete).with(target.path)
+        provider.delete_data
+      end
+    end
+
+  end
+end

data/spec/stockboy/providers/ftp_spec.rb

@@ -0,0 +1,143 @@
+require 'spec_helper'
+require 'stockboy/providers/ftp'
+
+module Stockboy
+  describe Providers::FTP do
+
+    subject(:provider) do
+      Stockboy::Providers::FTP.new do |ftp|
+        ftp.host = "localhost.test"
+        ftp.username = "a"
+        ftp.password = "b"
+        ftp.binary = true
+        ftp.passive = true
+        ftp.file_name = '*.csv'
+      end
+    end
+
+    it "should assign parameters" do
+      ftp = Stockboy::Providers::FTP.new
+      ftp.host = "localhost.test"
+      ftp.username = "uuu"
+      ftp.password = "ppp"
+      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}
+    end
+
+    describe ".new" do
+      it "has no errors" do
+        subject.errors.messages.should be_empty
+      end
+
+      it "accepts block initialization" do
+        ftp = Providers::FTP.new{ |f| f.host 'test2.local' }
+        ftp.host.should == 'test2.local'
+      end
+    end
+
+    describe "#client" do
+      it "should open connection to host with username and password" do
+        expect_connection
+
+        connection = false
+        provider.client { |f| connection = f }
+
+        connection.should be_a Net::FTP
+        connection.binary.should be_true
+        connection.passive.should be_true
+      end
+
+      it "should return yielded result" do
+        expect_connection
+
+        result = provider.client { |_| "a_file_name.csv" }
+
+        result.should == "a_file_name.csv"
+      end
+    end
+
+    describe "#data" do
+      it "adds an error on missing host" do
+        provider.host = nil
+        provider.data
+
+        provider.errors.include?(:host).should be_true
+      end
+
+      it "adds an error on missing file_name" do
+        provider.file_name = nil
+        provider.data
+
+        provider.errors.include?(:file_name).should be_true
+      end
+
+      it "downloads the last matching file" do
+        net_ftp = expect_connection
+        expect(net_ftp).to receive(:nlst).and_return ['20120101.csv', '20120102.csv']
+        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"
+      end
+
+      it "skips old files" do
+        net_ftp = expect_connection
+        expect(net_ftp).to receive(:nlst).and_return ['20120101.csv', '20120102.csv']
+        expect(net_ftp).to receive(:mtime).with('20120102.csv').and_return(Time.new(2009,01,01))
+        expect(net_ftp).to_not receive(:get)
+
+        provider.file_newer = Time.new(2010,1,1)
+
+        provider.data.should be_nil
+      end
+    end
+
+    describe "#matching_file" do
+      it "does not change until cleared" do
+        net_ftp = expect_connection
+        expect(net_ftp).to receive(:nlst).and_return ["1.csv", "2.csv"]
+
+        provider.matching_file.should == "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"
+        provider.clear
+        provider.matching_file.should == "3.csv"
+      end
+    end
+
+    describe "#delete_data" do
+      it "should raise an error when called blindly" do
+        expect_any_instance_of(Net::FTP).to_not receive(:delete)
+        expect { provider.delete_data }.to raise_error Stockboy::OutOfSequence
+      end
+
+      it "should delete the matching file" do
+        net_ftp = expect_connection
+        expect(net_ftp).to receive(:nlst).and_return ["1.csv", "2.csv"]
+
+        provider.matching_file.should == "2.csv"
+
+        net_ftp = expect_connection
+        expect(net_ftp).to receive(:delete).with("2.csv")
+
+        provider.delete_data.should == "2.csv"
+      end
+    end
+
+    def expect_connection(host="localhost.test", user="a", pass="b")
+      net_ftp = Net::FTP.new
+      expect(Net::FTP).to receive(:open).with(host, user, pass).and_yield(net_ftp)
+      net_ftp
+    end
+
+  end
+end

data/spec/stockboy/providers/http_spec.rb

@@ -0,0 +1,94 @@
+require 'spec_helper'
+require 'stockboy/providers/http'
+
+module Stockboy
+  describe Providers::HTTP do
+    subject(:provider) { Stockboy::Providers::HTTP.new }
+
+    it "should assign parameters from :uri option" do
+      provider.uri    = "http://www.example.com/"
+      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
+    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
+    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
+    end
+
+    describe ".new" do
+      its(:errors) { should be_empty }
+
+      it "accepts block DSL initialization" do
+        provider = Providers::HTTP.new do
+          get    "http://www.example.com/"
+          query  user: 'u'
+        end
+
+        provider.uri.should    == URI("http://www.example.com/?user=u")
+        provider.query.should  == { user: 'u' }
+        provider.method.should == :get
+      end
+    end
+
+    describe "validation" do
+      it "should not be valid without a method" do
+        provider.method = nil
+        provider.should_not be_valid
+        provider.errors.keys.should include(:method)
+      end
+
+      it "should not be valid without a uri" do
+        provider.uri = ""
+        provider.should_not be_valid
+        provider.errors.keys.should include(:uri)
+      end
+    end
+
+    describe "#data" do
+      let(:response)   { HTTPI::Response.new(200, {}, '{"success":true}') }
+
+      subject(:provider) do
+        Providers::HTTP.new do |s|
+          s.uri    = "http://www.example.com/"
+          s.query  = {username: "user"}
+          s.method = :get
+        end
+      end
+
+      it "returns string body on success" do
+        expect(HTTPI).to receive(:request) { response }
+
+        provider.data.should == '{"success":true}'
+      end
+    end
+
+    describe "#client" do
+      it "yields a generic HTTP interface" do
+        provider.client do |http|
+          http.should respond_to :get
+          http.should respond_to :post
+        end
+      end
+    end
+
+  end
+end
+

data/spec/stockboy/providers/imap_spec.rb

@@ -0,0 +1,76 @@
+require 'spec_helper'
+require 'stockboy/providers/imap'
+
+module Stockboy
+  describe Providers::IMAP do
+    subject(:provider) { Stockboy::Providers::IMAP.new }
+
+    it "should assign parameters" do
+      provider.host = "mail.localhost.test"
+      provider.username = "uuu"
+      provider.password = "ppp"
+      provider.mailbox = "INBOX/Data"
+      provider.subject = %r{New Records 20[1-9][0-9]-(0[1-9]|1[0-2])-([0-2][1-9]|3[0-1])}
+      provider.since = Date.new(2012,12,1)
+      provider.attachment = %r{data-[0-9]+\.csv}
+
+      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)
+    end
+
+    describe "deprecated options", pending: "implement deprecated_alias" do
+      it "promotes since instead of newer_than" do
+        provider = Providers::IMAP.new{ |f| f.newer_than Date.new(2012,12,1) }
+        provider.since.should == Date.new(2012,12,1)
+      end
+    end
+
+    describe ".new" do
+      it "has no errors" do
+        provider.errors.messages.should be_empty
+      end
+
+      it "accepts block initialization" do
+        provider = Providers::IMAP.new{ |f| f.host 'mail.test2.local' }
+        provider.host.should == 'mail.test2.local'
+      end
+    end
+
+    describe "#data" do
+
+      context "with no messages found" do
+        it "should be nil" do
+          allow(provider).to receive(:fetch_imap_message_keys).and_return []
+          provider.data.should be_nil
+        end
+      end
+
+    end
+
+    describe "#delete_data" do
+      let(:imap) { double(:imap) }
+
+      it "should raise an error when called blindly" do
+        expect { provider.delete_data }.to raise_error Stockboy::OutOfSequence
+      end
+
+      it "should call delete on the matching message" do
+        allow(provider).to receive(:client).and_yield(imap)
+        allow(provider).to receive(:fetch_imap_message_keys) { [5] }
+
+        provider.matching_message
+
+        expect(imap).to receive(:uid_store).with(5, "+FLAGS", [:Deleted])
+        expect(imap).to receive(:expunge)
+
+        provider.delete_data
+      end
+    end
+
+  end
+end

data/spec/stockboy/providers/soap_spec.rb

@@ -0,0 +1,107 @@
+require 'spec_helper'
+require 'stockboy/providers/soap'
+
+module Stockboy
+  describe Providers::SOAP do
+    before(:all) { savon.mock!   }
+    after(:all)  { savon.unmock! }
+    subject(:provider) { Stockboy::Providers::SOAP.new }
+
+    it "should assign parameters" do
+      provider.wsdl      = "http://api.example.com/?wsdl"
+      provider.request   = :get_user
+      provider.namespace = "http://api.example.com/"
+      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'}
+    end
+
+    describe ".new" do
+      its(:errors) { should be_empty }
+
+      it "accepts block initialization" do
+        provider = Providers::SOAP.new do |p|
+          p.request   = :get_user
+          p.endpoint  = "http://api.example.com/v1"
+          p.namespace = "http://api.example.com/namespace"
+          p.wsdl      = "http://api.example.com/?wsdl"
+          p.message   = {user: 'u', pass: 'p'}
+          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.namespace.should == "http://api.example.com/namespace"
+        provider.message.should   == {user: 'u', pass: 'p'}
+        provider.headers.should   == {key: 'k'}
+      end
+    end
+
+    describe "validation" do
+      context "with a WSDL document" do
+        before { provider.wsdl = "http://api.example.com/?wsdl" }
+        it     { should be_valid }
+      end
+
+      context "without a WSDL document" do
+        it "has error for blank endpoint & WSDL namespace" do
+          provider.valid?
+          provider.errors.keys.should include(:endpoint)
+        end
+      end
+    end
+
+    describe "#client" do
+      it "yields a Savon client" do
+        provider.endpoint = "http://api.example.com/v1"
+        provider.namespace = ''
+        provider.client do |soap|
+          soap.should be_a Savon::Client
+        end
+      end
+    end
+
+    describe "#data" do
+      let(:xml_success_fixture) do
+        File.read(RSpec.configuration.fixture_path.join "soap/get_list/success.xml")
+      end
+
+      let(:provider) do
+        Providers::SOAP.new do |s|
+          s.endpoint = "http://api.example.com/v1"
+          s.namespace = ''
+          s.request = :get_list
+          s.message = {username: "user", password: "pass"}
+        end
+      end
+
+      subject(:response) do
+        savon.expects(:get_list)
+             .with(message: {username: 'user', password: 'pass'})
+             .returns(xml_success_fixture)
+        provider.data
+      end
+
+      it "returns hash data on success" do
+        should be_a Hash
+      end
+
+      it "uses string keys" do
+        response.keys.each { |k| k.should 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]
+      end
+
+    end
+  end
+end