#!/bin/sh
#
# Copyright (C) 2012
#     Charles Roussel <charles.roussel@ensimag.imag.fr>
#     Simon Cathebras <simon.cathebras@ensimag.imag.fr>
#     Julien Khayat <julien.khayat@ensimag.imag.fr>
#     Guillaume Sasdy <guillaume.sasdy@ensimag.imag.fr>
#     Simon Perrat <simon.perrat@ensimag.imag.fr>
#
# License: GPL v2 or later

# tests for git-remote-mediawiki

global test_description := ''Test the Git Mediawiki remote helper: git push and git pull simple test cases''

source ./test-gitmw-lib.sh
source $TEST_DIRECTORY/test-lib.sh


test_check_precond


proc test_git_reimport {
	git -c remote.origin.dumbPush=true push &&
	git -c remote.origin.mediaImport=true pull --rebase
}

# Don't bother with permissions, be administrator by default
test_expect_success 'setup config' '
	git config --global remote.origin.mwLogin WikiAdmin &&
	git config --global remote.origin.mwPassword AdminPass &&
	test_might_fail git config --global --unset remote.origin.mediaImport
'

test_expect_success 'git push can upload media (File:) files' '
	wiki_reset &&
	git clone mediawiki::'"$WIKI_URL"' mw_dir &&
	(
		cd mw_dir &&
		echo "hello world" >Foo.txt &&
		git add Foo.txt &&
		git commit -m "add a text file" &&
		git push &&
		"$PERL_PATH" -e "print STDOUT \"binary content: \".chr(255);" >Foo.txt &&
		git add Foo.txt &&
		git commit -m "add a text file with binary content" &&
		git push
	)
'

test_expect_success 'git clone works on previously created wiki with media files' '
	test_when_finished "rm -rf mw_dir mw_dir_clone" &&
	git clone -c remote.origin.mediaimport=true \
		mediawiki::'"$WIKI_URL"' mw_dir_clone &&
	test_cmp mw_dir_clone/Foo.txt mw_dir/Foo.txt &&
	(cd mw_dir_clone && git checkout HEAD^) &&
	(cd mw_dir && git checkout HEAD^) &&
	test_cmp mw_dir_clone/Foo.txt mw_dir/Foo.txt
'

test_expect_success 'git push can upload media (File:) files containing valid UTF-8' '
	wiki_reset &&
	git clone mediawiki::'"$WIKI_URL"' mw_dir &&
	(
		cd mw_dir &&
		"$PERL_PATH" -e "print STDOUT \"UTF-8 content: éèàéê€.\";" >Bar.txt &&
		git add Bar.txt &&
		git commit -m "add a text file with UTF-8 content" &&
		git push
	)
'

test_expect_success 'git clone works on previously created wiki with media files containing valid UTF-8' '
	test_when_finished "rm -rf mw_dir mw_dir_clone" &&
	git clone -c remote.origin.mediaimport=true \
		mediawiki::'"$WIKI_URL"' mw_dir_clone &&
	test_cmp mw_dir_clone/Bar.txt mw_dir/Bar.txt
'

test_expect_success 'git push & pull work with locally renamed media files' '
	wiki_reset &&
	git clone mediawiki::'"$WIKI_URL"' mw_dir &&
	test_when_finished "rm -fr mw_dir" &&
	(
		cd mw_dir &&
		echo "A File" >Foo.txt &&
		git add Foo.txt &&
		git commit -m "add a file" &&
		git mv Foo.txt Bar.txt &&
		git commit -m "Rename a file" &&
		test_git_reimport &&
		echo "A File" >expect &&
		test_cmp expect Bar.txt &&
		test_path_is_missing Foo.txt
	)
'

test_expect_success 'git push can propagate local page deletion' '
	wiki_reset &&
	git clone mediawiki::'"$WIKI_URL"' mw_dir &&
	test_when_finished "rm -fr mw_dir" &&
	(
		cd mw_dir &&
		test_path_is_missing Foo.mw &&
		echo "hello world" >Foo.mw &&
		git add Foo.mw &&
		git commit -m "Add the page Foo" &&
		git push &&
		rm -f Foo.mw &&
		git commit -am "Delete the page Foo" &&
		test_git_reimport &&
		test_path_is_missing Foo.mw
	)
'

