dtaus 0.1.1 → 0.2.0

data/lib/dtaus.rb

@@ -1,210 +1,15 @@
+require 'date'
+require 'enumerator'
+require 'bigdecimal'
+
+require 'dtaus/datensatz'
+require 'dtaus/dta_generator'
 require 'dtaus/buchung'
 require 'dtaus/konto'
+require 'dtaus/erweiterung'
+require 'dtaus/converter'
+require 'dtaus/exceptions'
 
-#
-# :title:DTAUS-Datei erstellen
-#
-# =DTAUS-Datei für Sammellastschrift erstellen
-#
-# Quick How-To:
-#  auftraggeber = DTAUS::Konto.new(1234567890, 12345670, 'Muster GmbH', 'Deutsche Bank', true)
-#  kunde = DTAUS::Konto.new(1234567890, 12345670, 'Max Meier-Schulze', 'Sparkasse')
-#  buchung = DTAUS::Buchung.new(auftraggeber, kunde, 39.99, 'Vielen Dank für ihren Einkauf vom 01.01.2010. Rechnungsnummer 12345')
-#  dta = DTAUS.new(auftraggeber)
-#  dta.add(buchung)
-#  dta.to_file
-#
-# Typ der Datei ist 'LK' (Lastschrift Kunde)
-#
-# Infos zu DTAUS: http://www.infodrom.org/projects/dtaus/dtaus.php3
-# DTAUS online check: http://www.xpecto.de/index.php?id=148,7
-#
-class DTAUS
-
-  class DTAUSException < Exception
-  end
-
-  class IncorrectSize < DTAUSException
-  end
-
-  attr_reader :auftraggeber, :buchungen, :datum, :positiv
-  alias :positiv? :positiv
-
-  def initialize(auftraggeber, datum = Time.new)
-    raise DTAUSException.new("Konto expected, got #{auftraggeber.class}") unless auftraggeber.is_a?(DTAUS::Konto)
-    raise DTAUSException.new("Date or Time expected, got #{datum.class}") unless datum.is_a?(Date) or datum.is_a?(Time)
-
-    @datum        = datum
-    @auftraggeber = auftraggeber
-    @buchungen    = []
-  end
-
-  # 2 Zeichen  Art der Transaktionen
-  # "LB" für Lastschriften Bankseitig
-  # "LK" für Lastschriften Kundenseitig
-  # "GB" für Gutschriften Bankseitig
-  # "GK" für Gutschriften Kundenseitig
-  #
-  def typ
-   'LK'
-  end
-
-  # Eine Buchung hinzufügen.
-  # Es wird geprüft, ob das Vorzeichen identisch mit den bisherigen Vorzeichen ist.
-  #
-  def add(buchung)
-    raise DTAUSException.new("Buchung expected, got #{buchung.class}") unless buchung.is_a?(DTAUS::Buchung)
-    # Die erste Buchung bestimmt, ob alle Beträge positiv oder negativ sind.
-    if buchungen == []
-      @positiv = buchung.positiv? # alle Beträge sind positiv. Variable wird mit erstem Eintrag geändert
-    end
-    raise DTAusException.new("Das Vorzeichen wechselte") if @positiv != buchung.positiv?
-    @buchungen << buchung
-  end
-
-  # Gibt die DTAUS-Datei als String zurück
-  #
-  def to_dta
-    raise DTAUSException.new("Keine Buchungen vorhanden") unless buchungen.size > 0
-    temp  = dataA
-    temp += buchungen.inject(''){|temp, buchung| temp += buchung.to_dta}
-    temp += dataE
-    raise IncorrectSize.new("Datensatzlänge ist nicht durch 128 teilbar: #{temp.size}") if temp.size % 128 != 0
-    temp
-  end
-  alias :to_s :to_dta
-
-  # Schreibt die DTAUS-Datei
-  # Standarddateiname ist DTAUS0.TXT
-  #
-  def to_file(filename ='DTAUS0.TXT')
-    File.open(filename, 'w') do |file|
-      file << to_dta
-    end
-  end
-
-  # Zeichen umsetzen gemäss DTA-Norm
-  #
-  def self.convert_text(_text)
-    tmp = _text.to_s.dup
-    tmp = tmp.upcase()
-    tmp = tmp.gsub('Ä', 'AE')
-    tmp = tmp.gsub('Ü', 'UE')
-    tmp = tmp.gsub('Ö', 'OE')
-    tmp = tmp.gsub('ä', 'AE')
-    tmp = tmp.gsub('ü', 'UE')
-    tmp = tmp.gsub('ö', 'OE')
-    tmp = tmp.gsub('ß', 'SS')
-    tmp = tmp.strip
-  end
-
-  # Konvertiert einen String in einen Integer
-  # indem alle Nicht-Digits entfernt werden.
-  # Lässt Integer unberührt.
-  #
-  def self.convert_number(_number)
-    case _number
-      when Integer then _number
-      when String then _number.strip.gsub(/\D/, '').to_i
-      else raise DTAUSException.new("Cannot convert #{_number.class} to Integer")
-    end
-  end
-
-private
-
-  # Checksumme der Kontonummern
-  #
-  def checksum_konto
-    @buchungen.inject(0){|sum, buchung| sum += buchung.konto.nummer}
-  end
-
-  # Checksumme der Bankleitzahlen
-  #
-  def checksum_blz
-    @buchungen.inject(0){|sum, buchung| sum += buchung.konto.blz}
-  end
-
-  # Checksumme der Beträge
-  #
-  def checksum_betrag
-    @buchungen.inject(0){|sum, buchung| sum += buchung.betrag}
-  end
-
-  # Erstellt A-Segment der DTAUS-Datei
-  # Aufbau des Segments:
-  #
-  # Nr. Start Länge     Beschreibung
-  # 1   0     4 Zeichen   Länge des Datensatzes, immer 128 Bytes, also immer "0128"
-  # 2   4     1 Zeichen   Datensatz-Typ, immer 'A'
-  # 3   5     2 Zeichen   Art der Transaktionen
-  #             "LB" für Lastschriften Bankseitig
-  #             "LK" für Lastschriften Kundenseitig
-  #             "GB" für Gutschriften Bankseitig
-  #             "GK" für Gutschriften Kundenseitig
-  # 4   7     8 Zeichen   Bankleitzahl des Auftraggebers
-  # 5   15    8 Zeichen   CST, "00000000", nur belegt, wenn Diskettenabsender Kreditinstitut
-  # 6   23    27 Zeichen  Name des Auftraggebers
-  # 7   50    6 Zeichen   aktuelles Datum im Format DDMMJJ
-  # 8   56    4 Zeichen   CST, "    " (Blanks)
-  # 9   60    10 Zeichen  Kontonummer des Auftraggebers
-  # 10  70    10 Zeichen  Optionale Referenznummer
-  # 11a 80    15 Zeichen  Reserviert, 15 Blanks
-  # 11b 95    8 Zeichen   Ausführungsdatum im Format DDMMJJJJ. Nicht jünger als Erstellungsdatum (A7), jedoch höchstens 15 Kalendertage später. Sonst Blanks.
-  # 11c 103   24 Zeichen  Reserviert, 24 Blanks
-  # 12  127   1 Zeichen   Währungskennzeichen
-  #             " " = DM
-  #             "1" = Euro
-  #
-  # Insgesamt 128 Zeichen
-  #
-  def dataA( )
-    dta = '0128'                             #  4 Zeichen  Länge des Datensatzes, immer 128 Bytes, also immer "0128"
-    dta += 'A'                               #  1 Zeichen  Datensatz-Typ, immer 'A'
-    dta += typ                               #  2 Zeichen  Art der Transaktionen
-    dta += '%8i' % auftraggeber.blz          #  8 Zeichen  Bankleitzahl des Auftraggebers
-    dta += '%08i' % 0                        #  8 Zeichen  CST, "00000000", nur belegt, wenn Diskettenabsender Kreditinstitut
-    dta += '%-27.27s' % auftraggeber.name    # 27 Zeichen  Name des Auftraggebers
-    dta += @datum.strftime("%d%m%y")         #  6 Zeichen  aktuelles Datum im Format DDMMJJ
-    dta += ' ' * 4                           #  4 Zeichen  CST, "    " (Blanks)
-    dta += '%010i' % auftraggeber.nummer     # 10 Zeichen  Kontonummer des Auftraggebers
-    dta += '%010i' % 0                       # 10 Zeichen  Optionale Referenznummer
-    dta += ' '  * 15                         # 15 Zeichen  Reserviert, 15 Blanks
-    dta += '%8s' % @datum.strftime("%d%m%Y") #  8 Zeichen  Optionales Ausführungsdatum im Format DDMMJJJJ. Nicht jünger als Erstellungsdatum (A7), jedoch höchstens 15 Kalendertage später. Sonst Blanks.
-    dta += ' ' * 24                          # 24 Zeichen  Reserviert, 24 Blanks
-    dta += '1'                               #  1 Zeichen  Währungskennzeichen ('1' = Euro)
-    raise IncorrectSize.new("A-Segment: #{dta.size} Zeichen, 128 erwartet.") if dta.size != 128
-    return dta
-  end
-
-  # Erstellt E-Segment (Prüfsummen) der DTAUS-Datei
-  # Aufbau:
-  #
-  # Nr. Start Länge   Beschreibung
-  # 1   0   4 Zeichen   Länge des Datensatzes, immer 128 Bytes, also immer "0128"
-  # 2   4   1 Zeichen   Datensatz-Typ, immer 'E'
-  # 3   5   5 Zeichen   5 Blanks
-  # 4   10  7 Zeichen   Anzahl der Datensätze vom Typ C
-  # 5   17  13 Zeichen  Kontrollsumme Beträge
-  # 6   30  17 Zeichen  Kontrollsumme Kontonummern
-  # 7   47  17 Zeichen  Kontrollsumme Bankleitzahlen
-  # 8   64  13 Zeichen  Kontrollsumme Euro, nur belegt, wenn Euro als Währung angegeben wurde (A12, C17a)
-  # 9   77  51 Zeichen  51 Blanks
-  #
-  # Insgesamt 128 Zeichen
-  #
-  def dataE()
-    dta  = '0128'                    #  4 Zeichen  Länge des Datensatzes, immer 128 Bytes, also immer "0128"
-    dta += 'E'                       #  1 Zeichen  Datensatz-Typ, immer 'E'
-    dta += ' ' * 5                   #  5 Zeichen  5 Blanks
-    dta += '%07i' % @buchungen.size  #  7 Zeichen  Anzahl der Datensätze vom Typ C
-    dta += '0' * 13                  # 13 Zeichen  Kontrollsumme Beträge in DM
-    dta += '%017i' % checksum_konto  # 17 Zeichen  Kontrollsumme Kontonummern
-    dta += '%017i' % checksum_blz    # 17 Zeichen  Kontrollsumme Bankleitzahlen
-    dta += '%013i' % checksum_betrag # 13 Zeichen  Kontrollsumme Beträge in Euro
-    dta += ' '  * 51                 # 51 Zeichen  51 Blanks
-    raise IncorrectSize.new("E-Segment: #{dta.size}, 128 erwartet") if dta.size != 128
-    return dta
-  end
-
+# Namespace for +dtaus+ gem
+module DTAUS
 end
