king_dtaus 2.0.0 → 2.0.1.pre

data/spec/account_spec.rb

@@ -5,103 +5,189 @@ describe KingDta::Account do
 
   before :each do
     @ba = test_kto2 # BankAccount mocked as open struct
+    @dudes_konto = dudes_konto
   end
 
   it "should initialize a new account" do
-    lambda{ 
-      KingDta::Account.new(:bank_account_number => @ba.bank_account_number,
-                           :bank_number => @ba.bank_number,
-                           :owner_name => @ba.owner_name)
-    }.should_not raise_error
+    lambda{ KingDta::Account.new(:account_number => @ba.account_number, :bank_number => @ba.bank_number, :client_name => @ba.client_name) }.should_not raise_error
   end
 
   it "should initialize a new dtazv account" do
-    lambda{ 
-      KingDta::Account.new(sender_opts)
-    }.should_not raise_error
+    lambda{ KingDta::Account.new(
+              :account_number =>    @dudes_konto.account_number,
+              :bank_number =>       @dudes_konto.bank_number,
+              :client_name =>       @dudes_konto.client_name,
+              :client_number =>     @dudes_konto.client_number,
+              :bank_street =>       @dudes_konto.account_street,
+              :bank_city =>         @dudes_konto.account_city,
+              :bank_zip_code =>     @dudes_konto.account_zip_code,
+              :bank_name =>         @dudes_konto.bank_name,
+              :client_street =>     @dudes_konto.client_street,
+              :client_city =>       @dudes_konto.client_city,
+              :client_zip_code =>   @dudes_konto.client_zip_code
+          )}.should_not raise_error
   end
 
   it "should fail if bank account number is invalid" do
-    lambda{ 
-      KingDta::Account.new(:bank_account_number => 123456789011123456789011123456789011,
-                           :bank_number => @ba.bank_number,
-                           :owner_name => @ba.owner_name)
-
-    }.should raise_error(ArgumentError, 'Bank account number too long, max 10 allowed')
+    # lambda{ KingDta::Account.new(0, @ba.bank_number, @ba.client_name) }.should raise_error(ArgumentError)
+    lambda{ KingDta::Account.new(:account_number => 123456789011123456789011123456789011123456789011123456789011123456789011, :bank_number => @ba.bank_number, :client_name => @ba.client_name) }.should raise_error(ArgumentError, 'Account number too long, max 35 allowed')
   end
 
   it "should fail if bank number is invalid" do
-    lambda{ 
-      KingDta::Account.new( :bank_account_number => @ba.bank_account_number,
-                            :bank_number => 0,
-                            :owner_name => @ba.owner_name)
-    }.should raise_error(ArgumentError)
-
-    lambda{ 
-      KingDta::Account.new( :bank_account_number => @ba.bank_account_number,
-                            :bank_number => 123456789101112,
-                            :owner_name => @ba.owner_name)
-    }.should raise_error(ArgumentError, 'Bank number too long, max 8 allowed')
+    lambda{ KingDta::Account.new(:account_number => @ba.account_number, :bank_number => 0, :client_name => @ba.client_name) }.should raise_error(ArgumentError)
+    lambda{ KingDta::Account.new(:account_number => @ba.account_number, :bank_number => 123456789101112, :client_name => @ba.client_name) }.should raise_error(ArgumentError, 'Bank number too long, max 11 allowed')
   end
 
-  it "should fail if owner number is too long" do
-    lambda{ 
-      KingDta::Account.new( :bank_account_number => @ba.bank_account_number,
-                            :bank_number => @ba.bank_number,
-                            :owner_name => @ba.owner_name,
-                            :owner_number => 12345678901)
-    }.should raise_error(ArgumentError, 'Owner number too long, max 10 allowed')
+  it "should fail if clent number is too long" do
+    lambda{ KingDta::Account.new(:account_number => @ba.account_number, :bank_number => @ba.bank_number, :client_name => @ba.client_name, :client_number => 12345678901) }.should raise_error(ArgumentError, 'Client number too long, max 10 allowed')
   end
 
