pvdgm_services 0.1.0

data/spec/models/mds_pull_account_spec.rb

@@ -0,0 +1,468 @@
+require 'spec_helper'
+
+describe Services::MdsPullAccount do
+
+  before(:each) do
+    @mds_pull_account = Services::MdsPullAccount.new
+    @mds_pull_account.stub(:to_rrepr).and_return("")
+  end
+
+  context 'Public Methods' do
+
+    context '#process' do
+
+      before(:each) do
+        mock_ca = mock_model(Services::ConfiguredAccount)
+        mock_ca.stub(:to_rrepr).and_return("")
+        
+        @mds_pull_account.configured_account = mock_ca
+      end
+
+      it "should attempt to walk through all possible statuses in order to process the account" do
+        @mds_pull_account.should_receive(:update_attribute).with(:attempt, 1)
+
+        @mds_pull_account.should_receive(:perform_task).with(Services::MdsPullAccount::STATUS_NEW)
+        @mds_pull_account.should_receive(:perform_task).with(Services::MdsPullAccount::STATUS_PROVIDERS_IDENTIFIED)
+        @mds_pull_account.should_receive(:perform_task).with(Services::MdsPullAccount::STATUS_ASSESSMENTS_REQUESTED)
+        @mds_pull_account.should_receive(:perform_task).with(Services::MdsPullAccount::STATUS_FILES_IDENTIFIED)
+        @mds_pull_account.should_receive(:perform_task).with(Services::MdsPullAccount::STATUS_FILES_DOWNLOADED)
+        @mds_pull_account.should_receive(:perform_task).with(Services::MdsPullAccount::STATUS_SUBMITTED_TO_ABAQIS)
+        @mds_pull_account.should_receive(:perform_task).with(Services::MdsPullAccount::STATUS_FILE_SYSTEM_CLEAN)
+        @mds_pull_account.should_receive(:perform_task).with(Services::MdsPullAccount::STATUS_REMOTE_CLEAN)
+
+        @mds_pull_account.process
+      end
+
+      it "should delay the job if the attempt number is not evenly divisible by 3" do
+        @mds_pull_account.should_receive(:perform_task).with(Services::MdsPullAccount::STATUS_NEW).and_raise("Failed to list files")
+        @mds_pull_account.should_receive(:update_attribute)
+        @mds_pull_account.stub(:attempt).and_return(0, 1)
+
+        ServicesMailer.should_receive(:delaying_job).with(@mds_pull_account).and_return do
+          double("MailMessage").tap do | mail_message |
+            mail_message.should_receive(:deliver)
+          end
+        end
+        
+        expect { @mds_pull_account.process }.to raise_error(Ayl::Beanstalk::RequiresJobDecay)
+      end
+
+      it "should bury the job if the attempt number if evenly divisible by 3" do
+        @mds_pull_account.should_receive(:perform_task).exactly(3).times.with(Services::MdsPullAccount::STATUS_NEW).and_raise("Failed to list files")
+
+        @mds_pull_account.should_receive(:update_attribute).exactly(3).times
+        @mds_pull_account.stub(:attempt).and_return(0, 1, 1, 2, 2, 3, 3)
+
+        ServicesMailer.should_receive(:delaying_job).with(@mds_pull_account).exactly(2).times.and_return do
+          double("MailMessage").tap do | mail_message |
+            mail_message.should_receive(:deliver)
+          end
+        end
+        
+        ServicesMailer.should_receive(:burying_job).with(@mds_pull_account).and_return do
+          double("MailMessage").tap do | mail_message |
+            mail_message.should_receive(:deliver)
+          end
+        end
+
+        # Attempt #1
+        expect { @mds_pull_account.process }.to raise_error(Ayl::Beanstalk::RequiresJobDecay)
+        # Attempt #2
+        expect { @mds_pull_account.process }.to raise_error(Ayl::Beanstalk::RequiresJobDecay)
+        # Attempt #3
+        expect { @mds_pull_account.process }.to raise_error(Ayl::Beanstalk::RequiresJobBury)
+      end
+
+    end
+
+  end
+
+  context 'Private Methods' do
+
+    context '#service_impl' do
+
+      it "should return the instantiate service implementation class" do
+        mock_service_implementation = double("ServiceImplementation")
+
+        mock_service_definition = double("ServiceDefinition")
+        mock_service_definition.should_receive(:service_implementation).and_return(mock_service_implementation)
+
+        @mds_pull_account.should_receive(:service_definition).and_return(mock_service_definition)
+
+        expect(@mds_pull_account.send(:service_impl)).to be(mock_service_implementation)
+      end
+
+      it "should cache and return the instantiate service implementation class" do
+        mock_service_implementation = double("ServiceImplementation")
+
+        mock_service_definition = double("ServiceDefinition")
+        mock_service_definition.should_receive(:service_implementation).and_return(mock_service_implementation)
+
+        @mds_pull_account.should_receive(:service_definition).and_return(mock_service_definition)
+
+        expect(@mds_pull_account.send(:service_impl)).to be(mock_service_implementation)
+
+        # The second time shouldn't fire the mocks above.
+        expect(@mds_pull_account.send(:service_impl)).to be(mock_service_implementation)
+      end
+
+    end
+
+    context '#perform_task' do
+
+      it "should do nothing if the specified status doesn't match the status of the model" do
+
+        @mds_pull_account.status = Services::MdsPullAccount::STATUS_NEW
+        @mds_pull_account.should_not_receive(:send).with(Services::MdsPullAccount::STATE_MACHINE[Services::MdsPullAccount::STATUS_FILES_IDENTIFIED])
+        @mds_pull_account.should_not_receive(:update_attribute)
+
+        @mds_pull_account.send(:perform_task, Services::MdsPullAccount::STATUS_FILES_IDENTIFIED)
+
+      end
+      
+      it "should invoke ':identify_providers' if the status is STATUS_NEW and - if successful, update status to STATUS_PROVIDERS_IDENTIFIED" do
+        @mds_pull_account.status = Services::MdsPullAccount::STATUS_NEW
+        @mds_pull_account.should_receive(:identify_providers)
+        @mds_pull_account.should_receive(:update_attribute).with(:status, Services::MdsPullAccount::STATUS_PROVIDERS_IDENTIFIED)
+
+        @mds_pull_account.send(:perform_task, Services::MdsPullAccount::STATUS_NEW)
+      end
+
+      it "should invoke ':request_assessments_to_process' if the status is STATUS_PROVIDERS_IDENTIFIED and - if successful, update status to STATUS_ASSESSMENTS_REQUESTED" do
+        @mds_pull_account.status = Services::MdsPullAccount::STATUS_PROVIDERS_IDENTIFIED
+        @mds_pull_account.should_receive(:request_assessments_to_process)
+        @mds_pull_account.should_receive(:update_attribute).with(:status, Services::MdsPullAccount::STATUS_ASSESSMENTS_REQUESTED)
+
+        @mds_pull_account.send(:perform_task, Services::MdsPullAccount::STATUS_PROVIDERS_IDENTIFIED)
+      end
+
+      it "should invoke ':identify_files_to_pull' if the status is STATUS_ASSESSMENTS_REQUESTED and - if successful update status to STATUS_FILES_IDENTIFIED" do
+        @mds_pull_account.status = Services::MdsPullAccount::STATUS_ASSESSMENTS_REQUESTED
+        @mds_pull_account.should_receive(:identify_files_to_pull)
+        @mds_pull_account.should_receive(:update_attribute).with(:status, Services::MdsPullAccount::STATUS_FILES_IDENTIFIED)
+
+        @mds_pull_account.send(:perform_task, Services::MdsPullAccount::STATUS_ASSESSMENTS_REQUESTED)
+      end
+
+      it "should invoke ':download_files' if the status is STATUS_FILES_IDENTIFIED and - if successful update status to STATUS_FILES_DOWNLOADED" do
+        @mds_pull_account.status = Services::MdsPullAccount::STATUS_FILES_IDENTIFIED
+        @mds_pull_account.should_receive(:download_files)
+        @mds_pull_account.should_receive(:update_attribute).with(:status, Services::MdsPullAccount::STATUS_FILES_DOWNLOADED)
+
+        @mds_pull_account.send(:perform_task, Services::MdsPullAccount::STATUS_FILES_IDENTIFIED)
+      end
+
+      it "should invoke ':submit_files_to_abaqis' if the status is STATUS_FILES_DOWNLOADED and - if successful update status to STATUS_SUBMITTED_TO_ABAQIS" do
+        @mds_pull_account.status = Services::MdsPullAccount::STATUS_FILES_DOWNLOADED
+        @mds_pull_account.should_receive(:submit_files_to_abaqis)
+        @mds_pull_account.should_receive(:update_attribute).with(:status, Services::MdsPullAccount::STATUS_SUBMITTED_TO_ABAQIS)
+
+        @mds_pull_account.send(:perform_task, Services::MdsPullAccount::STATUS_FILES_DOWNLOADED)
+      end
+
+      it "should invoke ':clean_up_file_system' if the status is STATUS_SUBMITTED_TO_ABAQIS and - if successful update status to STATUS_FILE_SYSTEM_CLEAN" do
+        @mds_pull_account.status = Services::MdsPullAccount::STATUS_SUBMITTED_TO_ABAQIS
+        @mds_pull_account.should_receive(:clean_up_file_system)
+        @mds_pull_account.should_receive(:update_attribute).with(:status, Services::MdsPullAccount::STATUS_FILE_SYSTEM_CLEAN)
+
+        @mds_pull_account.send(:perform_task, Services::MdsPullAccount::STATUS_SUBMITTED_TO_ABAQIS)
+      end
+
+      it "should invoke ':clean_up_remote_server' if the status is STATUS_FILE_SYSTEM_CLEAN and - if successful update status to STATUS_REMOTE_CLEAN" do
+        @mds_pull_account.status = Services::MdsPullAccount::STATUS_FILE_SYSTEM_CLEAN
+        @mds_pull_account.should_receive(:clean_up_remote_server)
+        @mds_pull_account.should_receive(:update_attribute).with(:status, Services::MdsPullAccount::STATUS_REMOTE_CLEAN)
+
+        @mds_pull_account.send(:perform_task, Services::MdsPullAccount::STATUS_FILE_SYSTEM_CLEAN)
+      end
+
+      it "should do nothing if the specified status is STATUS_REMOTE_CLEAN and the current status is STATUS_REMOTE_CLEAN" do
+        @mds_pull_account.status = Services::MdsPullAccount::STATUS_REMOTE_CLEAN
+        @mds_pull_account.should_not_receive(:update_attribute)
+
+        @mds_pull_account.send(:perform_task, Services::MdsPullAccount::STATUS_REMOTE_CLEAN)
+      end
+
+      it "should not update the status if the method raises an exception" do
+        ex = Exception.new
+        @mds_pull_account.status = Services::MdsPullAccount::STATUS_NEW
+        @mds_pull_account.should_receive(:identify_providers).and_raise(ex)
+        @mds_pull_account.should_not_receive(:update_attribute)
+
+        expect { @mds_pull_account.send(:perform_task, Services::MdsPullAccount::STATUS_NEW) }.to raise_error(ex)
+
+      end
+
+    end
+
+    context '#perform_cleanup_on_remote_server' do
+
+      it "should invoke the cleanup on the service implementation class" do
+        mock_ca = mock_model(Services::ConfiguredAccount)
+        @mds_pull_account.configured_account = mock_ca
+
+        mock_service_impl = double("ServiceImplementation")
+        mock_service_impl.should_receive(:perform_cleanup_on_remote_server).with(mock_ca).and_return([ 1, 2, 3 ])
+
+        @mds_pull_account.should_receive(:service_impl).and_return(mock_service_impl)
+
+        expect(@mds_pull_account.send(:perform_cleanup_on_remote_server)).to eq([ 1, 2, 3 ])
+      end
+
+    end
+
+    context '#clean_up_remote_server' do
+
+      before(:each) do
+        mock_ca = mock_model(Services::ConfiguredAccount)
+        mock_ca.stub(:to_rrepr).and_return("")
+        @mds_pull_account.configured_account = mock_ca
+      end
+
+      it "should not update any AvailableFile statuses if no files have been cleared" do
+        @mds_pull_account.should_receive(:perform_cleanup_on_remote_server).and_return([])
+        
+        Services::AvailableFile.should_not_receive(:update_all)
+
+        @mds_pull_account.send(:clean_up_remote_server)
+      end
+
+      it "should update all the AvailableFile records that match the id's returned from the implementation" do
+        @mds_pull_account.should_receive(:perform_cleanup_on_remote_server).and_return([1,2,3])
+
+        Services::AvailableFile.should_receive(:where).with("id IN (1,2,3)").and_return do
+          double("WhereAvailableFiles").tap do | waf |
+            waf.should_receive(:update_all).with("status = '#{Services::AvailableFile::STATUS_CLEARED}'")
+          end
+        end
+        
+        @mds_pull_account.send(:clean_up_remote_server)
+      end
+
+    end
+
+    context '#clean_up_file_system' do
+
+      before(:each) do
+        @mock_sd = mock_model(Services::ServiceDefinition)
+
+        @mock_ca = mock_model(Services::ConfiguredAccount)
+        @mock_ca.stub(:to_rrepr).and_return("")
+        @mds_pull_account.configured_account = @mock_ca
+        @mds_pull_account.stub(:service_definition).and_return(@mock_sd)
+      end
+
+      it "shouldn't do much of anything if there are no files to be cleaned up" do
+        @mock_ca.should_receive(:available_files).and_return do 
+          double("AvailableFiles").tap do | available_files |
+            available_files.should_receive(:uploaded).and_return([])
+          end
+        end
+        @mds_pull_account.should_not_receive(:rm_rf)
+        @mds_pull_account.send(:clean_up_file_system)
+      end
+
+      it "should remove the file and update the status of the file as appropriate" do
+        mock_af = mock_model(Services::AvailableFile)
+        mock_af.should_receive(:download_path).and_return("/tmp/afile")
+        mock_af.should_receive(:update_attribute).with(:status, Services::AvailableFile::STATUS_DELETED)
+
+        @mock_ca.should_receive(:available_files).and_return do 
+          double("AvailableFiles").tap do | available_files |
+            available_files.should_receive(:uploaded).and_return([ mock_af ])
+          end
+        end
+        @mds_pull_account.should_receive(:rm_rf).with("/tmp/afile")
+        @mds_pull_account.send(:clean_up_file_system)
+      end
+
+    end
+
+    context '#submit_files_to_abaqis' do
+
+      before(:each) do
+        @mock_sd = mock_model(Services::ServiceDefinition)
+
+        @mock_ca = mock_model(Services::ConfiguredAccount)
+        @mock_ca.stub(:to_rrepr).and_return("")
+        @mds_pull_account.configured_account = @mock_ca
+        @mds_pull_account.stub(:service_definition).and_return(@mock_sd)
+      end
+
+      it "should not attempt to push any MDS files to abaqis if none are available" do
+        mock_mds_push = double("MdsPush")
+        mock_mds_push.should_not_receive(:push_mds_file)
+        Services::AbaqisMdsPush.should_receive(:service_impl).and_return(mock_mds_push)
+
+        @mock_ca.should_receive(:available_files).and_return do 
+          double("AvailableFiles").tap do | available_files |
+            available_files.should_receive(:downloaded).and_return([])
+          end
+        end
+        
+        @mds_pull_account.send(:submit_files_to_abaqis)
+      end
+
+      it "should attempt to push the MDS file to abaqis" do
+        mock_af = mock_model(Services::AvailableFile)
+
+        mock_mds_push = double("MdsPush")
+        mock_mds_push.should_receive(:push_mds_file).with(mock_af)
+        Services::AbaqisMdsPush.should_receive(:service_impl).and_return(mock_mds_push)
+
+        @mock_ca.should_receive(:available_files).and_return do 
+          double("AvailableFiles").tap do | available_files |
+            available_files.should_receive(:downloaded).and_return([ mock_af ])
+          end
+        end
+        
+        @mds_pull_account.send(:submit_files_to_abaqis)
+      end
+
+      it "should capture a failure to submit to abaqis" do
+        ex = Exception.new("Failed to submit")
+
+        mock_af = mock_model(Services::AvailableFile)
+        mock_af.should_receive(:update_attribute).with(:error, "Error pushing file to abaqis: #{ex.message}")
+        mock_af.stub(:to_rrepr).and_return("")
+
+        mock_mds_push = double("MdsPush")
+        mock_mds_push.should_receive(:push_mds_file).with(mock_af).and_raise(ex)
+        Services::AbaqisMdsPush.should_receive(:service_impl).and_return(mock_mds_push)
+
+        @mock_ca.should_receive(:available_files).and_return do 
+          double("AvailableFiles").tap do | available_files |
+            available_files.should_receive(:downloaded).and_return([ mock_af ])
+          end
+        end
+        
+        @mds_pull_account.send(:submit_files_to_abaqis)
+      end
+
+    end
+
+    context '#perform_file_downloads' do
+
+      it "should invoke the implementation's :perform_file_downloads method" do
+        mock_af = mock_model(Services::AvailableFile)
+
+        mock_ca = mock_model(Services::ConfiguredAccount)
+        @mds_pull_account.configured_account = mock_ca
+
+        mock_si = double("ServiceImplementation")
+        mock_si.should_receive(:perform_file_downloads).with(mock_ca, [ mock_af ]).and_return([ 1 ])
+        @mds_pull_account.should_receive(:service_impl).and_return(mock_si)
+
+        expect(@mds_pull_account.send(:perform_file_downloads, [ mock_af ])).to eq([ 1 ])
+      end
+
+    end
+
+    context '#download_files' do
+      
+      before(:each) do
+        @mock_sd = mock_model(Services::ServiceDefinition)
+
+        @mock_ca = mock_model(Services::ConfiguredAccount)
+        @mock_ca.stub(:to_rrepr).and_return("")
+        @mds_pull_account.configured_account = @mock_ca
+        @mds_pull_account.stub(:service_definition).and_return(@mock_sd)
+      end
+
+      it "should do nothing if there are no files downloaded" do
+        @mock_ca.should_receive(:available_files).and_return do
+          double("AvailableFiles").tap do | available_files |
+            available_files.should_receive(:available).and_return([])
+          end
+        end
+
+        @mds_pull_account.should_receive(:perform_file_downloads).with([]).and_return([])
+
+        Services::AvailableFile.should_not_receive(:update_all)
+
+        @mds_pull_account.send(:download_files)
+      end
+
+      it "should update the status of the files that were downloaded" do
+        mock_af = mock_model(Services::AvailableFile)
+
+        @mock_ca.should_receive(:available_files).and_return do
+          double("AvailableFiles").tap do | available_files |
+            available_files.should_receive(:available).and_return([ mock_af ])
+          end
+        end
+
+        @mds_pull_account.should_receive(:perform_file_downloads).with([ mock_af ]).and_return([ mock_af.id ])
+
+        Services::AvailableFile.should_receive(:where).with("id IN (#{mock_af.id})").and_return do
+          double("AvailableFilesWhere").tap do | afw |
+            afw.should_receive(:update_all).with("status = '#{Services::AvailableFile::STATUS_DOWNLOADED}', downloaded_at = '#{Time.now.strftime("%Y-%m-%d %H:%M:%S")}'")
+          end
+        end
+
+        @mds_pull_account.send(:download_files)
+      end
+
+    end
+
+    context '#list_available_files' do
+
+      it "should invoke the implementation's :list_available_files method" do
+        mock_ca = mock_model(Services::ConfiguredAccount)
+        @mds_pull_account.configured_account = mock_ca
+
+        mock_si = double("ServiceImplementation")
+        mock_si.should_receive(:list_available_files).with(mock_ca).and_return([ [ '123', 'the_file.zip' ] ])
+        @mds_pull_account.should_receive(:service_impl).and_return(mock_si)
+
+        expect(@mds_pull_account.send(:list_available_files)).to eq([ [ '123', 'the_file.zip' ] ])
+      end
+
+    end
+
+    context '#identify_files_to_pull' do
+
+      before(:each) do
+        @mock_sd = mock_model(Services::ServiceDefinition)
+
+        @mock_ca = mock_model(Services::ConfiguredAccount)
+        @mock_ca.stub(:to_rrepr).and_return("")
+        @mds_pull_account.configured_account = @mock_ca
+        @mds_pull_account.stub(:service_definition).and_return(@mock_sd)
+      end
+
+      it "should do nothing if there are no files to pull" do
+        @mds_pull_account.should_receive(:list_available_files).and_return([])
+
+        @mock_sd.should_not_receive(:available_files)
+
+        @mds_pull_account.send(:identify_files_to_pull)
+      end
+
+      it "should create an available file record for each file identified by the server" do
+        @mds_pull_account.should_receive(:list_available_files).and_return([ [ '1234', 'thefile' ], [ '2345', 'anotherfile', true ] ])
+
+        @mock_ca.should_receive(:available_files).and_return do
+          double("AvailableFiles").tap do | available_files |
+            available_files.should_receive(:create).with(request_id: '1234',
+                                                         filename: 'thefile',
+                                                         status: Services::AvailableFile::STATUS_AVAILABLE)
+          end
+        end
+
+        @mock_ca.should_receive(:available_files).and_return do
+          double("AvailableFiles").tap do | available_files |
+            available_files.should_receive(:create).with(request_id: '2345',
+                                                         filename: 'anotherfile',
+                                                         status: Services::AvailableFile::STATUS_AVAILABLE)
+          end
+        end
+
+        @mds_pull_account.send(:identify_files_to_pull)
+      end
+
+    end
+
+  end
+
+end

