allscripts_unity_client 4.0.1 → 5.0.0.pre.alpha

data/spec/support/factory_bot.rb

@@ -1,10 +0,0 @@
-# Include all factories
-FactoryBot.find_definitions
-
-RSpec.configure do |config|
-  config.include FactoryBot::Syntax::Methods
-
-  config.before(:suite) do
-    FactoryBot.lint
-  end
-end

data/spec/support/fixture_loader.rb

@@ -1,20 +0,0 @@
-require 'yaml'
-require 'json'
-
-class FixtureLoader
-  def self.load_yaml(filename)
-    YAML.load(read(filename))
-  end
-
-  def self.load_json(filename)
-    JSON.parse(read(filename))
-  end
-
-  def self.load_file(filename)
-    read(filename)
-  end
-
-  def self.read(filename)
-    File.read(File.expand_path("../../fixtures/#{filename}", __FILE__))
-  end
-end

data/spec/support/shared_examples_for_client_driver.rb

@@ -1,118 +0,0 @@
-shared_examples 'a client driver' do
-  describe '#security_token?' do
-    context 'when @security_token is nil' do
-      it do
-        subject.security_token = nil
-        expect(subject.security_token?).to be_falsey
-      end
-    end
-
-    context 'when @security_token is not nil' do
-      it do
-        subject.security_token = 'security token'
-        expect(subject.security_token?).to be_truthy
-      end
-    end
-  end
-
-  describe '#log_get_security_token' do
-    it 'should call log_info' do
-      allow(subject).to receive(:log_info)
-      subject.send(:log_get_security_token)
-      expect(subject).to have_received(:log_info)
-    end
-  end
-
-  describe '#log_retire_security_token' do
-    it 'should call log_info' do
-      allow(subject).to receive(:log_info)
-      subject.send(:log_retire_security_token)
-      expect(subject).to have_received(:log_info)
-    end
-  end
-
-  describe '#log_magic' do
-    it 'should call log_info' do
-      allow(subject).to receive(:log_info)
-      subject.send(:log_magic, double(parameters: { action: 'action'}))
-      expect(subject).to have_received(:log_info)
-    end
-
-    context 'when given nil for request' do
-      it { expect { subject.send(:log_magic, nil) }.to raise_error(ArgumentError) }
-    end
-  end
-
-  describe '#log_info' do
-    context 'when @options.logger? is true' do
-      it 'should call @options.logger.info' do
-        subject.options.logger = double('logger', info: true)
-        subject.send(:log_info, 'test')
-        expect(subject.options.logger).to have_received(:info)
-      end
-    end
-
-    context 'when @options.logger? is false' do
-      it 'should not call @options.logger.info' do
-        allow_message_expectations_on_nil
-        subject.options.logger = nil
-        allow(subject.options.logger).to receive(:info)
-        subject.send(:log_info, 'test')
-        expect(subject.options.logger).not_to have_received(:info)
-      end
-    end
-
-    context 'when given nil for message' do
-      it 'should not call @options.logger.info' do
-        subject.options.logger = double('logger', info: true)
-        subject.send(:log_info, nil)
-        expect(subject.options.logger).not_to have_received(:info)
-      end
-    end
-
-    context 'when @options.logger? is false' do
-      it 'should not call @logger.info' do
-        expect { subject.send(:log_info, 'test') }.not_to raise_error
-      end
-    end
-
-    context 'when @timer is nil and @options.logger is true' do
-      it 'should not include seconds in the log' do
-        subject.options.logger = double('logger', info: true)
-        subject.instance_variable_set('@timer', nil)
-        subject.send(:log_info, 'test')
-        expect(subject.options.logger).not_to have_received(:info).with(match(/seconds/))
-      end
-    end
-
-    context 'when @timer is not nil and @options.logger? is true' do
-      it 'should include seconds in log' do
-        subject.options.logger = double('logger', info: true)
-        subject.instance_variable_set('@timer', 1.2)
-        subject.send(:log_info, 'test')
-        expect(subject.options.logger).to have_received(:info).with(match(/seconds/))
-      end
-    end
-  end
-
-  describe '#start_timer' do
-    it 'sets @start_time' do
-      subject.send(:start_timer)
-      expect(subject.instance_variable_get('@start_time')).not_to be_nil
-    end
-  end
-
-  describe '#end_timer' do
-    it 'sets @end_time' do
-      subject.send(:start_timer)
-      subject.send(:end_timer)
-      expect(subject.instance_variable_get('@end_time')).not_to be_nil
-    end
-
-    it 'sets @timer to @end_time - @start_time' do
-      subject.send(:start_timer)
-      subject.send(:end_timer)
-      expect(subject.instance_variable_get('@timer')).to eq(subject.instance_variable_get('@end_time') - subject.instance_variable_get('@start_time'))
-    end
-  end
-end

