pvdgm_services 0.1.0

data/spec/roles/account_mapping_creator_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+
+describe Services::AccountMappingCreator do
+  let(:third_party) { Services::ThirdParty.new.tap { | tp | tp.extend Services::AccountMappingCreator } }
+
+  context '#create' do
+    
+    it "should create the account mapping and save it if is valid" do
+      params = {}
+
+      m_am = mock_model(Services::AccountMapping)
+      m_am.should_receive(:valid?).and_return(true)
+      m_am.should_receive(:save)
+
+      m_am_rel = double("AccountMappingRelationship")
+      m_am_rel.should_receive(:new).with(params).and_return(m_am)
+
+      third_party.should_receive(:account_mappings).and_return(m_am_rel)
+
+      expect(third_party.create(params)).to be(m_am)
+    end
+
+    it "should create the account mapping but not save it if is invalid" do
+      params = {}
+
+      m_am = mock_model(Services::AccountMapping)
+      m_am.should_receive(:valid?).and_return(false)
+      m_am.should_not_receive(:save)
+
+      m_am_rel = double("AccountMappingRelationship")
+      m_am_rel.should_receive(:new).with(params).and_return(m_am)
+
+      third_party.should_receive(:account_mappings).and_return(m_am_rel)
+
+      expect(third_party.create(params)).to be(m_am)
+    end
+
+  end
+
+end

data/spec/roles/account_mapping_updator_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe Services::AccountMappingUpdator do
+  let(:account_mapping) { Services::AccountMapping.new.tap { | am | am.extend Services::AccountMappingUpdator } }
+
+  context '#update' do
+
+    it "should update the AccountMapping object with the specified parameters" do
+      params = {}
+      account_mapping.should_receive(:update_attributes).with(params).and_return(account_mapping)
+      expect(account_mapping.update(params)).to be(account_mapping)
+    end
+
+  end
+
+end

data/spec/roles/configured_account_creator_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+
+describe Services::ConfiguredAccountCreator do
+  let(:service_definition) { Services::ThirdParty.new.tap { | tp | tp.extend Services::ConfiguredAccountCreator } }
+
+  context '#create' do
+    
+    it "should create the account mapping and save it if is valid" do
+      params = {}
+
+      m_am = mock_model(Services::ConfiguredAccount)
+      m_am.should_receive(:valid?).and_return(true)
+      m_am.should_receive(:save)
+
+      m_am_rel = double("ConfiguredAccountRelationship")
+      m_am_rel.should_receive(:new).with(params).and_return(m_am)
+
+      service_definition.should_receive(:configured_accounts).and_return(m_am_rel)
+
+      expect(service_definition.create(params)).to be(m_am)
+    end
+
+    it "should create the account mapping but not save it if is invalid" do
+      params = {}
+
+      m_am = mock_model(Services::ConfiguredAccount)
+      m_am.should_receive(:valid?).and_return(false)
+      m_am.should_not_receive(:save)
+
+      m_am_rel = double("ConfiguredAccountRelationship")
+      m_am_rel.should_receive(:new).with(params).and_return(m_am)
+
+      service_definition.should_receive(:configured_accounts).and_return(m_am_rel)
+
+      expect(service_definition.create(params)).to be(m_am)
+    end
+
+  end
+
+end

data/spec/roles/configured_account_updater_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe Services::ConfiguredAccountUpdater do
+  let(:configured_account) { Services::ConfiguredAccount.new.tap { | am | am.extend Services::ConfiguredAccountUpdater } }
+
+  context '#update' do
+
+    it "should update the ConfiguredAccount object with the specified parameters" do
+      params = {}
+      configured_account.should_receive(:update_attributes).with(params).and_return(configured_account)
+      expect(configured_account.update(params)).to be(configured_account)
+    end
+
+  end
+
+end