test_expect_success 'git push can propagate local media file deletion' '
	wiki_reset &&
	git clone mediawiki::'"$WIKI_URL"' mw_dir &&
	test_when_finished "rm -fr mw_dir" &&
	(
		cd mw_dir &&
		echo "hello world" >Foo.txt &&
		git add Foo.txt &&
		git commit -m "Add the text file Foo" &&
		git rm Foo.txt &&
		git commit -m "Delete the file Foo" &&
		test_git_reimport &&
		test_path_is_missing Foo.txt
	)
'

# test failure: the file is correctly uploaded, and then deleted but
# as no page link to it, the import (which looks at page revisions)
# doesn't notice the file deletion on the wiki. We fetch the list of
# files from the wiki, but as the file is deleted, it doesn't appear.
test_expect_failure 'git pull correctly imports media file deletion when no page link to it' '
	wiki_reset &&
	git clone mediawiki::'"$WIKI_URL"' mw_dir &&
	test_when_finished "rm -fr mw_dir" &&
	(
		cd mw_dir &&
		echo "hello world" >Foo.txt &&
		git add Foo.txt &&
		git commit -m "Add the text file Foo" &&
		git push &&
		git rm Foo.txt &&
		git commit -m "Delete the file Foo" &&
		test_git_reimport &&
		test_path_is_missing Foo.txt
	)
'

test_expect_success 'git push properly warns about insufficient permissions' '
	wiki_reset &&
	git clone mediawiki::'"$WIKI_URL"' mw_dir &&
	test_when_finished "rm -fr mw_dir" &&
	(
		cd mw_dir &&
		echo "A File" >foo.forbidden &&
		git add foo.forbidden &&
		git commit -m "add a file" &&
		git push 2>actual &&
		test_i18ngrep "foo.forbidden is not a permitted file" actual
	)
'

test_expect_success 'setup a repository with media files' '
	wiki_reset &&
	wiki_editpage testpage "I am linking a file [[File:File.txt]]" false &&
	echo "File content" >File.txt &&
	wiki_upload_file File.txt &&
	echo "Another file content" >AnotherFile.txt &&
	wiki_upload_file AnotherFile.txt
'

test_expect_success 'git clone works with one specific page cloned and mediaimport=true' '
	git clone -c remote.origin.pages=testpage \
		  -c remote.origin.mediaimport=true \
			mediawiki::'"$WIKI_URL"' mw_dir_15 &&
	test_when_finished "rm -rf mw_dir_15" &&
	test_contains_N_files mw_dir_15 3 &&
	test_path_is_file mw_dir_15/Testpage.mw &&
	test_path_is_file mw_dir_15/File:File.txt.mw &&
	test_path_is_file mw_dir_15/File.txt &&
	test_path_is_missing mw_dir_15/Main_Page.mw &&
	test_path_is_missing mw_dir_15/File:AnotherFile.txt.mw &&
	test_path_is_missing mw_dir_15/AnothetFile.txt &&
	wiki_check_content mw_dir_15/Testpage.mw Testpage &&
	test_cmp mw_dir_15/File.txt File.txt
'

test_expect_success 'git clone works with one specific page cloned and mediaimport=false' '
	test_when_finished "rm -rf mw_dir_16" &&
	git clone -c remote.origin.pages=testpage \
			mediawiki::'"$WIKI_URL"' mw_dir_16 &&
	test_contains_N_files mw_dir_16 1 &&
	test_path_is_file mw_dir_16/Testpage.mw &&
	test_path_is_missing mw_dir_16/File:File.txt.mw &&
	test_path_is_missing mw_dir_16/File.txt &&
	test_path_is_missing mw_dir_16/Main_Page.mw &&
	wiki_check_content mw_dir_16/Testpage.mw Testpage
'

# should behave like mediaimport=false
test_expect_success 'git clone works with one specific page cloned and mediaimport unset' '
	test_when_finished "rm -fr mw_dir_17" &&
	git clone -c remote.origin.pages=testpage \
		mediawiki::'"$WIKI_URL"' mw_dir_17 &&
	test_contains_N_files mw_dir_17 1 &&
	test_path_is_file mw_dir_17/Testpage.mw &&
	test_path_is_missing mw_dir_17/File:File.txt.mw &&
	test_path_is_missing mw_dir_17/File.txt &&
	test_path_is_missing mw_dir_17/Main_Page.mw &&
	wiki_check_content mw_dir_17/Testpage.mw Testpage
'