data/spec/support/shared_examples_for_unity_request.rb

@@ -1,114 +0,0 @@
-shared_examples 'a unity request' do
-  let(:magic_request) { build(:magic_request) }
-
-  describe '#to_hash' do
-    it ':action maps to Action' do
-      subject.parameters = build(:magic_request, action: 'Action')
-      expect(subject.to_hash['Action']).to eq('Action')
-    end
-
-    it ':appname maps to Appname' do
-      subject.parameters = build(:magic_request, appname: 'Appname')
-      expect(subject.to_hash['Appname']).to eq('Appname')
-    end
-
-    it ':patientid maps to PatientID' do
-      subject.parameters = build(:magic_request, patientid: 'PatientID')
-      expect(subject.to_hash['PatientID']).to eq('PatientID')
-    end
-
-    it ':token maps to Token' do
-      subject.parameters = build(:magic_request, token: 'Token')
-      expect(subject.to_hash['Token']).to eq('Token')
-    end
-
-    it ':parameter1 maps to Parameter1' do
-      subject.parameters = build(:magic_request, parameter1: 'Parameter1')
-      expect(subject.to_hash['Parameter1']).to eq('Parameter1')
-    end
-
-    it ':parameter2 maps to Parameter2' do
-      subject.parameters = build(:magic_request, parameter2: 'Parameter2')
-      expect(subject.to_hash['Parameter2']).to eq('Parameter2')
-    end
-
-    it ':parameter3 maps to Parameter3' do
-      subject.parameters = build(:magic_request, parameter3: 'Parameter3')
-      expect(subject.to_hash['Parameter3']).to eq('Parameter3')
-    end
-
-    it ':parameter4 maps to Parameter4' do
-      subject.parameters = build(:magic_request, parameter4: 'Parameter4')
-      expect(subject.to_hash['Parameter4']).to eq('Parameter4')
-    end
-
-    it ':parameter5 maps to Parameter5' do
-      subject.parameters = build(:magic_request, parameter5: 'Parameter5')
-      expect(subject.to_hash['Parameter5']).to eq('Parameter5')
-    end
-
-    it ':parameter6 maps to Parameter6' do
-      subject.parameters = build(:magic_request, parameter6: 'Parameter6')
-      expect(subject.to_hash['Parameter6']).to eq('Parameter6')
-    end
-
-    it 'calls process_date on parameters' do
-      subject.parameters = build(:populated_magic_request)
-      allow(subject).to receive(:process_date)
-      subject.to_hash
-      expect(subject).to have_received(:process_date).exactly(6).times
-    end
-  end
-
-  describe '#process_date' do
-    context 'when given nil' do
-      it { expect(subject.send(:process_date, nil)).to be_nil }
-    end
-
-    context 'when given a non-date string' do
-      it do
-        not_a_date = Faker::Name.name
-        expect(subject.send(:process_date, not_a_date)).to eq(not_a_date)
-      end
-    end
-
-    context 'when given a date string' do
-      it 'returns an ISO8601 string' do
-        date = '10/24/2013'
-        expect(subject.send(:process_date, date)).to eq('2013-10-24')
-      end
-    end
-
-    context 'when given a UTC date time string' do
-      it 'returns an ISO8601 string' do
-        now = DateTime.now.utc
-        now_iso8601 = now.strftime('%Y-%m-%dT%H:%M:%S%:z')
-        expect(subject.send(:process_date, now_iso8601)).to eq(now_iso8601)
-      end
-    end
-
-    context 'when given a Date' do
-      it 'returns an ISO8601 string' do
-        today = Date.today
-        today_iso8601 = Date.today.iso8601
-        expect(subject.send(:process_date, today)).to eq(today_iso8601)
-      end
-    end
-
-    context 'when given a UTC Time' do
-      it 'returns an ISO8601 string' do
-        now = Time.now.utc
-        now_iso8601 = now.strftime('%Y-%m-%dT%H:%M:%S%:z')
-        expect(subject.send(:process_date, now)).to eq(now_iso8601)
-      end
-    end
-
-    context 'when given a UTC DateTime' do
-      it 'returns an ISO8601 string' do
-        now = DateTime.now.utc
-        now_iso8601 = now.strftime('%Y-%m-%dT%H:%M:%S%:z')
-        expect(subject.send(:process_date, now)).to eq(now_iso8601)
-      end
-    end
-  end
-end

data/spec/support/shared_examples_for_unity_response.rb