data/spec/roles/configured_facility_creator_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+
+describe Services::ConfiguredFacilityCreator do
+  let(:service_definition) { Services::ThirdParty.new.tap { | tp | tp.extend Services::ConfiguredFacilityCreator } }
+
+  context '#create' do
+    
+    it "should create the account mapping and save it if is valid" do
+      params = {}
+
+      m_am = mock_model(Services::ConfiguredFacility)
+      m_am.should_receive(:valid?).and_return(true)
+      m_am.should_receive(:save)
+
+      m_am_rel = double("ConfiguredFacilityRelationship")
+      m_am_rel.should_receive(:new).with(params).and_return(m_am)
+
+      service_definition.should_receive(:configured_facilities).and_return(m_am_rel)
+
+      expect(service_definition.create(params)).to be(m_am)
+    end
+
+    it "should create the account mapping but not save it if is invalid" do
+      params = {}
+
+      m_am = mock_model(Services::ConfiguredFacility)
+      m_am.should_receive(:valid?).and_return(false)
+      m_am.should_not_receive(:save)
+
+      m_am_rel = double("ConfiguredFacilityRelationship")
+      m_am_rel.should_receive(:new).with(params).and_return(m_am)
+
+      service_definition.should_receive(:configured_facilities).and_return(m_am_rel)
+
+      expect(service_definition.create(params)).to be(m_am)
+    end
+
+  end
+
+end

data/spec/roles/configured_facility_updater_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe Services::ConfiguredFacilityUpdater do
+  let(:configured_facility) { Services::ConfiguredFacility.new.tap { | am | am.extend Services::ConfiguredFacilityUpdater } }
+
+  context '#update' do
+
+    it "should update the ConfiguredFacility object with the specified parameters" do
+      params = {}
+      configured_facility.should_receive(:update_attributes).with(params).and_return(configured_facility)
+      expect(configured_facility.update(params)).to be(configured_facility)
+    end
+
+  end
+
+end

data/spec/roles/credential_creator_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe Services::CredentialCreator do
+  let(:configured_account) { Services::ConfiguredAccount.new.tap { | cred | cred.extend Services::CredentialCreator } }
+
+  context '#add_credential' do
+
+    it "should append a new credential set to credential" do
+      params = { token: 'abc123' }
+      
+      m_cred = mock_model(Services::Credential)
+
+      Services::Credential.should_receive(:new).with(params).and_return(m_cred)
+      
+      m_creds = double("Credentials")
+      m_creds.should_receive(:<<).with(m_cred)
+      configured_account.should_receive(:credentials).and_return(m_creds)
+
+      configured_account.add_credential(params)
+    end
+  end
+
+end

data/spec/roles/credential_updater_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+describe Services::CredentialUpdater do
+  let(:configured_account) { Services::ConfiguredAccount.new.tap { | ca | ca.extend Services::CredentialUpdater } }
+
+  context '#update_credential' do
+
+    it "should update existing credential if one already exists" do
+      params = { password: 'abc123' }
+
+      m_cred = mock_model(Services::Credential)
+      m_cred.should_receive(:update_attributes).with(params)
+
+      configured_account.should_receive(:credentials).and_return([ m_cred ])
+
+      configured_account.update_credential(params)
+    end
+
+    it "should create a new set of credentials if they don't already exist" do
+      params = { password: 'abc123' }
+
+      m_cred = mock_model(Services::Credential)
+      # m_cred.should_receive(:update_attributes).with(params)
+
+      Services::Credential.should_receive(:new).with(params).and_return(m_cred)
+
+      m_creds = double("Credentials")
+      m_creds.should_receive(:first).and_return(nil)
+      m_creds.should_receive(:<<).with(m_cred)
+
+      configured_account.should_receive(:credentials).exactly(2).times.and_return(m_creds)
+
+      configured_account.update_credential(params)
+    end
+
+  end
+
+end

