package tests::LastTest;

use strict;

use base qw/ Lire::Test::TestCase tests::TestStoreFixture /;

use Lire::Last;
use Lire::ReportSpec;
use tests::MockAggregator;

sub new {
    my $self = shift()->SUPER::new( @_ );

    $self->init();

    return $self;
}

sub set_up {
    my $self = shift->SUPER::set_up();

    $self->set_up_test_schema();

    $self->{'spec'} = new Lire::ReportSpec();
    $self->{'spec'}->superservice( 'test' );
    $self->{'spec'}->id( 'test-last' );

    my $mock = new tests::MockAggregator( 'report_spec' => $self->{'spec'} );

    $self->{'last_nosort'} =
      new Lire::Last( 'report_spec' => $self->{'spec'},
                       'parent' => $mock,
                       'field' => 'user',
                       'name' => 'lastTest' );
    $self->{'last_sorted'} =
      new Lire::Last( 'report_spec' => $self->{'spec'},
                       'parent' => $mock,
                       'field' => 'user',
                       'sort_fields' => [ 'connection_id', 'user' ],
                       'name' => 'lastTest' );

    $self->{'cfg'}{'lr_scale_numbers'} = 0;
    $self->{'cfg'}{'lr_scale_bytes'} = 1;
    $self->{'cfg'}{'lr_scale_seconds'} = 1;

    return;
}

sub tear_down {
    my $self = $_[0];

    $self->SUPER::tear_down();

    return;
}

sub test_build_last_query {
    my $self = $_[0];

    my $op = $self->{'last_nosort'};
    foreach my $t ( [ 'file-size', undef,
                      [ 'lastTest', 'lr_last("file-size")' ] ],
                    [ 'file_size', [ 'time_taken', 'connection-id' ],
                      [ 'lastTest', 
                        'lr_last(file_size,time_taken,"connection-id")',
                        'lastTest_key',
                        'lr_last_key(file_size,time_taken,"connection-id")'
                      ] ], )
    {
        my ( $field, $sort_fields,  $aggrFields ) = @$t;

        $op->{'field'} = $field;
        $op->{'sort_fields'} = $sort_fields;
        my $e_query = new Lire::DlfQuery( 'test' );
        for ( my $i=0; $i < @$aggrFields; $i += 2) {
            $e_query->add_aggr_field( $aggrFields->[$i], $aggrFields->[$i+1] );
        }
        my $query = new Lire::DlfQuery( 'test' );
        $op->_build_last_query( $query );
        $self->assert_deep_equals( $e_query, $query );
    }
}

sub test_sql_required_fields {
    my $self = $_[0];

    $self->assert_deep_equals( [ 'user' ],
                               $self->{'last_nosort'}->sql_required_fields() );
    $self->assert_deep_equals( [ 'user', 'connection_id', 'user' ],
                               $self->{'last_sorted'}->sql_required_fields() );
}

sub test_create_value {
    my $self = $_[0];

    my $aggr = $self->{'last_nosort'};
    foreach my $t ( [ 'connection_id', 'QWERTY', undef, 10, 'QWERTY' ],
                    [ 'file_size', 10240, 'QWERTY', 0, '10k' ],
                    [ 'file_size', undef, undef, 0, 'NaN' ],
                    [ 'connection_id', undef, undef, 0, undef ], )
    {
        my ($field, $value, $total, $mc, $content ) = @$t;

        my $row = { 'lastTest_key' => $total,
                    'lastTest' => $value,
                    '_lr_lastTest_mc' => $mc };

        $aggr->{'field'} = $field;
        my $v = $aggr->create_value( undef, $row );
        my $e_v = { 'value' => $value,
                    'missing_cases' => $mc,
                    'content' => $content,
                    'total' => $total };
        $self->assert_deep_equals( $e_v, $v );
    }
}

1;