data/spec/models/mds_pull_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+
+describe Services::MdsPull do
+
+  before(:each) do
+    @mock_service_definition = double("ServiceDefinition")
+
+    @mds_pull = Services::MdsPull.new(@mock_service_definition)
+
+    Time.stub(:yesterday_at_midnight_mountain).and_return(Time.now)
+    Time.stub(:today_at_midnight_mountain).and_return(Time.now)
+  end
+
+  context '#invoke' do
+
+    it "should do nothing if there are no enabled accounts configured for this service" do
+      @mock_service_definition.should_receive(:configured_accounts).and_return do
+        double("ConfiguredAccounts").tap do | configured_accounts |
+          configured_accounts.should_receive(:enabled).and_return([])
+        end
+      end
+
+      Services::MdsPullAccount.should_not_receive(:create!)
+
+      @mds_pull.invoke
+    end
+
+    it "should create an MdsPullAccount record for each enabled account configured for the service and submitt the account to async for processing" do
+      mock_configured_account = double("ConfiguredAccount")
+
+      @mock_service_definition.should_receive(:configured_accounts).and_return do
+        double("ConfiguredAccounts").tap do | configured_accounts |
+          configured_accounts.should_receive(:enabled).and_return([ mock_configured_account ])
+        end
+      end
+
+      mock_pull_account = double("MdsPullAccount")
+      mock_pull_account.should_receive(:ayl_send_opts).with(:process, { :priority => 100, :time_to_run => 3600 })
+
+      Services::MdsPullAccount.should_receive(:create!).and_return(mock_pull_account)
+
+      @mds_pull.invoke
+      
+    end
+
+  end
+
+end

