pvdgm_services 0.1.0

data/spec/models/pcc_mds_pull_spec.rb

@@ -0,0 +1,273 @@
+require 'spec_helper'
+
+describe Services::PccMdsPull do
+
+  context '#Instance Methods' do
+
+    before(:each) do
+      @mock_sd = mock_model(Services::ServiceDefinition)
+      @mock_sd.stub(:hostname).and_return('the_server')
+      @mock_sd.stub(:username).and_return('the_user')
+      @mock_sd.stub(:base_uri).and_return('/home')
+
+      mock_credentials = mock_model(Services::Credential)
+      mock_credentials.stub(:password).and_return('the_password')
+
+      @mock_account_map = mock_model(Services::AccountMapping)
+      @mock_account_map.stub(:account_code).and_return('kind')
+
+      @pcc_mds_pull = Services::PccMdsPull.new(@mock_sd)
+      @pcc_mds_pull.stub(:server_credentials).and_return(mock_credentials)
+      @pcc_mds_pull.stub(:account_map).and_return(@mock_account_map)
+    end
+
+    context '#ftp_server' do
+
+      it "should return a reference to the ftp server to use for file access" do
+        mock_ftp_server = double("FtpServer")
+        Services::FtpServer.
+          should_receive(:new).
+          with('the_server',
+               'the_user',
+               'the_password',
+               '/home').
+          and_return(mock_ftp_server)
+
+        expect(@pcc_mds_pull.ftp_server).to be(mock_ftp_server)
+
+        # Call it again; but it shouldn't construct a new instance
+        # (see expectations)
+        expect(@pcc_mds_pull.ftp_server).to be(mock_ftp_server)
+      end
+
+    end
+
+    context '#list_available_files' do
+
+      before(:each) do
+        @mock_ftp_server = double("FtpServer")
+        @mock_ftp_server.
+          stub(:connect).
+          and_yield(@mock_ftp_server)
+
+        @mock_configured_account = mock_model(Services::ConfiguredAccount)
+        @mock_configured_account.stub(:account_id).and_return(3)
+        
+        @pcc_mds_pull.stub(:ftp_server).and_return(@mock_ftp_server)
+      end
+
+      it "should return an empty array if no files are available" do
+        @mock_ftp_server.
+          should_receive(:file_list).
+          with('kind', '*.zip').
+          and_return([])
+
+        expect(@pcc_mds_pull.list_available_files(@mock_configured_account)).to eq([])
+      end
+
+      it "should return an array of tuples when files are available" do
+        @mock_ftp_server.
+          should_receive(:file_list).
+          with('kind', '*.zip').
+          and_return([ 'file_1.zip', 'file_2.zip' ])
+
+        expect(@pcc_mds_pull.list_available_files(@mock_configured_account)).to eq([ [ 'file_1.zip', 'file_1.zip' ], [ 'file_2.zip', 'file_2.zip' ] ])
+      end
+
+    end
+
+    context '#perform_file_downloads' do
+
+      before(:each) do
+        @mock_ftp_server = double("FtpServer")
+        @mock_ftp_server.
+          stub(:connect).
+          and_yield(@mock_ftp_server)
+
+        @mock_configured_account = mock_model(Services::ConfiguredAccount)
+        @mock_configured_account.stub(:account_id).and_return(3)
+        
+        @pcc_mds_pull.stub(:ftp_server).and_return(@mock_ftp_server)
+      end
+
+      it "should return an empty array of available file ids if no files are specified for download" do
+        @pcc_mds_pull.
+          should_not_receive(:download_file)
+
+        expect(@pcc_mds_pull.perform_file_downloads(@mock_configured_account, [])).to eq([])
+      end
+
+      it "should return an array of the available file ids that were actually downloaded" do
+        mock_af_1 = mock_model(Services::AvailableFile)
+        mock_af_2 = mock_model(Services::AvailableFile)
+        mock_af_3 = mock_model(Services::AvailableFile)
+
+        @pcc_mds_pull.
+          should_receive(:download_file).
+          with(@mock_ftp_server, mock_af_1, 'kind').
+          and_return(mock_af_1.id)
+        @pcc_mds_pull.
+          should_receive(:download_file).
+          with(@mock_ftp_server, mock_af_2, 'kind').
+          and_return(nil) # File not actually downloaded successfully
+        @pcc_mds_pull.
+          should_receive(:download_file).
+          with(@mock_ftp_server, mock_af_3, 'kind').
+          and_return(mock_af_3.id)
+
+        expect(@pcc_mds_pull.perform_file_downloads(@mock_configured_account, [mock_af_1, mock_af_2, mock_af_3])).to eq([ mock_af_1.id, mock_af_3.id ])
+      end
+
+    end
+
+    context '#perform_cleanup_on_remote_server' do
+
+      before(:each) do
+        @mock_ftp_server = double("FtpServer")
+        @mock_ftp_server.
+          stub(:connect).
+          and_yield(@mock_ftp_server)
+
+        @mock_configured_account = mock_model(Services::ConfiguredAccount)
+        @mock_configured_account.stub(:account_id).and_return(3)
+        
+        @pcc_mds_pull.stub(:ftp_server).and_return(@mock_ftp_server)
+      end
+
+      it "should return an empty array if no files needed to be cleaned up" do
+        @mock_configured_account.should_receive(:available_files).and_return do
+          double("AvailableFiles").tap do | available_files |
+            available_files.should_receive(:deleted).and_return([])
+          end
+        end
+
+        @pcc_mds_pull.should_not_receive(:remove_file)
+
+        expect(@pcc_mds_pull.perform_cleanup_on_remote_server(@mock_configured_account)).to eq([])
+      end
+
+      it "should return an empty array if no files were successfully cleaned up" do
+        mock_af_1 = mock_model(Services::AvailableFile)
+        mock_af_2 = mock_model(Services::AvailableFile)
+        mock_af_3 = mock_model(Services::AvailableFile)
+
+        @mock_configured_account.should_receive(:available_files).and_return do
+          double("AvailableFiles").tap do | available_files |
+            available_files.should_receive(:deleted).and_return([ mock_af_1, mock_af_2, mock_af_3 ])
+          end
+        end
+
+        @pcc_mds_pull.
+          should_receive(:remove_file).
+          with(@mock_ftp_server, mock_af_1, 'kind').
+          and_return(nil)
+
+        @pcc_mds_pull.
+          should_receive(:remove_file).
+          with(@mock_ftp_server, mock_af_2, 'kind').
+          and_return(nil)
+
+        @pcc_mds_pull.
+          should_receive(:remove_file).
+          with(@mock_ftp_server, mock_af_3, 'kind').
+          and_return(nil)
+
+        expect(@pcc_mds_pull.perform_cleanup_on_remote_server(@mock_configured_account)).to eq([])
+      end
+
+      it "should return an array of the successfully removed files" do
+        mock_af_1 = mock_model(Services::AvailableFile)
+        mock_af_2 = mock_model(Services::AvailableFile)
+        mock_af_3 = mock_model(Services::AvailableFile)
+
+        @mock_configured_account.should_receive(:available_files).and_return do
+          double("AvailableFiles").tap do | available_files |
+            available_files.should_receive(:deleted).and_return([ mock_af_1, mock_af_2, mock_af_3 ])
+          end
+        end
+
+        @pcc_mds_pull.
+          should_receive(:remove_file).
+          with(@mock_ftp_server, mock_af_1, 'kind').
+          and_return(23)
+
+        @pcc_mds_pull.
+          should_receive(:remove_file).
+          with(@mock_ftp_server, mock_af_2, 'kind').
+          and_return(nil)
+
+        @pcc_mds_pull.
+          should_receive(:remove_file).
+          with(@mock_ftp_server, mock_af_3, 'kind').
+          and_return(82)
+
+        expect(@pcc_mds_pull.perform_cleanup_on_remote_server(@mock_configured_account)).to eq([ 23, 82 ])
+      end
+
+    end
+
+    context '#download_file' do
+
+      it "should return the id of the file if successfully downloaded" do
+        mock_af = mock_model(Services::AvailableFile)
+        mock_af.should_receive(:request_id).and_return('file_1')
+        mock_af.should_receive(:download_path).and_return('/tmp')
+
+        mock_server = double("FtpServer")
+        mock_server.
+          should_receive(:download_file).
+          with('kind', 'file_1', '/tmp')
+
+        expect(@pcc_mds_pull.download_file(mock_server, mock_af, 'kind')).to eq(mock_af.id)
+      end
+
+      it "should return nil if file was not successfully downloaded" do
+        mock_af = mock_model(Services::AvailableFile)
+        mock_af.should_receive(:request_id).and_return('file_1')
+        mock_af.should_receive(:download_path).and_return('/tmp')
+        mock_af.should_receive(:to_rrepr).and_return("")
+
+        mock_server = double("FtpServer")
+        mock_server.
+          should_receive(:download_file).
+          with('kind', 'file_1', '/tmp').
+          and_raise(Exception)
+
+        expect(@pcc_mds_pull.download_file(mock_server, mock_af, 'kind')).to be_nil
+      end
+
+    end
+
+    context '#remove_file' do
+
+      it "should return the id of the file if successfully removed" do
+        mock_af = mock_model(Services::AvailableFile)
+        mock_af.should_receive(:request_id).and_return('file_1')
+
+        mock_server = double("FtpServer")
+        mock_server.
+          should_receive(:remove_file).
+          with('kind', 'file_1')
+
+        expect(@pcc_mds_pull.remove_file(mock_server, mock_af, 'kind')).to eq(mock_af.id)
+      end
+
+      it "should return nil if the file is not successfully removed" do
+        mock_af = mock_model(Services::AvailableFile)
+        mock_af.should_receive(:request_id).and_return('file_1')
+        mock_af.should_receive(:to_rrepr).and_return("")
+
+        mock_server = double("FtpServer")
+        mock_server.
+          should_receive(:remove_file).
+          with('kind', 'file_1').
+          and_raise(Exception)
+
+        expect(@pcc_mds_pull.remove_file(mock_server, mock_af, 'kind')).to be_nil
+      end
+
+    end
+
+  end
+
+end