data/spec/roles/facility_mapping_creator_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+
+describe Services::FacilityMappingCreator do
+  let(:third_party) { Services::ThirdParty.new.tap { | tp | tp.extend Services::FacilityMappingCreator } }
+
+  context '#create' do
+    
+    it "should create the facility mapping and save it if is valid" do
+      params = {}
+
+      m_am = mock_model(Services::FacilityMapping)
+      m_am.should_receive(:valid?).and_return(true)
+      m_am.should_receive(:save)
+
+      m_am_rel = double("FacilityMappingRelationship")
+      m_am_rel.should_receive(:new).with(params).and_return(m_am)
+
+      third_party.should_receive(:facility_mappings).and_return(m_am_rel)
+
+      expect(third_party.create(params)).to be(m_am)
+    end
+
+    it "should create the facility mapping but not save it if is invalid" do
+      params = {}
+
+      m_am = mock_model(Services::FacilityMapping)
+      m_am.should_receive(:valid?).and_return(false)
+      m_am.should_not_receive(:save)
+
+      m_am_rel = double("FacilityMappingRelationship")
+      m_am_rel.should_receive(:new).with(params).and_return(m_am)
+
+      third_party.should_receive(:facility_mappings).and_return(m_am_rel)
+
+      expect(third_party.create(params)).to be(m_am)
+    end
+
+  end
+
+end

data/spec/roles/facility_mapping_updater_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe Services::FacilityMappingUpdater do
+  let(:facility_mapping) { Services::FacilityMapping.new.tap { | am | am.extend Services::FacilityMappingUpdater } }
+
+  context '#update' do
+
+    it "should update the FacilityMapping object with the specified parameters" do
+      params = {}
+      facility_mapping.should_receive(:update_attributes).with(params).and_return(facility_mapping)
+      expect(facility_mapping.update(params)).to be(facility_mapping)
+    end
+
+  end
+
+end

data/spec/roles/hl7_adt_message_saver_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+describe Services::Hl7AdtMessageSaver do
+  let(:context) { Object.new.tap { |context| context.extend Services::Hl7AdtMessageSaver } }
+
+  context '#persist' do
+
+    it "should save the message if it is valid" do
+      m_msg = mock_model(Services::Hl7Message)
+      m_msg.should_receive(:message_type=).with('A01')
+      m_msg.should_receive(:message=).with('message body')
+      m_msg.should_receive(:valid?).and_return(true)
+      m_msg.should_receive(:save)
+
+      Services::Hl7Message.should_receive(:new).and_return(m_msg)
+
+      expect(context.persist('A01', 'message body')).to be(m_msg)
+    end
+
+    it "should not save the message if it is valid" do
+      m_msg = mock_model(Services::Hl7Message)
+      m_msg.should_receive(:message_type=).with(nil)
+      m_msg.should_receive(:message=).with('message body')
+      m_msg.should_receive(:valid?).and_return(false)
+      m_msg.should_not_receive(:save)
+
+      Services::Hl7Message.should_receive(:new).and_return(m_msg)
+
+      expect(context.persist(nil, 'message body')).to be(m_msg)
+    end
+
+  end
+  
+
+end

data/spec/roles/hl7_message_trimmer_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+describe Services::Hl7MessageTrimmer do
+
+  it "will not delete HL7 Messages that are newer than 30 days regardless of status" do
+    # Create HL7 messages with each status and verify they don't get deleted
+    Services::Hl7Message.create(status: Services::Hl7Message::STATUS_RECEIVED, message_type: 'A08')
+    Services::Hl7Message.create(status: Services::Hl7Message::STATUS_PROCESSED, message_type: 'A08')
+    Services::Hl7Message.create(status: Services::Hl7Message::STATUS_ERRORED, message_type: 'A08')
+
+    Services::Hl7MessageTrimmingContext.call
+
+    expect(Services::Hl7Message.count).to be(3)
+  end
+
+  it "will delete all processed HL7 messages older than 30 days" do
+    m1 = Services::Hl7Message.create(status: Services::Hl7Message::STATUS_RECEIVED, message_type: 'A08')
+    m2 = Services::Hl7Message.create(status: Services::Hl7Message::STATUS_PROCESSED, message_type: 'A08')
+    m3 = Services::Hl7Message.create(status: Services::Hl7Message::STATUS_ERRORED, message_type: 'A08')
+
+    m1.update_attribute(:updated_at, Time.now - 31.days)
+    m2.update_attribute(:updated_at, Time.now - 31.days)
+    m3.update_attribute(:updated_at, Time.now - 31.days)
+
+    Services::Hl7MessageTrimmingContext.call
+
+    expect(Services::Hl7Message.count).to be(2)
+    expect(Services::Hl7Message.where(id: m2.id).count).to be(0)
+  end
+
+end