data/spec/models/mds_push_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+describe Services::MdsPush do
+
+  context 'Instance Methods' do
+    before(:each) do
+      @service_definition = double("ServiceDefinition")
+      @mds_push = Services::MdsPush.new(@service_definition)
+    end
+
+    context '#invoke' do
+
+    end
+
+    context '#push_mds_file' do
+
+      it "should raise an exception if the downloaded file doesn't exist" do
+        mock_af = double("AvailableFile")
+        mock_af.should_receive(:downloaded_file_exists?).and_return(false)
+        mock_af.should_receive(:downloaded_file_path).and_return('/tmp')
+
+        expect { @mds_push.push_mds_file(mock_af) }.to raise_error
+      end
+
+      it "should raise an exception if the downloaded file is not valid" do
+        mock_af = double("AvailableFile")
+        mock_af.should_receive(:downloaded_file_exists?).and_return(true)
+        mock_af.should_receive(:valid_mds_file?).and_return(false)
+        mock_af.should_receive(:downloaded_file_path).and_return('/tmp')
+
+        expect { @mds_push.push_mds_file(mock_af) }.to raise_error
+      end
+
+    end
+
+  end
+
+  context 'Class Methods' do
+
+
+  end
+
+end

data/spec/models/mds_ws_response_spec.rb

