#!/usr/bin/env perl
# Copyright (C) 2017 The Qt Company Ltd and/or its subsidiary(-ies).
# SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
use 5.010;
use strict;
use warnings;

=head1 NAME

10-git-qtqa-combine.t - basic git-qtqa-combine test

=cut

use English qw(-no_match_vars);
use File::Spec::Functions;
use File::Temp qw(tempdir);
use File::chdir;
use FindBin;
use Readonly;
use Test::More;
use autodie;

use lib "$FindBin::Bin/../../lib/perl5";

Readonly my $GIT_COMBINE => catfile( $FindBin::Bin, '..', 'git-qtqa-combine' );

# Like system(), but die on failure.
sub system_or_die
{
    my (@cmd) = @_;
    if (system( @cmd ) != 0) {
        die "@cmd exited with status $?";
    }
}

# Create an empty file with the given $filename, if it does not yet exist.
sub touch
{
    my ($filename) = @_;
    open( my $fh, '>>', $filename );
    close( $fh );
    return;
}

# Given a $ref and (optional) $dir, returns the SHA1 of that $ref.
# $dir defaults to '.' if omitted.
sub get_ref
{
    my ($ref, $dir) = @_;
    if (!$dir) {
        $dir = '.';
    }

    local $CWD = $dir;

    my $commit = qx(git rev-parse "$ref");
    ($? == 0) || die;

    chomp $commit;
    return $commit;
}

# Given a $rev (ref or SHA1), returns a list of parent commits of that revision.
sub get_parent_commits
{
    my ($rev) = @_;

    my $out = qx(git log -n1 "$rev" --format=format:%P);
    ($? == 0) || die;

    chomp $out;
    my @parents = split( /\s/, $out );
    return @parents;
}

# Creates a git repo and populates some refs.
# Takes the following named arguments:
#
#  dir => the directory where the repo shall be created.
#  refs => a hashref with git ref names as keys, and
#          arrayrefs containing filenames to create as values.
#
# All created files are empty.
sub make_git_repo
{
    my (%args) = @_;

    my $dir = $args{ dir };
    my %refs = %{ $args{ refs } || {} };

    system_or_die( 'git', 'init', '--quiet', $dir );

    local $CWD = $dir;

    # Allow pushing to checked out branch
    system_or_die( 'git', 'config', 'receive.denyCurrentBranch', 'ignore' );

    if (!%refs) {
        return;
    }

    # For simplicity, we always have one initial commit from which all others are descended.
    touch( 'dummy' );
    system_or_die( 'git', 'add', 'dummy' );
    system_or_die( 'git', 'commit', '--quiet', '-m', 'Initial commit' );

    my $initial_commit = get_ref( 'refs/heads/master' );

    my $last_ref;

    system_or_die( 'git', 'checkout', '--quiet', '-b', '_workbranch' );

    while (my ($ref, $files_arrayref) = each %refs) {
        my @files = @{ $files_arrayref };

        system_or_die( 'git', 'reset', '--quiet', '--hard', $initial_commit );
        system_or_die( 'git', 'rm', '--quiet', 'dummy' );
        foreach my $file (@files) {
            touch( $file );
        }
        system_or_die( 'git', 'add', @files );
        system_or_die( 'git', 'commit', '--quiet', '-m', 'Committed files' );
        my $commit = get_ref( 'refs/heads/_workbranch' );
        system_or_die( 'git', 'update-ref', $ref, $commit );

        $last_ref = $ref;
    }

    system_or_die( 'git', 'checkout', '--quiet', $last_ref );
    system_or_die( 'git', 'branch', '-D', '_workbranch' );

    if (!$refs{ 'refs/heads/master' }) {
        system_or_die( 'git', 'branch', '-D', 'master' );
    }

    return;
}

# Verify the state of a particular ref in a particular git repo.
# Takes an argument hash with the following keys:
#
#   dir => directory of the git repo (defaults to '.')
#   ref => git ref to check
#   testname => name of the test, for Test::More messages
#   expected_files => arrayref of expected files to be present
#                     when 'ref' is checked out
#   expected_parents => arrayref of expected parent SHA1s of 'ref'
#
sub verify_git_state
{
    my (%args) = @_;

    my $dir = $args{ dir } || '.';
    my $ref = $args{ 'ref' };
    my $testname = $args{ testname };
    my @expected_files = @{ $args{ expected_files } || [] };
    my @expected_parents = @{ $args{ expected_parents } || [] };

    local $CWD = $dir;

    system_or_die( qw(git reset --hard --quiet), $ref );

    my @files = sort glob '*';

    is_deeply(
        \@files,
        [ sort @expected_files ],
        "$testname: correct files exist"
    );

    my @parents = get_parent_commits( $ref );
    is_deeply(
        [ sort @parents ],
        [ sort @expected_parents ],
        "$testname: merge commit parents look correct"
    );

    return;
}

