src/t/TestTrust.pm

   1 package t::TestTrust;
   2
   3 # This file is part of the breadcrumbs daemon (bcd).
   4 # Copyright (C) 2007 Pasqualino Ferrentino
   5
   6 # This program is free software; you can redistribute it and/or modify
   7 # it under the terms of the GNU General Public License as published by
   8 # the Free Software Foundation; either version 2 of the License, or
   9 # (at your option) any later version.
  10
  11 # This program is distributed in the hope that it will be useful, but
  12 # WITHOUT ANY WARRANTY; without even the implied warranty of
  13 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 # General Public License for more details.
  15
  16 # You should have received a copy of the GNU General Public License
  17 # along with this program; if not, write to the Free Software
  18 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  19 # 02110-1301, USA.
  20
  21 # Contact: lino.ferrentino@yahoo.it (in Italian, English or German).
  22
  23 use strict;
  24 use warnings;
  25
  26 use t::TestCommonDb;
  27 our @ISA = qw(t::TestCommonDb);
  28
  29 use Bcd::Data::Trust;
  30 use Bcd::Data::StatementsStash;
  31
  32 use Data::Dumper;
  33
  34 my @test_users = (
  35                   {
  36                       #0
  37                       nick => 'zero_user',
  38                       id_ant_nest => 1613499,
  39                       bias => 1.01,
  40                       alfa => 0.93
  41                       },
  42                   {
  43                       #1
  44                       nick => 'lino',
  45                       bias => 1.01,
  46                       alfa => 0.93
  47                       },
  48                   {
  49                       #2
  50                       nick => 'eli',
  51                       bias => 0.99,
  52                       alfa => 1.22
  53                       },
  54                   {
  55                       #3
  56                       nick => 'enzo',
  57                       bias => 1.12,
  58                       alfa => 0.98
  59                       },
  60                   {
  61                       #4
  62                       nick => 'giuseppe',
  63                       bias => 0.52,
  64                       alfa => 0.78,
  65                   },
  66                   {
  67                       #5
  68                       nick => 'andrea',
  69                       bias => 2.1,
  70                       alfa => 1.22
  71                       },
  72                   {
  73                       #6
  74                       nick => 'tizi',
  75                       bias => 1.92,
  76                       alfa => 0.77
  77                       },
  78                   {
  79                       #7
  80                       nick => 'monica',
  81                       bias => 0.83,
  82                       alfa => 1.12,
  83                   },
  84                   {
  85                       #8
  86                       nick => 'carla',
  87                       bias => 1.02,
  88                       alfa => 0.44,
  89                   },
  90                   {
  91                       #9
  92                       nick => 'benedetto',
  93                       id_ant_nest => 1613499,
  94                       bias => 1.14,
  95                       alfa => 0.88,
  96                   },
  97                   );
  98
  99 my @test_trusts = (
 100                    [1, 2, 0.98, 0.97],
 101                    [1, 3, 0.77, 0.80],
 102                    [2, 3, 0.93, 0.94],
 103                    [1, 5, 0.99, 0.60],
 104                    [5, 6, 0.99, 0.99],
 105                    [6, 7, 0.97, 0.96],
 106                    [7, 8, 0.43, 0.61],
 107                    [1, 9, 0.97, 0.67],
 108                    [3, 4, 0.89, 0.99],
 109                    [2, 4, 0.32, 0.94],
 110                    );
 111
 112 my @user_ids = ();
 113
 114 #this function should set up the "fake" users in this ant nest
 115 sub set_up{
 116     my $self = shift;
 117
 118     #first of all I create the test ant nest
 119     $self->_create_test_ant_nest(80128);
 120     $self->_create_test_ant_nest(16134);
 121
 122     my $personal_data_id = Bcd::Data::Users->create_personal_data_for_user($self->{stash}, {});
 123
 124     @user_ids = ();
 125
 126     for (@test_users){
 127         my $id = $self->_create_a_test_user_for_trust($_, $personal_data_id);
 128         push(@user_ids, $id);
 129     }
 130
 131     #ok, now I should make the trusts
 132     for (@test_trusts){
 133
 134         Bcd::Data::Trust->create_trust_between
 135             ($self->{stash},
 136              $user_ids[$_->[0]],
 137              $user_ids[$_->[1]],
 138              $_->[2],
 139              $_->[3]);
 140     }
 141
 142
 143 }
 144
 145 #this method simply creates a user, just to test
 146 #returns the id of this user.
 147 sub _create_a_test_user_for_trust{
 148     my ($self, $user, $personal_data_id) = @_;
 149
 150     my $ant_nest = exists($user->{id_ant_nest}) ? $user->{id_ant_nest} : 8012899;
 151
 152     #the test db should be changed
 153     my $sql = qq{insert into users(nick, id_ant_nest,
 154                                    users_state, alfa, bias, id_personal_data) values (?, $ant_nest, 4, ?, ?, ?)};
 155
 156     my $st = $self->{stash}->get_connection()->prepare($sql);
 157
 158     $st->bind_param(1, $user->{nick});
 159     $st->bind_param(2, $user->{alfa});
 160     $st->bind_param(3, $user->{bias});
 161     $st->bind_param(4, $personal_data_id);
 162     $st->execute();
 163
 164     my $id_of_insertion = $self->{stash}->get_id_of_last_user();
 165
 166     return $id_of_insertion;
 167 }
 168
 169 #this is the only test which uses this fixture, so I create the fixture only once
 170 #but it is shared by all the test inside this file
 171 sub test_trust{
 172     my $self = shift;
 173
 174     $self->_test_is_valid_trust();
 175     $self->_test_is_valid_trust_bb();
 176     $self->_test_exists_direct_trust_between();
 177     $self->_test_simple_path();
 178     $self->_test_composite_paths();
 179     $self->_test_simple_trusts();
 180     $self->_test_composite_trusts();
 181     $self->_test_no_path_trust();
 182     $self->_test_reachables_no_limit();
 183     $self->_test_get_maximum_reachable_set();
 184     $self->_test_reachables_with_limit();
 185
 186     $self->_test_get_trust();
 187
 188     $self->_test_incoming_net();
 189     $self->_test_outgoing_net();
 190
 191     #these tests MUST be run in sequence.
 192     $self->_test_new_booking();
 193     $self->_test_create_new_trust();
 194     $self->_test_change_trust();
 195     $self->_test_rollback_change_trust();
 196     $self->_test_commit_trust_changes();
 197     $self->_test_get_backupped_trusts();
 198 }
 199
 200 sub _test_outgoing_net{
 201     my $self = shift;
 202     my $stash = $self->{stash};
 203     print ".";
 204
 205     #print "_________________________ test outgoing net\n";
 206     my $outgoing_net;
 207     $outgoing_net = Bcd::Data::Trust->get_outgoing_trust_net($stash, $user_ids[5]);
 208     $self->assert_equals(8, scalar(keys(%{$outgoing_net})));
 209     #print Dumper($outgoing_net);
 210
 211     my $trust_4 = $outgoing_net->{$user_ids[4]};
 212     $self->assert_str_equals("8.33853676860981e-06", $trust_4->[2]);
 213
 214     my $trust_8 = $outgoing_net->{$user_ids[8]};
 215     $self->assert_str_equals("0.000245666165323859", $trust_8->[2]);
 216
 217     #print "_________________________ test outgoing net        END!\n";
 218 }
 219
 220
 221 sub _test_incoming_net{
 222     my $self = shift;
 223     my $stash = $self->{stash};
 224     print ".";
 225
 226     #print "_________________________ test incoming_net\n";
 227     #print Dumper (\@user_ids);
 228     my $incoming_net;
 229     $incoming_net = Bcd::Data::Trust->get_incoming_trust_net($stash, $user_ids[5]);
 230     $self->assert_equals(8, scalar(keys(%{$incoming_net})));
 231
 232     #print "||||||||||||||||||||||||||||||||||||||||||||||||||| end count\n";
 233     #print "the net is\n";
 234     #print Dumper($incoming_net);
 235
 236     #ok, I take the path from the most distant people, just to test...
 237     my $trust_4 = $incoming_net->{$user_ids[4]};
 238
 239     #print Dumper($trust_4);
 240     $self->assert_str_equals("0.00770656129838086", $trust_4->[2]);
 241
 242     my $trust_8 = $incoming_net->{$user_ids[8]};
 243     $self->assert_str_equals("0.00688167479645286", $trust_8->[2]);
 244
 245 }
 246
 247 sub _test_get_trust{
 248     my $self = shift;
 249     my $stash = $self->{stash};
 250     print ".";
 251
 252     my ($trust, $am_i_second) = Bcd::Data::Trust->_get_trust_between($stash, $user_ids[1], $user_ids[5]);
 253
 254     $self->assert_equals("0.99", $trust);
 255     $self->assert_equals("0", $am_i_second);
 256
 257     ($trust, $am_i_second) = Bcd::Data::Trust->_get_trust_between($stash, $user_ids[5], $user_ids[1]);
 258
 259     $self->assert_equals("0.60", $trust);
 260     $self->assert_equals("1", $am_i_second);
 261
 262 }
 263
 264 sub _test_new_booking{
 265     my $self = shift;
 266     my $stash = $self->{stash};
 267     print ".";
 268
 269     Bcd::Data::Trust->create_new_trust_booking($stash, 5, 7, 0.43);
 270
 271     my $sql = qq{select * from trusts_bookings where u1 = ? and u2 = ?};
 272
 273     my $st = $stash->get_connection()->prepare($sql);
 274
 275     $st->bind_param(1, 5);
 276     $st->bind_param(2, 7);
 277
 278     $st->execute();
 279
 280     my $ref = $st->fetchrow_arrayref();
 281     $self->assert_equals("0.43", $ref->[2]);
 282
 283 }
 284
 285 sub _test_create_new_trust{
 286
 287     my $self = shift;
 288     my $stash = $self->{stash};
 289     print ".";
 290
 291     #this is useless, because in this module the tests are run in sequence...
 292     #and so this row has been already put by the preceding test
 293     #Bcd::Data::Trust->create_new_trust_booking($stash, 5, 7, 0.43);
 294
 295
 296     #ok, now let's create the inverse trust
 297     Bcd::Data::Trust->create_new_trust($stash, 7, 5, 0.98);
 298
 299     #there should be a new row in the trust table
 300     my $sql = qq{select * from trusts where u1=? and u2 = ?};
 301     my $st = $stash->get_connection()->prepare($sql);
 302     $st->bind_param(1, 5);
 303     $st->bind_param(2, 7);
 304
 305     $st->execute();
 306     my $row = $st->fetchrow_arrayref();
 307
 308
 309     $self->assert_equals("0.43", $row->[2]);
 310     $self->assert_equals("0.98", $row->[3]);
 311     $st->finish();
 312
 313     #then I should assert myself that the booking has been deleted
 314     $sql = qq{select * from trusts_bookings where u1=? and u2 = ?};
 315     $st = $stash->get_connection()->prepare($sql);
 316     $st->bind_param(1, 5);
 317     $st->bind_param(2, 7);
 318
 319     $st->execute();
 320     $row = $st->fetchrow_arrayref();
 321
 322
 323     $self->assert_null($row); #nothing.
 324     $st->finish();
 325 }
 326
 327 sub _test_change_trust{
 328     my $self = shift;
 329     my $stash = $self->{stash};
 330     print ".";
 331
 332     #ok, now let's try to change the trust of the first user
 333     Bcd::Data::Trust->change_trust($stash, 5, 7, 0.66);
 334
 335
 336     #I should have a row in the trusts_backups table
 337     my $sql = qq{SELECT * from trusts_backups where u1=? AND u2=?};
 338     my $st_select_backup = $stash->get_connection()->prepare($sql);
 339
 340     $st_select_backup->bind_param(1, 5);
 341     $st_select_backup->bind_param(2, 7);
 342
 343     $st_select_backup->execute();
 344     my $row = $st_select_backup->fetchrow_arrayref();
 345
 346     #I should have the backup...
 347     $self->assert_equals("0.43", $row->[2]);
 348
 349     #AND i have the trust changed in the trust table
 350     $sql = qq{SELECT * from trusts where u1=? AND u2=?};
 351     my $st_select_trust = $stash->get_connection()->prepare($sql);
 352
 353     $st_select_trust->bind_param(1, 5);
 354     $st_select_trust->bind_param(2, 7);
 355
 356     $st_select_trust->execute();
 357     $row = $st_select_trust->fetchrow_arrayref();
 358
 359     #I should have the new trust
 360     $self->assert_equals("0.66", $row->[2]);
 361
 362     #####################################################
 363
 364     #let's try to change the trust once again
 365     Bcd::Data::Trust->change_trust($stash, 5, 7, 0.44);
 366
 367     $st_select_backup->bind_param(1, 5);
 368     $st_select_backup->bind_param(2, 7);
 369
 370     $st_select_backup->execute();
 371     $row = $st_select_backup->fetchrow_arrayref();
 372
 373     #I should have the backup, unchanged
 374     $self->assert_equals("0.43", $row->[2]);
 375
 376     #AND i have the trust changed in the trust table
 377     $st_select_trust->bind_param(1, 5);
 378     $st_select_trust->bind_param(2, 7);
 379
 380     $st_select_trust->execute();
 381     $row = $st_select_trust->fetchrow_arrayref();
 382
 383     #I should have the new trust
 384     $self->assert_equals("0.44", $row->[2]);
 385
 386     ###################################################
 387     ## let's try to change the trust for the second user
 388     #let's try to change the trust once again
 389     Bcd::Data::Trust->change_trust($stash, 7, 5, 0.12);
 390
 391     $st_select_backup->bind_param(1, 7);
 392     $st_select_backup->bind_param(2, 5);
 393
 394     $st_select_backup->execute();
 395     $row = $st_select_backup->fetchrow_arrayref();
 396
 397     #I should have the backup
 398     $self->assert_equals("0.98", $row->[2]);
 399
 400     #AND i have the trust changed in the trust table
 401     $st_select_trust->bind_param(1, 5);
 402     $st_select_trust->bind_param(2, 7);
 403
 404     $st_select_trust->execute();
 405     $row = $st_select_trust->fetchrow_arrayref();
 406
 407     #I should have the new trust
 408     $self->assert_equals("0.12", $row->[3]);
 409
 410
 411     #################################################
 412     ## second change for the second user
 413
 414     Bcd::Data::Trust->change_trust($stash, 7, 5, 0.11);
 415
 416     $st_select_backup->bind_param(1, 7);
 417     $st_select_backup->bind_param(2, 5);
 418
 419     $st_select_backup->execute();
 420     $row = $st_select_backup->fetchrow_arrayref();
 421
 422     #I should have the backup, unchanged
 423     $self->assert_equals("0.98", $row->[2]);
 424
 425     #AND i have the trust changed in the trust table
 426     $st_select_trust->bind_param(1, 5);
 427     $st_select_trust->bind_param(2, 7);
 428
 429     $st_select_trust->execute();
 430     $row = $st_select_trust->fetchrow_arrayref();
 431
 432     #I should have the new trust
 433     $self->assert_equals("0.11", $row->[3]);
 434
 435 }
 436
 437 sub _test_rollback_change_trust{
 438     my $self = shift;
 439     my $stash = $self->{stash};
 440     print ".";
 441
 442     #I try other changes
 443     Bcd::Data::Trust->change_trust($stash, $user_ids[5], $user_ids[1], 0.25);
 444     Bcd::Data::Trust->change_trust($stash, $user_ids[5], $user_ids[6], 0.22);
 445
 446     my ($trust, $am_i_second) = Bcd::Data::Trust->_get_trust_between($stash, $user_ids[5], $user_ids[1]);
 447     $self->assert_equals("0.25", $trust);
 448     $self->assert_equals("1", $am_i_second);
 449
 450     Bcd::Data::Trust->rollback_trust_changes($stash, $user_ids[5]);
 451
 452     #ok, now I should have the old trusts...
 453     ($trust, $am_i_second) = Bcd::Data::Trust->_get_trust_between($stash, $user_ids[5], $user_ids[1]);
 454
 455     $self->assert_equals("0.60", $trust);
 456     $self->assert_equals("1", $am_i_second);
 457
 458     ($trust, $am_i_second) = Bcd::Data::Trust->_get_trust_between($stash, $user_ids[5], $user_ids[6]);
 459
 460     $self->assert_equals("0.99", $trust);
 461     $self->assert_equals("0", $am_i_second);
 462
 463     #then I should see that the rollbacks are deleted...
 464     my $sql = qq{SELECT * from trusts_backups where u1=?};
 465     my $st_select_backup = $stash->get_connection()->prepare($sql);
 466
 467     $st_select_backup->bind_param(1, $user_ids[5]);
 468     $st_select_backup->execute();
 469
 470     my $row = $st_select_backup->fetchrow_arrayref();
 471
 472     $self->assert_null($row);
 473
 474 }
 475
 476 sub _test_commit_trust_changes{
 477
 478     my $self = shift;
 479     my $stash = $self->{stash};
 480     print ".";
 481
 482     #I make some changes
 483     Bcd::Data::Trust->change_trust($stash, $user_ids[5], $user_ids[1], 0.25);
 484     Bcd::Data::Trust->change_trust($stash, $user_ids[5], $user_ids[6], 0.22);
 485
 486     #now I commit them
 487     Bcd::Data::Trust->commit_trust_changes($stash, $user_ids[5]);
 488
 489     #ok, if I make another change the previous change is the backup
 490     Bcd::Data::Trust->change_trust($stash, $user_ids[5], $user_ids[1], 0.24);
 491
 492     my ($trust, $am_i_second) = Bcd::Data::Trust->_get_trust_between($stash, $user_ids[5], $user_ids[1]);
 493     $self->assert_equals("0.24", $trust);
 494     $self->assert_equals("1", $am_i_second);
 495
 496     my $sql = qq{SELECT * from trusts_backups where u1=?};
 497     my $st_select_backup = $stash->get_connection()->prepare($sql);
 498
 499     $st_select_backup->bind_param(1, $user_ids[5]);
 500     $st_select_backup->execute();
 501
 502     my $row = $st_select_backup->fetchrow_arrayref();
 503
 504     $self->assert_equals("0.25", $row->[2]);
 505     $self->assert_equals("1",    $row->[3]);
 506
 507
 508
 509 }
 510
 511 sub _test_get_backupped_trusts{
 512     my $self = shift;
 513     my $stash = $self->{stash};
 514     print ".";
 515
 516     Bcd::Data::Trust->commit_trust_changes($stash, $user_ids[5]);
 517
 518     my ($trust51_old, $am_i_second1) = Bcd::Data::Trust->_get_trust_between($stash, $user_ids[5], $user_ids[1]);
 519     my ($trust56_old, $am_i_second2) = Bcd::Data::Trust->_get_trust_between($stash, $user_ids[5], $user_ids[6]);
 520
 521     #I make some changes
 522     Bcd::Data::Trust->change_trust($stash, $user_ids[5], $user_ids[1], 0.55);
 523     Bcd::Data::Trust->change_trust($stash, $user_ids[5], $user_ids[6], 0.33);
 524
 525     my $backups = Bcd::Data::Trust->get_user_backupped_trusts($stash, $user_ids[5]);
 526
 527     $self->assert_equals($trust51_old, $backups->{$user_ids[1]});
 528     $self->assert_equals($trust56_old, $backups->{$user_ids[6]});
 529
 530
 531 }
 532
 533 sub _test_exists_direct_trust_between{
 534     my $self = shift;
 535     my $stash = $self->{stash};
 536     print ".";
 537
 538     my $res = Bcd::Data::Trust->exists_direct_trust_between
 539         ($stash, $user_ids[1],$user_ids[2]);
 540     $self->assert_num_equals(1, $res);
 541
 542     $res = Bcd::Data::Trust->exists_direct_trust_between
 543         ($stash, $user_ids[1], $user_ids[6]);
 544     $self->assert_num_equals(0, $res);
 545 }
 546
 547 sub _test_simple_path{
 548     my $self = shift;
 549     my $stash = $self->{stash};
 550     print ".";
 551
 552     my ($res, $path) = Bcd::Data::Trust->get_path($user_ids[1], $user_ids[1], $stash);
 553     $self->assert_num_equals(1, $res);
 554     $self->assert_num_equals($user_ids[1], $path->[0]->[0]);
 555
 556
 557     ($res, $path) = Bcd::Data::Trust->get_path($user_ids[1], $user_ids[6], $stash);
 558     $self->assert_num_equals(1, $res);
 559     $self->assert_num_equals($user_ids[1], $path->[0]->[0]);
 560     $self->assert_num_equals($user_ids[5], $path->[1]->[0]);
 561     $self->assert_num_equals($user_ids[6], $path->[2]->[0]);
 562
 563
 564     ($res ,$path) = Bcd::Data::Trust->get_path($user_ids[2], $user_ids[8], $stash);
 565
 566     $self->assert_num_equals(1, $res);
 567     $self->assert_num_equals($user_ids[2], $path->[0]->[0]);
 568     $self->assert_num_equals($user_ids[1], $path->[1]->[0]);
 569     $self->assert_num_equals($user_ids[5], $path->[2]->[0]);
 570     $self->assert_num_equals($user_ids[6], $path->[3]->[0]);
 571     $self->assert_num_equals($user_ids[7], $path->[4]->[0]);
 572     $self->assert_num_equals($user_ids[8], $path->[5]->[0]);
 573
 574     ($res ,$path) = Bcd::Data::Trust->get_path($user_ids[8],$user_ids[2], $stash);
 575
 576
 577     $self->assert_num_equals(1, $res);
 578     $self->assert_num_equals($user_ids[8], $path->[0]->[0]);
 579     $self->assert_num_equals($user_ids[7], $path->[1]->[0]);
 580     $self->assert_num_equals($user_ids[6], $path->[2]->[0]);
 581     $self->assert_num_equals($user_ids[5], $path->[3]->[0]);
 582     $self->assert_num_equals($user_ids[1], $path->[4]->[0]);
 583     $self->assert_num_equals($user_ids[2], $path->[5]->[0]);
 584
 585     ($res ,$path) = Bcd::Data::Trust->get_path($user_ids[1],$user_ids[4], $stash);
 586     $self->assert_num_equals(1, $res);
 587     $self->assert_num_equals($user_ids[1], $path->[0]->[0]);
 588     $self->assert_num_equals($user_ids[2], $path->[1]->[0]);
 589 }
 590
 591 sub _test_composite_paths{
 592     my $self = shift;
 593     my $stash = $self->{stash};
 594     print ".";
 595
 596    #I add some other trusts... and see what happens
 597     my $sql = qq{insert into trusts values($user_ids[7],$user_ids[1],0.78,0.88)};
 598     my $st = $self->{stash}->get_connection()->prepare($sql);
 599     $st->execute();
 600
 601     my ($res, $path);
 602
 603     ($res ,$path) = Bcd::Data::Trust->get_path($user_ids[2],$user_ids[7], $stash);
 604     $self->assert_num_equals(1, $res);
 605     $self->_check_path([2, 1, 7], $path);
 606
 607     ($res ,$path) = Bcd::Data::Trust->get_path($user_ids[8], $user_ids[3], $stash);
 608     $self->assert_num_equals(1, $res);
 609     $self->_check_path([8, 7, 1, 3], $path);
 610
 611     #undo the changes...
 612     #$self->{"conn"}->rollback();
 613     #you cannot rollback, with a rollback you erase the entire fixture.
 614
 615     #I simply delete the row
 616     $sql = qq{DELETE from trusts where u1=$user_ids[7] and u2=$user_ids[1]};
 617     $st = $self->{stash}->get_connection()->prepare($sql);
 618     $st->execute();
 619
 620     #the old path, without the new trust...
 621     ($res ,$path) = Bcd::Data::Trust->get_path($user_ids[2], $user_ids[7], $stash);
 622     $self->assert_num_equals(1, $res);
 623     $self->_check_path([2, 1, 5, 6, 7], $path);
 624 }
 625
 626 sub _check_path{
 627     my ($self, $path_to_check, $returned_path) = @_;
 628
 629     my $index = 0;
 630     foreach (@{$path_to_check}){
 631         $self->assert_num_equals($user_ids[$_], $returned_path->[$index]->[0]);
 632         $index++;
 633     }
 634 }
 635
 636 # #this should test some simple trusts...
 637 sub _test_simple_trusts{
 638
 639     my $self = shift;
 640     my $stash = $self->{stash};
 641     my $trust;
 642
 643     #the trust with myself is one -> 100bB
 644     $trust = Bcd::Data::Trust->get_trust($user_ids[2],$user_ids[2], $stash);
 645     $self->assert_num_equals(100, $trust);
 646
 647     $trust = Bcd::Data::Trust->get_trust($user_ids[1], $user_ids[3], $stash);
 648     $self->assert_num_equals(98.55, $trust);
 649
 650 }
 651
 652 sub _test_composite_trusts{
 653     my $self = shift;
 654     my $stash = $self->{stash};
 655     my $trust;
 656
 657
 658     $trust = Bcd::Data::Trust->get_trust($user_ids[3], $user_ids[2], $stash);
 659     $self->assert_num_equals(99.64, $trust);
 660
 661     $trust = Bcd::Data::Trust->get_trust($user_ids[3], $user_ids[6], $stash);
 662     $self->assert_num_equals(83.41, $trust);
 663
 664     $trust = Bcd::Data::Trust->get_trust($user_ids[3], $user_ids[7], $stash);
 665     $self->assert_num_equals(45.99, $trust);
 666
 667     $trust = Bcd::Data::Trust->get_trust($user_ids[3], $user_ids[8], $stash);
 668     $self->assert_num_equals(3.60, $trust);
 669
 670     $trust = Bcd::Data::Trust->get_trust($user_ids[1], $user_ids[6], $stash);
 671     $self->assert_num_equals(94.43, $trust);
 672 }
 673
 674 sub _test_no_path_trust{
 675     my $self = shift;
 676     my $trust;
 677
 678     #the trust with a not existing path is zero
 679     $trust = Bcd::Data::Trust->get_trust_decimal($user_ids[3], $user_ids[0] , $self->{stash});
 680     $self->assert_num_equals(0, $trust);
 681 }
 682
 683
 684 #this hash is a precomputed set from some users in the test ant nest
 685 my $expected_set_from_user_1 = {
 686     3 => 0.7161,
 687     4 => 0.0074,
 688     2 => 0.9114,
 689     5 => 0.9207,
 690     9 => 0.9021,
 691     6 => 0.2775,
 692     7 => 0.000807065,
 693 };
 694
 695 sub _check_reachable_set_from_user {
 696     my ($self, $expected_list_of_reachable_ants, $expectd_set, $returned_set) = @_;
 697
 698     $self->assert_num_equals($#{$expected_list_of_reachable_ants}+1, scalar(keys(%{$returned_set})));
 699
 700     for (@{$expected_list_of_reachable_ants}){
 701         $self->assert_str_equals(
 702                                  $expectd_set->{$_}
 703                                  ,
 704                                  substr($returned_set->{$user_ids[$_]}, 0, length($expectd_set->{$_}))
 705                                  );
 706     }
 707
 708 }
 709
 710 sub _test_reachables_no_limit{
 711     my $self = shift;
 712     my $hash;
 713     my $stash = $self->{stash};
 714
 715
 716     $hash = Bcd::Data::Trust->get_reachable_users_from_user_trust_no_limit($user_ids[1], 0.7060, $stash);
 717     $self->_check_reachable_set_from_user([3, 2, 5, 9], $expected_set_from_user_1, $hash);
 718
 719     $hash = Bcd::Data::Trust->get_reachable_users_from_user_trust_no_limit($user_ids[1], 0.26, $stash);
 720     $self->_check_reachable_set_from_user([3, 2, 5, 9, 6], $expected_set_from_user_1, $hash);
 721
 722     $hash = Bcd::Data::Trust->get_reachable_users_from_user_trust_no_limit($user_ids[1], 0.00003, $stash);
 723     $self->_check_reachable_set_from_user([3, 2, 4, 5, 9, 6, 7], $expected_set_from_user_1, $hash);
 724
 725     $hash = Bcd::Data::Trust->get_reachable_users_from_user_trust_no_limit($user_ids[0], 0.03, $stash);
 726     $self->_check_reachable_set_from_user([], $expected_set_from_user_1, $hash);
 727 }
 728
 729 sub _test_reachables_with_limit{
 730     my $self = shift;
 731     my $hash;
 732     my $stash = $self->{stash};
 733
 734     #I should NOT reach the ant in the other ant nest
 735     $hash = Bcd::Data::Trust->get_reachable_users_from_user_trust_limited($user_ids[1], 0.7060, $stash);
 736     $self->_check_reachable_set_from_user([3, 2, 5], $expected_set_from_user_1, $hash);
 737
 738     $hash = Bcd::Data::Trust->get_reachable_users_from_user_trust_limited($user_ids[1], 0.26, $stash);
 739     $self->_check_reachable_set_from_user([3, 2, 5, 6], $expected_set_from_user_1, $hash);
 740
 741     $hash = Bcd::Data::Trust->get_reachable_users_from_user_trust_limited($user_ids[1], 0.00003, $stash);
 742     $self->_check_reachable_set_from_user([3, 2, 5, 6, 7, 4], $expected_set_from_user_1, $hash);
 743 }
 744
 745 sub _test_get_maximum_reachable_set{
 746     my $self=shift;
 747     my $stash = $self->{"stash"};
 748
 749     my $maximum_set = Bcd::Data::Trust->_get_maximum_reachable_set($user_ids[5], $stash);
 750
 751     #the maximum set should be equal to all the test set
 752     my $index = 0;
 753     for(@test_users){
 754         if (!defined($_->{id_ant_nest})){
 755             $self->assert_not_null($maximum_set->{$user_ids[$index]});
 756         }
 757         $index++;
 758     }
 759 }
 760
 761 sub _test_is_valid_trust{
 762     my $self=shift;
 763     my $stash = $self->{"stash"};
 764
 765     $self->assert_num_equals(1, Bcd::Data::Trust->is_valid_trust(0.5));
 766     $self->assert_num_equals(0, Bcd::Data::Trust->is_valid_trust(0));
 767     $self->assert_num_equals(0, Bcd::Data::Trust->is_valid_trust(-0.5));
 768     $self->assert_num_equals(1, Bcd::Data::Trust->is_valid_trust(1));
 769     $self->assert_num_equals(0, Bcd::Data::Trust->is_valid_trust(1.5));
 770 }
 771
 772 sub _test_is_valid_trust_bb{
 773
 774     my $self=shift;
 775     my $stash = $self->{"stash"};
 776
 777     $self->assert_num_equals(1, Bcd::Data::Trust->is_valid_trust_bb(0.5));
 778     $self->assert_num_equals(1, Bcd::Data::Trust->is_valid_trust_bb(0));
 779     $self->assert_num_equals(1, Bcd::Data::Trust->is_valid_trust_bb(-0.5));
 780     $self->assert_num_equals(1, Bcd::Data::Trust->is_valid_trust_bb(100));
 781     $self->assert_num_equals(1, Bcd::Data::Trust->is_valid_trust_bb(-100));
 782     $self->assert_num_equals(0, Bcd::Data::Trust->is_valid_trust_bb(150));
 783 }
 784
 785 1;
 786