@@ -0,0 +1,54 @@
+require 'spec_helper'
+
+describe Services::MdsWsResponse do
+
+  context '.parse_xml_response' do
+
+    success_response = <<-EOF
+<composite_file_response>
+  <status>SUCCESS</status>
+  <filename>CMP_6MB.zip</filename>
+  <acknowledgement_id>MDS30cu0000000000002</acknowledgement_id>
+  <submission_datetime>2/22/2012 13:12:36</submission_datetime>
+</composite_file_response>
+EOF
+
+    error_response = <<-EOF
+<composite_file_response>
+  <status>ERROR</status>
+  <error_message>Authentication failed for 2.</error_message>
+  <submission_datetime>2/22/2012 12:55:15</submission_datetime>
+</composite_file_response>
+EOF
+
+    invalid_response = <<-EOF
+A day in the life
+EOF
+
+    it "should successfully parse a success response xml" do
+      response = Services::MdsWsResponse.parse_xml_response(success_response)
+      
+      response.status.should == 'SUCCESS'
+      response.error_message.should be_nil
+      response.filename.should == 'CMP_6MB.zip'
+      response.acknowledgement_id.should == 'MDS30cu0000000000002'
+      response.submission_datetime.should == '2/22/2012 13:12:36'
+    end
+
+    it "should successfully parse an error response xml" do
+      response = Services::MdsWsResponse.parse_xml_response(error_response)
+      
+      response.status.should == 'ERROR'
+      response.error_message.should == 'Authentication failed for 2.'
+      response.filename.should be_nil
+      response.acknowledgement_id.should be_nil
+      response.submission_datetime.should == '2/22/2012 12:55:15'
+    end
+
+    it "should raise an exception if non-valid XML is provided to parse" do
+      lambda { Services::MdsWsResponse.parse_xml_response(invalid_response) }.should raise_error
+    end
+
+  end
+
+end