# Basic test combining three input repos into one output, then updating when
# one of the input repos is modified.
sub test_basic_combine
{
    local $CWD = tempdir( 'git-qtqa-combine.XXXXXX', TMPDIR => 1, CLEANUP => 1 );

    mkdir 'work';

    my @all_in = qw(in1 in2 in3);

    for my $in (@all_in) {
        make_git_repo(
            dir => $in,
            refs => {
                'refs/heads/master' => [ "file_from_$in" ],
            },
        );
    }
    make_git_repo( dir => 'out1' );

    my (@all_in_revs) = map { get_ref( 'refs/heads/master', $_ ) } @all_in;

    my @cmd = (
        $GIT_COMBINE,
        qw(--workdir work),
        map( { ('--in', "url=$CWD/$_", 'ref=refs/heads/master') } @all_in ),
        '--out', "url=$CWD/out1", 'ref=refs/heads/master',
    );

    is( system( @cmd ), 0, 'basic: exit code 0' );

    my %state = (
        dir => 'out1',
        'ref' => 'refs/heads/master',
        expected_files => [ map { "file_from_$_" } @all_in ],
        expected_parents => \@all_in_revs,
    );

    verify_git_state( testname => 'basic', %state );

    # Check that running again is a no-op
    is( system( @cmd ), 0, 'basic no-op: exit code 0' );
    verify_git_state( testname => 'basic no-op', %state );

    # Check that, if only one of the inputs now changes, the change is merged OK
    # and the merge commit only merges the new history.
    my $old_out_rev = get_ref( 'refs/heads/master', 'out1' );
    my $new_in2_rev;

    # Create a new commit in 'in2'; the file from in2 is renamed so we can tell if
    # the content change is correctly merged.
    {
        local $CWD = 'in2';
        system_or_die( 'git', 'checkout', '--quiet', 'master' );
        system_or_die( 'git', 'mv', 'file_from_in2', 'renamed_file_from_in2' );
        system_or_die( 'git', 'commit', '--quiet', '-m', 'Moved a file' );
        $new_in2_rev = get_ref( 'refs/heads/master' );
    }

    is( system( @cmd ), 0, 'basic update: exit code 0' );

    # file rename should be reflected in the update ...
    $state{ expected_files } = [ 'file_from_in1', 'renamed_file_from_in2', 'file_from_in3' ];
    # and the merge commit should only be merging the changed input repo into the output repo
    $state{ expected_parents } = [ $old_out_rev, $new_in2_rev ];
    verify_git_state( testname => 'basic update', %state );

    return;
}

# Test combining three input repositories into two output repositories in a few different
# ways, with a single command line and with usage of 'files' patterns.
sub test_multi_combine_with_files
{
    local $CWD = tempdir( 'git-qtqa-combine.XXXXXX', TMPDIR => 1, CLEANUP => 1 );

    mkdir 'work';

    my @all_in = qw(in1 in2 in3);
    my @all_out = qw(out1 out2);

    for my $in (@all_in) {
        make_git_repo(
            dir => $in,
            refs => {
                "refs/heads/$in" => [ "file_from_$in.txt", "file_from_$in.cpp" ],
                # Let in2 have a "master" branch, while the others don't.
                # This checks that having an unused master branch doesn't hurt, and
                # having no master branch also doesn't hurt.
                (($in eq 'in2') ? ("refs/heads/master" => [ "some_other_file.txt" ]) : ()),
            },
        );
    }
    for my $out (@all_out) {
        make_git_repo( dir => $out );
    }

    my ($in1_rev, $in2_rev, $in3_rev) = map { get_ref( "refs/heads/$_", $_ ) } @all_in;

    is(
        system(
            $GIT_COMBINE,
            qw(--workdir work),
            '--in',  "url=$CWD/in1",   'ref=refs/heads/in1', 'files=*.txt',
            '--in',  "url=$CWD/in2",   'ref=refs/heads/in2', 'files=*.cpp',
            '--out', "url=$CWD/out1",  'ref=refs/heads/one_txt_two_cpp',
            '--in',  "url=$CWD/in1",   'ref=refs/heads/in1', 'files=*.cpp',
            '--in',  "url=$CWD/in2",   'ref=refs/heads/in2', 'files=*.txt',
            '--out', "url=$CWD/out1",  'ref=refs/heads/one_cpp_two_txt',
            '--in',  "url=$CWD/in2",   'ref=refs/heads/in2', 'files=*.cpp',
            '--in',  "url=$CWD/in3",   'ref=refs/heads/in3', 'files=*.txt',
            '--out', "url=$CWD/out2",  'ref=refs/heads/two_cpp_three_txt',
        ),
        0,
        'multi: exit code 0'
    );

    verify_git_state(
        testname => 'multi one_txt_two_cpp',
        dir => 'out1',
        'ref' => 'refs/heads/one_txt_two_cpp',
        expected_files => [ 'file_from_in1.txt', 'file_from_in2.cpp' ],
        expected_parents => [ $in1_rev, $in2_rev ],
    );

    verify_git_state(
        testname => 'multi one_cpp_two_txt',
        dir => 'out1',
        'ref' => 'refs/heads/one_cpp_two_txt',
        expected_files => [ 'file_from_in1.cpp', 'file_from_in2.txt' ],
        expected_parents => [ $in1_rev, $in2_rev ],
    );

    verify_git_state(
        testname => 'multi two_cpp_three_txt',
        dir => 'out2',
        'ref' => 'refs/heads/two_cpp_three_txt',
        expected_files => [ 'file_from_in2.cpp', 'file_from_in3.txt' ],
        expected_parents => [ $in2_rev, $in3_rev ],
    );

    return;
}