data/spec/models/service_implementation_spec.rb

@@ -0,0 +1,88 @@
+require 'spec_helper'
+
+describe Services::ServiceImplementation do
+
+  before(:each) do
+    @mock_sd = double("ServiceDefinition")
+  end
+
+  context '#initialize' do
+
+    it "should hold onto the specified service definition" do
+      si = Services::ServiceImplementation.new @mock_sd
+
+      expect(si.service_definition).to be(@mock_sd)
+    end
+
+  end
+
+  context '#server_credentials' do
+
+    it "should return the first set of credentials associated with the service definition" do
+      mock_credentials = double("Credentials")
+
+      si = Services::ServiceImplementation.new @mock_sd
+
+      @mock_sd.should_receive(:credentials).and_return([ mock_credentials ])
+
+      expect(si.server_credentials).to be(mock_credentials)
+    end
+
+    it "should cache the credentials after the first call" do
+      mock_credentials = double("Credentials")
+
+      si = Services::ServiceImplementation.new @mock_sd
+
+      @mock_sd.should_receive(:credentials).exactly(1).times.and_return([ mock_credentials ])
+
+      expect(si.server_credentials).to be(mock_credentials)
+
+      expect(si.server_credentials).to be(mock_credentials)
+    end
+
+    it "should raise an exception if there are no credentials associated with the server" do
+      si = Services::ServiceImplementation.new @mock_sd
+
+      @mock_sd.should_receive(:credentials).exactly(1).times.and_return([ ])
+      @mock_sd.should_receive(:to_rrepr).and_return("The Error")
+
+      expect { si.server_credentials }.to raise_error
+    end
+
+  end
+
+  context '#account_map' do
+
+    it "should look up the account mapping for the specified account id" do
+      @mock_sd.should_receive(:third_party_id).and_return(9)
+
+      si = Services::ServiceImplementation.new @mock_sd
+
+      mock_account_map = double("AccountMapping")
+
+      Services::AccountMapping.
+        should_receive(:where).
+        with(account_id: 2, third_party_id: 9).
+        and_return([ mock_account_map ])
+
+      expect(si.account_map(2)).to be(mock_account_map)
+    end
+
+    it "should raise an exception if the account mapping doesn't exist" do
+      @mock_sd.should_receive(:third_party_id).and_return(9)
+
+      @mock_sd.should_receive(:to_rrepr).and_return("The Error")
+
+      si = Services::ServiceImplementation.new @mock_sd
+
+      Services::AccountMapping.
+        should_receive(:where).
+        with(account_id: 2, third_party_id: 9).
+        and_return([ ])
+
+      expect { si.account_map(2) }.to raise_error
+    end
+
+  end
+
+end