-  it "should fail if street and/or Zip Code is too long" do    
-    opts = sender_opts.merge( :bank_street => "Lorem ipsum dolor sit amet, consectetur")
-    lambda{
-      KingDta::Account.new(opts)
-    }.should raise_error(ArgumentError, 'Bank street too long, max 35 allowed')
+  it "should fail if street and/or Zip Code is too long" do
+    lambda{ KingDta::Account.new(
+            :account_number =>    @dudes_konto.account_number,
+            :bank_number =>       @dudes_konto.bank_number,
+            :client_name =>       @dudes_konto.client_name,
+            :client_number =>     @dudes_konto.client_number,
+            :bank_street =>       "Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.",
+            :bank_city =>         @dudes_konto.account_city,
+            :bank_zip_code =>     @dudes_konto.account_zip_code,
+            :bank_name =>         @dudes_konto.bank_name,
+            :client_street =>     @dudes_konto.client_street,
+            :client_city =>       @dudes_konto.client_city,
+            :client_zip_code =>   @dudes_konto.client_zip_code
+          )}.should raise_error(ArgumentError, 'Street and/or Zip Code too long, max 35 allowed')
   end
 
   it "should fail if city is too long" do
-    opts = sender_opts.merge( :bank_city => "Lorem ipsum dolor sit amet, consecte")
-    lambda{ 
-      KingDta::Account.new opts
-    }.should raise_error(ArgumentError, 'Bank city too long, max 35 allowed')
+    lambda{ KingDta::Account.new(
+            :account_number =>    @dudes_konto.account_number,
+            :bank_number =>       @dudes_konto.bank_number,
+            :client_name =>       @dudes_konto.client_name,
+            :client_number =>     @dudes_konto.client_number,
+            :bank_street =>       @dudes_konto.account_street,
+            :bank_city =>         "Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.",
+            :bank_zip_code =>     @dudes_konto.account_zip_code,
+            :bank_name =>         @dudes_konto.account_bank_name,
+            :client_street =>     @dudes_konto.client_street,
+            :client_city =>       @dudes_konto.client_city,
+            :client_zip_code =>   @dudes_konto.client_zip_code
+          )}.should raise_error(ArgumentError, 'City too long, max 35 allowed')
   end
 
   it "should fail if bank name is too long" do
-    opts = sender_opts.merge( :bank_name => "Lorem ipsum dolor sit amet, consecte")
-    lambda{
-      KingDta::Account.new opts
-    }.should raise_error(ArgumentError, 'Bank name too long, max 35 allowed')
+    lambda{ KingDta::Account.new(
+            :account_number =>    @dudes_konto.account_number,
+            :bank_number =>       @dudes_konto.bank_number,
+            :client_name =>       @dudes_konto.client_name,
+            :client_number =>     @dudes_konto.client_number,
+            :bank_street =>       @dudes_konto.account_street,
+            :bank_city =>         @dudes_konto.account_city,
+            :bank_zip_code =>     @dudes_konto.account_zip_code,
+            :bank_name =>         "Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.",
+            :client_street =>     @dudes_konto.client_street,
+            :client_city =>       @dudes_konto.client_city,
+            :client_zip_code =>   @dudes_konto.client_zip_code
+          )}.should raise_error(ArgumentError, 'Bank Name too long, max 35 allowed')
   end
 
-  it "should fail if client street is too long" do
-    opts = sender_opts.merge( :owner_street => "Lorem ipsum dolor sit amet, consecte")
-    lambda{
-      KingDta::Account.new opts
-    }.should raise_error(ArgumentError, 'Owner street too long, max 35 allowed')
+  it "should fail if sender street and/or zipcode is too long" do
+    lambda{ KingDta::Account.new(
+            :account_number =>    @dudes_konto.account_number,
+            :bank_number =>       @dudes_konto.bank_number,
+            :client_name =>       @dudes_konto.client_name,
+            :client_number =>     @dudes_konto.client_number,
+            :bank_street =>       @dudes_konto.account_street,
+            :bank_city =>         @dudes_konto.account_city,
+            :bank_zip_code =>     @dudes_konto.account_zip_code,
+            :bank_name =>         @dudes_konto.bank_name,
+            :client_street =>     "Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.",
+            :client_city =>       @dudes_konto.client_city,
+            :client_zip_code =>   @dudes_konto.client_zip_code
+          )}.should raise_error(ArgumentError, 'Client Street and/or Zip Code too long, max 35 allowed')
   end
 
   it "should fail if city is too long" do
-    opts = sender_opts.merge( :owner_city => "Lorem ipsum dolor sit amet, consecte")
-    lambda{
-      KingDta::Account.new opts
-    }.should raise_error(ArgumentError, 'Owner city too long, max 35 allowed')
+    lambda{ KingDta::Account.new(
+            :account_number =>    @dudes_konto.account_number,
+            :bank_number =>       @dudes_konto.bank_number,
+            :client_name =>       @dudes_konto.client_name,
+            :client_number =>     @dudes_konto.client_number,
+            :bank_street =>       @dudes_konto.account_street,
+            :bank_city =>         @dudes_konto.account_city,
+            :bank_zip_code =>     @dudes_konto.account_zip_code,
+            :bank_name =>         @dudes_konto.bank_name,
+            :client_street =>     @dudes_konto.client_street,
+            :client_city =>       "Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.",
+            :client_zip_code =>   @dudes_konto.client_zip_code
+          )}.should raise_error(ArgumentError, 'Client City too long, max 35 allowed')
   end
 
   it "should return account street and zip" do
