SL/BackgroundJob/SelfTest/Transactions.pm

   1 package SL::BackgroundJob::SelfTest::Transactions;
   2
   3 use utf8;
   4 use strict;
   5 use parent qw(SL::BackgroundJob::SelfTest::Base);
   6
   7 use SL::DBUtils;
   8
   9 use Rose::Object::MakeMethods::Generic (
  10   scalar => [ qw(dbh fromdate todate) ],
  11 );
  12
  13 sub run {
  14   my ($self) = @_;
  15
  16   $self->_setup;
  17
  18   $self->tester->plan(tests => 18);
  19
  20   $self->check_konten_mit_saldo_nicht_in_guv;
  21   $self->check_bilanzkonten_mit_pos_eur;
  22   $self->check_balanced_individual_transactions;
  23   $self->check_verwaiste_acc_trans_eintraege;
  24   $self->check_verwaiste_invoice_eintraege;
  25   $self->check_ar_acc_trans_amount;
  26   $self->check_netamount_laut_invoice_ar;
  27   $self->check_invnumbers_unique;
  28   $self->check_summe_stornobuchungen;
  29   $self->check_ar_paid;
  30   $self->check_ap_paid;
  31   $self->check_ar_overpayments;
  32   $self->check_ap_overpayments;
  33   $self->check_paid_stornos;
  34   $self->check_stornos_ohne_partner;
  35   $self->check_overpayments;
  36   $self->check_every_account_with_taxkey;
  37   $self->calc_saldenvortraege;
  38 }
  39
  40 sub _setup {
  41   my ($self) = @_;
  42
  43   # TODO FIXME calc dates better, unless this is wanted
  44   $self->fromdate(DateTime->new(day => 1, month => 1, year => DateTime->today->year));
  45   $self->todate($self->fromdate->clone->add(years => 1)->add(days => -1));
  46
  47   $self->dbh($::form->get_standard_dbh);
  48 }
  49
  50 sub check_konten_mit_saldo_nicht_in_guv {
  51   my ($self) = @_;
  52
  53   my $query = qq|
  54     SELECT c.accno, c.description, c.category, SUM(a.amount) AS Saldo
  55     FROM chart c,
  56          acc_trans a
  57     WHERE c.id = a.chart_id
  58      and  (c.category like 'I' or c.category like 'E')
  59      and  amount != 0
  60      and  pos_eur is null
  61          and  a.transdate >= ? and a.transdate <= ?
  62     GROUP BY c.accno,c.description,c.category,c.pos_bilanz,c.pos_eur
  63     ORDER BY c.accno|;
  64
  65   my $konten_nicht_in_guv =  selectall_hashref_query($::form, $self->dbh, $query, $self->fromdate, $self->todate);
  66
  67   my $correct = 0 == scalar grep { $_->{Saldo} } @$konten_nicht_in_guv;
  68
  69   $self->tester->ok($correct, "Erfolgskonten mit Saldo nicht in GuV (Saldenvortragskonten können ignoriert werden, sollten aber 0 sein)");
  70   if (!$correct) {
  71     for my $konto (@$konten_nicht_in_guv) {
  72       $self->tester->diag($konto);
  73     }
  74   }
  75 }
  76
  77 sub check_bilanzkonten_mit_pos_eur {
  78   my ($self) = @_;
  79
  80   my $query = qq|SELECT accno, description FROM chart WHERE (category = 'A' OR category = 'L' OR category = 'Q') AND (pos_eur IS NOT NULL OR pos_eur != 0)|;
  81
  82   my $bilanzkonten_mit_pos_eur = selectall_hashref_query($::form, $self->dbh, $query);
  83   if (@$bilanzkonten_mit_pos_eur) {
  84      $self->tester->ok(0, "Es gibt Bilanzkonten die der GuV/EÜR zugeordnet sind)");
  85      $self->tester->diag("$_->{accno}  $_->{description}") for @$bilanzkonten_mit_pos_eur;
  86   } else {
  87      $self->tester->ok(1, "Keine Bilanzkonten in der GuV");
  88   }
  89 }
  90
  91 sub check_balanced_individual_transactions {
  92   my ($self) = @_;
  93
  94   my $query = qq|
  95     select sum(ac.amount) as amount,trans_id,ar.invnumber as ar,ap.invnumber as ap,gl.reference as gl
  96       from acc_trans ac
  97       left join ar on (ar.id = ac.trans_id)
  98       left join ap on (ap.id = ac.trans_id)
  99       left join gl on (gl.id = ac.trans_id)
 100     where ac.transdate >= ? AND ac.transdate <= ?
 101     group by trans_id,ar.invnumber,ap.invnumber,gl.reference
 102     having sum(ac.amount) != 0;|;
 103
 104   my $acs = selectall_hashref_query($::form, $self->dbh, $query, $self->fromdate, $self->todate);
 105   if (@$acs) {
 106     $self->tester->ok(0, "Es gibt unausgeglichene acc_trans-Transaktionen:");
 107     for my $ac (@{ $acs }) {
 108       $self->tester->diag("trans_id: $ac->{trans_id},  amount = $ac->{amount}, ar: $ac->{ar} ap: $ac->{ap} gl: $ac->{gl}");
 109     }
 110   } else {
 111     $self->tester->ok(1, "Alle acc_trans Transaktionen ergeben in Summe 0, keine unausgeglichenen Transaktionen");
 112   }
 113 }
 114
 115 sub check_verwaiste_acc_trans_eintraege {
 116   my ($self) = @_;
 117
 118   my $query = qq|
 119       select trans_id,amount,accno,description from acc_trans a
 120     left join chart c on (c.id = a.chart_id)
 121     where trans_id not in (select id from gl union select id from ar union select id from ap order by id)
 122       and a.transdate >= ? and a.transdate <= ? ;|;
 123
 124   my $verwaiste_acs = selectall_hashref_query($::form, $self->dbh, $query, $self->fromdate, $self->todate);
 125   if (@$verwaiste_acs) {
 126      $self->tester->ok(0, "Es gibt verwaiste acc-trans Einträge! (wo ar/ap/gl-Eintrag fehlt)");
 127      $self->tester->diag($_) for @$verwaiste_acs;
 128   } else {
 129      $self->tester->ok(1, "Keine verwaisten acc-trans Einträge (wo ar/ap/gl-Eintrag fehlt)");
 130   }
 131 }
 132
 133 sub check_verwaiste_invoice_eintraege {
 134   # this check is always run for all invoice entries in the entire database
 135   my ($self) = @_;
 136   my $query = qq|
 137      select * from invoice i
 138       where trans_id not in (select id from ar union select id from ap order by id) |;
 139
 140   my $verwaiste_invoice = selectall_hashref_query($::form, $self->dbh, $query);
 141   if (@$verwaiste_invoice) {
 142      $self->tester->ok(0, "Es gibt verwaiste invoice Einträge! (wo ar/ap-Eintrag fehlt)");
 143      for my $invoice ( @{ $verwaiste_invoice }) {
 144         $self->tester->diag("invoice: id: $invoice->{id}  trans_id: $invoice->{trans_id}   description: $invoice->{description}  itime: $invoice->{itime}");
 145      };
 146   } else {
 147      $self->tester->ok(1, "Keine verwaisten invoice Einträge (wo ar/ap-Eintrag fehlt)");                                                                                       }
 148 }
 149
 150 sub check_netamount_laut_invoice_ar {
 151   my ($self) = @_;
 152   my $query = qq|
 153     select sum(round(cast(i.qty*(i.fxsellprice * (1-i.discount)) as numeric), 2))
 154     from invoice i
 155     left join ar a on (a.id = i.trans_id)
 156     where a.transdate >= ? and a.transdate <= ?;|;
 157   my ($netamount_laut_invoice) =  selectfirst_array_query($::form, $self->dbh, $query, $self->fromdate, $self->todate);
 158
 159   $query = qq| select sum(netamount) from ar where transdate >= ? and transdate <= ?; |;
 160   my ($netamount_laut_ar) =  selectfirst_array_query($::form, $self->dbh, $query, $self->fromdate, $self->todate);
 161
 162   my $correct = $netamount_laut_invoice - $netamount_laut_ar == 0;
 163
 164   $self->tester->ok($correct, "Summe laut Verkaufsbericht sollte gleich Summe aus Verkauf -> Berichte -> Rechnungen sein");
 165   if (!$correct) {
 166     $self->tester->diag("Netto-Summe laut Verkaufsbericht (invoice): $netamount_laut_invoice");
 167     $self->tester->diag("Netto-Summe laut Verkauf -> Berichte -> Rechnungen: $netamount_laut_ar");
 168   }
 169 }
 170
 171 sub check_invnumbers_unique {
 172   my ($self) = @_;
 173
 174   my $query = qq| select  invnumber,count(invnumber) as count from ar
 175                where transdate >= ? and transdate <= ?
 176                group by invnumber
 177                having count(invnumber) > 1; |;
 178   my $non_unique_invnumbers =  selectall_hashref_query($::form, $self->dbh, $query, $self->fromdate, $self->todate);
 179
 180   if (@$non_unique_invnumbers) {
 181     $self->tester->ok(0, "Es gibt doppelte Rechnungsnummern");
 182     for my $invnumber (@{ $non_unique_invnumbers }) {
 183       $self->tester->diag("invnumber: $invnumber->{invnumber}    $invnumber->{count}x");
 184     }
 185   } else {
 186     $self->tester->ok(1, "Alle Rechnungsnummern sind eindeutig");
 187   }
 188 }
 189
 190 sub check_summe_stornobuchungen {
 191   my ($self) = @_;
 192
 193   my $query = qq|
 194     select sum(amount) from ar a JOIN customer c ON (a.customer_id = c.id)
 195     WHERE storno is true
 196       AND a.transdate >= ? and a.transdate <= ?|;
 197   my ($summe_stornobuchungen_ar) = selectfirst_array_query($::form, $self->dbh, $query, $self->fromdate, $self->todate);
 198
 199   $query = qq|
 200     select sum(amount) from ap a JOIN vendor c ON (a.vendor_id = c.id)
 201     WHERE storno is true
 202       AND a.transdate >= ? and a.transdate <= ?|;
 203   my ($summe_stornobuchungen_ap) = selectfirst_array_query($::form, $self->dbh, $query, $self->fromdate, $self->todate);
 204
 205   $self->tester->ok($summe_stornobuchungen_ap == 0, 'Summe aller Einkaufsrechnungen (stornos + stornierte) soll 0 sein');
 206   $self->tester->ok($summe_stornobuchungen_ar == 0, 'Summe aller Verkaufsrechnungen (stornos + stornierte) soll 0 sein');
 207   $self->tester->diag("Summe Einkaufsrechnungen (ar): $summe_stornobuchungen_ar") if $summe_stornobuchungen_ar;
 208   $self->tester->diag("Summe Einkaufsrechnungen (ap): $summe_stornobuchungen_ap") if $summe_stornobuchungen_ap;
 209 }
 210
 211 sub check_ar_paid {
 212   my ($self) = @_;
 213
 214   my $query = qq|
 215       select invnumber,paid,
 216            (select sum(amount) from acc_trans a left join chart c on (c.id = a.chart_id) where trans_id = ar.id and c.link like '%AR_paid%') as accpaid ,
 217            paid+(select sum(amount) from acc_trans a left join chart c on (c.id = a.chart_id) where trans_id = ar.id and c.link like '%AR_paid%') as diff
 218     from ar
 219     where
 220           (select sum(amount) from acc_trans a left join chart c on (c.id = a.chart_id) where trans_id = ar.id and c.link like '%AR_paid%') is not null
 221             AND storno is false
 222       AND transdate >= ? and transdate <= ?
 223     order by diff |;
 224
 225   my $paid_diffs_ar = selectall_hashref_query($::form, $self->dbh, $query, $self->fromdate, $self->todate);
 226
 227   my $errors = scalar grep { $_->{diff} != 0 } @$paid_diffs_ar;
 228
 229   $self->tester->ok(!$errors, "Vergleich ar paid mit acc_trans AR_paid");
 230
 231   for my $paid_diff_ar (@{ $paid_diffs_ar }) {
 232     next if $paid_diff_ar->{diff} == 0;
 233     $self->tester->diag("ar invnumber: $paid_diff_ar->{invnumber} : paid: $paid_diff_ar->{paid}    acc_paid= $paid_diff_ar->{accpaid}    diff: $paid_diff_ar->{diff}");
 234   }
 235 }
 236
 237 sub check_ap_paid {
 238   my ($self) = @_;
 239
 240   my $query = qq|
 241       select invnumber,paid,
 242             (select sum(amount) from acc_trans a left join chart c on (c.id = a.chart_id) where trans_id = ap.id and c.link like '%AP_paid%') as accpaid ,
 243             paid-(select sum(amount) from acc_trans a left join chart c on (c.id = a.chart_id) where trans_id = ap.id and c.link like '%AP_paid%') as diff
 244      from ap
 245      where
 246            (select sum(amount) from acc_trans a left join chart c on (c.id = a.chart_id) where trans_id = ap.id and c.link like '%AP_paid%') is not null
 247        AND transdate >= ? and transdate <= ?
 248      order by diff |;
 249
 250   my $paid_diffs_ap = selectall_hashref_query($::form, $self->dbh, $query, $self->fromdate, $self->todate);
 251
 252   my $errors = scalar grep { $_->{diff} != 0 } @$paid_diffs_ap;
 253
 254   $self->tester->ok(!$errors, "Vergleich ap paid mit acc_trans AP_paid");
 255   for my $paid_diff_ap (@{ $paid_diffs_ap }) {
 256      next if $paid_diff_ap->{diff} == 0;
 257      $self->tester->diag("ap invnumber: $paid_diff_ap->{invnumber} : paid: $paid_diff_ap->{paid}    acc_paid= $paid_diff_ap->{accpaid}    diff: $paid_diff_ap->{diff}");
 258   }
 259 }
 260
 261 sub check_ar_overpayments {
 262   my ($self) = @_;
 263
 264   my $query = qq|
 265        select invnumber,paid,amount,transdate,c.customernumber,c.name from ar left join customer c on (ar.customer_id = c.id)
 266      where abs(paid) > abs(amount)
 267        AND transdate >= ? and transdate <= ?
 268          order by invnumber;|;
 269
 270   my $overpaids_ar =  selectall_hashref_query($::form, $self->dbh, $query, $self->fromdate, $self->todate);
 271
 272   my $correct = 0 == @$overpaids_ar;
 273
 274   $self->tester->ok($correct, "Keine Überzahlungen laut ar.paid");
 275   for my $overpaid_ar (@{ $overpaids_ar }) {
 276     $self->tester->diag("ar invnumber: $overpaid_ar->{invnumber} : paid: $overpaid_ar->{paid}    amount= $overpaid_ar->{amount}  transdate = $overpaid_ar->{transdate}");
 277   }
 278 }
 279
 280 sub check_ap_overpayments {
 281   my ($self) = @_;
 282
 283   my $query = qq|
 284       select invnumber,paid,amount,transdate,vc.vendornumber,vc.name from ap left join vendor vc on (ap.vendor_id = vc.id)
 285     where abs(paid) > abs(amount)
 286       AND transdate >= ? and transdate <= ?
 287         order by invnumber;|;
 288
 289   my $overpaids_ap =  selectall_hashref_query($::form, $self->dbh, $query, $self->fromdate, $self->todate);
 290
 291   my $correct = 0 == @$overpaids_ap;
 292
 293   $self->tester->ok($correct, "Überzahlungen laut ap.paid:");
 294   for my $overpaid_ap (@{ $overpaids_ap }) {
 295     $self->tester->diag("ap invnumber: $overpaid_ap->{invnumber} : paid: $overpaid_ap->{paid}    amount= $overpaid_ap->{amount}  transdate = $overpaid_ap->{transdate}");
 296   }
 297 }
 298
 299 sub check_paid_stornos {
 300   my ($self) = @_;
 301
 302   my $query = qq|
 303     SELECT ar.invnumber,sum(amount - COALESCE((SELECT sum(amount)*-1 FROM acc_trans LEFT JOIN chart ON (acc_trans.chart_id=chart.id) WHERE link ilike '%paid%' AND acc_trans.trans_id=ar.id ),0)) as "open"
 304     FROM ar, customer
 305     WHERE paid != amount
 306       AND ar.storno
 307       AND (ar.customer_id = customer.id)
 308       AND ar.transdate >= ? and ar.transdate <= ?
 309     GROUP BY ar.invnumber;|;
 310   my $paid_stornos = selectall_hashref_query($::form, $self->dbh, $query, $self->fromdate, $self->todate);
 311
 312   $self->tester->ok(0 == @$paid_stornos, "Keine bezahlten Stornos");
 313   for my $paid_storno (@{ $paid_stornos }) {
 314     $self->tester->diag("invnumber: $paid_storno->{invnumber}   offen: $paid_storno->{open}");
 315   }
 316 }
 317
 318 sub check_stornos_ohne_partner {
 319   my ($self) = @_;
 320
 321   my $query = qq|
 322     SELECT (SELECT cast ('ar' as text)) as invoice ,ar.id,invnumber,storno,amount,transdate,type,customernumber as cv_number
 323     FROM ar
 324     LEFT JOIN customer c on (c.id = ar.customer_id)
 325     WHERE storno_id is null AND storno is true AND ar.id not in (SELECT storno_id FROM ar WHERE storno_id is not null AND storno is true)
 326     UNION
 327     SELECT (SELECT cast ('ap' as text)) as invoice,ap.id,invnumber,storno,amount,transdate,type,vendornumber as cv_number
 328     FROM ap
 329     LEFT JOIN vendor v on (v.id = ap.vendor_id)
 330     WHERE storno_id is null AND storno is true AND ap.id not in (SELECT storno_id FROM ap WHERE storno_id is not null AND storno is true);
 331   |;
 332
 333   my $stornos_ohne_partner =  selectall_hashref_query($::form, $self->dbh, $query);
 334
 335   $self->tester->ok(@$stornos_ohne_partner == 0, 'Es sollte keine Stornos ohne Partner geben');
 336   if (@$stornos_ohne_partner) {
 337     $self->tester->diag("Stornos ohne Partner:   (kann passieren wenn Stornorechnung außerhalb Zeitraum liegt)");
 338     $self->tester->diag("gilt aber trotzdem als paid zu dem Zeitpunkt, oder?");
 339   }
 340   my $stornoheader = 0;
 341   for my $storno (@{ $stornos_ohne_partner }) {
 342     if (!$stornoheader++) {
 343       $self->tester->diag(join "\t", keys %$storno);
 344     }
 345     $self->tester->diag(join "\t", map { $storno->{$_} } keys %$storno);
 346   }
 347 }
 348
 349 sub check_overpayments {
 350   my ($self) = @_;
 351
 352   # Vergleich ar.paid und das was laut acc_trans bezahlt wurde
 353   # "als bezahlt markieren" ohne sauberes Ausbuchen führt zu Differenzen bei offenen Forderungen
 354   # geht nur auf wenn acc_trans Zahlungseingänge auch im Untersuchungszeitraum lagen
 355   # Stornos werden rausgefiltert
 356   my $query = qq|
 357 SELECT
 358 invnumber,customernumber,name,ar.transdate,ar.datepaid,
 359 amount,
 360 amount-paid as "open via ar",
 361 paid as "paid via ar",
 362 coalesce((SELECT sum(amount)*-1 FROM acc_trans LEFT JOIN chart ON (acc_trans.chart_id=chart.id) WHERE link ilike '%paid%' AND acc_trans.trans_id=ar.id AND acc_trans.transdate <= ?),0) as "paid via acc_trans"
 363 FROM ar left join customer c on (c.id = ar.customer_id)
 364 WHERE
 365  (ar.storno IS FALSE)
 366  AND (transdate <= ? )
 367 ;|;
 368
 369   my $invoices = selectall_hashref_query($::form, $self->dbh, $query, $self->todate, $self->todate);
 370
 371   my $count_overpayments = scalar grep {
 372        $_->{"paid via ar"} != $_->{"paid via acc_trans"}
 373     || (    $_->{"amount"} - $_->{"paid via acc_trans"} != $_->{"open via ar"}
 374          && $_->{"paid via ar"} != $_->{"paid via acc_trans"} )
 375   } @$invoices;
 376
 377   $self->tester->ok($count_overpayments == 0, 'Vergleich ar.paid und das was laut acc_trans bezahlt wurde');
 378
 379   if ($count_overpayments) {
 380     for my $invoice (@{ $invoices }) {
 381       if ($invoice->{"paid via ar"} != $invoice->{"paid via acc_trans"}) {
 382         $self->tester->diag("paid via ar (@{[ $invoice->{'paid via ar'} * 1 ]}) !=   paid via acc_trans  (@{[ $invoice->{'paid via acc_trans'} * 1 ]}) (at least until transdate!)");
 383         if (defined $invoice->{datepaid}) {
 384           $self->tester->diag("datepaid = $invoice->{datepaid})");
 385         }
 386         $self->tester->diag("Überzahlung!") if $invoice->{"paid via acc_trans"} > $invoice->{amount};
 387       } elsif ( $invoice->{"amount"} - $invoice->{"paid via acc_trans"} != $invoice->{"open via ar"} && $invoice->{"paid via ar"} != $invoice->{"paid via acc_trans"}) {
 388         $self->tester->diag("amount - paid_via_acc_trans !=  open_via_ar");
 389         $self->tester->diag("Überzahlung!") if $invoice->{"paid via acc_trans"} > $invoice->{amount};
 390       } else {
 391         # nothing wrong
 392       }
 393     }
 394   }
 395 }
 396
 397 sub calc_saldenvortraege {
 398   my ($self) = @_;
 399
 400   my $saldenvortragskonto = '9000';
 401
 402   # Saldo Saldenvortragskonto 9000 am Jahresanfang
 403   my $query = qq|
 404       select sum(amount) from acc_trans where chart_id = (select id from chart where accno = ?) and transdate <= ?|;
 405   my ($saldo_9000_jahresanfang) = selectfirst_array_query($::form, $self->dbh, $query, $saldenvortragskonto, DateTime->new(day => 1, month => 1, year => DateTime->today->year));
 406   $self->tester->diag("Saldo 9000 am 01.01.@{[DateTime->today->year]}: @{[ $saldo_9000_jahresanfang * 1 ]}    (sollte 0 sein)");
 407
 408     # Saldo Saldenvortragskonto 9000 am Jahresende
 409   $query = qq|
 410       select sum(amount) from acc_trans where chart_id = (select id from chart where accno = ?) and transdate <= ?|;
 411   my ($saldo_9000_jahresende) = selectfirst_array_query($::form, $self->dbh, $query, $saldenvortragskonto, DateTime->new(day => 31, month => 12, year => DateTime->today->year));
 412   $self->tester->diag("Saldo $saldenvortragskonto am 31.12.@{[DateTime->today->year]}: @{[ $saldo_9000_jahresende * 1 ]}    (sollte 0 sein)");
 413 }
 414
 415 sub check_every_account_with_taxkey {
 416   my ($self) = @_;
 417
 418   my $query = qq|SELECT accno, description FROM chart WHERE id NOT IN (select chart_id from taxkeys)|;
 419   my $accounts_without_tk = selectall_hashref_query($::form, $self->dbh, $query);
 420
 421   if ( scalar @{ $accounts_without_tk } > 0 ){
 422     $self->tester->ok(0, "Folgende Konten haben keinen gültigen Steuerschlüssel:");
 423
 424     for my $account_without_tk (@{ $accounts_without_tk } ) {
 425       $self->tester->diag("Kontonummer: $account_without_tk->{accno} Beschreibung: $account_without_tk->{description}");
 426     }
 427   } else {
 428     $self->tester->ok(1, "Jedes Konto hat einen gültigen Steuerschlüssel!");
 429   }
 430 }
 431
 432 sub check_ar_acc_trans_amount {
 433   my ($self) = @_;
 434
 435   my $query = qq|
 436           select ar.invnumber, ar.netamount, ac.amount
 437            from ar left join acc_trans ac on (ac.trans_id = ar.id) where ac.chart_link like 'AR_amount%' AND ac.amount <> ar.netamount|;
 438
 439   my $ar_amount_not_ac_amount = selectall_hashref_query($::form, $self->dbh, $query);
 440
 441   if ( scalar @{ $ar_amount_not_ac_amount } > 0 ) {
 442     $self->tester->ok(0, "Folgende Ausgangsrechnungen haben einen falschen Netto-Wert im Nebenbuch:");
 443
 444     for my $ar_ac_amount_nok (@{ $ar_amount_not_ac_amount } ) {
 445       $self->tester->diag("Rechnungsnummer: $ar_ac_amount_nok->{invnumber} Hauptbuch-Wert: $ar_ac_amount_nok->{amount}
 446                             Nebenbuch-Wert: $ar_ac_amount_nok->{netamount}");
 447     }
 448   } else {
 449     $self->tester->ok(1, "Hauptbuch-Nettowert und Nebenbuch-Nettowert stimmen überein.");
 450   }
 451
 452 }
 453
 454 1;
 455
 456 __END__
 457
 458 =encoding utf-8
 459
 460 =head1 NAME
 461
 462 SL::BackgroundJob::SelfTest::Transactions - base tests
 463
 464 =head1 DESCRIPTION
 465
 466 Several tests for data integrity.
 467
 468 =head1 FUNCTIONS
 469
 470 =head1 BUGS
 471
 472 =head1 AUTHOR
 473
 474 G. Richardson E<lt>information@richardson-bueren.deE<gt>
 475 Jan Büren E<lt>information@richardson-bueren.deE<gt>
 476 Sven Schoeling E<lt>s.schoeling@linet-services.deE<gt>
 477
 478 =cut
 479