@@ -1,26 +0,0 @@
-shared_examples 'a unity response' do
-  let(:attributes_hash) { FixtureLoader.load_yaml('attributes_hash.yml') }
-  let(:no_attributes_hash) { FixtureLoader.load_yaml('no_attributes_hash.yml') }
-  let(:date_string_hash) { FixtureLoader.load_yaml('date_string_hash.yml') }
-  let(:date_hash) { FixtureLoader.load_yaml('date_hash.yml') }
-
-  describe '#strip_attributes' do
-    context 'when given nil' do
-      it { expect(subject.send(:strip_attributes, nil)).to be_nil }
-    end
-
-    it 'recursively strips attribute keys off hashes' do
-      expect(subject.send(:strip_attributes, attributes_hash)).to eq(no_attributes_hash)
-    end
-  end
-
-  describe '#convert_dates_to_utc' do
-    context 'when given nil' do
-      it { expect(subject.send(:convert_dates_to_utc, nil)).to be_nil }
-    end
-
-    it 'recursively converts date strings' do
-      expect(subject.send(:convert_dates_to_utc, date_string_hash)).to eq(date_hash)
-    end
-  end
-end

data/spec/unity_request_spec.rb

@@ -1,37 +0,0 @@
-require 'spec_helper'
-
-describe AllscriptsUnityClient::UnityRequest do
-  it_behaves_like 'a unity request'
-
-  subject { build(:unity_request) }
-
-  describe '#initialize' do
-    context 'when nil is given for parameters' do
-      it { expect { build(:unity_request, parameters: nil) }.to raise_error(ArgumentError) }
-    end
-
-    context 'when nil is given for timezone' do
-      it { expect { build(:unity_request, timezone: nil) }.to raise_error(ArgumentError) }
-    end
-
-    context 'when nil is given for appname' do
-      it { expect { build(:unity_request, appname: nil) }.to raise_error(ArgumentError) }
-    end
-
-    context 'when nil is given for security_token' do
-      it { expect { build(:unity_request, security_token: nil) }.to raise_error(ArgumentError) }
-    end
-  end
-
-  describe '#to_hash' do
-    it ':userid maps to UserID' do
-      subject.parameters = build(:magic_request, userid: 'UserID')
-      expect(subject.to_hash['UserID']).to eq('UserID')
-    end
-
-    it ':data maps to Base64 encoded data' do
-      subject.parameters = build(:magic_request, data: 'data')
-      expect(subject.to_hash['data']).to eq(['data'].pack('m'))
-    end
-  end
-end

data/spec/unity_response_spec.rb

@@ -1,36 +0,0 @@
-require 'spec_helper'
-
-describe AllscriptsUnityClient::UnityResponse do
-  it_behaves_like 'a unity response'
-
-  subject { build(:unity_response, response: get_server_info) }
-
-  let(:get_server_info) { FixtureLoader.load_yaml('get_server_info_xml.yml') }
-
-  describe '#initialize' do
-    context 'when nil is given for response' do
-      it { expect { build(:unity_response, response: nil) }.to raise_error(ArgumentError) }
-    end
-
-    context 'when nil is given for timezone' do
-      it { expect { build(:unity_response, timezone: nil) }.to raise_error(ArgumentError) }
-    end
-  end
-
-  describe '#to_hash' do
-    context 'when given a GetServerInfo SOAP response hash' do
-      it 'strips Unity SOAP wrappers' do
-        expect(subject.to_hash[:server_time_zone]).to_not be_nil
-      end
-
-      context 'when given nil magic_result' do
-        it 'returns []' do
-          magic_response = get_server_info
-          magic_response[:magic_response][:magic_result][:diffgram] = nil
-          subject.response = magic_response
-          expect(subject.to_hash).to eq([])
-        end
-      end
-    end
-  end
-end

data/spec/utilities_spec.rb