-    acnt = KingDta::Account.new( sender_opts )
-    acnt.bank_zip_city.should == "51063 BANK KOELN"
+    konto = KingDta::Account.new(
+      :account_number =>    @dudes_konto.account_number,
+      :bank_number =>       @dudes_konto.bank_number,
+      :client_name =>       @dudes_konto.client_name,
+      :client_number =>     @dudes_konto.client_number,
+      :bank_street =>       @dudes_konto.account_street,
+      :bank_city =>         @dudes_konto.account_city,
+      :bank_zip_code =>     @dudes_konto.account_zip_code,
+      :bank_name =>         @dudes_konto.bank_name,
+      :client_street =>     @dudes_konto.client_street,
+      :client_city =>       @dudes_konto.client_city,
+      :client_zip_code =>   @dudes_konto.client_zip_code
+    )
+    konto.zip_city.should == "51063 BANK KOELN"
   end
 
   it "should return sender street and zip" do
-    acnt = KingDta::Account.new( sender_opts )
-    acnt.owner_zip_city.should == "51063 MEINE KOELN"
+    konto = KingDta::Account.new(
+      :account_number =>    @dudes_konto.account_number,
+      :bank_number =>       @dudes_konto.bank_number,
+      :client_name =>       @dudes_konto.client_name,
+      :client_number =>     @dudes_konto.client_number,
+      :bank_street =>       @dudes_konto.account_street,
+      :bank_city =>         @dudes_konto.account_city,
+      :bank_zip_code =>     @dudes_konto.account_zip_code,
+      :bank_name =>         @dudes_konto.bank_name,
+      :client_street =>     @dudes_konto.client_street,
+      :client_city =>       @dudes_konto.client_city,
+      :client_zip_code =>   @dudes_konto.client_zip_code
+    )
+    konto.client_zip_city.should == "51063 MEINE KOELN"
+  end
+
+  it "should return sender name1 - the first 35 characters of a name" do
+    konto = KingDta::Account.new(
+      :account_number =>    @dudes_konto.account_number,
+      :bank_number =>       @dudes_konto.bank_number,
+      :client_name =>       @dudes_konto.client_name,
+      :client_number =>     @dudes_konto.client_number,
+      :bank_street =>       @dudes_konto.account_street,
+      :bank_city =>         @dudes_konto.account_city,
+      :bank_zip_code =>     @dudes_konto.account_zip_code,
+      :bank_name =>         @dudes_konto.bank_name,
+      :client_street =>     @dudes_konto.client_street,
+      :client_city =>       @dudes_konto.client_city,
+      :client_zip_code =>   @dudes_konto.client_zip_code
+    )
+    konto.client_name_1.should == "JAN KUS"
   end
 
-  it "should set owner country code from iban" do
-    opts = receiver_opts
-    opts[:owner_country_code] = nil
-    acnt = KingDta::Account.new( opts )
-    acnt.owner_country_code.should == "PL"
+  it "should return sender name1 - the characters 36 - 70 of a name" do
+    konto = KingDta::Account.new(
+      :account_number =>    @dudes_konto.account_number,
+      :bank_number =>       @dudes_konto.bank_number,
+      :client_name =>       @dudes_konto.client_name,
+      :client_number =>     @dudes_konto.client_number,
+      :bank_street =>       @dudes_konto.account_street,
+      :bank_city =>         @dudes_konto.account_city,
+      :bank_zip_code =>     @dudes_konto.account_zip_code,
+      :bank_name =>         @dudes_konto.bank_name,
+      :client_street =>     @dudes_konto.client_street,
+      :client_city =>       @dudes_konto.client_city,
+      :client_zip_code =>   @dudes_konto.client_zip_code
+    )
+    konto.client_name_2.should == nil
   end
-end
+
+end

data/spec/booking_spec.rb

@@ -4,7 +4,9 @@ require 'spec_helper'
 describe KingDta::Booking do
 
   before :each do