-

data/test/buchung_test.rb

@@ -0,0 +1,182 @@
+require File.expand_path(File.dirname(__FILE__) + "/test_helper")
+
+class BuchungTest < Test::Unit::TestCase
+
+  def setup
+    @konto = DTAUS::Konto.new(
+      :kontonummer => 1234567890, 
+      :blz => 12345678, 
+      :kontoinhaber => 'Kunde', 
+      :bankname =>'Bank Name'
+    )
+  end
+        
+  def test_initialize
+    buchung = DTAUS::Buchung.new(
+      :kunden_konto => @konto,
+      :betrag => 100.0,
+      :verwendungszweck => "Vielen Dank für Ihren Einkauf!"
+    )
+    assert buchung, "Buchung kann mit zwei Konten angelegt werden"
+    assert_equal @konto, buchung.kunden_konto
+    assert_equal 10000, buchung.betrag
+    assert_equal true, buchung.positiv?
+    assert_equal "VIELEN DANK FUER IHREN EINKAUF!", buchung.verwendungszweck
+    assert_equal 1, buchung.erweiterungen.size
+
+    buchung = DTAUS::Buchung.new(
+      :kunden_konto => @konto,
+      :betrag => -100.0,
+      :verwendungszweck => "Vielen Dank für Ihren Einkauf!"
+    )
+    assert buchung, "Buchung kann mit negativem Betrag angelegt werden"
+    assert_equal @konto, buchung.kunden_konto
+    assert_equal 10000, buchung.betrag
+    assert_equal false, buchung.positiv?
+    assert_equal "VIELEN DANK FUER IHREN EINKAUF!", buchung.verwendungszweck
+    
+    konto = DTAUS::Konto.new(
+      :kontonummer => 1234567890, 
+      :blz => 12345678, 
+      :kontoinhaber => 'Sehr laaaaaaanger Kundenname GmbH', 
+      :bankname =>'Bank Name'
+    )
+    buchung = DTAUS::Buchung.new(
+      :kunden_konto => konto,
+      :betrag => -100.0,
+      :verwendungszweck => "Vielen Dank für Ihren Einkauf!"
+    )
+    assert buchung, "Buchung kann mit langem Kundennamen angelegt werden"
+    assert_equal 2, buchung.erweiterungen.size
+  end
+  
+  def test_initialize_missing_parameters
+    exception = assert_raise( ArgumentError ) do
+      DTAUS::Buchung.new(
+        :auftraggeber_konto => @konto_auftraggeber,
+        #:kunden_konto => @konto,
+        :betrag => 100.0
+      )
+    end
+    assert_equal "Missing params[:kunden_konto] for new Buchung.", exception.message
+
+    exception = assert_raise( ArgumentError ) do
+      DTAUS::Buchung.new(
+        :auftraggeber_konto => @konto_auftraggeber,
+        :kunden_konto => @konto
+        #:betrag => 100.0
+      )
+    end
+    assert_equal "Missing params[:betrag] for new Buchung.", exception.message
+
+  end
+  
+  def test_initialize_incorrect_transaktionstyp
+    exception = assert_raise( DTAUS::DTAUSException ) do
+      DTAUS::Buchung.new(
+        :auftraggeber_konto => @konto_auftraggeber,
+        :kunden_konto => @konto,
+        :betrag => 100.0,
+        :transaktionstyp => :xxx,
+        :verwendungszweck => "Vielen Dank für Ihren Einkauf!"
+      )
+    end
+    assert_equal "Transaktionstyp has to be one of [:lastschrift, :gutschrift]", exception.message
+  end
+
+  def test_initialize_incorrect_konto
+    exception = assert_raise( DTAUS::DTAUSException ) do
+      DTAUS::Buchung.new(
+        :auftraggeber_konto => @konto_auftraggeber,
+        :kunden_konto => 123456789,
+        :betrag => 100.0,
+        :verwendungszweck => "Vielen Dank für Ihren Einkauf!"
+      )
+    end
+    assert_equal "Konto expected for Parameter 'kunden_konto', got Fixnum", exception.message
+  end
+  
+  def test_initialize_correct_betrag
+    booking = DTAUS::Buchung.new(
+      :kunden_konto => @konto,
+      :betrag => 123,
+      :verwendungszweck => "Vielen Dank für Ihren Einkauf!"
+    )
+    assert_equal 12300, booking.betrag
+
+    booking = DTAUS::Buchung.new(
+      :kunden_konto => @konto,
+      :betrag => 123.00,
+      :verwendungszweck => "Vielen Dank für Ihren Einkauf!"
+    )
+    assert_equal 12300, booking.betrag
+
+    booking = DTAUS::Buchung.new(
+      :kunden_konto => @konto,
+      :betrag => 123.99,
+      :verwendungszweck => "Vielen Dank für Ihren Einkauf!"
+    )
+    assert_equal 12399, booking.betrag
+
+    booking = DTAUS::Buchung.new(
+      :kunden_konto => @konto,
+      :betrag => BigDecimal("123.98"),
+      :verwendungszweck => "Vielen Dank für Ihren Einkauf!"
+    )
+    assert_equal 12398, booking.betrag
+
+    booking = DTAUS::Buchung.new(
+      :kunden_konto => @konto,
+      :betrag => "123,85",
+      :verwendungszweck => "Vielen Dank für Ihren Einkauf!"
+    )
+    assert_equal 12385, booking.betrag
+
+    booking = DTAUS::Buchung.new(
+      :kunden_konto => @konto,
+      :betrag => BigDecimal("0.019"),
+      :verwendungszweck => "Vielen Dank für Ihren Einkauf!"
+    )
+    assert_equal 001, booking.betrag
+
+  end
+  
+  def test_initialize_incorrect_betrag
+    exception = assert_raise( DTAUS::DTAUSException ) do
+      DTAUS::Buchung.new(
+        :kunden_konto => @konto,
+        :betrag => "0.00",
+        :verwendungszweck => "Vielen Dank für Ihren Einkauf!"
+      )
+    end
+    assert_equal "Betrag must not be 0.00 €!", exception.message
+
+    exception = assert_raise( DTAUS::DTAUSException ) do
+      DTAUS::Buchung.new(
+        :kunden_konto => @konto,
+        :betrag => 0,
+        :verwendungszweck => "Vielen Dank für Ihren Einkauf!"
+      )
+    end
+    assert_equal "Betrag must not be 0.00 €!", exception.message
+  end
+
+  def test_initialize_incorrect_erweiterungen
+    exception = assert_raise( DTAUS::IncorrectSizeException ) do
+      konto = DTAUS::Konto.new(
+        :kontonummer => 1234567890, 
+        :blz => 12345678, 
+        :kontoinhaber => 'seeeeeeeehr laaaaaaaanger naaaaaame ' * 9, 
+        :bankname =>'Bank Name'
+      )
+
+      DTAUS::Buchung.new(
+        :kunden_konto => konto,
+        :betrag => 100.0,
+        :verwendungszweck => "Vielen Dank für Ihren Einkauf!" * 5
+      )
+    end
+    assert_equal "Zuviele Erweiterungen: 16, maximal 15. Verwendungszweck zu lang?", exception.message
+  end
+
+end