test_done
(CommandList
  children: [
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:test_description)
          op: Equal
          rhs: {(SQ <"Test the Git Mediawiki remote helper: git push and git pull simple test cases">)}
          spids: [35]
        )
      ]
      spids: [35]
    )
    (C {(.)} {(./test-gitmw-lib.sh)})
    (C {(.)} {($ VSub_Name "$TEST_DIRECTORY") (/test-lib.sh)})
    (C {(test_check_precond)})
    (FuncDef
      name: test_git_reimport
      body: 
        (BraceGroup
          children: [
            (AndOr
              children: [
                (C {(git)} {(-c)} {(remote.origin.dumbPush) (Lit_Other "=") (true)} {(push)})
                (C {(git)} {(-c)} {(remote.origin.mediaImport) (Lit_Other "=") (true)} {(pull)} 
                  {(--rebase)}
                )
              ]
              op_id: Op_DAmp
            )
          ]
          spids: [61]
        )
      spids: [56 60]
    )
    (C {(test_expect_success)} {(SQ <"setup config">)} 
      {
        (SQ <"\n"> <"\tgit config --global remote.origin.mwLogin WikiAdmin &&\n"> 
          <"\tgit config --global remote.origin.mwPassword AdminPass &&\n"> <"\ttest_might_fail git config --global --unset remote.origin.mediaImport\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"git push can upload media (File:) files">)} 
      {(SQ <"\n"> <"\twiki_reset &&\n"> <"\tgit clone mediawiki::">) (DQ ($ VSub_Name "$WIKI_URL")) 
        (SQ <" mw_dir &&\n"> <"\t(\n"> <"\t\tcd mw_dir &&\n"> <"\t\techo \"hello world\" >Foo.txt &&\n"> 
          <"\t\tgit add Foo.txt &&\n"> <"\t\tgit commit -m \"add a text file\" &&\n"> <"\t\tgit push &&\n"> 
          <
"\t\t\"$PERL_PATH\" -e \"print STDOUT \\\"binary content: \\\".chr(255);\" >Foo.txt &&\n"
          > <"\t\tgit add Foo.txt &&\n"> <"\t\tgit commit -m \"add a text file with binary content\" &&\n"> 
          <"\t\tgit push\n"> <"\t)\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"git clone works on previously created wiki with media files">)} 
      {
        (SQ <"\n"> <"\ttest_when_finished \"rm -rf mw_dir mw_dir_clone\" &&\n"> 
          <"\tgit clone -c remote.origin.mediaimport=true \\\n"> <"\t\tmediawiki::">
        ) (DQ ($ VSub_Name "$WIKI_URL")) 
        (SQ <" mw_dir_clone &&\n"> <"\ttest_cmp mw_dir_clone/Foo.txt mw_dir/Foo.txt &&\n"> 
          <"\t(cd mw_dir_clone && git checkout HEAD^) &&\n"> <"\t(cd mw_dir && git checkout HEAD^) &&\n"> <"\ttest_cmp mw_dir_clone/Foo.txt mw_dir/Foo.txt\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"git push can upload media (File:) files containing valid UTF-8">)} 
      {(SQ <"\n"> <"\twiki_reset &&\n"> <"\tgit clone mediawiki::">) (DQ ($ VSub_Name "$WIKI_URL")) 
        (SQ <" mw_dir &&\n"> <"\t(\n"> <"\t\tcd mw_dir &&\n"> 
          <
"\t\t\"$PERL_PATH\" -e \"print STDOUT \\\"UTF-8 content: \u00e9\u00e8\u00e0\u00e9\u00ea\u20ac.\\\";\" >Bar.txt &&\n"
          > <"\t\tgit add Bar.txt &&\n"> <"\t\tgit commit -m \"add a text file with UTF-8 content\" &&\n"> 
          <"\t\tgit push\n"> <"\t)\n">
        )
      }
    )
    (C {(test_expect_success)} 
      {(SQ <"git clone works on previously created wiki with media files containing valid UTF-8">)} 
      {
        (SQ <"\n"> <"\ttest_when_finished \"rm -rf mw_dir mw_dir_clone\" &&\n"> 
          <"\tgit clone -c remote.origin.mediaimport=true \\\n"> <"\t\tmediawiki::">
        ) (DQ ($ VSub_Name "$WIKI_URL")) 
        (SQ <" mw_dir_clone &&\n"> <"\ttest_cmp mw_dir_clone/Bar.txt mw_dir/Bar.txt\n">)
      }
    )
    (C {(test_expect_success)} {(SQ <"git push & pull work with locally renamed media files">)} 
      {(SQ <"\n"> <"\twiki_reset &&\n"> <"\tgit clone mediawiki::">) (DQ ($ VSub_Name "$WIKI_URL")) 
        (SQ <" mw_dir &&\n"> <"\ttest_when_finished \"rm -fr mw_dir\" &&\n"> <"\t(\n"> 
          <"\t\tcd mw_dir &&\n"> <"\t\techo \"A File\" >Foo.txt &&\n"> <"\t\tgit add Foo.txt &&\n"> 
          <"\t\tgit commit -m \"add a file\" &&\n"> <"\t\tgit mv Foo.txt Bar.txt &&\n"> <"\t\tgit commit -m \"Rename a file\" &&\n"> 
          <"\t\ttest_git_reimport &&\n"> <"\t\techo \"A File\" >expect &&\n"> <"\t\ttest_cmp expect Bar.txt &&\n"> 
          <"\t\ttest_path_is_missing Foo.txt\n"> <"\t)\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"git push can propagate local page deletion">)} 
      {(SQ <"\n"> <"\twiki_reset &&\n"> <"\tgit clone mediawiki::">) (DQ ($ VSub_Name "$WIKI_URL")) 
        (SQ <" mw_dir &&\n"> <"\ttest_when_finished \"rm -fr mw_dir\" &&\n"> <"\t(\n"> 
          <"\t\tcd mw_dir &&\n"> <"\t\ttest_path_is_missing Foo.mw &&\n"> <"\t\techo \"hello world\" >Foo.mw &&\n"> 
          <"\t\tgit add Foo.mw &&\n"> <"\t\tgit commit -m \"Add the page Foo\" &&\n"> <"\t\tgit push &&\n"> <"\t\trm -f Foo.mw &&\n"> 
          <"\t\tgit commit -am \"Delete the page Foo\" &&\n"> <"\t\ttest_git_reimport &&\n"> <"\t\ttest_path_is_missing Foo.mw\n"> <"\t)\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"git push can propagate local media file deletion">)} 
      {(SQ <"\n"> <"\twiki_reset &&\n"> <"\tgit clone mediawiki::">) (DQ ($ VSub_Name "$WIKI_URL")) 
        (SQ <" mw_dir &&\n"> <"\ttest_when_finished \"rm -fr mw_dir\" &&\n"> <"\t(\n"> 
          <"\t\tcd mw_dir &&\n"> <"\t\techo \"hello world\" >Foo.txt &&\n"> <"\t\tgit add Foo.txt &&\n"> 
          <"\t\tgit commit -m \"Add the text file Foo\" &&\n"> <"\t\tgit rm Foo.txt &&\n"> <"\t\tgit commit -m \"Delete the file Foo\" &&\n"> 
          <"\t\ttest_git_reimport &&\n"> <"\t\ttest_path_is_missing Foo.txt\n"> <"\t)\n">
        )
      }
    )
    (C {(test_expect_failure)} 
      {(SQ <"git pull correctly imports media file deletion when no page link to it">)} 
      {(SQ <"\n"> <"\twiki_reset &&\n"> <"\tgit clone mediawiki::">) (DQ ($ VSub_Name "$WIKI_URL")) 
        (SQ <" mw_dir &&\n"> <"\ttest_when_finished \"rm -fr mw_dir\" &&\n"> <"\t(\n"> 
          <"\t\tcd mw_dir &&\n"> <"\t\techo \"hello world\" >Foo.txt &&\n"> <"\t\tgit add Foo.txt &&\n"> 
          <"\t\tgit commit -m \"Add the text file Foo\" &&\n"> <"\t\tgit push &&\n"> <"\t\tgit rm Foo.txt &&\n"> <"\t\tgit commit -m \"Delete the file Foo\" &&\n"> 
          <"\t\ttest_git_reimport &&\n"> <"\t\ttest_path_is_missing Foo.txt\n"> <"\t)\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"git push properly warns about insufficient permissions">)} 
      {(SQ <"\n"> <"\twiki_reset &&\n"> <"\tgit clone mediawiki::">) (DQ ($ VSub_Name "$WIKI_URL")) 
        (SQ <" mw_dir &&\n"> <"\ttest_when_finished \"rm -fr mw_dir\" &&\n"> <"\t(\n"> 
          <"\t\tcd mw_dir &&\n"> <"\t\techo \"A File\" >foo.forbidden &&\n"> <"\t\tgit add foo.forbidden &&\n"> 
          <"\t\tgit commit -m \"add a file\" &&\n"> <"\t\tgit push 2>actual &&\n"> 
          <"\t\ttest_i18ngrep \"foo.forbidden is not a permitted file\" actual\n"> <"\t)\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"setup a repository with media files">)} 
      {
        (SQ <"\n"> <"\twiki_reset &&\n"> 
          <"\twiki_editpage testpage \"I am linking a file [[File:File.txt]]\" false &&\n"> <"\techo \"File content\" >File.txt &&\n"> <"\twiki_upload_file File.txt &&\n"> 
          <"\techo \"Another file content\" >AnotherFile.txt &&\n"> <"\twiki_upload_file AnotherFile.txt\n">
        )
      }
    )
    (C {(test_expect_success)} 
      {(SQ <"git clone works with one specific page cloned and mediaimport=true">)} 
      {
        (SQ <"\n"> <"\tgit clone -c remote.origin.pages=testpage \\\n"> 
          <"\t\t  -c remote.origin.mediaimport=true \\\n"> <"\t\t\tmediawiki::">
        ) (DQ ($ VSub_Name "$WIKI_URL")) 
        (SQ <" mw_dir_15 &&\n"> <"\ttest_when_finished \"rm -rf mw_dir_15\" &&\n"> 
          <"\ttest_contains_N_files mw_dir_15 3 &&\n"> <"\ttest_path_is_file mw_dir_15/Testpage.mw &&\n"> 
          <"\ttest_path_is_file mw_dir_15/File:File.txt.mw &&\n"> <"\ttest_path_is_file mw_dir_15/File.txt &&\n"> <"\ttest_path_is_missing mw_dir_15/Main_Page.mw &&\n"> 
          <"\ttest_path_is_missing mw_dir_15/File:AnotherFile.txt.mw &&\n"> <"\ttest_path_is_missing mw_dir_15/AnothetFile.txt &&\n"> 
          <"\twiki_check_content mw_dir_15/Testpage.mw Testpage &&\n"> <"\ttest_cmp mw_dir_15/File.txt File.txt\n">
        )
      }
    )
    (C {(test_expect_success)} 
      {(SQ <"git clone works with one specific page cloned and mediaimport=false">)} 
      {
        (SQ <"\n"> <"\ttest_when_finished \"rm -rf mw_dir_16\" &&\n"> 
          <"\tgit clone -c remote.origin.pages=testpage \\\n"> <"\t\t\tmediawiki::">
        ) (DQ ($ VSub_Name "$WIKI_URL")) 
        (SQ <" mw_dir_16 &&\n"> <"\ttest_contains_N_files mw_dir_16 1 &&\n"> 
          <"\ttest_path_is_file mw_dir_16/Testpage.mw &&\n"> <"\ttest_path_is_missing mw_dir_16/File:File.txt.mw &&\n"> 
          <"\ttest_path_is_missing mw_dir_16/File.txt &&\n"> <"\ttest_path_is_missing mw_dir_16/Main_Page.mw &&\n"> 
          <"\twiki_check_content mw_dir_16/Testpage.mw Testpage\n">
        )
      }
    )
    (C {(test_expect_success)} 
      {(SQ <"git clone works with one specific page cloned and mediaimport unset">)} 
      {
        (SQ <"\n"> <"\ttest_when_finished \"rm -fr mw_dir_17\" &&\n"> 
          <"\tgit clone -c remote.origin.pages=testpage \\\n"> <"\t\tmediawiki::">
        ) (DQ ($ VSub_Name "$WIKI_URL")) 
        (SQ <" mw_dir_17 &&\n"> <"\ttest_contains_N_files mw_dir_17 1 &&\n"> 
          <"\ttest_path_is_file mw_dir_17/Testpage.mw &&\n"> <"\ttest_path_is_missing mw_dir_17/File:File.txt.mw &&\n"> 
          <"\ttest_path_is_missing mw_dir_17/File.txt &&\n"> <"\ttest_path_is_missing mw_dir_17/Main_Page.mw &&\n"> 
          <"\twiki_check_content mw_dir_17/Testpage.mw Testpage\n">
        )
      }
    )
    (C {(test_done)})
  ]
)