data/spec/models/sltc_api_exception_spec.rb

@@ -0,0 +1,136 @@
+require 'spec_helper'
+
+describe Services::SltcApiException do
+
+  context '#initialize' do
+
+    it "should have a message that is whatever is returned from :format_exception_message" do
+      inner_exception = Exception.new
+
+      ex = Services::SltcApiException.new(inner_exception)
+      expect(ex.message).to eq("Unknown SimpleLTC API Error (no http_code associated with inner exception)")
+      expect(ex.inner_exception).to eq(inner_exception)
+    end
+
+  end
+
+  context 'Public Instance Methods' do
+
+    context '#http_code' do
+      
+      it "should return the value of the http_code attribute of the inner exception" do
+        inner_exception = Exception.new("Error Message")
+        inner_exception.stub(:http_code).and_return(500)
+
+        ex = Services::SltcApiException.new(inner_exception)
+        expect(ex.http_code).to eq(500)
+      end
+
+      it "should return nil if the inner exception doesn't have an http_code attribute" do
+        inner_exception = Exception.new("Error Message")
+
+        ex = Services::SltcApiException.new(inner_exception)
+        expect(ex.http_code).to be_nil
+      end
+
+    end
+
+    context '#http_message' do
+
+      it "should return the message string from the inner exception" do
+        inner_exception = Exception.new("Error Message")
+
+        ex = Services::SltcApiException.new(inner_exception)
+        expect(ex.http_message).to eq("Error Message")
+      end
+
+    end
+
+  end
+
+  context 'Private Instance Methods' do
+
+    context '#basic_message_fmt' do
+
+      it "should provide a message that displays the http_code and message when an http_code is present" do
+        mock_exception = double("Exception")
+        mock_exception.stub(:http_code).and_return(500)
+        mock_exception.stub(:message).and_return("General Error")
+
+        ex = Services::SltcApiException.new(mock_exception)
+        expect(ex.send(:basic_message_fmt)).to eq("500: General Error")
+      end
+
+      it "should return a general message if no http_code is found on the inner exception" do
+        inner_exception = Exception.new
+        ex = Services::SltcApiException.new(inner_exception)
+        expect(ex.send(:basic_message_fmt)).to eq("no http_code associated with inner exception")
+      end
+
+    end
+
+    context '#extract_sltc_error_information' do
+
+      it "should return an error message displaying the SLTC error code/message when provided in the response" do
+        inner_exception = Exception.new("Error Message")
+        inner_exception.stub(:http_code).and_return(500)
+        inner_exception.stub(:response).and_return('{ "ErrorCode": 12, "Message": "Sltc Error Message" }')
+
+        ex = Services::SltcApiException.new(inner_exception)
+        expect(ex.send(:extract_sltc_error_information)).to eq("SimpleLTC error response: (12) Sltc Error Message (500: Error Message)")
+      end
+
+      it "should return the raw json as part of the message if no 'Message' key is found in response" do
+        inner_exception = Exception.new("Error Message")
+        inner_exception.stub(:http_code).and_return(500)
+        inner_exception.stub(:response).and_return('{ "ErrorCode": 12 }')
+
+        ex = Services::SltcApiException.new(inner_exception)
+        expect(ex.send(:extract_sltc_error_information)).to eq("No error message in SimpleLTC error response ({ \"ErrorCode\": 12 }) (500: Error Message)")
+      end
+
+      it "should return the raw json as part of the message if the response json does not parse to a hash" do
+        inner_exception = Exception.new("Error Message")
+        inner_exception.stub(:http_code).and_return(500)
+        inner_exception.stub(:response).and_return('[ 1 ]')
+
+        ex = Services::SltcApiException.new(inner_exception)
+        expect(ex.send(:extract_sltc_error_information)).to eq("No error message in SimpleLTC error response ([ 1 ]) (500: Error Message)")
+      end
+
+      it "should format the exception returned when there was an error parsing the json response" do
+        inner_exception = Exception.new("Error Message")
+        inner_exception.stub(:http_code).and_return(500)
+        inner_exception.stub(:response).and_return('{ "ErrorCode":')
+
+        ex = Services::SltcApiException.new(inner_exception)
+        expect(ex.send(:extract_sltc_error_information)).to eq("Error parsing SimpleLTC API Error JSON ({ \"ErrorCode\":): 757: unexpected token at '{ \"ErrorCode\":' (500: Error Message)")
+      end
+
+    end
+
+    context '#format_exception_message' do
+
+      it "should return a generic error message if there is no raw json" do
+        inner_exception = Exception.new("Error Message")
+        inner_exception.stub(:http_code).and_return(500)
+        inner_exception.stub(:response).and_return(nil)
+
+        ex = Services::SltcApiException.new(inner_exception)
+        expect(ex.send(:format_exception_message)).to eq("Unknown SimpleLTC API Error (500: Error Message)")
+      end
+
+      it "should return the value returned by extract_sltc_error_information if the json response is not nil" do
+        inner_exception = Exception.new("Error Message")
+        inner_exception.stub(:http_code).and_return(500)
+        inner_exception.stub(:response).and_return('{ "ErrorCode": 12, "Message": "Sltc Error Message" }')
+
+        ex = Services::SltcApiException.new(inner_exception)
+        ex.should_receive(:extract_sltc_error_information).and_return("Message returned from extract_sltc_error_information")
+        expect(ex.send(:format_exception_message)).to eq("Message returned from extract_sltc_error_information")
+      end
+
+    end
+  end
+
+end

