t/t9811-git-p4-label-import.sh

   1 #!/bin/sh
   2
   3 test_description='git p4 label tests'
   4
   5 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main
   6 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME
   7
   8 . ./lib-git-p4.sh
   9
  10 test_expect_success 'start p4d' '
  11         start_p4d
  12 '
  13
  14 # Basic p4 label import tests.
  15 #
  16 test_expect_success 'basic p4 labels' '
  17         test_when_finished cleanup_git &&
  18         (
  19                 cd "$cli" &&
  20                 mkdir -p main &&
  21
  22                 echo f1 >main/f1 &&
  23                 p4 add main/f1 &&
  24                 p4 submit -d "main/f1" &&
  25
  26                 echo f2 >main/f2 &&
  27                 p4 add main/f2 &&
  28                 p4 submit -d "main/f2" &&
  29
  30                 echo f3 >main/file_with_\$metachar &&
  31                 p4 add main/file_with_\$metachar &&
  32                 p4 submit -d "file with metachar" &&
  33
  34                 p4 tag -l TAG_F1_ONLY main/f1 &&
  35                 p4 tag -l TAG_WITH\$_SHELL_CHAR main/... &&
  36                 p4 tag -l this_tag_will_be\ skipped main/... &&
  37
  38                 echo f4 >main/f4 &&
  39                 p4 add main/f4 &&
  40                 p4 submit -d "main/f4" &&
  41
  42                 p4 label -i <<-EOF &&
  43                 Label: TAG_LONG_LABEL
  44                 Description:
  45                    A Label first line
  46                    A Label second line
  47                 View:   //depot/...
  48                 EOF
  49
  50                 p4 tag -l TAG_LONG_LABEL ... &&
  51
  52                 p4 labels ... &&
  53
  54                 git p4 clone --dest="$git" //depot@all &&
  55                 cd "$git" &&
  56                 git config git-p4.labelImportRegexp ".*TAG.*" &&
  57                 git p4 sync --import-labels --verbose &&
  58
  59                 git tag &&
  60                 git tag >taglist &&
  61                 test_line_count = 3 taglist &&
  62
  63                 cd main &&
  64                 git checkout TAG_F1_ONLY &&
  65                 ! test -f f2 &&
  66                 git checkout TAG_WITH\$_SHELL_CHAR &&
  67                 test -f f1 && test -f f2 && test -f file_with_\$metachar &&
  68
  69                 git show TAG_LONG_LABEL | grep -q "A Label second line"
  70         )
  71 '
  72 # Test some label corner cases:
  73 #
  74 # - two tags on the same file; both should be available
  75 # - a tag that is only on one file; this kind of tag
  76 #   cannot be imported (at least not easily).
  77
  78 test_expect_success 'two labels on the same changelist' '
  79         test_when_finished cleanup_git &&
  80         (
  81                 cd "$cli" &&
  82                 mkdir -p main &&
  83
  84                 p4 edit main/f1 main/f2 &&
  85                 echo "hello world" >main/f1 &&
  86                 echo "not in the tag" >main/f2 &&
  87                 p4 submit -d "main/f[12]: testing two labels" &&
  88
  89                 p4 tag -l TAG_F1_1 main/... &&
  90                 p4 tag -l TAG_F1_2 main/... &&
  91
  92                 p4 labels ... &&
  93
  94                 git p4 clone --dest="$git" //depot@all &&
  95                 cd "$git" &&
  96                 git p4 sync --import-labels &&
  97
  98                 git tag | grep TAG_F1 &&
  99                 git tag | grep -q TAG_F1_1 &&
 100                 git tag | grep -q TAG_F1_2 &&
 101
 102                 cd main &&
 103
 104                 git checkout TAG_F1_1 &&
 105                 ls &&
 106                 test -f f1 &&
 107
 108                 git checkout TAG_F1_2 &&
 109                 ls &&
 110                 test -f f1
 111         )
 112 '
 113
 114 # Export some git tags to p4
 115 test_expect_success 'export git tags to p4' '
 116         test_when_finished cleanup_git &&
 117         git p4 clone --dest="$git" //depot@all &&
 118         (
 119                 cd "$git" &&
 120                 git tag -m "A tag created in git:xyzzy" GIT_TAG_1 &&
 121                 echo "hello world" >main/f10 &&
 122                 git add main/f10 &&
 123                 git commit -m "Adding file for export test" &&
 124                 git config git-p4.skipSubmitEdit true &&
 125                 git p4 submit &&
 126                 git tag -m "Another git tag" GIT_TAG_2 &&
 127                 git tag LIGHTWEIGHT_TAG &&
 128                 git p4 rebase --import-labels --verbose &&
 129                 git p4 submit --export-labels --verbose
 130         ) &&
 131         (
 132                 cd "$cli" &&
 133                 p4 sync ... &&
 134                 p4 labels ... | grep GIT_TAG_1 &&
 135                 p4 labels ... | grep GIT_TAG_2 &&
 136                 p4 labels ... | grep LIGHTWEIGHT_TAG &&
 137                 p4 label -o GIT_TAG_1 | grep "tag created in git:xyzzy" &&
 138                 p4 sync ...@GIT_TAG_1 &&
 139                 ! test -f main/f10 &&
 140                 p4 sync ...@GIT_TAG_2 &&
 141                 test -f main/f10
 142         )
 143 '
 144
 145 # Export a tag from git where an affected file is deleted later on
 146 # Need to create git tags after rebase, since only then can the
 147 # git commits be mapped to p4 changelists.
 148 test_expect_success 'export git tags to p4 with deletion' '
 149         test_when_finished cleanup_git &&
 150         git p4 clone --dest="$git" //depot@all &&
 151         (
 152                 cd "$git" &&
 153                 git p4 sync --import-labels &&
 154                 echo "deleted file" >main/deleted_file &&
 155                 git add main/deleted_file &&
 156                 git commit -m "create deleted file" &&
 157                 git rm main/deleted_file &&
 158                 echo "new file" >main/f11 &&
 159                 git add main/f11 &&
 160                 git commit -m "delete the deleted file" &&
 161                 git config git-p4.skipSubmitEdit true &&
 162                 git p4 submit &&
 163                 git p4 rebase --import-labels --verbose &&
 164                 git tag -m "tag on deleted file" GIT_TAG_ON_DELETED HEAD~1 &&
 165                 git tag -m "tag after deletion" GIT_TAG_AFTER_DELETION HEAD &&
 166                 git p4 submit --export-labels --verbose
 167         ) &&
 168         (
 169                 cd "$cli" &&
 170                 p4 sync ... &&
 171                 p4 sync ...@GIT_TAG_ON_DELETED &&
 172                 test -f main/deleted_file &&
 173                 p4 sync ...@GIT_TAG_AFTER_DELETION &&
 174                 ! test -f main/deleted_file &&
 175                 echo "checking label contents" &&
 176                 p4 label -o GIT_TAG_ON_DELETED | grep "tag on deleted file"
 177         )
 178 '
 179
 180 # Create a tag in git that cannot be exported to p4
 181 test_expect_success 'tag that cannot be exported' '
 182         test_when_finished cleanup_git &&
 183         git p4 clone --dest="$git" //depot@all &&
 184         (
 185                 cd "$git" &&
 186                 git checkout -b a_branch &&
 187                 echo "hello" >main/f12 &&
 188                 git add main/f12 &&
 189                 git commit -m "adding f12" &&
 190                 git tag -m "tag on a_branch" GIT_TAG_ON_A_BRANCH &&
 191                 git checkout main &&
 192                 git p4 submit --export-labels
 193         ) &&
 194         (
 195                 cd "$cli" &&
 196                 p4 sync ... &&
 197                 ! p4 labels | grep GIT_TAG_ON_A_BRANCH
 198         )
 199 '
 200
 201 test_expect_success 'use git config to enable import/export of tags' '
 202         git p4 clone --verbose --dest="$git" //depot@all &&
 203         (
 204                 cd "$git" &&
 205                 git config git-p4.exportLabels true &&
 206                 git config git-p4.importLabels true &&
 207                 git tag CFG_A_GIT_TAG &&
 208                 git p4 rebase --verbose &&
 209                 git p4 submit --verbose &&
 210                 git tag &&
 211                 git tag | grep TAG_F1_1
 212         ) &&
 213         (
 214                 cd "$cli" &&
 215                 p4 labels &&
 216                 p4 labels | grep CFG_A_GIT_TAG
 217         )
 218 '
 219
 220 p4_head_revision() {
 221         p4 changes -m 1 "$@" | awk '{print $2}'
 222 }
 223
 224 # Importing a label that references a P4 commit that
 225 # has not been seen. The presence of a label on a commit
 226 # we haven't seen should not cause git-p4 to fail. It should
 227 # merely skip that label, and still import other labels.
 228 test_expect_success 'importing labels with missing revisions' '
 229         test_when_finished cleanup_git &&
 230         (
 231                 rm -fr "$cli" "$git" &&
 232                 mkdir "$cli" &&
 233                 P4CLIENT=missing-revision &&
 234                 client_view "//depot/missing-revision/... //missing-revision/..." &&
 235                 cd "$cli" &&
 236                 >f1 && p4 add f1 && p4 submit -d "start" &&
 237
 238                 p4 tag -l TAG_S0 ... &&
 239
 240                 >f2 && p4 add f2 && p4 submit -d "second" &&
 241
 242                 startrev=$(p4_head_revision //depot/missing-revision/...) &&
 243
 244                 >f3 && p4 add f3 && p4 submit -d "third" &&
 245
 246                 p4 edit f2 && date >f2 && p4 submit -d "change" f2 &&
 247
 248                 endrev=$(p4_head_revision //depot/missing-revision/...) &&
 249
 250                 p4 tag -l TAG_S1 ... &&
 251
 252                 # we should skip TAG_S0 since it is before our startpoint,
 253                 # but pick up TAG_S1.
 254
 255                 git p4 clone --dest="$git" --import-labels -v \
 256                         //depot/missing-revision/...@$startrev,$endrev &&
 257                 (
 258                         cd "$git" &&
 259                         git rev-parse TAG_S1 &&
 260                         ! git rev-parse TAG_S0
 261                 )
 262         )
 263 '
 264
 265 test_done