data/spec/roles/monthly_service_table_cleaner_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+describe Services::MonthlyServiceTableCleaner do
+  let(:context) { Object.new.tap { | context | context.extend Services::MonthlyServiceTableCleaner } }
+
+  context '#where_clause' do
+
+    it "should_return a where clause with a status filter set" do
+      expect(context.send(:where_clause, 3)).to eq("DATEDIFF(CURRENT_DATE, created_at) > 30 AND status = 3")
+    end
+
+  end
+
+  context '#clean_up_service_tables' do
+
+    it "should clean up the assessment_requests, available_files and mds_pull_accounts tables" do
+      Services::AssessmentRequest.should_receive(:destroy_all).with("DATEDIFF(CURRENT_DATE, created_at) > 30 AND status = #{Services::AssessmentRequest::STATUS_COMPLETED}")
+      Services::AvailableFile.should_receive(:destroy_all).with("DATEDIFF(CURRENT_DATE, created_at) > 30 AND status = #{Services::AvailableFile::STATUS_CLEARED}")
+      Services::MdsPullAccount.should_receive(:destroy_all).with("DATEDIFF(CURRENT_DATE, created_at) > 30 AND status = #{Services::MdsPullAccount::STATUS_REMOTE_CLEAN}")
+
+      context.clean_up_service_tables
+    end
+
+  end
+  
+
+end

data/spec/roles/new_registration_notifier_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+describe Services::NewRegistrationNotifier do
+  let(:registration) { Services::SltcRegistration.new.tap { | reg | reg.extend Services::NewRegistrationNotifier } }
+
+  context '#notify' do
+
+    it "should send an email out" do
+      m_notification = double("MailerNotification")
+      m_notification.should_receive(:deliver)
+
+      ServicesMailer.should_receive(:notify_sltc_client_registration).with(registration).and_return(m_notification)
+
+      registration.notify
+    end
+
+  end
+end

data/spec/roles/service_ceator_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+describe Services::ServiceCreator do
+  let(:context) { Object.new.tap { | tp | tp.extend Services::ServiceCreator } }
+
+  context '#create' do
+    
+    it "should create the service and save it if is valid" do
+      params = {}
+
+      m_svc = mock_model(Services::Service)
+      m_svc.should_receive(:valid?).and_return(true)
+      m_svc.should_receive(:save)
+
+      Services::Service.should_receive(:new).with(params).and_return(m_svc)
+
+      expect(context.create(params)).to be(m_svc)
+    end
+
+    it "should create the service but not save it if is invalid" do
+      params = {}
+
+      m_svc = mock_model(Services::Service)
+      m_svc.should_receive(:valid?).and_return(false)
+      m_svc.should_not_receive(:save)
+
+      Services::Service.should_receive(:new).with(params).and_return(m_svc)
+
+      expect(context.create(params)).to be(m_svc)
+    end
+
+  end
+
+end

data/spec/roles/service_definition_creator_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+
+describe Services::ServiceDefinitionCreator do
+  let(:third_party) { Services::ThirdParty.new.tap { | tp | tp.extend Services::ServiceDefinitionCreator } }
+
+  context '#create' do
+    
+    it "should create the service definition and save it if is valid" do
+      params = {}
+
+      m_sd = mock_model(Services::ServiceDefinition)
+      m_sd.should_receive(:valid?).and_return(true)
+      m_sd.should_receive(:save)
+
+      m_sd_rel = double("ServiceDefinitionRelationship")
+      m_sd_rel.should_receive(:new).with(params).and_return(m_sd)
+
+      third_party.should_receive(:service_definitions).and_return(m_sd_rel)
+
+      expect(third_party.create(params)).to be(m_sd)
+    end
+
+    it "should create the service definition but not save it if is invalid" do
+      params = {}
+
+      m_sd = mock_model(Services::ServiceDefinition)
+      m_sd.should_receive(:valid?).and_return(false)
+      m_sd.should_not_receive(:save)
+
+      m_sd_rel = double("ServiceDefinitionRelationship")
+      m_sd_rel.should_receive(:new).with(params).and_return(m_sd)
+
+      third_party.should_receive(:service_definitions).and_return(m_sd_rel)
+
+      expect(third_party.create(params)).to be(m_sd)
+    end
+
+  end
+
+end