-    @account = KingDta::Account.new(receiver_opts)
+    kto1 = test_kto1
+    kto2 = test_kto2
+    @account = KingDta::Account.new(:account_number => kto2.account_number, :bank_number => kto2.bank_number, :client_name => kto2.client_name, :bank_name => kto2.bank_name )
   end
 
   it "should have no rounding error for string" do

data/spec/dtaus_spec.rb

@@ -8,9 +8,9 @@ describe KingDta::Dtaus do
     @dtaus_gk = KingDta::Dtaus.new('GK', Date.today)
     @kto1 = test_kto1
     @kto2 = test_kto2
-    @dtaus.account = KingDta::Account.new(:bank_account_number => @kto1.bank_account_number, :bank_number => @kto1.bank_number, :owner_name => @kto1.owner_name, :bank_name => @kto1.bank_name)
-    @dtaus_gk.account = KingDta::Account.new(:bank_account_number => @kto1.bank_account_number, :bank_number => @kto1.bank_number, :owner_name => @kto1.owner_name, :bank_name => @kto1.bank_name)
-    @booking = KingDta::Booking.new(KingDta::Account.new(:bank_account_number => @kto2.bank_account_number, :bank_number => @kto2.bank_number, :owner_name => @kto2.owner_name, :bank_name => @kto2.bank_name), 220.25 )
+    @dtaus.account = KingDta::Account.new(:account_number => @kto1.account_number, :bank_number => @kto1.bank_number, :client_name => @kto1.client_name, :bank_name => @kto1.bank_name)
+    @dtaus_gk.account = KingDta::Account.new(:account_number => @kto1.account_number, :bank_number => @kto1.bank_number, :client_name => @kto1.client_name, :bank_name => @kto1.bank_name)
+    @booking = KingDta::Booking.new(KingDta::Account.new(:account_number => @kto2.account_number, :bank_number => @kto2.bank_number, :client_name => @kto2.client_name, :bank_name => @kto2.bank_name), 220.25 )
   end
 
   it "should not init without values" do
@@ -41,7 +41,7 @@ describe KingDta::Dtaus do
 
   it "should not add a booking if closed" do
     @dtaus.add(@booking)
-    negative_booking = KingDta::Booking.new(KingDta::Account.new(:bank_account_number => @kto2.bank_account_number, :bank_number => @kto2.bank_number, :owner_name => @kto2.owner_name, :bank_name => @kto2.bank_name ), -120.25 )
+    negative_booking = KingDta::Booking.new(KingDta::Account.new(:account_number => @kto2.account_number, :bank_number => @kto2.bank_number, :client_name => @kto2.client_name, :bank_name => @kto2.bank_name ), -120.25 )
     lambda{ @dtaus.add(negative_booking) }.should raise_error(KingDta::Exception)
   end
 
@@ -55,7 +55,7 @@ describe KingDta::Dtaus do
     out = "0128ALK3704004400000000GIMME YOUR MONEY AG        #{Date.today.strftime("%d%m%y")}    78289700370000000000               #{Date.today.strftime("%d%m%Y")}                        1"
     str.should == out
     #60-70 kontonummer mit nullen aufgefüllt - hier nicht da ktnr == 10 stellen
-    str[60...70].should == "#{test_kto1.bank_account_number}"
+    str[60...70].should == "#{test_kto1.account_number}"
     str.should include(test_kto1.bank_number)
   end
 
@@ -85,31 +85,17 @@ describe KingDta::Dtaus do
     @dtaus.add_c(@booking)
     str = @dtaus.dta_string
     str.length.should == 256
-    str.should include(@kto2.owner_name.upcase)
+    str.should include(@kto2.client_name.upcase)
     out = "0216C00000000370400440002787777000000000000005000 0000000000037040044782897003700000022025   PETER & MAY GMBH                           GIMME YOUR MONEY AGSALESKING MONATSBEITRAG 08/1  010210 FREELANCER VERSION                                              "
     str.should == out
   end
 
-  it "should create c-sektion with long account owner name in extension" do
-    @dtaus.account = KingDta::Account.new(:bank_account_number => @kto1.bank_account_number, :bank_number => @kto1.bank_number, 
-                                          :owner_name =>  'A very long name exeeding 27 characters even longer 54 chars', :bank_name => @kto1.bank_name)
-
-    @dtaus.add(@booking)
-    @dtaus.bookings.first.text = 'SalesKing Monatsbeitrag 08/10 Freelancer Version'
-    @dtaus.add_c(@booking)
-    str = @dtaus.dta_string
-    str.length.should == 256
-    str.should include(@kto2.owner_name.upcase)
-    out = "0245C00000000370400440002787777000000000000005000 0000000000037040044782897003700000022025   PETER & MAY GMBH                   A VERY LONG NAME EXEEDING 2SALESKING MONATSBEITRAG 08/1  020210 FREELANCER VERSION      037 CHARACTERS EVEN LONGER 54           "
-    str.should == out
-  end
-
   it "should create c-sektion with default booking text" do
     @dtaus.default_text = 'Default verwendungszweck'
     @dtaus.add_c(@booking)
     str = @dtaus.dta_string
     str.length.should == 256