data/test/converter_test.rb

@@ -0,0 +1,33 @@
+require File.expand_path(File.dirname(__FILE__) + "/test_helper")
+
+class ConverterTest < Test::Unit::TestCase
+
+  def test_convert_text
+    assert_equal "ABC", DTAUS::Converter.convert_text("Abc")
+    assert_equal "AEOEUESS", DTAUS::Converter.convert_text("äöüß")
+    assert_equal "AEOEUE", DTAUS::Converter.convert_text("ÄÖÜ")
+    
+    # FAILS
+#    assert_equal "ÑØÇ", DTAUS::Converter.convert_text("Ñøç")
+  end
+
+  def test_convert_number
+    assert_equal 123, DTAUS::Converter.convert_number("123")
+    assert_equal 123, DTAUS::Converter.convert_number("0123")
+    assert_equal 234567, DTAUS::Converter.convert_number("23.45.67")
+    assert_equal 112345, DTAUS::Converter.convert_number("Hauptstraße 1a; 12345 Musterstadt")
+  end
+
+  def test_convert_number_incorrect_class
+    exception = assert_raise( DTAUS::DTAUSException ) do
+      DTAUS::Converter.convert_number(123.45)
+    end
+    assert_equal "Cannot convert Float to Integer", exception.message
+
+    exception = assert_raise( DTAUS::DTAUSException ) do
+      DTAUS::Converter.convert_number({:number => 123})
+    end
+    assert_equal "Cannot convert Hash to Integer", exception.message
+  end
+
+end