data/spec/models/sltc_api_spec.rb

@@ -0,0 +1,192 @@
+require 'spec_helper'
+
+describe Services::SltcApi do
+
+  context '#initialize' do
+
+    it "should faithfully reproduce the parameters in the accessors" do
+
+      api = Services::SltcApi.new("https://api-test.simpleltc.com/v1",
+                                        "the_token",
+                                        "the_account",
+                                        "the_username",
+                                        "the_password")
+
+      expect(api.base_uri).to eq('https://api-test.simpleltc.com/v1')
+      expect(api.api_key).to eq('the_token')
+      expect(api.account).to eq('the_account')
+      expect(api.username).to eq('the_username')
+      expect(api.password).to eq('the_password')
+
+    end
+
+  end
+
+  context 'Instance Methods' do
+
+    before(:each) do
+      @api = Services::SltcApi.new("https://api-test.simpleltc.com/v1",
+                                         "the_token",
+                                         "the_account",
+                                         "the_username",
+                                         "the_password")
+
+    end
+
+    context '#get_response' do
+
+      it "should return a hash converted from JSON when using the default no-parameter" do
+        response = @api.send(:get_response) do
+          '{ "Message" : "The Message" }'
+        end
+        
+        expect(response).to be_a(Hash)
+      end
+
+      it "should return the raw body of the block if the 'binary_response' parameter is true" do
+        response = @api.send(:get_response, true) do
+          '{ "Message" : "The Message" }'
+        end
+        
+        expect(response).to eq('{ "Message" : "The Message" }')
+      end
+
+      it "should raise an SltcApiException if a RestClient::Exception is raised in the block" do
+        expect { @api.send(:get_response) { raise RestClient::Exception } }.to raise_error(Services::SltcApiException)
+      end
+
+      it "should allow a non-RestClient::Exception to be raised out of the method" do
+        ex = Exception.new
+        expect { @api.send(:get_response) { raise ex } }.to raise_error(ex)
+      end
+
+    end
+
+    context '#authentication_headers' do
+
+      it "should return a hash of the headers to be sent for authentication" do
+        expected_hash = {
+          'SLTC-Api-Key' => 'the_token',
+          "Host"=>"api-test.simpleltc.com"
+        }
+
+        expect(@api.send(:authentication_headers)).to eq(expected_hash)
+      end
+    end
+
+    context '#list_providers' do
+
+      it "should make the web service call and return the response as a hash" do
+        json = '[ { "id" : 3993, "name" : "Rouster Health" }, { "id" : 3994, "name" : "Blueth Health" }, { "id" : 4003, "name" : "Orange Health" } ]'
+        providers = [
+                     { 'id' => 3993, 'name' => "Rouster Health" },
+                     { 'id' => 3994, 'name' => "Blueth Health" },
+                     { 'id' => 4003, 'name' => "Orange Health" }
+                    ]
+
+        @api.should_receive(:build_url).and_return('the_url')
+        @api.should_receive(:authentication_headers).and_return( { header: 'the_headers' } )
+
+        RestClient::Request.
+          should_receive(:execute).
+          with({ method: :get,
+                 url: 'the_url',
+                 user: 'the_username@the_account',
+                 password: 'the_password',
+                 headers: { header: 'the_headers', 'Accept' => 'application/json' }}).
+          and_return(json)
+
+        expect(@api.list_providers).to eq(providers)
+      end
+
+    end
+
+    context '#list_batches' do
+
+      it "should make the web service call and return the response as a hash" do
+        json = '[ { "id" : 1, "provider" : { "id" : 12, "name" : "Health" }, "filename" : "the_filename", "status" : "Verified", "statusDate" : "2013-10-01T00:00Z", "uploadDate" : "2013-10-01T01:00Z", "totalRecords" : 12 } ]'
+        batches = [
+                   { "id" => 1, "provider" => { "id" => 12, "name" => "Health" }, "filename" => 'the_filename', "status" => "Verified", "statusDate" => "2013-10-01T00:00Z", "uploadDate" => "2013-10-01T01:00Z", "totalRecords" => 12 }
+                  ]
+
+        @api.should_receive(:build_url).and_return('the_url')
+        @api.should_receive(:authentication_headers).and_return( { header: 'the_headers' } )
+        @api.should_receive(:account).and_return('the_account')
+        @api.should_receive(:password).and_return('the_password')
+
+        # RestClient.should_receive(:get).with('the_url', { header: 'the_headers', 'Accept' => 'application/json' }).and_return(json)
+        RestClient::Request.
+          should_receive(:execute).
+          with({ method: :get,
+                 url: 'the_url',
+                 user: "the_username@the_account",
+                 password: "the_password",
+                 headers: { header: 'the_headers', 'Accept' => 'application/json' } }).
+          and_return(json)
+
+        expect(@api.list_providers).to eq(batches)
+      end
+
+    end
+
+  end
+
+  context 'Private Methods' do
+    before(:each) do
+      @api = Services::SltcApi.new("https://api-test.simpleltc.com/v1",
+                                   "the_token",
+                                   "the_account",
+                                   "the_username",
+                                   "the_password")
+
+    end
+
+    context '#authentication_headers' do
+
+      it "should incorporate all the necessary headers for authentication" do
+        expect(@api.send(:authentication_headers)).to eq({
+                                                           'SLTC-Api-Key' => 'the_token',
+                                                           'Host' => 'api-test.simpleltc.com'
+                                                         })
+      end
+    end
+
+    context '#build_url' do
+      
+      it "should return the url that has no parameters" do
+        expect(@api.send(:build_url, :MdsBatches)).
+          to eq("https://api-test.simpleltc.com/v1/MdsBatches")
+      end
+
+      it "should return the url that has a string parameter" do
+        expect(@api.send(:build_url, :MdsBatches, 'value')).
+          to eq("https://api-test.simpleltc.com/v1/MdsBatches/value")
+      end
+
+      it "should return the url that has multiple query parameters" do
+        expect(@api.send(:build_url, :MdsBatches, { a: 'aval', b: 'bval' })).
+          to eq("https://api-test.simpleltc.com/v1/MdsBatches?a=aval&b=bval")
+      end
+
+      it "should return the url that has a single query parameter" do
+        expect(@api.send(:build_url, :MdsBatches, { a: 'aval' })).
+          to eq("https://api-test.simpleltc.com/v1/MdsBatches?a=aval")
+      end
+
+      it "should return the url that has an empty hash of query parameters" do
+        expect(@api.send(:build_url, :MdsBatches, {})).
+          to eq("https://api-test.simpleltc.com/v1/MdsBatches")
+      end
+
+      it "should return the url that has a query parameter value that is a time" do
+        d = Time.now
+        dv = d.strftime("%Y-%m-%dT%H:%MZ")
+        expect(@api.send(:build_url, :MdsBatches, {d: d})).
+          to eq("https://api-test.simpleltc.com/v1/MdsBatches?d=#{dv}")
+        
+      end
+    end
+
+  end
+
+end