webtools-bmo-qa/t/webservice_bug_comments.t

##########################################
# Test for xmlrpc call to Bug.comments() #
##########################################

use strict;
use warnings;
use lib qw(lib);
use DateTime;
use QA::Util;
use QA::Tests qw(STANDARD_BUG_TESTS PRIVATE_BUG_USER);
use Test::More tests => 331;
my ($config, @clients) = get_rpc_clients();

# These gets populated when we call Bug.add_comment.
our $creation_time;
our %comments = (
    public_comment_public_bug  => 0,
    public_comment_private_bug  => 0,
    private_comment_public_bug  => 0,
    private_comment_private_bug => 0,
);

sub test_comments {
    my ($comments_returned, $call, $t, $rpc) = @_;

    my $comment = $comments_returned->[0];
    ok($comment->{bug_id}, "bug_id exists");
    # XXX At some point we should test attachment_id here.

    if ($t->{args}->{comment_ids}) {
        my $expected_id = $t->{args}->{comment_ids}->[0];
        is($comment->{id}, $expected_id, "comment id is correct");

        my %reverse_map = reverse %comments;
        my $expected_text = $reverse_map{$expected_id};
        is($comment->{text}, $expected_text, "comment has the correct text");

        my $priv_login = $rpc->bz_config->{PRIVATE_BUG_USER . '_user_login'};
        is($comment->{creator}, $priv_login, "comment creator is correct");


        my $creation_day;
        if ($rpc->isa('QA::RPC::XMLRPC')) {
            $creation_day = $creation_time->ymd('');
        }
        else {
            $creation_day = $creation_time->ymd;
        }
        like($comment->{time}, qr/^\Q${creation_day}\ET\d\d:\d\d:\d\d/,
             "comment time has the right format");
    }
    else {
        foreach my $field (qw(id text creator time)) {
            ok(defined $comment->{$field}, "$field is defined");
        }
    }
}

################
# Bug ID Tests #
################

sub post_bug_success {
    my ($call, $t) = @_;
    my @bugs = values %{ $call->result->{bugs} };
    is(scalar @bugs, 1, "Got exactly one bug");
    my @comments = map { @{ $_->{comments} } } @bugs;
    test_comments(\@comments, @_);
}

foreach my $rpc (@clients) {
    $rpc->bz_run_tests(tests => STANDARD_BUG_TESTS, method => 'Bug.comments',
                       post_success => \&post_bug_success);
}

####################
# Comment ID Tests #
####################

# First, create comments using add_comment.
my @add_comment_tests;
foreach my $key (keys %comments) {
    $key =~ /^([a-z]+)_comment_(\w+)$/;
    my $is_private = ($1 eq 'private' ? 1 : 0);
    my $bug_alias = $2;
    push(@add_comment_tests, { args => { id => $bug_alias, comment => $key,
                                         private => $is_private },
                               test => "Add comment: $key",
                               user => PRIVATE_BUG_USER });
}

# Set the comment id for each comment that we add, so we can test getting
# them back, later.
sub post_add {
    my ($call, $t) = @_;
    my $key = $t->{args}->{comment};
    $comments{$key} = $call->result->{id};
}

$creation_time = DateTime->now();
# We only need to create these comments once, with one of the interfaces.
$clients[0]->bz_run_tests(
    tests => \@add_comment_tests, method => 'Bug.add_comment',
    post_success => \&post_add);

# Now check access on each private and public comment

my @comment_tests = (
    # Logged-out user
    { args => { comment_ids => [$comments{'public_comment_public_bug'}] },
      test => 'Logged-out user can access public comment on public bug by id',
    },
    { args  => { comment_ids => [$comments{'private_comment_public_bug'}] },
      test  => 'Logged-out user cannot access private comment on public bug',
      error => 'is private',
    },
    { args  => { comment_ids => [$comments{'public_comment_private_bug'}] },
      test  => 'Logged-out user cannot access comments by id on private bug',
      error => 'You are not authorized to access',
    },
    { args  => { comment_ids => [$comments{'private_comment_private_bug'}] },
      test  => 'Logged-out user cannot access private comment on private bug',
      error => 'You are not authorized to access',
    },

    # Logged-in, unprivileged user.
    { user => 'unprivileged',
      args => { comment_ids => [$comments{'public_comment_public_bug'}] },
      test => 'Logged-in user can see a public comment on a public bug by id',
    },
    { user  => 'unprivileged',
      args  => { comment_ids => [$comments{'private_comment_public_bug'}] },
      test  => 'Logged-in user cannot access private comment on public bug',
      error => 'is private',
    },
    { user  => 'unprivileged',
      args  => { comment_ids => [$comments{'public_comment_private_bug'}] },
      test  => 'Logged-in user cannot access comments by id on private bug',
      error => "You are not authorized to access",
    },
    { user  => 'unprivileged',
      args  => { comment_ids => [$comments{'private_comment_private_bug'}] },
      test  => 'Logged-in user cannot access private comment on private bug',
      error => "You are not authorized to access",
    },

    # User who can see private bugs and private comments
    { user => PRIVATE_BUG_USER,
      args => { comment_ids => [$comments{'private_comment_public_bug'}] },
      test => PRIVATE_BUG_USER . ' can see private comment on public bug',
    },
    { user  => PRIVATE_BUG_USER,
      args  => { comment_ids => [$comments{'private_comment_private_bug'}] },
      test  => PRIVATE_BUG_USER . ' can see private comment on private bug',
    },
);

sub post_comments {
    my ($call) = @_;
    my @comments = values %{ $call->result->{comments} };
    is(scalar @comments, 1, "Got exactly one comment");
    test_comments(\@comments, @_);
}

foreach my $rpc (@clients) {
    $rpc->bz_run_tests(tests => \@comment_tests, method => 'Bug.comments',
                       post_success => \&post_comments);
}