data/test/datensatz_test.rb

@@ -0,0 +1,202 @@
+require File.expand_path(File.dirname(__FILE__) + "/test_helper")
+
+class DatensatzTest < Test::Unit::TestCase
+
+  def setup
+    @konto = DTAUS::Konto.new(
+      :kontonummer => 1234567890, 
+      :blz => 12345678, 
+      :kontoinhaber => 'Kunde', 
+      :bankname =>'Bank Name'
+    )
+    @konto_auftraggeber = DTAUS::Konto.new(
+      :kontonummer => 9876543210, 
+      :blz => 12345678, 
+      :kontoinhaber => 'Auftraggeber', 
+      :bankname =>'Bank Name', 
+      :is_auftraggeber => true
+    )
+    @buchung = DTAUS::Buchung.new(
+      :auftraggeber_konto => @konto_auftraggeber,
+      :kunden_konto => @konto,
+      :betrag => 100.0,
+      :verwendungszweck => "Vielen Dank für Ihren Einkauf!"
+    )
+    @buchung_negativ = DTAUS::Buchung.new(
+      :auftraggeber_konto => @konto_auftraggeber,
+      :kunden_konto => @konto,
+      :betrag => -100.0,
+      :verwendungszweck => "Vielen Dank für Ihren Einkauf!"
+    )
+  end
+
+  def test_initialize
+    dta = DTAUS::Datensatz.new(:lastschrift, @konto_auftraggeber)
+    assert dta, "Datensatz kann ohne Datum angelegt werden"
+    assert_equal @konto_auftraggeber, dta.auftraggeber_konto
+    assert_in_delta Time.now, dta.ausfuehrungsdatum, 0.01
+    assert_equal :lastschrift, dta.transaktionstyp
+
+    time = DateTime.parse('2011-05-23T14:59:55+02:00')
+    dta = DTAUS::Datensatz.new(:lastschrift, @konto_auftraggeber, time)
+    assert dta, "Datensatz kann mit Datum und Zeit angelegt werden"
+    assert_equal @konto_auftraggeber, dta.auftraggeber_konto
+    assert_equal time, dta.ausfuehrungsdatum
+    assert_equal :lastschrift, dta.transaktionstyp
+
+    date = Date.parse('2011-05-23')
+    dta = DTAUS::Datensatz.new(:gutschrift, @konto_auftraggeber, date)
+    assert dta, "Datensatz kann mit Datum angelegt werden"
+    assert_equal @konto_auftraggeber, dta.auftraggeber_konto
+    assert_equal date, dta.ausfuehrungsdatum
+    assert_equal :gutschrift, dta.transaktionstyp
+  end
+
+  def test_initialize_incorrect_transaktionstyp
+    exception = assert_raise( DTAUS::DTAUSException ) do
+      DTAUS::Datensatz.new(:xxx, @konto_auftraggeber)
+    end
+    assert_equal "Transaktionstyp has to be one of [:lastschrift, :gutschrift]", exception.message
+  end
+
+  def test_initialize_incorrect_auftraggeber
+    exception = assert_raise( DTAUS::DTAUSException ) do
+      DTAUS::Datensatz.new(:lastschrift, '0123456789')
+    end
+    assert_equal "Konto expected, got String", exception.message
+  end
+
+  def test_initialize_incorrect_datetime
+    exception = assert_raise( DTAUS::DTAUSException ) do
+      DTAUS::Datensatz.new(:lastschrift, @konto_auftraggeber, 2011)
+    end
+    assert_equal "Date or Time expected, got Fixnum", exception.message
+  end
+
+  def test_add
+    dta = DTAUS::Datensatz.new(:lastschrift, @konto_auftraggeber)
+    assert_equal [], dta.buchungen
+    assert_equal nil, dta.positiv?
+
+    dta.add(@buchung)
+    assert_equal [@buchung], dta.buchungen
+    assert_equal true, dta.positiv?
+
+    dta.add(@buchung)
+    assert_equal [@buchung, @buchung], dta.buchungen
+    assert_equal true, dta.positiv?
+  end
+  
+  def test_add_incorrect_buchung
+    dta = DTAUS::Datensatz.new(:lastschrift, @konto_auftraggeber)
+
+    exception = assert_raise( DTAUS::DTAUSException ) do
+      dta.add("buchung")
+    end
+    assert_equal "Buchung expected, got String", exception.message
+  end
+
+  def test_add_mit_vorzeichenwechsel
+    dta = DTAUS::Datensatz.new(:lastschrift, @konto_auftraggeber)
+    assert_equal nil, dta.positiv?
+
+    dta.add(@buchung)
+    assert_equal true, dta.positiv?
+
+    exception = assert_raise( DTAUS::DTAUSException ) do
+      dta.add(@buchung_negativ)
+    end
+    assert_equal "Nicht erlaubter Vorzeichenwechsel! Buchung muss wie die vorherigen Buchungen positiv sein!", exception.message
+  end
+
+  def test_to_dta
+    dta = DTAUS::Datensatz.new(:lastschrift, @konto_auftraggeber, Date.parse('2011-05-23'))
+    
+    exception = assert_raise( DTAUS::DTAUSException ) do
+      dta.to_dta
+    end
+    assert_equal "Keine Buchungen vorhanden", exception.message
+    
+    dta.add(@buchung)
+    assert_equal \
+      "0128ALK1234567800000000AUFTRAGGEBER               230511    9876543210000"+
+      "0000000               23052011                        10216C0000000012345"+
+      "6781234567890000000000000005000 0000000000012345678987654321000000010000 "+
+      "  KUNDE                              AUFTRAGGEBER               VIELEN DA"+
+      "NK FUER IHREN EINK1  0102AUF!                                            "+
+      "                   0128E     00000010000000000000000000012345678900000000"+
+      "00123456780000000010000                                                   ", dta.to_dta
+
+    dta = DTAUS::Datensatz.new(:gutschrift, @konto_auftraggeber, Date.parse('2011-05-23'))
+    buchung = DTAUS::Buchung.new(
+      :auftraggeber_konto => @konto_auftraggeber,
+      :kunden_konto => @konto,
+      :betrag => 100.0,
+      :transaktionstyp => :gutschrift,
+      :verwendungszweck => "Vielen Dank für Ihren Einkauf!"
+    )
+    dta.add(buchung)
+    assert_equal \
+      "0128AGK1234567800000000AUFTRAGGEBER               230511    9876543210000"+
+      "0000000               23052011                        10216C0000000012345"+
+      "6781234567890000000000000051000 0000000000012345678987654321000000010000 "+
+      "  KUNDE                              AUFTRAGGEBER               VIELEN DA"+
+      "NK FUER IHREN EINK1  0102AUF!                                            "+
+      "                   0128E     00000010000000000000000000012345678900000000"+
+      "00123456780000000010000                                                   ", dta.to_dta
+  end
+  
+  def test_fuehrende_nullen
+    konto_s = DTAUS::Konto.new(
+      :kontonummer => "0034567890", 
+      :blz => 12345678, 
+      :kontoinhaber => 'Kunde', 
+      :bankname =>'Bank Name',
+      :kundennummer => "0099887766"
+    )
+    konto_auftraggeber_s = DTAUS::Konto.new(
+      :kontonummer => "0076543210", 
+      :blz => 12345678, 
+      :kontoinhaber => 'Auftraggeber', 
+      :bankname =>'Bank Name', 
+      :is_auftraggeber => true
+    )
+    buchung_s = DTAUS::Buchung.new(
+      :auftraggeber_konto => konto_auftraggeber_s,
+      :kunden_konto => konto_s,
+      :betrag => 100.0,
+      :verwendungszweck => "Vielen Dank für Ihren Einkauf!"
+    )
+    
+    dta_s = DTAUS::Datensatz.new(:lastschrift, konto_auftraggeber_s)
+    dta_s.add(buchung_s)
+    
+    # kontonummern und kundennummern ohne führende nullen (integer)
+    konto_i = DTAUS::Konto.new(
+      :kontonummer => 34567890, 
+      :blz => 12345678, 
+      :kontoinhaber => 'Kunde', 
+      :bankname =>'Bank Name',
+      :kundennummer => 99887766
+    )
+    konto_auftraggeber_i = DTAUS::Konto.new(
+      :kontonummer => 76543210, 
+      :blz => 12345678, 
+      :kontoinhaber => 'Auftraggeber', 
+      :bankname =>'Bank Name', 
+      :is_auftraggeber => true
+    )
+    buchung_i = DTAUS::Buchung.new(
+      :auftraggeber_konto => konto_auftraggeber_i,
+      :kunden_konto => konto_i,
+      :betrag => 100.0,
+      :verwendungszweck => "Vielen Dank für Ihren Einkauf!"
+    )
+    
+    dta_i = DTAUS::Datensatz.new(:lastschrift, konto_auftraggeber_i)
+    dta_i.add(buchung_i)
+    
+    assert_equal dta_s.to_dta, dta_i.to_dta
+  end
+  
+end