-    str.should include(@kto2.owner_name.upcase)
+    str.should include(@kto2.client_name.upcase)
     out = "0187C00000000370400440002787777000000000000005000 0000000000037040044782897003700000022025   PETER & MAY GMBH                           GIMME YOUR MONEY AGDEFAULT VERWENDUNGSZWECK   1  00                                                                     "
     str.should == out
   end
@@ -119,8 +105,8 @@ describe KingDta::Dtaus do
     @dtaus.add(@booking)
     str = @dtaus.create
     str.length.should == 512
-    str.should include(@kto1.owner_name.upcase)
-    str.should include(@kto2.owner_name.upcase)
+    str.should include(@kto1.client_name.upcase)
+    str.should include(@kto2.client_name.upcase)
     str.should include(@dtaus.default_text.upcase)
     out = "0128ALK3704004400000000GIMME YOUR MONEY AG        #{Date.today.strftime("%d%m%y")}    78289700370000000000               #{Date.today.strftime("%d%m%Y")}                        1"+
           "0187C00000000370400440002787777000000000000005000 0000000000037040044782897003700000022025   PETER & MAY GMBH                           GIMME YOUR MONEY AGDEFAULT VERWENDUNGSZWECK   1  00                                                                     "+
@@ -128,21 +114,12 @@ describe KingDta::Dtaus do
     str.should == out
   end
 
-  it "should create whole dta string with long texts exeeding extension" do
-    @dtaus.account = KingDta::Account.new(:bank_account_number => @kto1.bank_account_number, :bank_number => @kto1.bank_number,
-                                          :owner_name =>  'A very long name exeeding 27 characters even longer 54 chars', :bank_name => @kto1.bank_name)
-    @dtaus.add(@booking)
-    @dtaus.bookings.first.text = 'Rgn R-3456-0102220 Monatsbeitrag 08/10 Freelancer Version Vielen Dank Ihre SalesKing GmbH' * 20
-    @dtaus.bookings.first.account.owner_name =  'A very long name exeeding 27 characters even longer 54 chars'
-    str = @dtaus.create ## should not raise error
-  end
-
   it "should create whole dta string with long booking text in extension" do
     @dtaus.add(@booking)
     @dtaus.bookings.first.text = 'Rgn R-3456-0102220 Monatsbeitrag 08/10 Freelancer Version Vielen Dank Ihre SalesKing GmbH'
     str = @dtaus.create
     str.length.should == 640
-    str.should include(@kto2.owner_name.upcase)
+    str.should include(@kto2.client_name.upcase)
     out = "0128ALK3704004400000000GIMME YOUR MONEY AG        #{Date.today.strftime("%d%m%y")}    78289700370000000000               #{Date.today.strftime("%d%m%Y")}                        1"+
           "0274C00000000370400440002787777000000000000005000 0000000000037040044782897003700000022025   PETER & MAY GMBH                           GIMME YOUR MONEY AGRGN R-3456-0102220 MONATSBE1  0302ITRAG 08/10 FREELANCER VERS02ION VIELEN DANK IHRE SALESK           02ING GMBH                                                                                                                      "+
           "0128E     0000001000000000000000000000002787777000000000370400440000000022025                                                   "
@@ -154,8 +131,8 @@ describe KingDta::Dtaus do
     6.times { @dtaus.add(@booking) }
     str = @dtaus.create
     str.length.should == 1792
-    str.should include(@kto1.owner_name.upcase)
-    str.should include(@kto2.owner_name.upcase)
+    str.should include(@kto1.client_name.upcase)
+    str.should include(@kto2.client_name.upcase)
     str.should include(@dtaus.default_text.upcase)
     out = "0128ALK3704004400000000GIMME YOUR MONEY AG        #{Date.today.strftime("%d%m%y")}    78289700370000000000               #{Date.today.strftime("%d%m%Y")}                        1"+
           "0187C00000000370400440002787777000000000000005000 0000000000037040044782897003700000022025   PETER & MAY GMBH                           GIMME YOUR MONEY AGDEFAULT VERWENDUNGSZWECK   1  00                                                                     "+