data/spec/roles/service_definition_updater_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe Services::ServiceDefinitionUpdater do
+  let(:service_definition) { Services::ServiceDefinition.new.tap { | am | am.extend Services::ServiceDefinitionUpdater } }
+
+  context '#update' do
+
+    it "should update the ServiceDefinition object with the specified parameters" do
+      params = {}
+      service_definition.should_receive(:update_attributes).with(params).and_return(service_definition)
+      expect(service_definition.update(params)).to be(service_definition)
+    end
+
+  end
+
+end

data/spec/roles/service_invoker_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+describe Services::ServiceInvoker do
+  let(:service) { Services::Service.new.tap { | svc | svc.extend Services::ServiceInvoker } }
+  
+  context '#invoke' do
+
+    it "should invoke the service for each service definition owned by the service" do
+
+      m_sd1 = mock_model(Services::ServiceDefinition)
+      m_sd1.should_receive(:ayl_send_opts).with(:invoke, priority: 100, time_to_run: 3600)
+      m_sd2 = mock_model(Services::ServiceDefinition)
+      m_sd2.should_receive(:ayl_send_opts).with(:invoke, priority: 100, time_to_run: 3600)
+
+      service.should_receive(:service_definitions).and_return([ m_sd1, m_sd2 ])
+
+      service.invoke
+    end
+
+  end
+
+end

data/spec/roles/service_updater_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+describe Services::ServiceUpdater do
+  let(:service) { Services::Service.new.tap { | svc | svc.extend Services::ServiceUpdater } }
+  
+  context '#update' do
+
+    it "should update the attributes of the services from the parameters" do
+      params = { name: 'the service' }
+
+      service.should_receive(:update_attributes).with(params)
+
+      expect(service.update(params)).to be(service)
+    end
+
+  end
+end

data/spec/roles/sltc_baseline_requestor_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+describe Services::SltcBaselineRequestor do
+  let(:configured_account) { Services::ConfiguredAccount.new.tap { | ca | ca.extend Services::SltcBaselineRequestor } }
+  
+  context'#request_baseline_params' do
+
+    it "should request a baseline from SLTC" do
+      params = {
+        provider_id: 9,
+        uploaded_before: '2013-11-10',
+        uploaded_after: '2013-10-10'
+      }
+
+      m_si = double("ServiceImplementation")
+      m_si.
+        should_receive(:request_baseline).
+        with(configured_account, 9, Time.parse(params[:uploaded_after]), Time.parse(params[:uploaded_before]))
+
+      m_sd = mock_model(Services::ServiceDefinition)
+      m_sd.should_receive(:service_implementation).and_return(m_si)
+
+      configured_account.should_receive(:service_definition).and_return(m_sd)
+
+      configured_account.request_baseline(params)
+    end
+    
+  end
+
+end

data/spec/roles/sltc_provider_lister_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+describe Services::SltcProviderLister do
+  let(:configured_account) { Services::ConfiguredAccount.new.tap { | ca | ca.extend Services::SltcProviderLister } }
+
+  context '#list_providers' do
+
+    it "should request the list of providers for the configured account from SLTC" do
+      provider_list = [ { 'id' => 9, 'name' => 'facility' } ]
+
+      m_api = double("SltcApi")
+      m_api.should_receive(:list_providers).and_return(provider_list)
+
+      m_si = double("ServiceImplementation")
+      m_si.should_receive(:api_impl).with(configured_account).and_return(m_api)
+
+      m_sd = mock_model(Services::ServiceDefinition)
+      m_sd.should_receive(:service_implementation).and_return(m_si)
+
+      configured_account.should_receive(:service_definition).and_return(m_sd)
+      
+      expect(configured_account.list_providers).to eq(provider_list)
+    end
+
+  end
+
+end