data/test/erweiterung_test.rb

@@ -0,0 +1,42 @@
+require File.expand_path(File.dirname(__FILE__) + "/test_helper")
+
+class ErweiterungTest < Test::Unit::TestCase
+
+  def test_initialize
+    erw = DTAUS::Erweiterung.new(:kunde, 'text')
+    
+    assert erw
+    assert_equal '01', erw.type
+    assert_equal 27, erw.text.size
+    assert_equal 'TEXT                       ', erw.text
+  end
+
+  def test_initialize_incorrect_type
+    exception = assert_raise( DTAUS::IncorrectErweiterungTypeException ) do
+      erw = DTAUS::Erweiterung.new(:fail, 'text')
+    end
+    assert_equal "Allowed types: :kunde, :verwendungszweck, :auftraggeber", exception.message
+  end
+  
+  def test_initialize_incorrect_size
+    exception = assert_raise( DTAUS::IncorrectSizeException ) do
+      erw = DTAUS::Erweiterung.new(:kunde, '1234567890123456789012345678')
+    end
+    assert_equal "Text size may not exceed 27 Chars", exception.message
+  end
+  
+  def test_from_string
+    erweiterungen = DTAUS::Erweiterung.from_string(:kunde, 'sehr langer text sehr langer text sehr langer text')
+    assert_equal 1, erweiterungen.size
+    assert_equal 'R TEXT SEHR LANGER TEXT    ', erweiterungen[0].text
+
+    erweiterungen = DTAUS::Erweiterung.from_string(:kunde, 'kurzer text')
+    assert_equal 0, erweiterungen.size
+
+    erweiterungen = DTAUS::Erweiterung.from_string(:kunde, 'längerer text mit ümläuten. ßÄÖÜ und trotzdem wird korrekt getrennt')
+    assert_equal 2, erweiterungen.size
+    assert_equal 'EN. SSAEOEUE UND TROTZDEM W', erweiterungen[0].text
+    assert_equal 'IRD KORREKT GETRENNT       ', erweiterungen[1].text
+  end
+
+end