epics 2.11.0 → 3.0.0.rc2

data/spec/segmented_download_spec.rb

@@ -0,0 +1,248 @@
+RSpec.describe 'segmented downloads' do
+  versions = [Epics::Keyring::VERSION_24, Epics::Keyring::VERSION_25, Epics::Keyring::VERSION_30]
+
+  let(:url) { 'https://194.180.18.30/ebicsweb/ebicsweb' }
+  let(:version) { Epics::Keyring::VERSION_25 }
+  let(:client) do
+    Epics::Client.new(File.open(File.join(File.dirname(__FILE__), 'fixtures', 'SIZBN001.key')),
+                      'secret', url, 'SIZBN001', 'EBIX', 'EBICS', version:)
+  end
+  let(:ns) { { 'e' => client.urn_schema } }
+  let(:transaction_id) { 'ECD6F062AAEDFA77250526A68CBEC549' }
+
+  describe 'Epics::GenericRequest#to_transfer_download_xml' do
+    let(:order) { Epics::C53.new(client, from: Date.new(2026, 9, 24), to: Date.new(2026, 9, 24)) }
+    let(:xml) { Nokogiri::XML(order.to_transfer_download_xml(2, false)) }
+
+    before { order.transaction_id = transaction_id }
+
+    versions.each do |version|
+      context version do
+        let(:version) { version }
+
+        it 'is a valid EBICS document' do
+          expect(xml.to_xml).to be_a_valid_ebics_doc(version)
+        end
+
+        it 'requests the segment of the transaction without sending order data' do
+          expect(xml.at_xpath('//e:header/e:static/e:TransactionID', ns).text).to eq(transaction_id)
+          expect(xml.at_xpath('//e:header/e:mutable/e:TransactionPhase', ns).text).to eq('Transfer')
+          expect(xml.at_xpath('//e:header/e:mutable/e:SegmentNumber', ns).text).to eq('2')
+          expect(xml.at_xpath('//e:header/e:mutable/e:SegmentNumber', ns)['lastSegment']).to eq('false')
+          expect(xml.at_xpath('//e:body', ns).elements).to be_empty
+        end
+      end
+    end
+
+    it 'marks the last segment' do
+      segment_number = Nokogiri::XML(order.to_transfer_download_xml(3, true))
+                               .at_xpath('//e:header/e:mutable/e:SegmentNumber', ns)
+
+      expect(segment_number.text).to eq('3')
+      expect(segment_number['lastSegment']).to eq('true')
+    end
+  end
+
+  describe 'Epics::GenericRequest#to_receipt_xml' do
+    let(:order) { Epics::C53.new(client, from: Date.new(2026, 9, 24), to: Date.new(2026, 9, 24)) }
+
+    before { order.transaction_id = transaction_id }
+
+    def receipt_code(xml)
+      Nokogiri::XML(xml).at_xpath('//e:body/e:TransferReceipt/e:ReceiptCode', ns).text
+    end
+
+    it 'acknowledges the download by default' do
+      expect(receipt_code(order.to_receipt_xml)).to eq('0')
+    end
+
+    versions.each do |version|
+      context version do
+        let(:version) { version }
+
+        it 'rejects the download when not acknowledged' do
+          xml = order.to_receipt_xml(acknowledged: false)
+
+          expect(xml).to be_a_valid_ebics_doc(version)
+          expect(receipt_code(xml)).to eq('1')
+        end
+      end
+    end
+  end
+
+  describe 'Epics::Client#download' do
+    def response(phase, order_data: nil, segment_number: nil, num_segments: nil, return_code: '000000')
+      <<~XML
+        <?xml version="1.0" encoding="UTF-8"?>
+        <ebicsResponse xmlns="#{client.urn_schema}" Version="#{version}" Revision="1">
+          <header authenticate="true">
+            <static>
+              <TransactionID>#{transaction_id}</TransactionID>
+              #{"<NumSegments>#{num_segments}</NumSegments>" if num_segments}
+            </static>
+            <mutable>
+              <TransactionPhase>#{phase}</TransactionPhase>
+              #{segment_number_xml(segment_number) if segment_number}
+              <ReturnCode>#{return_code}</ReturnCode>
+            </mutable>
+          </header>
+          <body>
+            #{data_transfer_xml(phase, order_data) if order_data}
+            <ReturnCode authenticate="true">000000</ReturnCode>
+          </body>
+        </ebicsResponse>
+      XML
+    end
+
+    def segment_number_xml(segment_number)
+      %(<SegmentNumber lastSegment="#{segment_number == segments.size}">#{segment_number}</SegmentNumber>)
+    end
+
+    def data_transfer_xml(phase, order_data)
+      <<~XML
+        <DataTransfer>
+          #{data_encryption_info_xml if phase == 'Initialisation'}
+          <OrderData>#{Base64.strict_encode64(order_data)}</OrderData>
+        </DataTransfer>
+      XML
+    end
+
+    def data_encryption_info_xml
+      <<~XML
+        <DataEncryptionInfo authenticate="true">
+          <TransactionKey>#{Base64.strict_encode64(client.encryption_key.key.public_encrypt(transaction_key))}</TransactionKey>
+        </DataEncryptionInfo>
+      XML
+    end
+
+    def summarize(request)
+      segment_number = request.at_xpath('//e:header/e:mutable/e:SegmentNumber', ns)
+      receipt_code = request.at_xpath('//e:body/e:TransferReceipt/e:ReceiptCode', ns)
+
+      [request.at_xpath('//e:header/e:mutable/e:TransactionPhase', ns).text,
+       segment_number&.text,
+       segment_number&.[]('lastSegment'),
+       receipt_code&.text].compact
+    end
+
+    let(:zipped_order_data) { File.binread(File.join(File.dirname(__FILE__), 'fixtures', 'test.zip')) }
+    let(:transaction_key) { SecureRandom.random_bytes(16) }
+    let(:order_data_encrypted) do
+      cipher = OpenSSL::Cipher.new('aes-128-cbc').encrypt
+      cipher.key = transaction_key
+
+      cipher.update(Zlib::Deflate.deflate(zipped_order_data)) + cipher.final
+    end
+    let(:missing_bytes) { 0 }
+    let(:segment_count) { 3 }
+    let(:segments) do
+      received = order_data_encrypted.byteslice(0, order_data_encrypted.bytesize - missing_bytes)
+
+      received.bytes.each_slice((received.bytesize / segment_count.to_f).ceil).map { |bytes| bytes.pack('C*') }
+    end
+    let(:initialisation_response) do
+      response('Initialisation', order_data: segments.first, segment_number: 1, num_segments: segments.size)
+    end
+    let(:aborted_segment) { nil }
+    let(:requests) { [] }
+
+    subject { client.C53(Date.new(2026, 9, 24), Date.new(2026, 9, 24)) }
+
+    before do
+      stub_request(:post, url).to_return do |http_request|
+        requests << summarize(Nokogiri::XML(http_request.body))
+        phase, *details = requests.last
+        body = case phase
+               when 'Initialisation' then initialisation_response
+               when 'Transfer'
+                 segment_number = Integer(details.first)
+                 if segment_number == aborted_segment
+                   response('Transfer', return_code: '091102')
+                 else
+                   response('Transfer', order_data: segments[segment_number - 1], segment_number:)
+                 end
+               when 'Receipt' then response('Receipt', return_code: details == ['0'] ? '011000' : '011001')
+               end
+
+        { status: 200, body: }
+      end
+    end
+
+    context 'when the order data arrives short by whole cipher blocks' do
+      let(:missing_bytes) { 32 }
+
+      it 'raises after sending a negative receipt' do
+        expect { subject }.to raise_error(Epics::InvalidOrderDataError, /C53/) do |error|
+          expect(error.cause).to be_a(Zlib::BufError)
+        end
+        expect(requests).to eq([%w[Initialisation], %w[Transfer 2 false], %w[Transfer 3 true], %w[Receipt 1]])
+      end
+    end
+
+    context 'when the order data arrives short by part of a cipher block' do
+      let(:missing_bytes) { 5 }
+
+      it 'raises after sending a negative receipt' do
+        expect { subject }.to raise_error(Epics::InvalidOrderDataError, /C53/) do |error|
+          expect(error.cause).to be_a(OpenSSL::Cipher::CipherError)
+        end
+        expect(requests).to eq([%w[Initialisation], %w[Transfer 2 false], %w[Transfer 3 true], %w[Receipt 1]])
+      end
+    end
+
+    context 'when the bank aborts the transaction during the transfer' do
+      let(:aborted_segment) { 2 }
+
+      it "raises the bank's error without sending a receipt" do
+        expect { subject }.to raise_error(Epics::Error::TechnicalError) do |error|
+          expect(error.symbol).to eq('EBICS_TX_ABORT')
+        end
+        expect(requests).to eq([%w[Initialisation], %w[Transfer 2 false]])
+      end
+    end
+
+    context 'when the negative receipt cannot be sent' do
+      let(:missing_bytes) { 32 }
+
+      before do
+        stub_request(:post, url).with { |request| summarize(Nokogiri::XML(request.body)) == %w[Receipt 1] }
+                                .to_raise(Faraday::ConnectionFailed)
+      end
+
+      it 'raises the reason the order data could not be read' do
+        expect { subject }.to raise_error(Epics::InvalidOrderDataError, /C53/) do |error|
+          expect(error.cause).to be_a(Zlib::BufError)
+        end
+      end
+    end
+
+    context 'when the response is not segmented' do
+      let(:initialisation_response) { response('Initialisation', order_data: order_data_encrypted) }
+
+      it 'returns the order data without sending a receipt' do
+        expect(subject).to eq(["ebics is great\n"])
+        expect(requests).to eq([%w[Initialisation]])
+      end
+    end
+
+    context 'when the order data fits into a single segment' do
+      let(:segment_count) { 1 }
+
+      it 'returns the order data and sends the receipt' do
+        expect(subject).to eq(["ebics is great\n"])
+        expect(requests).to eq([%w[Initialisation], %w[Receipt 0]])
+      end
+    end
+
+    versions.each do |version|
+      context "when the order data spans several segments (#{version})" do
+        let(:version) { version }
+
+        it 'returns the order data of all segments and sends the receipt after the last one' do
+          expect(subject).to eq(["ebics is great\n"])
+          expect(requests).to eq([%w[Initialisation], %w[Transfer 2 false], %w[Transfer 3 true], %w[Receipt 0]])
+        end
+      end
+    end
+  end
+end

data/spec/{key_spec.rb → signature_algorithm/rsa_pss_spec.rb}

@@ -1,6 +1,6 @@
-RSpec.describe Epics::Key do
+RSpec.describe Epics::SignatureAlgorithm::RsaPss do
 
-  subject { described_class.new( File.read(File.join( File.dirname(__FILE__), 'fixtures', 'e002.pem'))) }
+  subject { described_class.new( File.read(File.join( File.dirname(__FILE__), '..', 'fixtures', 'e002.pem'))) }
 
   describe '#public_digest' do
 
@@ -14,17 +14,8 @@ RSpec.describe Epics::Key do
     let(:dsi) { OpenSSL::Digest::SHA256.new.digest("ruby is great") }
 
     it 'will generated a digest that can be verified with openssl key.verify_pss' do
-      signed_digest = subject.sign(dsi)
-
-      key = subject.key
-
-      verification_result = key.verify_pss(
-                              'SHA256',
-                              Base64.decode64(signed_digest),
-                              dsi,
-                              salt_length: :digest,
-                              mgf1_hash:   'SHA256',
-                            )
+      signed_digest = Base64.encode64(subject.sign(dsi)).strip
+      verification_result = subject.verify(signed_digest, dsi)
 
       expect(verification_result).to eq(true)
     end

data/spec/support/ebics_matcher.rb

@@ -1,22 +1,30 @@
-RSpec::Matchers.define :be_a_valid_ebics_doc do
-
+RSpec::Matchers.define :be_a_valid_ebics_doc do |version|
   ##
   # use #open instead of #read to have the includes working
   # http://stackoverflow.com/questions/11996326/nokogirixmlschema-syntaxerror-on-schema-load/22971456#22971456
-  def xsd
-    @xsd ||= Nokogiri::XML::Schema(File.open( File.join( File.dirname(__FILE__), '..', 'xsd', 'ebics_H004.xsd') ))
+  def xsd(version)
+    @xsd ||= {}
+    @xsd[version] ||= Nokogiri::XML::Schema(case version
+    when Epics::Keyring::VERSION_30
+      File.open( File.join( File.dirname(__FILE__), '..', 'xsd', 'H005', 'ebics_H005.xsd') )
+    when Epics::Keyring::VERSION_25
+      File.open( File.join( File.dirname(__FILE__), '..', 'xsd', 'H004', 'ebics_H004.xsd') )
+    when Epics::Keyring::VERSION_24
+      File.open( File.join( File.dirname(__FILE__), '..', 'xsd', 'H003', 'ebics.xsd') )
+    when 'H000'
+      File.open( File.join( File.dirname(__FILE__), '..', 'xsd', 'H000', 'ebics_hev.xsd') )
+    end)
   end
 
   match do |actual|
-    xsd.valid?(Nokogiri::XML(actual))
+    xsd(version).valid?(Nokogiri::XML(actual))
   end
 
   failure_message do |actual|
-    "expected that #{actual} would be a valid EBICS doc:\n\n #{xsd.validate(Nokogiri::XML(actual))}"
+    "expected that #{actual} would be a valid EBICS doc:\n\n #{xsd(version).validate(Nokogiri::XML(actual))}"
   end
 
   description do
-    "be a valid EBICS document"
+    'be a valid EBICS document'
   end
-
-end
+end