@@ -1,144 +0,0 @@
-require 'spec_helper'
-
-describe AllscriptsUnityClient::Utilities do
-  subject { described_class }
-
-  let(:date_string) { '2013-02-15' }
-  let(:date) { Date.parse(date_string) }
-  let(:datetime_string) { '2013-02-15T00:00:00Z' }
-  let(:datetime) { timezone.parse(datetime_string) }
-  let(:timezone) { ActiveSupport::TimeZone['Etc/UTC'] }
-
-  let(:string) { 'string' }
-  let(:string_array) { ['string'] }
-  let(:base64_string) { "c3RyaW5n\n" }
-
-  let(:string_keyed_hash) { FixtureLoader.load_yaml('string_keyed_hash.yml') }
-  let(:symbol_keyed_hash) { FixtureLoader.load_yaml('symbol_keyed_hash.yml') }
-
-  let(:datetime_string_one) { 'Feb 27 2013 12:37PM' }
-  let(:datetime_string_two) { 'Feb 28 2013  1:34PM' }
-  let(:datetime_string_three) { '12/25/2013 12:37 PM' }
-  let(:datetime_string_four) { 'Nov  1 2011 11:31AM' }
-  let(:datetime_one) { timezone.parse(datetime_string_one) }
-  let(:datetime_two) { timezone.parse(datetime_string_two) }
-  let(:datetime_three) { timezone.parse(datetime_string_three) }
-  let(:datetime_four) { timezone.parse(datetime_string_four) }
-  let(:date_string_one) { '20-Jul-2014' }
-  let(:date_string_two) { '12/25/2013' }
-  let(:date_string_three) { 'Nov  1 2011' }
-  let(:date_one) { Date.parse(date_string_one) }
-  let(:date_two) { Date.parse(date_string_two) }
-  let(:date_three) { Date.parse(date_string_three) }
-
-  let(:invalid_date_string_one) { "32-13-2014\n02/21/2014"}
-
-  describe '.try_to_encode_as_date' do
-    context 'when given nil' do
-      it { expect(subject.try_to_encode_as_date(timezone, nil)).to be_nil }
-    end
-
-    context 'when given date string' do
-      it 'returns the string as a Date' do
-        expect(subject.try_to_encode_as_date(timezone, date_string)).to eq(date)
-      end
-    end
-
-    context 'when given date time string' do
-      it 'returns the string as a DateTime' do
-        expect(subject.try_to_encode_as_date(timezone, datetime_string)).to eq(datetime)
-      end
-    end
-
-    context 'when given datetime_string_one' do
-      it 'returns the string as a DateTime' do
-        expect(subject.try_to_encode_as_date(timezone, datetime_string_one)).to eq(datetime_one)
-      end
-    end
-
-    context 'when given datetime_string_two' do
-      it 'returns the string as a DateTime' do
-        expect(subject.try_to_encode_as_date(timezone, datetime_string_two)).to eq(datetime_two)
-      end
-    end
-
-    context 'when given datetime_string_three' do
-      it 'returns the string as a DateTime' do
-        expect(subject.try_to_encode_as_date(timezone, datetime_string_three)).to eq(datetime_three)
-      end
-    end
-
-    context 'when given datetime_string_four' do
-      it 'returns the string as a DateTime' do
-        expect(subject.try_to_encode_as_date(timezone, datetime_string_four)).to eq(datetime_four)
-      end
-    end
-
-    context 'when given date_string_one' do
-      it 'returns the string as a Date' do
-        expect(subject.try_to_encode_as_date(timezone, date_string_one)).to eq(date_one)
-      end
-    end
-
-    context 'when given date_string_two' do
-      it 'returns the string as a Date' do
-        expect(subject.try_to_encode_as_date(timezone, date_string_two)).to eq(date_two)
-      end
-    end
-
-    context 'when given date_string_three' do
-      it 'returns the string as a Date' do
-        expect(subject.try_to_encode_as_date(timezone, date_string_three)).to eq(date_three)
-      end
-    end
-
-    context 'when given a non-date string' do
-      it 'returns that string' do
-        expect(subject.try_to_encode_as_date(timezone, string)).to eq(string)
-      end
-    end
-
-    context 'when given an invalid date string' do
-      it 'returns that string' do
-        expect(subject.try_to_encode_as_date(timezone, invalid_date_string_one)).to eq(invalid_date_string_one)
-      end
-    end
-
-    context 'when givn an valid date string that represents an invalid date' do
-      it 'it returns the string' do
-        date = "10/00/1999"
-        date_time = "10/00/1999 01:01:01"
-        expect(subject.try_to_encode_as_date(timezone, date)).to be(date)
-        expect(subject.try_to_encode_as_date(timezone, date_time)).to be(date_time)
-      end
-    end
-  end
-
-  describe '.encode_data' do
-    context 'when given nil' do
-      it { expect(subject.encode_data(nil)).to be_nil }
-    end
-
-    context 'when given a string' do
-      it 'returns a base64 encoded version of that string' do
-        expect(subject.encode_data(string)).to eq(base64_string)
-      end
-    end
-
-    context 'when given an array of strings' do
-      it 'returns a base64 encoded version of that string' do
-        expect(subject.encode_data(string_array)).to eq(base64_string)
-      end
-    end
-  end
-
-  describe '.recursively_symbolize_keys' do
-    context 'when given nil' do
-      it { expect(subject.recursively_symbolize_keys(nil)).to be_nil }
-    end
-
-    context 'when given a hash with string keys' do
-      it { expect(subject.recursively_symbolize_keys(string_keyed_hash)).to eq(symbol_keyed_hash) }
-    end
-  end
-end