# Test usage of the 'submodule' option
sub test_submodule_combine
{
    local $CWD = tempdir( 'git-qtqa-combine.XXXXXX', TMPDIR => 1, CLEANUP => 1 );

    mkdir 'work';

    foreach my $in (qw(in1 in2)) {
        make_git_repo(
            dir => $in,
            refs => {
                'refs/heads/master' => [ "file_from_$in" ],
            },
        );
    }
    make_git_repo(
        dir => 'sub',
        refs => {
            'refs/heads/master' => [ 'file_from_sub' ],
        },
    );

    # Let in2 have sub as a submodule.
    {
        local $CWD = 'in2';
        system_or_die( 'git', 'checkout', '--quiet', 'master' );
        system_or_die( 'git', 'submodule', 'add', "$CWD/../sub", 'sub' );
        system_or_die( 'git', 'commit', '-m', 'Added submodule' );
    }

    my ($in1_rev, $sub_rev) = map { get_ref( 'refs/heads/master', $_ ) } qw(in1 sub);

    make_git_repo( dir => 'out1' );

    my @cmd = (
        $GIT_COMBINE,
        qw(--workdir work),
        '--in',  "url=$CWD/in1", 'ref=refs/heads/master',
        '--in',  "url=$CWD/in2", 'ref=refs/heads/master', 'submodule=sub',
        '--out', "url=$CWD/out1", 'ref=refs/heads/master',
    );

    is( system( @cmd ), 0, 'submodule: exit code 0' );

    my %state = (
        dir => 'out1',
        'ref' => 'refs/heads/master',
        expected_files => [ 'file_from_in1', 'file_from_sub' ],
        expected_parents => [ $in1_rev, $sub_rev ],
    );

    verify_git_state( testname => 'submodule', %state );

    # Create a new commit in 'sub'
    my $new_sub_rev;
    {
        local $CWD = 'sub';
        system_or_die( 'git', 'checkout', '--quiet', 'master' );
        system_or_die( 'git', 'mv', 'file_from_sub', 'renamed_file_from_sub' );
        system_or_die( 'git', 'commit', '--quiet', '-m', 'Moved a file' );
        $new_sub_rev = get_ref( 'refs/heads/master' );
    }

    # Check that running again is a no-op; i.e. the new commit in 'sub' is _not_ taken,
    # because the parent repo wasn't updated.
    is( system( @cmd ), 0, 'submodule no-op: exit code 0' );
    verify_git_state( testname => 'submodule no-op', %state );

    my $old_out_rev = get_ref( 'refs/heads/master', 'out1' );

    # Now update submodule pointer
    {
        local $CWD = 'in2';
        {
            local $CWD = 'sub';
            system_or_die( 'git', 'fetch', '--quiet', "../../sub", 'refs/heads/master' );
            system_or_die( 'git', 'reset', '--hard', 'FETCH_HEAD' );
        }
        system_or_die( 'git', 'add', 'sub' );
        system_or_die( 'git', 'commit', '-m', 'Updated submodule.' );
    }

    is( system( @cmd ), 0, 'submodule update: exit code 0' );

    # file rename should be reflected in the update ...
    $state{ expected_files } = [ 'file_from_in1', 'renamed_file_from_sub' ];
    # and the merge commit should only be merging the changed input repo (submodule) into the output repo
    $state{ expected_parents } = [ $old_out_rev, $new_sub_rev ];
    verify_git_state( testname => 'basic update', %state );

    return;
}

sub run
{
    if ($OSNAME =~ m{win32}i) {
        plan skip_all => "git-qtqa-combine is not supported on $OSNAME";
    }

    # set a fake git user.name and user.email for the test;
    # the account under which this test is running might not
    # have any set
    local $ENV{ GIT_COMMITTER_NAME } = '10-git-qtqa-combine.t';
    local $ENV{ GIT_COMMITTER_EMAIL } = 'autotest@example.com';
    local $ENV{ GIT_AUTHOR_NAME } = $ENV{ GIT_COMMITTER_NAME };
    local $ENV{ GIT_AUTHOR_EMAIL } = $ENV{ GIT_COMMITTER_EMAIL };

    test_basic_combine;
    test_multi_combine_with_files;
    test_submodule_combine;
    done_testing;

    return;
}

run if (!caller);
1;