2006-05-29 21:30:15 +02:00
|
|
|
#!/bin/sh
|
|
|
|
|
2008-09-03 10:59:33 +02:00
|
|
|
test_description='git send-email'
|
2006-05-29 21:30:15 +02:00
|
|
|
. ./test-lib.sh
|
|
|
|
|
2010-08-13 22:40:09 +02:00
|
|
|
# May be altered later in the test
|
|
|
|
PREREQ="PERL"
|
2009-04-03 21:33:59 +02:00
|
|
|
|
2014-11-25 23:11:39 +01:00
|
|
|
test_expect_success $PREREQ 'prepare reference tree' '
|
2014-11-25 23:14:41 +01:00
|
|
|
echo "1A quick brown fox jumps over the" >file &&
|
|
|
|
echo "lazy dog" >>file &&
|
|
|
|
git add file &&
|
|
|
|
GIT_AUTHOR_NAME="A" git commit -a -m "Initial."
|
2014-11-25 23:11:39 +01:00
|
|
|
'
|
2006-05-29 21:30:15 +02:00
|
|
|
|
2014-11-25 23:11:39 +01:00
|
|
|
test_expect_success $PREREQ 'Setup helper tool' '
|
2014-11-25 23:21:07 +01:00
|
|
|
write_script fake.sendmail <<-\EOF &&
|
|
|
|
shift
|
|
|
|
output=1
|
|
|
|
while test -f commandline$output
|
|
|
|
do
|
|
|
|
output=$(($output+1))
|
|
|
|
done
|
|
|
|
for a
|
|
|
|
do
|
|
|
|
echo "!$a!"
|
|
|
|
done >commandline$output
|
|
|
|
cat >"msgtxt$output"
|
|
|
|
EOF
|
2014-11-25 23:14:41 +01:00
|
|
|
git add fake.sendmail &&
|
|
|
|
GIT_AUTHOR_NAME="A" git commit -a -m "Second."
|
2014-11-25 23:11:39 +01:00
|
|
|
'
|
2006-05-29 21:30:15 +02:00
|
|
|
|
2014-11-25 23:52:42 +01:00
|
|
|
clean_fake_sendmail () {
|
2008-02-24 22:03:52 +01:00
|
|
|
rm -f commandline* msgtxt*
|
|
|
|
}
|
|
|
|
|
2010-08-13 22:40:09 +02:00
|
|
|
test_expect_success $PREREQ 'Extract patches' '
|
2014-11-25 23:14:41 +01:00
|
|
|
patches=`git format-patch -s --cc="One <one@example.com>" --cc=two@example.com -n HEAD^1`
|
2006-07-03 01:03:59 +02:00
|
|
|
'
|
|
|
|
|
2009-03-03 05:52:18 +01:00
|
|
|
# Test no confirm early to ensure remaining tests will not hang
|
|
|
|
test_no_confirm () {
|
|
|
|
rm -f no_confirm_okay
|
|
|
|
echo n | \
|
|
|
|
GIT_SEND_EMAIL_NOTTY=1 \
|
|
|
|
git send-email \
|
|
|
|
--from="Example <from@example.com>" \
|
|
|
|
--to=nobody@example.com \
|
|
|
|
--smtp-server="$(pwd)/fake.sendmail" \
|
|
|
|
$@ \
|
2014-11-25 23:52:42 +01:00
|
|
|
$patches >stdout &&
|
2009-03-03 05:52:18 +01:00
|
|
|
test_must_fail grep "Send this email" stdout &&
|
2014-11-25 23:52:42 +01:00
|
|
|
>no_confirm_okay
|
2009-03-03 05:52:18 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
# Exit immediately to prevent hang if a no-confirm test fails
|
|
|
|
check_no_confirm () {
|
2010-08-13 22:40:09 +02:00
|
|
|
if ! test -f no_confirm_okay
|
|
|
|
then
|
|
|
|
say 'confirm test failed; skipping remaining tests to prevent hanging'
|
|
|
|
PREREQ="$PREREQ,CHECK_NO_CONFIRM"
|
|
|
|
fi
|
|
|
|
return 0
|
2009-03-03 05:52:18 +01:00
|
|
|
}
|
|
|
|
|
2010-08-13 22:40:09 +02:00
|
|
|
test_expect_success $PREREQ 'No confirm with --suppress-cc' '
|
|
|
|
test_no_confirm --suppress-cc=sob &&
|
|
|
|
check_no_confirm
|
2009-03-03 05:52:18 +01:00
|
|
|
'
|
|
|
|
|
2010-08-13 22:40:09 +02:00
|
|
|
|
|
|
|
test_expect_success $PREREQ 'No confirm with --confirm=never' '
|
|
|
|
test_no_confirm --confirm=never &&
|
|
|
|
check_no_confirm
|
2009-03-03 05:52:18 +01:00
|
|
|
'
|
|
|
|
|
|
|
|
# leave sendemail.confirm set to never after this so that none of the
|
|
|
|
# remaining tests prompt unintentionally.
|
2010-08-13 22:40:09 +02:00
|
|
|
test_expect_success $PREREQ 'No confirm with sendemail.confirm=never' '
|
2009-03-03 05:52:18 +01:00
|
|
|
git config sendemail.confirm never &&
|
2010-08-13 22:40:09 +02:00
|
|
|
test_no_confirm --compose --subject=foo &&
|
|
|
|
check_no_confirm
|
2009-03-03 05:52:18 +01:00
|
|
|
'
|
|
|
|
|
2010-08-13 22:40:09 +02:00
|
|
|
test_expect_success $PREREQ 'Send patches' '
|
2014-11-25 23:14:41 +01:00
|
|
|
git send-email --suppress-cc=sob --from="Example <nobody@example.com>" --to=nobody@example.com --smtp-server="$(pwd)/fake.sendmail" $patches 2>errors
|
2006-07-03 01:03:59 +02:00
|
|
|
'
|
2006-05-29 21:30:15 +02:00
|
|
|
|
2010-08-13 22:40:10 +02:00
|
|
|
test_expect_success $PREREQ 'setup expect' '
|
2014-11-26 00:03:45 +01:00
|
|
|
cat >expected <<-\EOF
|
|
|
|
!nobody@example.com!
|
|
|
|
!author@example.com!
|
|
|
|
!one@example.com!
|
|
|
|
!two@example.com!
|
|
|
|
EOF
|
2010-08-13 22:40:10 +02:00
|
|
|
'
|
|
|
|
|
2014-11-25 23:11:39 +01:00
|
|
|
test_expect_success $PREREQ 'Verify commandline' '
|
|
|
|
test_cmp expected commandline1
|
|
|
|
'
|
2006-05-29 21:30:15 +02:00
|
|
|
|
2010-08-13 22:40:09 +02:00
|
|
|
test_expect_success $PREREQ 'Send patches with --envelope-sender' '
|
2014-11-25 23:14:41 +01:00
|
|
|
clean_fake_sendmail &&
|
|
|
|
git send-email --envelope-sender="Patch Contributor <patch@example.com>" --suppress-cc=sob --from="Example <nobody@example.com>" --to=nobody@example.com --smtp-server="$(pwd)/fake.sendmail" $patches 2>errors
|
2009-11-22 18:54:10 +01:00
|
|
|
'
|
|
|
|
|
2010-08-13 22:40:10 +02:00
|
|
|
test_expect_success $PREREQ 'setup expect' '
|
2014-11-26 00:03:45 +01:00
|
|
|
cat >expected <<-\EOF
|
|
|
|
!patch@example.com!
|
|
|
|
!-i!
|
|
|
|
!nobody@example.com!
|
|
|
|
!author@example.com!
|
|
|
|
!one@example.com!
|
|
|
|
!two@example.com!
|
|
|
|
EOF
|
2010-08-13 22:40:10 +02:00
|
|
|
'
|
|
|
|
|
2014-11-25 23:11:39 +01:00
|
|
|
test_expect_success $PREREQ 'Verify commandline' '
|
|
|
|
test_cmp expected commandline1
|
|
|
|
'
|
2009-11-22 18:54:10 +01:00
|
|
|
|
2010-08-13 22:40:09 +02:00
|
|
|
test_expect_success $PREREQ 'Send patches with --envelope-sender=auto' '
|
2014-11-25 23:14:41 +01:00
|
|
|
clean_fake_sendmail &&
|
|
|
|
git send-email --envelope-sender=auto --suppress-cc=sob --from="Example <nobody@example.com>" --to=nobody@example.com --smtp-server="$(pwd)/fake.sendmail" $patches 2>errors
|
2009-11-26 20:04:29 +01:00
|
|
|
'
|
|
|
|
|
2010-08-13 22:40:10 +02:00
|
|
|
test_expect_success $PREREQ 'setup expect' '
|
2014-11-26 00:03:45 +01:00
|
|
|
cat >expected <<-\EOF
|
|
|
|
!nobody@example.com!
|
|
|
|
!-i!
|
|
|
|
!nobody@example.com!
|
|
|
|
!author@example.com!
|
|
|
|
!one@example.com!
|
|
|
|
!two@example.com!
|
|
|
|
EOF
|
2010-08-13 22:40:10 +02:00
|
|
|
'
|
|
|
|
|
2014-11-25 23:11:39 +01:00
|
|
|
test_expect_success $PREREQ 'Verify commandline' '
|
|
|
|
test_cmp expected commandline1
|
|
|
|
'
|
2009-11-26 20:04:29 +01:00
|
|
|
|
2010-08-13 22:40:10 +02:00
|
|
|
test_expect_success $PREREQ 'setup expect' "
|
2007-11-19 05:14:55 +01:00
|
|
|
cat >expected-show-all-headers <<\EOF
|
|
|
|
0001-Second.patch
|
|
|
|
(mbox) Adding cc: A <author@example.com> from line 'From: A <author@example.com>'
|
2009-02-15 05:32:14 +01:00
|
|
|
(mbox) Adding cc: One <one@example.com> from line 'Cc: One <one@example.com>, two@example.com'
|
|
|
|
(mbox) Adding cc: two@example.com from line 'Cc: One <one@example.com>, two@example.com'
|
2007-11-19 05:14:55 +01:00
|
|
|
Dry-OK. Log says:
|
|
|
|
Server: relay.example.com
|
|
|
|
MAIL FROM:<from@example.com>
|
2009-10-08 19:03:26 +02:00
|
|
|
RCPT TO:<to@example.com>
|
|
|
|
RCPT TO:<cc@example.com>
|
|
|
|
RCPT TO:<author@example.com>
|
|
|
|
RCPT TO:<one@example.com>
|
|
|
|
RCPT TO:<two@example.com>
|
|
|
|
RCPT TO:<bcc@example.com>
|
2007-11-19 05:14:55 +01:00
|
|
|
From: Example <from@example.com>
|
|
|
|
To: to@example.com
|
2009-10-08 19:03:26 +02:00
|
|
|
Cc: cc@example.com,
|
|
|
|
A <author@example.com>,
|
|
|
|
One <one@example.com>,
|
|
|
|
two@example.com
|
2007-11-19 05:14:55 +01:00
|
|
|
Subject: [PATCH 1/1] Second.
|
|
|
|
Date: DATE-STRING
|
|
|
|
Message-Id: MESSAGE-ID-STRING
|
|
|
|
X-Mailer: X-MAILER-STRING
|
|
|
|
In-Reply-To: <unique-message-id@example.com>
|
|
|
|
References: <unique-message-id@example.com>
|
|
|
|
|
|
|
|
Result: OK
|
|
|
|
EOF
|
2010-08-13 22:40:10 +02:00
|
|
|
"
|
2007-11-19 05:14:55 +01:00
|
|
|
|
2013-05-30 09:11:13 +02:00
|
|
|
test_suppress_self () {
|
|
|
|
test_commit $3 &&
|
|
|
|
test_when_finished "git reset --hard HEAD^" &&
|
|
|
|
|
|
|
|
write_script cccmd-sed <<-EOF &&
|
|
|
|
sed -n -e s/^cccmd--//p "\$1"
|
|
|
|
EOF
|
|
|
|
|
|
|
|
git commit --amend --author="$1 <$2>" -F - &&
|
|
|
|
clean_fake_sendmail &&
|
|
|
|
git format-patch --stdout -1 >"suppress-self-$3.patch" &&
|
|
|
|
|
|
|
|
git send-email --from="$1 <$2>" \
|
|
|
|
--to=nobody@example.com \
|
|
|
|
--cc-cmd=./cccmd-sed \
|
|
|
|
--suppress-cc=self \
|
|
|
|
--smtp-server="$(pwd)/fake.sendmail" \
|
|
|
|
suppress-self-$3.patch &&
|
|
|
|
|
|
|
|
mv msgtxt1 msgtxt1-$3 &&
|
|
|
|
sed -e '/^$/q' msgtxt1-$3 >"msghdr1-$3" &&
|
|
|
|
>"expected-no-cc-$3" &&
|
|
|
|
|
|
|
|
(grep '^Cc:' msghdr1-$3 >"actual-no-cc-$3";
|
|
|
|
test_cmp expected-no-cc-$3 actual-no-cc-$3)
|
|
|
|
}
|
|
|
|
|
|
|
|
test_suppress_self_unquoted () {
|
|
|
|
test_suppress_self "$1" "$2" "unquoted-$3" <<-EOF
|
|
|
|
test suppress-cc.self unquoted-$3 with name $1 email $2
|
|
|
|
|
|
|
|
unquoted-$3
|
|
|
|
|
2013-06-05 20:10:57 +02:00
|
|
|
cccmd--$1 <$2>
|
|
|
|
|
2013-05-30 09:11:13 +02:00
|
|
|
Cc: $1 <$2>
|
|
|
|
Signed-off-by: $1 <$2>
|
|
|
|
EOF
|
|
|
|
}
|
|
|
|
|
2013-06-05 20:11:02 +02:00
|
|
|
test_suppress_self_quoted () {
|
|
|
|
test_suppress_self "$1" "$2" "quoted-$3" <<-EOF
|
|
|
|
test suppress-cc.self quoted-$3 with name $1 email $2
|
|
|
|
|
|
|
|
quoted-$3
|
|
|
|
|
|
|
|
cccmd--"$1" <$2>
|
|
|
|
|
|
|
|
Cc: $1 <$2>
|
|
|
|
Cc: "$1" <$2>
|
|
|
|
Signed-off-by: $1 <$2>
|
|
|
|
Signed-off-by: "$1" <$2>
|
|
|
|
EOF
|
|
|
|
}
|
|
|
|
|
2013-05-30 09:11:13 +02:00
|
|
|
test_expect_success $PREREQ 'self name is suppressed' "
|
2013-06-05 20:10:57 +02:00
|
|
|
test_suppress_self_unquoted 'A U Thor' 'author@example.com' \
|
2013-05-30 09:11:13 +02:00
|
|
|
'self_name_suppressed'
|
|
|
|
"
|
|
|
|
|
2013-06-05 20:11:02 +02:00
|
|
|
test_expect_success $PREREQ 'self name with dot is suppressed' "
|
|
|
|
test_suppress_self_quoted 'A U. Thor' 'author@example.com' \
|
|
|
|
'self_name_dot_suppressed'
|
|
|
|
"
|
|
|
|
|
2013-06-05 20:11:04 +02:00
|
|
|
test_expect_success $PREREQ 'non-ascii self name is suppressed' "
|
|
|
|
test_suppress_self_quoted 'Füñný Nâmé' 'odd_?=mail@example.com' \
|
|
|
|
'non_ascii_self_suppressed'
|
|
|
|
"
|
|
|
|
|
2014-12-14 16:59:47 +01:00
|
|
|
# This name is long enough to force format-patch to split it into multiple
|
|
|
|
# encoded-words, assuming it uses UTF-8 with the "Q" encoding.
|
|
|
|
test_expect_success $PREREQ 'long non-ascii self name is suppressed' "
|
|
|
|
test_suppress_self_quoted 'Ƒüñníęř €. Nâṁé' 'odd_?=mail@example.com' \
|
|
|
|
'long_non_ascii_self_suppressed'
|
|
|
|
"
|
|
|
|
|
2013-06-05 20:11:08 +02:00
|
|
|
test_expect_success $PREREQ 'sanitized self name is suppressed' "
|
|
|
|
test_suppress_self_unquoted '\"A U. Thor\"' 'author@example.com' \
|
|
|
|
'self_name_sanitized_suppressed'
|
|
|
|
"
|
|
|
|
|
2010-08-13 22:40:09 +02:00
|
|
|
test_expect_success $PREREQ 'Show all headers' '
|
2007-11-19 05:14:55 +01:00
|
|
|
git send-email \
|
|
|
|
--dry-run \
|
2009-02-15 05:32:15 +01:00
|
|
|
--suppress-cc=sob \
|
2007-11-19 05:14:55 +01:00
|
|
|
--from="Example <from@example.com>" \
|
|
|
|
--to=to@example.com \
|
|
|
|
--cc=cc@example.com \
|
|
|
|
--bcc=bcc@example.com \
|
|
|
|
--in-reply-to="<unique-message-id@example.com>" \
|
|
|
|
--smtp-server relay.example.com \
|
|
|
|
$patches |
|
|
|
|
sed -e "s/^\(Date:\).*/\1 DATE-STRING/" \
|
|
|
|
-e "s/^\(Message-Id:\).*/\1 MESSAGE-ID-STRING/" \
|
|
|
|
-e "s/^\(X-Mailer:\).*/\1 X-MAILER-STRING/" \
|
|
|
|
>actual-show-all-headers &&
|
2008-03-12 22:36:36 +01:00
|
|
|
test_cmp expected-show-all-headers actual-show-all-headers
|
2007-11-19 05:14:55 +01:00
|
|
|
'
|
|
|
|
|
2010-08-13 22:40:09 +02:00
|
|
|
test_expect_success $PREREQ 'Prompting works' '
|
2009-04-05 05:23:21 +02:00
|
|
|
clean_fake_sendmail &&
|
send-email: avoid questions when user has an ident
Currently we keep getting questions even when the user has properly
configured his full name and password:
Who should the emails appear to be from?
[Felipe Contreras <felipe.contreras@gmail.com>]
And once a question pops up, other questions are turned on. This is
annoying.
The reason it's safe to avoid this question is because currently the
script fails completely when the author (or committer) is not correct,
so we won't even be reaching this point in the code.
The scenarios, and the current situation:
1) No information at all, no fully qualified domain name
fatal: empty ident name (for <felipec@nysa.(none)>) not allowed
2) Only full name
fatal: unable to auto-detect email address (got 'felipec@nysa.(none)')
3) Full name + fqdm
Who should the emails appear to be from?
[Felipe Contreras <felipec@nysa.felipec.org>]
4) Full name + EMAIL
Who should the emails appear to be from?
[Felipe Contreras <felipe.contreras@gmail.com>]
5) User configured
6) GIT_COMMITTER
7) GIT_AUTHOR
All these are the same as 4)
After this patch:
1) 2) won't change: git send-email would still die
4) 5) 6) 7) will change: git send-email won't ask the user
This is good, that's what we would expect, because the identity is
explicit.
3) will change: git send-email won't ask the user
This is bad, because we will try with an address such as
'felipec@nysa.felipec.org', which is most likely not what the user
wants, but the user will get warned by default (confirm=auto), and if
not, most likely the sending won't work, which the user would readily
note and fix.
The worst possible scenario is that such mail address does work, and the
user sends an email from that address unintentionally, when in fact the
user expected to correct that address in the prompt. This is a very,
very, very unlikely scenario, with many dependencies:
1) No configured user.name/user.email
2) No specified $EMAIL
3) No configured sendemail.from
4) No specified --from argument
5) A fully qualified domain name
6) A full name in the geckos field
7) A sendmail configuration that allows sending from this domain name
8) confirm=never, or
8.1) confirm configuration not hitting, or
8.2) Getting the error, not being aware of it
9) The user expecting to correct this address in the prompt
In a more likely scenario where 7) is not the case (can't send from
nysa.felipec.org), the user will simply see the mail was not sent
properly, and fix the problem.
The much more likely scenario though, is where 5) is not the case
(nysa.(none)), and git send-email will fail right away like it does now.
So the likelihood of this affecting anybody seriously is very very slim,
and the chances of this affecting somebody slightly are still very
small. The vast majority, if not all, of git users won't be affected
negatively, and a lot will benefit from this.
Tests-by: Jeff King <peff@peff.net>
Signed-off-by: Felipe Contreras <felipe.contreras@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2012-11-24 12:16:19 +01:00
|
|
|
(echo "to@example.com"
|
2009-04-05 05:23:21 +02:00
|
|
|
echo ""
|
|
|
|
) | GIT_SEND_EMAIL_NOTTY=1 git send-email \
|
|
|
|
--smtp-server="$(pwd)/fake.sendmail" \
|
|
|
|
$patches \
|
|
|
|
2>errors &&
|
send-email: avoid questions when user has an ident
Currently we keep getting questions even when the user has properly
configured his full name and password:
Who should the emails appear to be from?
[Felipe Contreras <felipe.contreras@gmail.com>]
And once a question pops up, other questions are turned on. This is
annoying.
The reason it's safe to avoid this question is because currently the
script fails completely when the author (or committer) is not correct,
so we won't even be reaching this point in the code.
The scenarios, and the current situation:
1) No information at all, no fully qualified domain name
fatal: empty ident name (for <felipec@nysa.(none)>) not allowed
2) Only full name
fatal: unable to auto-detect email address (got 'felipec@nysa.(none)')
3) Full name + fqdm
Who should the emails appear to be from?
[Felipe Contreras <felipec@nysa.felipec.org>]
4) Full name + EMAIL
Who should the emails appear to be from?
[Felipe Contreras <felipe.contreras@gmail.com>]
5) User configured
6) GIT_COMMITTER
7) GIT_AUTHOR
All these are the same as 4)
After this patch:
1) 2) won't change: git send-email would still die
4) 5) 6) 7) will change: git send-email won't ask the user
This is good, that's what we would expect, because the identity is
explicit.
3) will change: git send-email won't ask the user
This is bad, because we will try with an address such as
'felipec@nysa.felipec.org', which is most likely not what the user
wants, but the user will get warned by default (confirm=auto), and if
not, most likely the sending won't work, which the user would readily
note and fix.
The worst possible scenario is that such mail address does work, and the
user sends an email from that address unintentionally, when in fact the
user expected to correct that address in the prompt. This is a very,
very, very unlikely scenario, with many dependencies:
1) No configured user.name/user.email
2) No specified $EMAIL
3) No configured sendemail.from
4) No specified --from argument
5) A fully qualified domain name
6) A full name in the geckos field
7) A sendmail configuration that allows sending from this domain name
8) confirm=never, or
8.1) confirm configuration not hitting, or
8.2) Getting the error, not being aware of it
9) The user expecting to correct this address in the prompt
In a more likely scenario where 7) is not the case (can't send from
nysa.felipec.org), the user will simply see the mail was not sent
properly, and fix the problem.
The much more likely scenario though, is where 5) is not the case
(nysa.(none)), and git send-email will fail right away like it does now.
So the likelihood of this affecting anybody seriously is very very slim,
and the chances of this affecting somebody slightly are still very
small. The vast majority, if not all, of git users won't be affected
negatively, and a lot will benefit from this.
Tests-by: Jeff King <peff@peff.net>
Signed-off-by: Felipe Contreras <felipe.contreras@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2012-11-24 12:16:19 +01:00
|
|
|
grep "^From: A U Thor <author@example.com>\$" msgtxt1 &&
|
2010-01-27 00:08:31 +01:00
|
|
|
grep "^To: to@example.com\$" msgtxt1
|
2009-04-05 05:23:21 +02:00
|
|
|
'
|
|
|
|
|
2012-11-28 21:06:26 +01:00
|
|
|
test_expect_success $PREREQ,AUTOIDENT 'implicit ident is allowed' '
|
|
|
|
clean_fake_sendmail &&
|
|
|
|
(sane_unset GIT_AUTHOR_NAME &&
|
|
|
|
sane_unset GIT_AUTHOR_EMAIL &&
|
|
|
|
sane_unset GIT_COMMITTER_NAME &&
|
|
|
|
sane_unset GIT_COMMITTER_EMAIL &&
|
|
|
|
GIT_SEND_EMAIL_NOTTY=1 git send-email \
|
|
|
|
--smtp-server="$(pwd)/fake.sendmail" \
|
|
|
|
--to=to@example.com \
|
|
|
|
$patches </dev/null 2>errors
|
|
|
|
)
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success $PREREQ,!AUTOIDENT 'broken implicit ident aborts send-email' '
|
|
|
|
clean_fake_sendmail &&
|
|
|
|
(sane_unset GIT_AUTHOR_NAME &&
|
|
|
|
sane_unset GIT_AUTHOR_EMAIL &&
|
|
|
|
sane_unset GIT_COMMITTER_NAME &&
|
|
|
|
sane_unset GIT_COMMITTER_EMAIL &&
|
|
|
|
GIT_SEND_EMAIL_NOTTY=1 && export GIT_SEND_EMAIL_NOTTY &&
|
|
|
|
test_must_fail git send-email \
|
|
|
|
--smtp-server="$(pwd)/fake.sendmail" \
|
|
|
|
--to=to@example.com \
|
|
|
|
$patches </dev/null 2>errors &&
|
|
|
|
test_i18ngrep "tell me who you are" errors
|
|
|
|
)
|
|
|
|
'
|
|
|
|
|
2015-06-30 14:16:42 +02:00
|
|
|
test_expect_success $PREREQ 'setup tocmd and cccmd scripts' '
|
|
|
|
write_script tocmd-sed <<-\EOF &&
|
|
|
|
sed -n -e "s/^tocmd--//p" "$1"
|
|
|
|
EOF
|
|
|
|
write_script cccmd-sed <<-\EOF
|
|
|
|
sed -n -e "s/^cccmd--//p" "$1"
|
|
|
|
EOF
|
|
|
|
'
|
|
|
|
|
2010-09-24 19:03:00 +02:00
|
|
|
test_expect_success $PREREQ 'tocmd works' '
|
|
|
|
clean_fake_sendmail &&
|
|
|
|
cp $patches tocmd.patch &&
|
|
|
|
echo tocmd--tocmd@example.com >>tocmd.patch &&
|
|
|
|
git send-email \
|
|
|
|
--from="Example <nobody@example.com>" \
|
|
|
|
--to-cmd=./tocmd-sed \
|
|
|
|
--smtp-server="$(pwd)/fake.sendmail" \
|
|
|
|
tocmd.patch \
|
|
|
|
&&
|
|
|
|
grep "^To: tocmd@example.com" msgtxt1
|
|
|
|
'
|
|
|
|
|
2010-08-13 22:40:09 +02:00
|
|
|
test_expect_success $PREREQ 'cccmd works' '
|
2009-06-18 14:31:32 +02:00
|
|
|
clean_fake_sendmail &&
|
|
|
|
cp $patches cccmd.patch &&
|
2010-09-30 15:43:09 +02:00
|
|
|
echo "cccmd-- cccmd@example.com" >>cccmd.patch &&
|
2009-06-18 14:31:32 +02:00
|
|
|
git send-email \
|
|
|
|
--from="Example <nobody@example.com>" \
|
|
|
|
--to=nobody@example.com \
|
|
|
|
--cc-cmd=./cccmd-sed \
|
|
|
|
--smtp-server="$(pwd)/fake.sendmail" \
|
|
|
|
cccmd.patch \
|
|
|
|
&&
|
2009-10-08 19:03:26 +02:00
|
|
|
grep "^ cccmd@example.com" msgtxt1
|
2009-06-18 14:31:32 +02:00
|
|
|
'
|
|
|
|
|
2010-08-13 22:40:09 +02:00
|
|
|
test_expect_success $PREREQ 'reject long lines' '
|
2010-08-13 22:40:10 +02:00
|
|
|
z8=zzzzzzzz &&
|
|
|
|
z64=$z8$z8$z8$z8$z8$z8$z8$z8 &&
|
|
|
|
z512=$z64$z64$z64$z64$z64$z64$z64$z64 &&
|
2008-02-24 22:03:52 +01:00
|
|
|
clean_fake_sendmail &&
|
2008-01-18 15:19:48 +01:00
|
|
|
cp $patches longline.patch &&
|
|
|
|
echo $z512$z512 >>longline.patch &&
|
2008-07-12 17:47:52 +02:00
|
|
|
test_must_fail git send-email \
|
2008-01-18 15:19:48 +01:00
|
|
|
--from="Example <nobody@example.com>" \
|
|
|
|
--to=nobody@example.com \
|
|
|
|
--smtp-server="$(pwd)/fake.sendmail" \
|
|
|
|
$patches longline.patch \
|
|
|
|
2>errors &&
|
|
|
|
grep longline.patch errors
|
|
|
|
'
|
|
|
|
|
2010-08-13 22:40:09 +02:00
|
|
|
test_expect_success $PREREQ 'no patch was sent' '
|
2008-02-24 22:03:52 +01:00
|
|
|
! test -e commandline1
|
2008-01-18 15:19:48 +01:00
|
|
|
'
|
|
|
|
|
2010-08-13 22:40:09 +02:00
|
|
|
test_expect_success $PREREQ 'Author From: in message body' '
|
2009-02-15 05:32:14 +01:00
|
|
|
clean_fake_sendmail &&
|
|
|
|
git send-email \
|
|
|
|
--from="Example <nobody@example.com>" \
|
|
|
|
--to=nobody@example.com \
|
|
|
|
--smtp-server="$(pwd)/fake.sendmail" \
|
|
|
|
$patches &&
|
2014-11-25 23:52:42 +01:00
|
|
|
sed "1,/^\$/d" <msgtxt1 >msgbody1 &&
|
2009-02-15 05:32:14 +01:00
|
|
|
grep "From: A <author@example.com>" msgbody1
|
|
|
|
'
|
|
|
|
|
2010-08-13 22:40:09 +02:00
|
|
|
test_expect_success $PREREQ 'Author From: not in message body' '
|
2009-02-15 05:32:14 +01:00
|
|
|
clean_fake_sendmail &&
|
|
|
|
git send-email \
|
|
|
|
--from="A <author@example.com>" \
|
|
|
|
--to=nobody@example.com \
|
|
|
|
--smtp-server="$(pwd)/fake.sendmail" \
|
|
|
|
$patches &&
|
2014-11-25 23:52:42 +01:00
|
|
|
sed "1,/^\$/d" <msgtxt1 >msgbody1 &&
|
2009-02-15 05:32:14 +01:00
|
|
|
! grep "From: A <author@example.com>" msgbody1
|
|
|
|
'
|
|
|
|
|
2010-08-13 22:40:09 +02:00
|
|
|
test_expect_success $PREREQ 'allow long lines with --no-validate' '
|
2008-01-18 15:20:10 +01:00
|
|
|
git send-email \
|
|
|
|
--from="Example <nobody@example.com>" \
|
|
|
|
--to=nobody@example.com \
|
|
|
|
--smtp-server="$(pwd)/fake.sendmail" \
|
2015-01-31 03:40:17 +01:00
|
|
|
--no-validate \
|
2008-01-18 15:20:10 +01:00
|
|
|
$patches longline.patch \
|
|
|
|
2>errors
|
|
|
|
'
|
|
|
|
|
2010-08-13 22:40:09 +02:00
|
|
|
test_expect_success $PREREQ 'Invalid In-Reply-To' '
|
2008-02-24 22:03:52 +01:00
|
|
|
clean_fake_sendmail &&
|
2008-02-22 01:16:04 +01:00
|
|
|
git send-email \
|
|
|
|
--from="Example <nobody@example.com>" \
|
|
|
|
--to=nobody@example.com \
|
|
|
|
--in-reply-to=" " \
|
|
|
|
--smtp-server="$(pwd)/fake.sendmail" \
|
2010-10-19 11:50:39 +02:00
|
|
|
$patches \
|
2011-01-04 21:56:58 +01:00
|
|
|
2>errors &&
|
2008-02-24 22:03:52 +01:00
|
|
|
! grep "^In-Reply-To: < *>" msgtxt1
|
2008-02-22 01:16:04 +01:00
|
|
|
'
|
|
|
|
|
2010-08-13 22:40:09 +02:00
|
|
|
test_expect_success $PREREQ 'Valid In-Reply-To when prompting' '
|
2008-02-24 22:03:52 +01:00
|
|
|
clean_fake_sendmail &&
|
2008-02-22 01:16:04 +01:00
|
|
|
(echo "From Example <from@example.com>"
|
|
|
|
echo "To Example <to@example.com>"
|
|
|
|
echo ""
|
2014-03-07 00:22:34 +01:00
|
|
|
) | GIT_SEND_EMAIL_NOTTY=1 git send-email \
|
2008-02-22 01:16:04 +01:00
|
|
|
--smtp-server="$(pwd)/fake.sendmail" \
|
|
|
|
$patches 2>errors &&
|
2008-02-24 22:03:52 +01:00
|
|
|
! grep "^In-Reply-To: < *>" msgtxt1
|
2008-02-22 01:16:04 +01:00
|
|
|
'
|
|
|
|
|
t9001: send-email interation with --in-reply-to and --chain-reply-to
1. When --in-reply-to gives $reply_to, the first one becomes a reply to
that message, with or without --chain-reply-to.
2. When --chain-reply-to is in effect, all the messages are strung
together to form a single chain. The first message may be in reply to
the $reply_to given by --in-reply-to command line option (see
previous), or the root of the discussion thread. The second one is a
response to the first one, and the third one is a response to the
second one, etc.
3. When --chain-reply-to is not in effect:
a. When --in-reply-to is used, too, the second and the subsequent ones
become replies to $reply_to. Together with the first rule, all
messages become replies to $reply_to given by --in-reply-to.
b. When --in-reply-to is not used, presumably the second and
subsequent ones become replies to the first one, which would be the
root.
The documentation is reasonably clear about the 1., 2. and 3a. above, I
think, even though I do not think 3b. is clearly specified.
The two tests added by this patch at least documents what happens between
these two options.
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2010-10-19 20:46:31 +02:00
|
|
|
test_expect_success $PREREQ 'In-Reply-To without --chain-reply-to' '
|
|
|
|
clean_fake_sendmail &&
|
|
|
|
echo "<unique-message-id@example.com>" >expect &&
|
|
|
|
git send-email \
|
|
|
|
--from="Example <nobody@example.com>" \
|
|
|
|
--to=nobody@example.com \
|
2015-01-31 03:40:17 +01:00
|
|
|
--no-chain-reply-to \
|
t9001: send-email interation with --in-reply-to and --chain-reply-to
1. When --in-reply-to gives $reply_to, the first one becomes a reply to
that message, with or without --chain-reply-to.
2. When --chain-reply-to is in effect, all the messages are strung
together to form a single chain. The first message may be in reply to
the $reply_to given by --in-reply-to command line option (see
previous), or the root of the discussion thread. The second one is a
response to the first one, and the third one is a response to the
second one, etc.
3. When --chain-reply-to is not in effect:
a. When --in-reply-to is used, too, the second and the subsequent ones
become replies to $reply_to. Together with the first rule, all
messages become replies to $reply_to given by --in-reply-to.
b. When --in-reply-to is not used, presumably the second and
subsequent ones become replies to the first one, which would be the
root.
The documentation is reasonably clear about the 1., 2. and 3a. above, I
think, even though I do not think 3b. is clearly specified.
The two tests added by this patch at least documents what happens between
these two options.
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2010-10-19 20:46:31 +02:00
|
|
|
--in-reply-to="$(cat expect)" \
|
|
|
|
--smtp-server="$(pwd)/fake.sendmail" \
|
|
|
|
$patches $patches $patches \
|
|
|
|
2>errors &&
|
2010-11-12 15:55:08 +01:00
|
|
|
# The first message is a reply to --in-reply-to
|
t9001: send-email interation with --in-reply-to and --chain-reply-to
1. When --in-reply-to gives $reply_to, the first one becomes a reply to
that message, with or without --chain-reply-to.
2. When --chain-reply-to is in effect, all the messages are strung
together to form a single chain. The first message may be in reply to
the $reply_to given by --in-reply-to command line option (see
previous), or the root of the discussion thread. The second one is a
response to the first one, and the third one is a response to the
second one, etc.
3. When --chain-reply-to is not in effect:
a. When --in-reply-to is used, too, the second and the subsequent ones
become replies to $reply_to. Together with the first rule, all
messages become replies to $reply_to given by --in-reply-to.
b. When --in-reply-to is not used, presumably the second and
subsequent ones become replies to the first one, which would be the
root.
The documentation is reasonably clear about the 1., 2. and 3a. above, I
think, even though I do not think 3b. is clearly specified.
The two tests added by this patch at least documents what happens between
these two options.
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2010-10-19 20:46:31 +02:00
|
|
|
sed -n -e "s/^In-Reply-To: *\(.*\)/\1/p" msgtxt1 >actual &&
|
|
|
|
test_cmp expect actual &&
|
2010-11-12 15:55:08 +01:00
|
|
|
# Second and subsequent messages are replies to the first one
|
|
|
|
sed -n -e "s/^Message-Id: *\(.*\)/\1/p" msgtxt1 >expect &&
|
t9001: send-email interation with --in-reply-to and --chain-reply-to
1. When --in-reply-to gives $reply_to, the first one becomes a reply to
that message, with or without --chain-reply-to.
2. When --chain-reply-to is in effect, all the messages are strung
together to form a single chain. The first message may be in reply to
the $reply_to given by --in-reply-to command line option (see
previous), or the root of the discussion thread. The second one is a
response to the first one, and the third one is a response to the
second one, etc.
3. When --chain-reply-to is not in effect:
a. When --in-reply-to is used, too, the second and the subsequent ones
become replies to $reply_to. Together with the first rule, all
messages become replies to $reply_to given by --in-reply-to.
b. When --in-reply-to is not used, presumably the second and
subsequent ones become replies to the first one, which would be the
root.
The documentation is reasonably clear about the 1., 2. and 3a. above, I
think, even though I do not think 3b. is clearly specified.
The two tests added by this patch at least documents what happens between
these two options.
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2010-10-19 20:46:31 +02:00
|
|
|
sed -n -e "s/^In-Reply-To: *\(.*\)/\1/p" msgtxt2 >actual &&
|
|
|
|
test_cmp expect actual &&
|
|
|
|
sed -n -e "s/^In-Reply-To: *\(.*\)/\1/p" msgtxt3 >actual &&
|
|
|
|
test_cmp expect actual
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success $PREREQ 'In-Reply-To with --chain-reply-to' '
|
|
|
|
clean_fake_sendmail &&
|
|
|
|
echo "<unique-message-id@example.com>" >expect &&
|
|
|
|
git send-email \
|
|
|
|
--from="Example <nobody@example.com>" \
|
|
|
|
--to=nobody@example.com \
|
|
|
|
--chain-reply-to \
|
|
|
|
--in-reply-to="$(cat expect)" \
|
|
|
|
--smtp-server="$(pwd)/fake.sendmail" \
|
|
|
|
$patches $patches $patches \
|
|
|
|
2>errors &&
|
|
|
|
sed -n -e "s/^In-Reply-To: *\(.*\)/\1/p" msgtxt1 >actual &&
|
|
|
|
test_cmp expect actual &&
|
|
|
|
sed -n -e "s/^Message-Id: *\(.*\)/\1/p" msgtxt1 >expect &&
|
|
|
|
sed -n -e "s/^In-Reply-To: *\(.*\)/\1/p" msgtxt2 >actual &&
|
|
|
|
test_cmp expect actual &&
|
|
|
|
sed -n -e "s/^Message-Id: *\(.*\)/\1/p" msgtxt2 >expect &&
|
|
|
|
sed -n -e "s/^In-Reply-To: *\(.*\)/\1/p" msgtxt3 >actual &&
|
|
|
|
test_cmp expect actual
|
|
|
|
'
|
|
|
|
|
2010-08-13 22:40:09 +02:00
|
|
|
test_expect_success $PREREQ 'setup fake editor' '
|
2014-11-25 23:21:07 +01:00
|
|
|
write_script fake-editor <<-\EOF
|
|
|
|
echo fake edit >>"$1"
|
|
|
|
EOF
|
2008-02-24 22:04:14 +01:00
|
|
|
'
|
|
|
|
|
2008-05-04 07:37:55 +02:00
|
|
|
test_set_editor "$(pwd)/fake-editor"
|
2008-05-04 07:37:53 +02:00
|
|
|
|
2010-08-13 22:40:09 +02:00
|
|
|
test_expect_success $PREREQ '--compose works' '
|
2008-02-24 22:04:14 +01:00
|
|
|
clean_fake_sendmail &&
|
2009-03-03 05:52:18 +01:00
|
|
|
git send-email \
|
|
|
|
--compose --subject foo \
|
|
|
|
--from="Example <nobody@example.com>" \
|
|
|
|
--to=nobody@example.com \
|
|
|
|
--smtp-server="$(pwd)/fake.sendmail" \
|
|
|
|
$patches \
|
|
|
|
2>errors
|
2008-02-24 22:04:14 +01:00
|
|
|
'
|
|
|
|
|
2010-08-13 22:40:09 +02:00
|
|
|
test_expect_success $PREREQ 'first message is compose text' '
|
2008-02-24 22:04:14 +01:00
|
|
|
grep "^fake edit" msgtxt1
|
|
|
|
'
|
|
|
|
|
2010-08-13 22:40:09 +02:00
|
|
|
test_expect_success $PREREQ 'second message is patch' '
|
2008-02-24 22:04:14 +01:00
|
|
|
grep "Subject:.*Second" msgtxt2
|
|
|
|
'
|
|
|
|
|
2010-08-13 22:40:10 +02:00
|
|
|
test_expect_success $PREREQ 'setup expect' "
|
2009-02-15 05:32:15 +01:00
|
|
|
cat >expected-suppress-sob <<\EOF
|
2008-04-29 12:56:47 +02:00
|
|
|
0001-Second.patch
|
|
|
|
(mbox) Adding cc: A <author@example.com> from line 'From: A <author@example.com>'
|
2009-02-15 05:32:14 +01:00
|
|
|
(mbox) Adding cc: One <one@example.com> from line 'Cc: One <one@example.com>, two@example.com'
|
|
|
|
(mbox) Adding cc: two@example.com from line 'Cc: One <one@example.com>, two@example.com'
|
2008-04-29 12:56:47 +02:00
|
|
|
Dry-OK. Log says:
|
|
|
|
Server: relay.example.com
|
|
|
|
MAIL FROM:<from@example.com>
|
2009-10-08 19:03:26 +02:00
|
|
|
RCPT TO:<to@example.com>
|
|
|
|
RCPT TO:<cc@example.com>
|
|
|
|
RCPT TO:<author@example.com>
|
|
|
|
RCPT TO:<one@example.com>
|
|
|
|
RCPT TO:<two@example.com>
|
2008-04-29 12:56:47 +02:00
|
|
|
From: Example <from@example.com>
|
|
|
|
To: to@example.com
|
2009-10-08 19:03:26 +02:00
|
|
|
Cc: cc@example.com,
|
|
|
|
A <author@example.com>,
|
|
|
|
One <one@example.com>,
|
|
|
|
two@example.com
|
2008-04-29 12:56:47 +02:00
|
|
|
Subject: [PATCH 1/1] Second.
|
|
|
|
Date: DATE-STRING
|
|
|
|
Message-Id: MESSAGE-ID-STRING
|
|
|
|
X-Mailer: X-MAILER-STRING
|
|
|
|
|
|
|
|
Result: OK
|
|
|
|
EOF
|
2010-08-13 22:40:10 +02:00
|
|
|
"
|
2008-04-29 12:56:47 +02:00
|
|
|
|
2009-02-15 05:32:15 +01:00
|
|
|
test_suppression () {
|
2008-04-29 12:56:47 +02:00
|
|
|
git send-email \
|
|
|
|
--dry-run \
|
2009-06-18 14:31:32 +02:00
|
|
|
--suppress-cc=$1 ${2+"--suppress-cc=$2"} \
|
2008-04-29 12:56:47 +02:00
|
|
|
--from="Example <from@example.com>" \
|
|
|
|
--to=to@example.com \
|
|
|
|
--smtp-server relay.example.com \
|
|
|
|
$patches |
|
|
|
|
sed -e "s/^\(Date:\).*/\1 DATE-STRING/" \
|
|
|
|
-e "s/^\(Message-Id:\).*/\1 MESSAGE-ID-STRING/" \
|
|
|
|
-e "s/^\(X-Mailer:\).*/\1 X-MAILER-STRING/" \
|
2009-06-18 14:31:32 +02:00
|
|
|
>actual-suppress-$1${2+"-$2"} &&
|
|
|
|
test_cmp expected-suppress-$1${2+"-$2"} actual-suppress-$1${2+"-$2"}
|
2009-02-15 05:32:15 +01:00
|
|
|
}
|
|
|
|
|
2010-08-13 22:40:09 +02:00
|
|
|
test_expect_success $PREREQ 'sendemail.cc set' '
|
2009-02-15 05:32:15 +01:00
|
|
|
git config sendemail.cc cc@example.com &&
|
|
|
|
test_suppression sob
|
2008-04-29 12:56:47 +02:00
|
|
|
'
|
|
|
|
|
2010-08-13 22:40:10 +02:00
|
|
|
test_expect_success $PREREQ 'setup expect' "
|
2009-02-15 05:32:15 +01:00
|
|
|
cat >expected-suppress-sob <<\EOF
|
2008-04-29 12:56:47 +02:00
|
|
|
0001-Second.patch
|
|
|
|
(mbox) Adding cc: A <author@example.com> from line 'From: A <author@example.com>'
|
2009-02-15 05:32:14 +01:00
|
|
|
(mbox) Adding cc: One <one@example.com> from line 'Cc: One <one@example.com>, two@example.com'
|
|
|
|
(mbox) Adding cc: two@example.com from line 'Cc: One <one@example.com>, two@example.com'
|
2008-04-29 12:56:47 +02:00
|
|
|
Dry-OK. Log says:
|
|
|
|
Server: relay.example.com
|
|
|
|
MAIL FROM:<from@example.com>
|
2009-10-08 19:03:26 +02:00
|
|
|
RCPT TO:<to@example.com>
|
|
|
|
RCPT TO:<author@example.com>
|
|
|
|
RCPT TO:<one@example.com>
|
|
|
|
RCPT TO:<two@example.com>
|
2008-04-29 12:56:47 +02:00
|
|
|
From: Example <from@example.com>
|
|
|
|
To: to@example.com
|
2009-10-08 19:03:26 +02:00
|
|
|
Cc: A <author@example.com>,
|
|
|
|
One <one@example.com>,
|
|
|
|
two@example.com
|
2008-04-29 12:56:47 +02:00
|
|
|
Subject: [PATCH 1/1] Second.
|
|
|
|
Date: DATE-STRING
|
|
|
|
Message-Id: MESSAGE-ID-STRING
|
|
|
|
X-Mailer: X-MAILER-STRING
|
|
|
|
|
|
|
|
Result: OK
|
|
|
|
EOF
|
2010-08-13 22:40:10 +02:00
|
|
|
"
|
2008-04-29 12:56:47 +02:00
|
|
|
|
2010-08-13 22:40:09 +02:00
|
|
|
test_expect_success $PREREQ 'sendemail.cc unset' '
|
2008-04-29 12:56:47 +02:00
|
|
|
git config --unset sendemail.cc &&
|
2009-02-15 05:32:15 +01:00
|
|
|
test_suppression sob
|
|
|
|
'
|
|
|
|
|
2010-08-13 22:40:10 +02:00
|
|
|
test_expect_success $PREREQ 'setup expect' "
|
2009-06-18 14:31:32 +02:00
|
|
|
cat >expected-suppress-cccmd <<\EOF
|
|
|
|
0001-Second.patch
|
|
|
|
(mbox) Adding cc: A <author@example.com> from line 'From: A <author@example.com>'
|
|
|
|
(mbox) Adding cc: One <one@example.com> from line 'Cc: One <one@example.com>, two@example.com'
|
|
|
|
(mbox) Adding cc: two@example.com from line 'Cc: One <one@example.com>, two@example.com'
|
|
|
|
(body) Adding cc: C O Mitter <committer@example.com> from line 'Signed-off-by: C O Mitter <committer@example.com>'
|
|
|
|
Dry-OK. Log says:
|
|
|
|
Server: relay.example.com
|
|
|
|
MAIL FROM:<from@example.com>
|
2009-10-08 19:03:26 +02:00
|
|
|
RCPT TO:<to@example.com>
|
|
|
|
RCPT TO:<author@example.com>
|
|
|
|
RCPT TO:<one@example.com>
|
|
|
|
RCPT TO:<two@example.com>
|
|
|
|
RCPT TO:<committer@example.com>
|
2009-06-18 14:31:32 +02:00
|
|
|
From: Example <from@example.com>
|
|
|
|
To: to@example.com
|
2009-10-08 19:03:26 +02:00
|
|
|
Cc: A <author@example.com>,
|
|
|
|
One <one@example.com>,
|
|
|
|
two@example.com,
|
|
|
|
C O Mitter <committer@example.com>
|
2009-06-18 14:31:32 +02:00
|
|
|
Subject: [PATCH 1/1] Second.
|
|
|
|
Date: DATE-STRING
|
|
|
|
Message-Id: MESSAGE-ID-STRING
|
|
|
|
X-Mailer: X-MAILER-STRING
|
|
|
|
|
|
|
|
Result: OK
|
|
|
|
EOF
|
2010-08-13 22:40:10 +02:00
|
|
|
"
|
2009-06-18 14:31:32 +02:00
|
|
|
|
2010-08-13 22:40:09 +02:00
|
|
|
test_expect_success $PREREQ 'sendemail.cccmd' '
|
2014-11-25 23:21:07 +01:00
|
|
|
write_script cccmd <<-\EOF &&
|
|
|
|
echo cc-cmd@example.com
|
|
|
|
EOF
|
2009-06-18 14:31:32 +02:00
|
|
|
git config sendemail.cccmd ./cccmd &&
|
|
|
|
test_suppression cccmd
|
|
|
|
'
|
|
|
|
|
2010-08-13 22:40:10 +02:00
|
|
|
test_expect_success $PREREQ 'setup expect' '
|
2009-02-15 05:32:15 +01:00
|
|
|
cat >expected-suppress-all <<\EOF
|
|
|
|
0001-Second.patch
|
|
|
|
Dry-OK. Log says:
|
|
|
|
Server: relay.example.com
|
|
|
|
MAIL FROM:<from@example.com>
|
|
|
|
RCPT TO:<to@example.com>
|
|
|
|
From: Example <from@example.com>
|
|
|
|
To: to@example.com
|
|
|
|
Subject: [PATCH 1/1] Second.
|
|
|
|
Date: DATE-STRING
|
|
|
|
Message-Id: MESSAGE-ID-STRING
|
|
|
|
X-Mailer: X-MAILER-STRING
|
|
|
|
|
|
|
|
Result: OK
|
|
|
|
EOF
|
2010-08-13 22:40:10 +02:00
|
|
|
'
|
2009-02-15 05:32:15 +01:00
|
|
|
|
2010-08-13 22:40:09 +02:00
|
|
|
test_expect_success $PREREQ '--suppress-cc=all' '
|
2009-02-15 05:32:15 +01:00
|
|
|
test_suppression all
|
|
|
|
'
|
|
|
|
|
2010-08-13 22:40:10 +02:00
|
|
|
test_expect_success $PREREQ 'setup expect' "
|
2009-02-15 05:32:15 +01:00
|
|
|
cat >expected-suppress-body <<\EOF
|
|
|
|
0001-Second.patch
|
|
|
|
(mbox) Adding cc: A <author@example.com> from line 'From: A <author@example.com>'
|
|
|
|
(mbox) Adding cc: One <one@example.com> from line 'Cc: One <one@example.com>, two@example.com'
|
|
|
|
(mbox) Adding cc: two@example.com from line 'Cc: One <one@example.com>, two@example.com'
|
2009-06-18 14:31:32 +02:00
|
|
|
(cc-cmd) Adding cc: cc-cmd@example.com from: './cccmd'
|
2009-02-15 05:32:15 +01:00
|
|
|
Dry-OK. Log says:
|
|
|
|
Server: relay.example.com
|
|
|
|
MAIL FROM:<from@example.com>
|
2009-10-08 19:03:26 +02:00
|
|
|
RCPT TO:<to@example.com>
|
|
|
|
RCPT TO:<author@example.com>
|
|
|
|
RCPT TO:<one@example.com>
|
|
|
|
RCPT TO:<two@example.com>
|
|
|
|
RCPT TO:<cc-cmd@example.com>
|
2009-02-15 05:32:15 +01:00
|
|
|
From: Example <from@example.com>
|
|
|
|
To: to@example.com
|
2009-10-08 19:03:26 +02:00
|
|
|
Cc: A <author@example.com>,
|
|
|
|
One <one@example.com>,
|
|
|
|
two@example.com,
|
|
|
|
cc-cmd@example.com
|
2009-02-15 05:32:15 +01:00
|
|
|
Subject: [PATCH 1/1] Second.
|
|
|
|
Date: DATE-STRING
|
|
|
|
Message-Id: MESSAGE-ID-STRING
|
|
|
|
X-Mailer: X-MAILER-STRING
|
|
|
|
|
|
|
|
Result: OK
|
|
|
|
EOF
|
2010-08-13 22:40:10 +02:00
|
|
|
"
|
2009-02-15 05:32:15 +01:00
|
|
|
|
2010-08-13 22:40:09 +02:00
|
|
|
test_expect_success $PREREQ '--suppress-cc=body' '
|
2009-02-15 05:32:15 +01:00
|
|
|
test_suppression body
|
|
|
|
'
|
|
|
|
|
2010-08-13 22:40:10 +02:00
|
|
|
test_expect_success $PREREQ 'setup expect' "
|
2009-06-18 14:31:32 +02:00
|
|
|
cat >expected-suppress-body-cccmd <<\EOF
|
|
|
|
0001-Second.patch
|
|
|
|
(mbox) Adding cc: A <author@example.com> from line 'From: A <author@example.com>'
|
|
|
|
(mbox) Adding cc: One <one@example.com> from line 'Cc: One <one@example.com>, two@example.com'
|
|
|
|
(mbox) Adding cc: two@example.com from line 'Cc: One <one@example.com>, two@example.com'
|
|
|
|
Dry-OK. Log says:
|
|
|
|
Server: relay.example.com
|
|
|
|
MAIL FROM:<from@example.com>
|
2009-10-08 19:03:26 +02:00
|
|
|
RCPT TO:<to@example.com>
|
|
|
|
RCPT TO:<author@example.com>
|
|
|
|
RCPT TO:<one@example.com>
|
|
|
|
RCPT TO:<two@example.com>
|
2009-06-18 14:31:32 +02:00
|
|
|
From: Example <from@example.com>
|
|
|
|
To: to@example.com
|
2009-10-08 19:03:26 +02:00
|
|
|
Cc: A <author@example.com>,
|
|
|
|
One <one@example.com>,
|
|
|
|
two@example.com
|
2009-06-18 14:31:32 +02:00
|
|
|
Subject: [PATCH 1/1] Second.
|
|
|
|
Date: DATE-STRING
|
|
|
|
Message-Id: MESSAGE-ID-STRING
|
|
|
|
X-Mailer: X-MAILER-STRING
|
|
|
|
|
|
|
|
Result: OK
|
|
|
|
EOF
|
2010-08-13 22:40:10 +02:00
|
|
|
"
|
2009-06-18 14:31:32 +02:00
|
|
|
|
2010-08-13 22:40:09 +02:00
|
|
|
test_expect_success $PREREQ '--suppress-cc=body --suppress-cc=cccmd' '
|
2009-06-18 14:31:32 +02:00
|
|
|
test_suppression body cccmd
|
|
|
|
'
|
|
|
|
|
2010-08-13 22:40:10 +02:00
|
|
|
test_expect_success $PREREQ 'setup expect' "
|
2009-02-15 05:32:15 +01:00
|
|
|
cat >expected-suppress-sob <<\EOF
|
|
|
|
0001-Second.patch
|
|
|
|
(mbox) Adding cc: A <author@example.com> from line 'From: A <author@example.com>'
|
|
|
|
(mbox) Adding cc: One <one@example.com> from line 'Cc: One <one@example.com>, two@example.com'
|
|
|
|
(mbox) Adding cc: two@example.com from line 'Cc: One <one@example.com>, two@example.com'
|
|
|
|
Dry-OK. Log says:
|
|
|
|
Server: relay.example.com
|
|
|
|
MAIL FROM:<from@example.com>
|
2009-10-08 19:03:26 +02:00
|
|
|
RCPT TO:<to@example.com>
|
|
|
|
RCPT TO:<author@example.com>
|
|
|
|
RCPT TO:<one@example.com>
|
|
|
|
RCPT TO:<two@example.com>
|
2009-02-15 05:32:15 +01:00
|
|
|
From: Example <from@example.com>
|
|
|
|
To: to@example.com
|
2009-10-08 19:03:26 +02:00
|
|
|
Cc: A <author@example.com>,
|
|
|
|
One <one@example.com>,
|
|
|
|
two@example.com
|
2009-02-15 05:32:15 +01:00
|
|
|
Subject: [PATCH 1/1] Second.
|
|
|
|
Date: DATE-STRING
|
|
|
|
Message-Id: MESSAGE-ID-STRING
|
|
|
|
X-Mailer: X-MAILER-STRING
|
|
|
|
|
|
|
|
Result: OK
|
|
|
|
EOF
|
2010-08-13 22:40:10 +02:00
|
|
|
"
|
2009-02-15 05:32:15 +01:00
|
|
|
|
2010-08-13 22:40:09 +02:00
|
|
|
test_expect_success $PREREQ '--suppress-cc=sob' '
|
2011-01-04 21:56:58 +01:00
|
|
|
test_might_fail git config --unset sendemail.cccmd &&
|
2009-02-15 05:32:15 +01:00
|
|
|
test_suppression sob
|
|
|
|
'
|
|
|
|
|
2010-08-13 22:40:10 +02:00
|
|
|
test_expect_success $PREREQ 'setup expect' "
|
2009-02-15 05:32:15 +01:00
|
|
|
cat >expected-suppress-bodycc <<\EOF
|
|
|
|
0001-Second.patch
|
|
|
|
(mbox) Adding cc: A <author@example.com> from line 'From: A <author@example.com>'
|
|
|
|
(mbox) Adding cc: One <one@example.com> from line 'Cc: One <one@example.com>, two@example.com'
|
|
|
|
(mbox) Adding cc: two@example.com from line 'Cc: One <one@example.com>, two@example.com'
|
|
|
|
(body) Adding cc: C O Mitter <committer@example.com> from line 'Signed-off-by: C O Mitter <committer@example.com>'
|
|
|
|
Dry-OK. Log says:
|
|
|
|
Server: relay.example.com
|
|
|
|
MAIL FROM:<from@example.com>
|
2009-10-08 19:03:26 +02:00
|
|
|
RCPT TO:<to@example.com>
|
|
|
|
RCPT TO:<author@example.com>
|
|
|
|
RCPT TO:<one@example.com>
|
|
|
|
RCPT TO:<two@example.com>
|
|
|
|
RCPT TO:<committer@example.com>
|
2009-02-15 05:32:15 +01:00
|
|
|
From: Example <from@example.com>
|
|
|
|
To: to@example.com
|
2009-10-08 19:03:26 +02:00
|
|
|
Cc: A <author@example.com>,
|
|
|
|
One <one@example.com>,
|
|
|
|
two@example.com,
|
|
|
|
C O Mitter <committer@example.com>
|
2009-02-15 05:32:15 +01:00
|
|
|
Subject: [PATCH 1/1] Second.
|
|
|
|
Date: DATE-STRING
|
|
|
|
Message-Id: MESSAGE-ID-STRING
|
|
|
|
X-Mailer: X-MAILER-STRING
|
|
|
|
|
|
|
|
Result: OK
|
|
|
|
EOF
|
2010-08-13 22:40:10 +02:00
|
|
|
"
|
2009-02-15 05:32:15 +01:00
|
|
|
|
2010-08-13 22:40:09 +02:00
|
|
|
test_expect_success $PREREQ '--suppress-cc=bodycc' '
|
2009-02-15 05:32:15 +01:00
|
|
|
test_suppression bodycc
|
|
|
|
'
|
|
|
|
|
2010-08-13 22:40:10 +02:00
|
|
|
test_expect_success $PREREQ 'setup expect' "
|
2009-02-15 05:32:15 +01:00
|
|
|
cat >expected-suppress-cc <<\EOF
|
|
|
|
0001-Second.patch
|
|
|
|
(mbox) Adding cc: A <author@example.com> from line 'From: A <author@example.com>'
|
|
|
|
(body) Adding cc: C O Mitter <committer@example.com> from line 'Signed-off-by: C O Mitter <committer@example.com>'
|
|
|
|
Dry-OK. Log says:
|
|
|
|
Server: relay.example.com
|
|
|
|
MAIL FROM:<from@example.com>
|
2009-10-08 19:03:26 +02:00
|
|
|
RCPT TO:<to@example.com>
|
|
|
|
RCPT TO:<author@example.com>
|
|
|
|
RCPT TO:<committer@example.com>
|
2009-02-15 05:32:15 +01:00
|
|
|
From: Example <from@example.com>
|
|
|
|
To: to@example.com
|
2009-10-08 19:03:26 +02:00
|
|
|
Cc: A <author@example.com>,
|
|
|
|
C O Mitter <committer@example.com>
|
2009-02-15 05:32:15 +01:00
|
|
|
Subject: [PATCH 1/1] Second.
|
|
|
|
Date: DATE-STRING
|
|
|
|
Message-Id: MESSAGE-ID-STRING
|
|
|
|
X-Mailer: X-MAILER-STRING
|
|
|
|
|
|
|
|
Result: OK
|
|
|
|
EOF
|
2010-08-13 22:40:10 +02:00
|
|
|
"
|
2009-02-15 05:32:15 +01:00
|
|
|
|
2010-08-13 22:40:09 +02:00
|
|
|
test_expect_success $PREREQ '--suppress-cc=cc' '
|
2009-02-15 05:32:15 +01:00
|
|
|
test_suppression cc
|
2008-04-29 12:56:47 +02:00
|
|
|
'
|
|
|
|
|
2009-03-03 05:52:18 +01:00
|
|
|
test_confirm () {
|
|
|
|
echo y | \
|
|
|
|
GIT_SEND_EMAIL_NOTTY=1 \
|
|
|
|
git send-email \
|
|
|
|
--from="Example <nobody@example.com>" \
|
|
|
|
--to=nobody@example.com \
|
|
|
|
--smtp-server="$(pwd)/fake.sendmail" \
|
2014-11-25 23:52:42 +01:00
|
|
|
$@ $patches >stdout &&
|
2009-03-29 03:39:11 +02:00
|
|
|
grep "Send this email" stdout
|
2009-03-03 05:52:18 +01:00
|
|
|
}
|
|
|
|
|
2010-08-13 22:40:09 +02:00
|
|
|
test_expect_success $PREREQ '--confirm=always' '
|
2009-03-03 05:52:18 +01:00
|
|
|
test_confirm --confirm=always --suppress-cc=all
|
|
|
|
'
|
|
|
|
|
2010-08-13 22:40:09 +02:00
|
|
|
test_expect_success $PREREQ '--confirm=auto' '
|
2009-03-03 05:52:18 +01:00
|
|
|
test_confirm --confirm=auto
|
|
|
|
'
|
|
|
|
|
2010-08-13 22:40:09 +02:00
|
|
|
test_expect_success $PREREQ '--confirm=cc' '
|
2009-03-03 05:52:18 +01:00
|
|
|
test_confirm --confirm=cc
|
|
|
|
'
|
|
|
|
|
2010-08-13 22:40:09 +02:00
|
|
|
test_expect_success $PREREQ '--confirm=compose' '
|
2009-03-03 05:52:18 +01:00
|
|
|
test_confirm --confirm=compose --compose
|
|
|
|
'
|
|
|
|
|
t9001: use test_when_finished
The confirmation tests in t9001 all save the value of
sendemail.confirm, do something to it, then restore it at
the end, in a way that breaks the &&-chain (they are not
wrong, because they save the $? value, but it fools
--chain-lint).
Instead, they can all use test_when_finished, and we can
even make the code simpler by factoring out the shared
lines.
Note that we can _almost_ use test_config here, except that:
1. We do not restore the config with test_unconfig, but by
setting it back to some prior value.
2. We are not always setting a config variable. Sometimes
the change to be undone is unsetting it entirely.
We could teach test_config to handle these cases, but it's
not worth the complexity for a single call-site.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2015-03-20 11:13:22 +01:00
|
|
|
test_expect_success $PREREQ 'confirm by default (due to cc)' '
|
2015-03-25 06:32:20 +01:00
|
|
|
test_when_finished git config sendemail.confirm never &&
|
2009-03-03 05:52:18 +01:00
|
|
|
git config --unset sendemail.confirm &&
|
2009-03-29 03:39:11 +02:00
|
|
|
test_confirm
|
2009-03-03 05:52:18 +01:00
|
|
|
'
|
|
|
|
|
2010-08-13 22:40:09 +02:00
|
|
|
test_expect_success $PREREQ 'confirm by default (due to --compose)' '
|
2015-03-25 06:32:20 +01:00
|
|
|
test_when_finished git config sendemail.confirm never &&
|
2009-03-03 05:52:18 +01:00
|
|
|
git config --unset sendemail.confirm &&
|
|
|
|
test_confirm --suppress-cc=all --compose
|
|
|
|
'
|
|
|
|
|
2010-08-13 22:40:09 +02:00
|
|
|
test_expect_success $PREREQ 'confirm detects EOF (inform assumes y)' '
|
2015-03-25 06:32:20 +01:00
|
|
|
test_when_finished git config sendemail.confirm never &&
|
2009-03-29 03:39:11 +02:00
|
|
|
git config --unset sendemail.confirm &&
|
2009-03-31 18:22:12 +02:00
|
|
|
rm -fr outdir &&
|
|
|
|
git format-patch -2 -o outdir &&
|
2009-03-29 03:39:11 +02:00
|
|
|
GIT_SEND_EMAIL_NOTTY=1 \
|
|
|
|
git send-email \
|
|
|
|
--from="Example <nobody@example.com>" \
|
|
|
|
--to=nobody@example.com \
|
|
|
|
--smtp-server="$(pwd)/fake.sendmail" \
|
2014-11-25 23:52:42 +01:00
|
|
|
outdir/*.patch </dev/null
|
2009-03-29 03:39:11 +02:00
|
|
|
'
|
|
|
|
|
2010-08-13 22:40:09 +02:00
|
|
|
test_expect_success $PREREQ 'confirm detects EOF (auto causes failure)' '
|
2015-03-25 06:32:20 +01:00
|
|
|
test_when_finished git config sendemail.confirm never &&
|
2009-03-29 03:39:11 +02:00
|
|
|
git config sendemail.confirm auto &&
|
2009-03-31 18:22:13 +02:00
|
|
|
GIT_SEND_EMAIL_NOTTY=1 &&
|
|
|
|
export GIT_SEND_EMAIL_NOTTY &&
|
2009-03-29 03:39:11 +02:00
|
|
|
test_must_fail git send-email \
|
|
|
|
--from="Example <nobody@example.com>" \
|
|
|
|
--to=nobody@example.com \
|
|
|
|
--smtp-server="$(pwd)/fake.sendmail" \
|
2014-11-25 23:52:42 +01:00
|
|
|
$patches </dev/null
|
2009-03-29 03:39:11 +02:00
|
|
|
'
|
|
|
|
|
2013-04-12 00:36:10 +02:00
|
|
|
test_expect_success $PREREQ 'confirm does not loop forever' '
|
2015-03-25 06:32:20 +01:00
|
|
|
test_when_finished git config sendemail.confirm never &&
|
2009-03-29 03:39:11 +02:00
|
|
|
git config sendemail.confirm auto &&
|
2009-03-31 18:22:13 +02:00
|
|
|
GIT_SEND_EMAIL_NOTTY=1 &&
|
|
|
|
export GIT_SEND_EMAIL_NOTTY &&
|
|
|
|
yes "bogus" | test_must_fail git send-email \
|
2009-03-29 03:39:11 +02:00
|
|
|
--from="Example <nobody@example.com>" \
|
|
|
|
--to=nobody@example.com \
|
|
|
|
--smtp-server="$(pwd)/fake.sendmail" \
|
|
|
|
$patches
|
|
|
|
'
|
|
|
|
|
2010-08-13 22:40:09 +02:00
|
|
|
test_expect_success $PREREQ 'utf8 Cc is rfc2047 encoded' '
|
2009-03-31 18:22:14 +02:00
|
|
|
clean_fake_sendmail &&
|
|
|
|
rm -fr outdir &&
|
|
|
|
git format-patch -1 -o outdir --cc="àéìöú <utf8@example.com>" &&
|
|
|
|
git send-email \
|
|
|
|
--from="Example <nobody@example.com>" \
|
|
|
|
--to=nobody@example.com \
|
|
|
|
--smtp-server="$(pwd)/fake.sendmail" \
|
|
|
|
outdir/*.patch &&
|
2009-10-08 19:03:26 +02:00
|
|
|
grep "^ " msgtxt1 |
|
2009-06-07 03:12:31 +02:00
|
|
|
grep "=?UTF-8?q?=C3=A0=C3=A9=C3=AC=C3=B6=C3=BA?= <utf8@example.com>"
|
2009-03-31 18:22:14 +02:00
|
|
|
'
|
|
|
|
|
2010-08-13 22:40:09 +02:00
|
|
|
test_expect_success $PREREQ '--compose adds MIME for utf8 body' '
|
2008-03-28 22:28:33 +01:00
|
|
|
clean_fake_sendmail &&
|
2014-11-25 23:21:07 +01:00
|
|
|
write_script fake-editor-utf8 <<-\EOF &&
|
|
|
|
echo "utf8 body: àéìöú" >>"$1"
|
|
|
|
EOF
|
2014-11-25 23:14:41 +01:00
|
|
|
GIT_EDITOR="\"$(pwd)/fake-editor-utf8\"" \
|
|
|
|
git send-email \
|
|
|
|
--compose --subject foo \
|
|
|
|
--from="Example <nobody@example.com>" \
|
|
|
|
--to=nobody@example.com \
|
|
|
|
--smtp-server="$(pwd)/fake.sendmail" \
|
|
|
|
$patches &&
|
2008-03-28 22:28:33 +01:00
|
|
|
grep "^utf8 body" msgtxt1 &&
|
2009-06-07 03:12:31 +02:00
|
|
|
grep "^Content-Type: text/plain; charset=UTF-8" msgtxt1
|
2008-03-28 22:28:33 +01:00
|
|
|
'
|
|
|
|
|
2010-08-13 22:40:09 +02:00
|
|
|
test_expect_success $PREREQ '--compose respects user mime type' '
|
2008-03-28 22:28:33 +01:00
|
|
|
clean_fake_sendmail &&
|
2014-11-25 23:21:07 +01:00
|
|
|
write_script fake-editor-utf8-mime <<-\EOF &&
|
|
|
|
cat >"$1" <<-\EOM
|
|
|
|
MIME-Version: 1.0
|
|
|
|
Content-Type: text/plain; charset=iso-8859-1
|
|
|
|
Content-Transfer-Encoding: 8bit
|
|
|
|
Subject: foo
|
|
|
|
|
|
|
|
utf8 body: àéìöú
|
|
|
|
EOM
|
|
|
|
EOF
|
2014-11-25 23:14:41 +01:00
|
|
|
GIT_EDITOR="\"$(pwd)/fake-editor-utf8-mime\"" \
|
|
|
|
git send-email \
|
|
|
|
--compose --subject foo \
|
|
|
|
--from="Example <nobody@example.com>" \
|
|
|
|
--to=nobody@example.com \
|
|
|
|
--smtp-server="$(pwd)/fake.sendmail" \
|
|
|
|
$patches &&
|
2008-03-28 22:28:33 +01:00
|
|
|
grep "^utf8 body" msgtxt1 &&
|
|
|
|
grep "^Content-Type: text/plain; charset=iso-8859-1" msgtxt1 &&
|
2009-06-07 03:12:31 +02:00
|
|
|
! grep "^Content-Type: text/plain; charset=UTF-8" msgtxt1
|
2008-03-28 22:28:33 +01:00
|
|
|
'
|
|
|
|
|
2010-08-13 22:40:09 +02:00
|
|
|
test_expect_success $PREREQ '--compose adds MIME for utf8 subject' '
|
2008-03-28 22:29:01 +01:00
|
|
|
clean_fake_sendmail &&
|
2014-11-25 23:14:41 +01:00
|
|
|
GIT_EDITOR="\"$(pwd)/fake-editor\"" \
|
|
|
|
git send-email \
|
|
|
|
--compose --subject utf8-sübjëct \
|
|
|
|
--from="Example <nobody@example.com>" \
|
|
|
|
--to=nobody@example.com \
|
|
|
|
--smtp-server="$(pwd)/fake.sendmail" \
|
|
|
|
$patches &&
|
2008-03-28 22:29:01 +01:00
|
|
|
grep "^fake edit" msgtxt1 &&
|
2009-06-07 03:12:31 +02:00
|
|
|
grep "^Subject: =?UTF-8?q?utf8-s=C3=BCbj=C3=ABct?=" msgtxt1
|
2008-03-28 22:29:01 +01:00
|
|
|
'
|
|
|
|
|
2012-07-30 21:25:40 +02:00
|
|
|
test_expect_success $PREREQ 'utf8 author is correctly passed on' '
|
|
|
|
clean_fake_sendmail &&
|
|
|
|
test_commit weird_author &&
|
|
|
|
test_when_finished "git reset --hard HEAD^" &&
|
|
|
|
git commit --amend --author "Füñný Nâmé <odd_?=mail@example.com>" &&
|
|
|
|
git format-patch --stdout -1 >funny_name.patch &&
|
|
|
|
git send-email --from="Example <nobody@example.com>" \
|
2014-11-25 23:14:41 +01:00
|
|
|
--to=nobody@example.com \
|
|
|
|
--smtp-server="$(pwd)/fake.sendmail" \
|
|
|
|
funny_name.patch &&
|
2012-07-30 21:25:40 +02:00
|
|
|
grep "^From: Füñný Nâmé <odd_?=mail@example.com>" msgtxt1
|
|
|
|
'
|
|
|
|
|
2013-06-18 14:49:26 +02:00
|
|
|
test_expect_success $PREREQ 'utf8 sender is not duplicated' '
|
2013-06-18 14:49:29 +02:00
|
|
|
clean_fake_sendmail &&
|
|
|
|
test_commit weird_sender &&
|
|
|
|
test_when_finished "git reset --hard HEAD^" &&
|
|
|
|
git commit --amend --author "Füñný Nâmé <odd_?=mail@example.com>" &&
|
|
|
|
git format-patch --stdout -1 >funny_name.patch &&
|
|
|
|
git send-email --from="Füñný Nâmé <odd_?=mail@example.com>" \
|
2014-11-25 23:14:41 +01:00
|
|
|
--to=nobody@example.com \
|
|
|
|
--smtp-server="$(pwd)/fake.sendmail" \
|
|
|
|
funny_name.patch &&
|
2013-06-18 14:49:29 +02:00
|
|
|
grep "^From: " msgtxt1 >msgfrom &&
|
|
|
|
test_line_count = 1 msgfrom
|
|
|
|
'
|
|
|
|
|
2012-10-10 01:02:56 +02:00
|
|
|
test_expect_success $PREREQ 'sendemail.composeencoding works' '
|
|
|
|
clean_fake_sendmail &&
|
|
|
|
git config sendemail.composeencoding iso-8859-1 &&
|
2014-11-25 23:21:07 +01:00
|
|
|
write_script fake-editor-utf8 <<-\EOF &&
|
|
|
|
echo "utf8 body: àéìöú" >>"$1"
|
|
|
|
EOF
|
2014-11-25 23:14:41 +01:00
|
|
|
GIT_EDITOR="\"$(pwd)/fake-editor-utf8\"" \
|
|
|
|
git send-email \
|
|
|
|
--compose --subject foo \
|
|
|
|
--from="Example <nobody@example.com>" \
|
|
|
|
--to=nobody@example.com \
|
|
|
|
--smtp-server="$(pwd)/fake.sendmail" \
|
|
|
|
$patches &&
|
2012-10-10 01:02:56 +02:00
|
|
|
grep "^utf8 body" msgtxt1 &&
|
|
|
|
grep "^Content-Type: text/plain; charset=iso-8859-1" msgtxt1
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success $PREREQ '--compose-encoding works' '
|
|
|
|
clean_fake_sendmail &&
|
2014-11-25 23:21:07 +01:00
|
|
|
write_script fake-editor-utf8 <<-\EOF &&
|
|
|
|
echo "utf8 body: àéìöú" >>"$1"
|
|
|
|
EOF
|
2014-11-25 23:14:41 +01:00
|
|
|
GIT_EDITOR="\"$(pwd)/fake-editor-utf8\"" \
|
|
|
|
git send-email \
|
|
|
|
--compose-encoding iso-8859-1 \
|
|
|
|
--compose --subject foo \
|
|
|
|
--from="Example <nobody@example.com>" \
|
|
|
|
--to=nobody@example.com \
|
|
|
|
--smtp-server="$(pwd)/fake.sendmail" \
|
|
|
|
$patches &&
|
2012-10-10 01:02:56 +02:00
|
|
|
grep "^utf8 body" msgtxt1 &&
|
|
|
|
grep "^Content-Type: text/plain; charset=iso-8859-1" msgtxt1
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success $PREREQ '--compose-encoding overrides sendemail.composeencoding' '
|
|
|
|
clean_fake_sendmail &&
|
|
|
|
git config sendemail.composeencoding iso-8859-1 &&
|
2014-11-25 23:21:07 +01:00
|
|
|
write_script fake-editor-utf8 <<-\EOF &&
|
|
|
|
echo "utf8 body: àéìöú" >>"$1"
|
|
|
|
EOF
|
2014-11-25 23:14:41 +01:00
|
|
|
GIT_EDITOR="\"$(pwd)/fake-editor-utf8\"" \
|
|
|
|
git send-email \
|
|
|
|
--compose-encoding iso-8859-2 \
|
|
|
|
--compose --subject foo \
|
|
|
|
--from="Example <nobody@example.com>" \
|
|
|
|
--to=nobody@example.com \
|
|
|
|
--smtp-server="$(pwd)/fake.sendmail" \
|
|
|
|
$patches &&
|
2012-10-10 01:02:56 +02:00
|
|
|
grep "^utf8 body" msgtxt1 &&
|
|
|
|
grep "^Content-Type: text/plain; charset=iso-8859-2" msgtxt1
|
|
|
|
'
|
|
|
|
|
2012-10-22 14:41:48 +02:00
|
|
|
test_expect_success $PREREQ '--compose-encoding adds correct MIME for subject' '
|
|
|
|
clean_fake_sendmail &&
|
2014-11-25 23:14:41 +01:00
|
|
|
GIT_EDITOR="\"$(pwd)/fake-editor\"" \
|
|
|
|
git send-email \
|
|
|
|
--compose-encoding iso-8859-2 \
|
|
|
|
--compose --subject utf8-sübjëct \
|
|
|
|
--from="Example <nobody@example.com>" \
|
|
|
|
--to=nobody@example.com \
|
|
|
|
--smtp-server="$(pwd)/fake.sendmail" \
|
|
|
|
$patches &&
|
2012-10-22 14:41:48 +02:00
|
|
|
grep "^fake edit" msgtxt1 &&
|
|
|
|
grep "^Subject: =?iso-8859-2?q?utf8-s=C3=BCbj=C3=ABct?=" msgtxt1
|
|
|
|
'
|
|
|
|
|
2010-08-13 22:40:09 +02:00
|
|
|
test_expect_success $PREREQ 'detects ambiguous reference/file conflict' '
|
2014-11-25 23:52:42 +01:00
|
|
|
echo master >master &&
|
2008-11-11 00:54:00 +01:00
|
|
|
git add master &&
|
|
|
|
git commit -m"add master" &&
|
|
|
|
test_must_fail git send-email --dry-run master 2>errors &&
|
|
|
|
grep disambiguate errors
|
|
|
|
'
|
|
|
|
|
2010-08-13 22:40:09 +02:00
|
|
|
test_expect_success $PREREQ 'feed two files' '
|
2008-12-01 07:38:20 +01:00
|
|
|
rm -fr outdir &&
|
|
|
|
git format-patch -2 -o outdir &&
|
2009-03-03 05:52:18 +01:00
|
|
|
git send-email \
|
2014-11-25 23:14:41 +01:00
|
|
|
--dry-run \
|
|
|
|
--from="Example <nobody@example.com>" \
|
|
|
|
--to=nobody@example.com \
|
|
|
|
outdir/000?-*.patch 2>errors >out &&
|
2008-12-01 07:38:20 +01:00
|
|
|
grep "^Subject: " out >subjects &&
|
|
|
|
test "z$(sed -n -e 1p subjects)" = "zSubject: [PATCH 1/2] Second." &&
|
|
|
|
test "z$(sed -n -e 2p subjects)" = "zSubject: [PATCH 2/2] add master"
|
|
|
|
'
|
|
|
|
|
2010-08-13 22:40:09 +02:00
|
|
|
test_expect_success $PREREQ 'in-reply-to but no threading' '
|
2009-03-11 23:40:13 +01:00
|
|
|
git send-email \
|
|
|
|
--dry-run \
|
|
|
|
--from="Example <nobody@example.com>" \
|
|
|
|
--to=nobody@example.com \
|
|
|
|
--in-reply-to="<in-reply-id@example.com>" \
|
2015-01-31 03:40:17 +01:00
|
|
|
--no-thread \
|
2009-03-11 23:40:13 +01:00
|
|
|
$patches |
|
|
|
|
grep "In-Reply-To: <in-reply-id@example.com>"
|
|
|
|
'
|
|
|
|
|
2010-08-13 22:40:09 +02:00
|
|
|
test_expect_success $PREREQ 'no in-reply-to and no threading' '
|
2009-06-12 12:51:37 +02:00
|
|
|
git send-email \
|
|
|
|
--dry-run \
|
|
|
|
--from="Example <nobody@example.com>" \
|
|
|
|
--to=nobody@example.com \
|
2015-01-31 03:40:17 +01:00
|
|
|
--no-thread \
|
2009-06-12 12:51:37 +02:00
|
|
|
$patches $patches >stdout &&
|
|
|
|
! grep "In-Reply-To: " stdout
|
|
|
|
'
|
|
|
|
|
2010-08-13 22:40:09 +02:00
|
|
|
test_expect_success $PREREQ 'threading but no chain-reply-to' '
|
2009-06-12 12:51:40 +02:00
|
|
|
git send-email \
|
|
|
|
--dry-run \
|
|
|
|
--from="Example <nobody@example.com>" \
|
|
|
|
--to=nobody@example.com \
|
|
|
|
--thread \
|
2015-01-31 03:40:17 +01:00
|
|
|
--no-chain-reply-to \
|
2009-06-12 12:51:40 +02:00
|
|
|
$patches $patches >stdout &&
|
|
|
|
grep "In-Reply-To: " stdout
|
|
|
|
'
|
|
|
|
|
2010-08-13 22:40:09 +02:00
|
|
|
test_expect_success $PREREQ 'sendemail.to works' '
|
2010-03-07 23:46:48 +01:00
|
|
|
git config --replace-all sendemail.to "Somebody <somebody@ex.com>" &&
|
|
|
|
git send-email \
|
|
|
|
--dry-run \
|
|
|
|
--from="Example <nobody@example.com>" \
|
|
|
|
$patches $patches >stdout &&
|
|
|
|
grep "To: Somebody <somebody@ex.com>" stdout
|
|
|
|
'
|
|
|
|
|
2010-08-13 22:40:09 +02:00
|
|
|
test_expect_success $PREREQ '--no-to overrides sendemail.to' '
|
2010-03-07 23:46:48 +01:00
|
|
|
git send-email \
|
|
|
|
--dry-run \
|
|
|
|
--from="Example <nobody@example.com>" \
|
|
|
|
--no-to \
|
|
|
|
--to=nobody@example.com \
|
|
|
|
$patches $patches >stdout &&
|
|
|
|
grep "To: nobody@example.com" stdout &&
|
|
|
|
! grep "To: Somebody <somebody@ex.com>" stdout
|
|
|
|
'
|
|
|
|
|
2010-08-13 22:40:09 +02:00
|
|
|
test_expect_success $PREREQ 'sendemail.cc works' '
|
2010-03-07 23:46:48 +01:00
|
|
|
git config --replace-all sendemail.cc "Somebody <somebody@ex.com>" &&
|
|
|
|
git send-email \
|
|
|
|
--dry-run \
|
|
|
|
--from="Example <nobody@example.com>" \
|
|
|
|
--to=nobody@example.com \
|
|
|
|
$patches $patches >stdout &&
|
|
|
|
grep "Cc: Somebody <somebody@ex.com>" stdout
|
|
|
|
'
|
|
|
|
|
2010-08-13 22:40:09 +02:00
|
|
|
test_expect_success $PREREQ '--no-cc overrides sendemail.cc' '
|
2010-03-07 23:46:48 +01:00
|
|
|
git send-email \
|
|
|
|
--dry-run \
|
|
|
|
--from="Example <nobody@example.com>" \
|
|
|
|
--no-cc \
|
|
|
|
--cc=bodies@example.com \
|
|
|
|
--to=nobody@example.com \
|
|
|
|
$patches $patches >stdout &&
|
|
|
|
grep "Cc: bodies@example.com" stdout &&
|
|
|
|
! grep "Cc: Somebody <somebody@ex.com>" stdout
|
|
|
|
'
|
|
|
|
|
2010-08-13 22:40:09 +02:00
|
|
|
test_expect_success $PREREQ 'sendemail.bcc works' '
|
2010-03-07 23:46:48 +01:00
|
|
|
git config --replace-all sendemail.bcc "Other <other@ex.com>" &&
|
|
|
|
git send-email \
|
|
|
|
--dry-run \
|
|
|
|
--from="Example <nobody@example.com>" \
|
|
|
|
--to=nobody@example.com \
|
|
|
|
--smtp-server relay.example.com \
|
|
|
|
$patches $patches >stdout &&
|
|
|
|
grep "RCPT TO:<other@ex.com>" stdout
|
|
|
|
'
|
|
|
|
|
2010-08-13 22:40:09 +02:00
|
|
|
test_expect_success $PREREQ '--no-bcc overrides sendemail.bcc' '
|
2010-03-07 23:46:48 +01:00
|
|
|
git send-email \
|
|
|
|
--dry-run \
|
|
|
|
--from="Example <nobody@example.com>" \
|
|
|
|
--no-bcc \
|
|
|
|
--bcc=bodies@example.com \
|
|
|
|
--to=nobody@example.com \
|
|
|
|
--smtp-server relay.example.com \
|
|
|
|
$patches $patches >stdout &&
|
|
|
|
grep "RCPT TO:<bodies@example.com>" stdout &&
|
|
|
|
! grep "RCPT TO:<other@ex.com>" stdout
|
|
|
|
'
|
|
|
|
|
2010-09-29 09:26:44 +02:00
|
|
|
test_expect_success $PREREQ 'patches To headers are used by default' '
|
|
|
|
patch=`git format-patch -1 --to="bodies@example.com"` &&
|
|
|
|
test_when_finished "rm $patch" &&
|
|
|
|
git send-email \
|
|
|
|
--dry-run \
|
|
|
|
--from="Example <nobody@example.com>" \
|
|
|
|
--smtp-server relay.example.com \
|
|
|
|
$patch >stdout &&
|
|
|
|
grep "RCPT TO:<bodies@example.com>" stdout
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success $PREREQ 'patches To headers are appended to' '
|
|
|
|
patch=`git format-patch -1 --to="bodies@example.com"` &&
|
|
|
|
test_when_finished "rm $patch" &&
|
|
|
|
git send-email \
|
|
|
|
--dry-run \
|
|
|
|
--from="Example <nobody@example.com>" \
|
|
|
|
--to=nobody@example.com \
|
|
|
|
--smtp-server relay.example.com \
|
|
|
|
$patch >stdout &&
|
|
|
|
grep "RCPT TO:<bodies@example.com>" stdout &&
|
|
|
|
grep "RCPT TO:<nobody@example.com>" stdout
|
|
|
|
'
|
|
|
|
|
2010-10-04 09:05:24 +02:00
|
|
|
test_expect_success $PREREQ 'To headers from files reset each patch' '
|
|
|
|
patch1=`git format-patch -1 --to="bodies@example.com"` &&
|
|
|
|
patch2=`git format-patch -1 --to="other@example.com" HEAD~` &&
|
|
|
|
test_when_finished "rm $patch1 && rm $patch2" &&
|
|
|
|
git send-email \
|
|
|
|
--dry-run \
|
|
|
|
--from="Example <nobody@example.com>" \
|
|
|
|
--to="nobody@example.com" \
|
|
|
|
--smtp-server relay.example.com \
|
|
|
|
$patch1 $patch2 >stdout &&
|
|
|
|
test $(grep -c "RCPT TO:<bodies@example.com>" stdout) = 1 &&
|
|
|
|
test $(grep -c "RCPT TO:<nobody@example.com>" stdout) = 2 &&
|
|
|
|
test $(grep -c "RCPT TO:<other@example.com>" stdout) = 1
|
|
|
|
'
|
|
|
|
|
2010-08-13 22:40:10 +02:00
|
|
|
test_expect_success $PREREQ 'setup expect' '
|
2014-11-26 00:03:45 +01:00
|
|
|
cat >email-using-8bit <<\EOF
|
2010-06-17 22:10:39 +02:00
|
|
|
From fe6ecc66ece37198fe5db91fa2fc41d9f4fe5cc4 Mon Sep 17 00:00:00 2001
|
|
|
|
Message-Id: <bogus-message-id@example.com>
|
|
|
|
From: author@example.com
|
|
|
|
Date: Sat, 12 Jun 2010 15:53:58 +0200
|
|
|
|
Subject: subject goes here
|
|
|
|
|
|
|
|
Dieser deutsche Text enthält einen Umlaut!
|
|
|
|
EOF
|
2010-08-13 22:40:10 +02:00
|
|
|
'
|
2010-06-17 22:10:39 +02:00
|
|
|
|
2012-10-24 10:03:35 +02:00
|
|
|
test_expect_success $PREREQ 'setup expect' '
|
2014-11-26 00:03:45 +01:00
|
|
|
echo "Subject: subject goes here" >expected
|
2012-10-24 10:03:35 +02:00
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success $PREREQ 'ASCII subject is not RFC2047 quoted' '
|
|
|
|
clean_fake_sendmail &&
|
|
|
|
echo bogus |
|
|
|
|
git send-email --from=author@example.com --to=nobody@example.com \
|
|
|
|
--smtp-server="$(pwd)/fake.sendmail" \
|
|
|
|
--8bit-encoding=UTF-8 \
|
|
|
|
email-using-8bit >stdout &&
|
|
|
|
grep "Subject" msgtxt1 >actual &&
|
|
|
|
test_cmp expected actual
|
|
|
|
'
|
|
|
|
|
2010-08-13 22:40:10 +02:00
|
|
|
test_expect_success $PREREQ 'setup expect' '
|
2014-11-26 00:03:45 +01:00
|
|
|
cat >content-type-decl <<-\EOF
|
|
|
|
MIME-Version: 1.0
|
|
|
|
Content-Type: text/plain; charset=UTF-8
|
|
|
|
Content-Transfer-Encoding: 8bit
|
|
|
|
EOF
|
2010-08-13 22:40:10 +02:00
|
|
|
'
|
2010-06-17 22:10:39 +02:00
|
|
|
|
2010-08-13 22:40:09 +02:00
|
|
|
test_expect_success $PREREQ 'asks about and fixes 8bit encodings' '
|
2010-06-17 22:10:39 +02:00
|
|
|
clean_fake_sendmail &&
|
|
|
|
echo |
|
|
|
|
git send-email --from=author@example.com --to=nobody@example.com \
|
|
|
|
--smtp-server="$(pwd)/fake.sendmail" \
|
|
|
|
email-using-8bit >stdout &&
|
|
|
|
grep "do not declare a Content-Transfer-Encoding" stdout &&
|
|
|
|
grep email-using-8bit stdout &&
|
|
|
|
grep "Which 8bit encoding" stdout &&
|
2010-06-29 00:46:22 +02:00
|
|
|
egrep "Content|MIME" msgtxt1 >actual &&
|
2010-06-17 22:10:39 +02:00
|
|
|
test_cmp actual content-type-decl
|
|
|
|
'
|
|
|
|
|
2010-08-13 22:40:09 +02:00
|
|
|
test_expect_success $PREREQ 'sendemail.8bitEncoding works' '
|
2010-06-17 22:10:39 +02:00
|
|
|
clean_fake_sendmail &&
|
|
|
|
git config sendemail.assume8bitEncoding UTF-8 &&
|
|
|
|
echo bogus |
|
|
|
|
git send-email --from=author@example.com --to=nobody@example.com \
|
|
|
|
--smtp-server="$(pwd)/fake.sendmail" \
|
|
|
|
email-using-8bit >stdout &&
|
2010-06-29 00:46:22 +02:00
|
|
|
egrep "Content|MIME" msgtxt1 >actual &&
|
2010-06-17 22:10:39 +02:00
|
|
|
test_cmp actual content-type-decl
|
|
|
|
'
|
|
|
|
|
2010-08-13 22:40:09 +02:00
|
|
|
test_expect_success $PREREQ '--8bit-encoding overrides sendemail.8bitEncoding' '
|
2010-06-17 22:10:39 +02:00
|
|
|
clean_fake_sendmail &&
|
|
|
|
git config sendemail.assume8bitEncoding "bogus too" &&
|
|
|
|
echo bogus |
|
|
|
|
git send-email --from=author@example.com --to=nobody@example.com \
|
|
|
|
--smtp-server="$(pwd)/fake.sendmail" \
|
|
|
|
--8bit-encoding=UTF-8 \
|
|
|
|
email-using-8bit >stdout &&
|
2010-06-29 00:46:22 +02:00
|
|
|
egrep "Content|MIME" msgtxt1 >actual &&
|
2010-06-17 22:10:39 +02:00
|
|
|
test_cmp actual content-type-decl
|
|
|
|
'
|
|
|
|
|
2010-08-13 22:40:10 +02:00
|
|
|
test_expect_success $PREREQ 'setup expect' '
|
2014-11-26 00:03:45 +01:00
|
|
|
cat >email-using-8bit <<-\EOF
|
|
|
|
From fe6ecc66ece37198fe5db91fa2fc41d9f4fe5cc4 Mon Sep 17 00:00:00 2001
|
|
|
|
Message-Id: <bogus-message-id@example.com>
|
|
|
|
From: author@example.com
|
|
|
|
Date: Sat, 12 Jun 2010 15:53:58 +0200
|
|
|
|
Subject: Dieser Betreff enthält auch einen Umlaut!
|
|
|
|
|
|
|
|
Nothing to see here.
|
|
|
|
EOF
|
2010-08-13 22:40:10 +02:00
|
|
|
'
|
2010-06-17 22:10:39 +02:00
|
|
|
|
2010-08-13 22:40:10 +02:00
|
|
|
test_expect_success $PREREQ 'setup expect' '
|
2014-11-26 00:03:45 +01:00
|
|
|
cat >expected <<-\EOF
|
|
|
|
Subject: =?UTF-8?q?Dieser=20Betreff=20enth=C3=A4lt=20auch=20einen=20Umlaut!?=
|
|
|
|
EOF
|
2010-08-13 22:40:10 +02:00
|
|
|
'
|
2010-06-17 22:10:39 +02:00
|
|
|
|
2010-08-13 22:40:09 +02:00
|
|
|
test_expect_success $PREREQ '--8bit-encoding also treats subject' '
|
2010-06-17 22:10:39 +02:00
|
|
|
clean_fake_sendmail &&
|
|
|
|
echo bogus |
|
|
|
|
git send-email --from=author@example.com --to=nobody@example.com \
|
|
|
|
--smtp-server="$(pwd)/fake.sendmail" \
|
|
|
|
--8bit-encoding=UTF-8 \
|
|
|
|
email-using-8bit >stdout &&
|
|
|
|
grep "Subject" msgtxt1 >actual &&
|
|
|
|
test_cmp expected actual
|
|
|
|
'
|
|
|
|
|
git-send-email: add --transfer-encoding option
The thread at http://thread.gmane.org/gmane.comp.version-control.git/257392
details problems when applying patches with "git am" in a repository with
CRLF line endings. In the example in the thread, the repository originated
from "git-svn" so it is not possible to use core.eol and friends on it.
Right now, the best option is to use "git am --keep-cr". However, when
a patch create new files, the patch application process will reject the
new file because it finds a "/dev/null\r" string instead of "/dev/null".
The problem is that SMTP transport is CRLF-unsafe. Sending a patch by
email is the same as passing it through "dos2unix | unix2dos". The newly
introduced CRLFs are normally transparent because git-am strips them. The
keepcr=true setting preserves them, but it is mostly working by chance
and it would be very problematic to have a "git am" workflow in a
repository with mixed LF and CRLF line endings.
The MIME solution to this is the quoted-printable transfer enconding.
This is not something that we want to enable by default, since it makes
received emails horrible to look at. However, it is a very good match
for projects that store CRLF line endings in the repository.
The only disadvantage of quoted-printable is that quoted-printable
patches fail to apply if the maintainer uses "git am --keep-cr". This
is because the decoded patch will have two carriage returns at the end
of the line. Therefore, add support for base64 transfer encoding too,
which makes received emails downright impossible to look at outside
a MUA, but really just works.
The patch covers all bases, including users that still live in the late
80s, by also providing a 7bit content transfer encoding that refuses
to send emails with non-ASCII character in them. And finally, "8bit"
will add a Content-Transfer-Encoding header but otherwise do nothing.
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2014-11-25 15:00:27 +01:00
|
|
|
test_expect_success $PREREQ 'setup expect' '
|
2014-11-26 00:03:45 +01:00
|
|
|
cat >email-using-8bit <<-\EOF
|
|
|
|
From fe6ecc66ece37198fe5db91fa2fc41d9f4fe5cc4 Mon Sep 17 00:00:00 2001
|
|
|
|
Message-Id: <bogus-message-id@example.com>
|
|
|
|
From: A U Thor <author@example.com>
|
|
|
|
Date: Sat, 12 Jun 2010 15:53:58 +0200
|
|
|
|
Content-Type: text/plain; charset=UTF-8
|
|
|
|
Subject: Nothing to see here.
|
|
|
|
|
|
|
|
Dieser Betreff enthält auch einen Umlaut!
|
|
|
|
EOF
|
git-send-email: add --transfer-encoding option
The thread at http://thread.gmane.org/gmane.comp.version-control.git/257392
details problems when applying patches with "git am" in a repository with
CRLF line endings. In the example in the thread, the repository originated
from "git-svn" so it is not possible to use core.eol and friends on it.
Right now, the best option is to use "git am --keep-cr". However, when
a patch create new files, the patch application process will reject the
new file because it finds a "/dev/null\r" string instead of "/dev/null".
The problem is that SMTP transport is CRLF-unsafe. Sending a patch by
email is the same as passing it through "dos2unix | unix2dos". The newly
introduced CRLFs are normally transparent because git-am strips them. The
keepcr=true setting preserves them, but it is mostly working by chance
and it would be very problematic to have a "git am" workflow in a
repository with mixed LF and CRLF line endings.
The MIME solution to this is the quoted-printable transfer enconding.
This is not something that we want to enable by default, since it makes
received emails horrible to look at. However, it is a very good match
for projects that store CRLF line endings in the repository.
The only disadvantage of quoted-printable is that quoted-printable
patches fail to apply if the maintainer uses "git am --keep-cr". This
is because the decoded patch will have two carriage returns at the end
of the line. Therefore, add support for base64 transfer encoding too,
which makes received emails downright impossible to look at outside
a MUA, but really just works.
The patch covers all bases, including users that still live in the late
80s, by also providing a 7bit content transfer encoding that refuses
to send emails with non-ASCII character in them. And finally, "8bit"
will add a Content-Transfer-Encoding header but otherwise do nothing.
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2014-11-25 15:00:27 +01:00
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success $PREREQ 'sendemail.transferencoding=7bit fails on 8bit data' '
|
|
|
|
clean_fake_sendmail &&
|
|
|
|
git config sendemail.transferEncoding 7bit &&
|
|
|
|
test_must_fail git send-email \
|
2014-11-25 23:14:41 +01:00
|
|
|
--transfer-encoding=7bit \
|
|
|
|
--smtp-server="$(pwd)/fake.sendmail" \
|
|
|
|
email-using-8bit \
|
|
|
|
2>errors >out &&
|
git-send-email: add --transfer-encoding option
The thread at http://thread.gmane.org/gmane.comp.version-control.git/257392
details problems when applying patches with "git am" in a repository with
CRLF line endings. In the example in the thread, the repository originated
from "git-svn" so it is not possible to use core.eol and friends on it.
Right now, the best option is to use "git am --keep-cr". However, when
a patch create new files, the patch application process will reject the
new file because it finds a "/dev/null\r" string instead of "/dev/null".
The problem is that SMTP transport is CRLF-unsafe. Sending a patch by
email is the same as passing it through "dos2unix | unix2dos". The newly
introduced CRLFs are normally transparent because git-am strips them. The
keepcr=true setting preserves them, but it is mostly working by chance
and it would be very problematic to have a "git am" workflow in a
repository with mixed LF and CRLF line endings.
The MIME solution to this is the quoted-printable transfer enconding.
This is not something that we want to enable by default, since it makes
received emails horrible to look at. However, it is a very good match
for projects that store CRLF line endings in the repository.
The only disadvantage of quoted-printable is that quoted-printable
patches fail to apply if the maintainer uses "git am --keep-cr". This
is because the decoded patch will have two carriage returns at the end
of the line. Therefore, add support for base64 transfer encoding too,
which makes received emails downright impossible to look at outside
a MUA, but really just works.
The patch covers all bases, including users that still live in the late
80s, by also providing a 7bit content transfer encoding that refuses
to send emails with non-ASCII character in them. And finally, "8bit"
will add a Content-Transfer-Encoding header but otherwise do nothing.
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2014-11-25 15:00:27 +01:00
|
|
|
grep "cannot send message as 7bit" errors &&
|
|
|
|
test -z "$(ls msgtxt*)"
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success $PREREQ '--transfer-encoding overrides sendemail.transferEncoding' '
|
|
|
|
clean_fake_sendmail &&
|
2015-03-20 11:07:15 +01:00
|
|
|
git config sendemail.transferEncoding 8bit &&
|
git-send-email: add --transfer-encoding option
The thread at http://thread.gmane.org/gmane.comp.version-control.git/257392
details problems when applying patches with "git am" in a repository with
CRLF line endings. In the example in the thread, the repository originated
from "git-svn" so it is not possible to use core.eol and friends on it.
Right now, the best option is to use "git am --keep-cr". However, when
a patch create new files, the patch application process will reject the
new file because it finds a "/dev/null\r" string instead of "/dev/null".
The problem is that SMTP transport is CRLF-unsafe. Sending a patch by
email is the same as passing it through "dos2unix | unix2dos". The newly
introduced CRLFs are normally transparent because git-am strips them. The
keepcr=true setting preserves them, but it is mostly working by chance
and it would be very problematic to have a "git am" workflow in a
repository with mixed LF and CRLF line endings.
The MIME solution to this is the quoted-printable transfer enconding.
This is not something that we want to enable by default, since it makes
received emails horrible to look at. However, it is a very good match
for projects that store CRLF line endings in the repository.
The only disadvantage of quoted-printable is that quoted-printable
patches fail to apply if the maintainer uses "git am --keep-cr". This
is because the decoded patch will have two carriage returns at the end
of the line. Therefore, add support for base64 transfer encoding too,
which makes received emails downright impossible to look at outside
a MUA, but really just works.
The patch covers all bases, including users that still live in the late
80s, by also providing a 7bit content transfer encoding that refuses
to send emails with non-ASCII character in them. And finally, "8bit"
will add a Content-Transfer-Encoding header but otherwise do nothing.
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2014-11-25 15:00:27 +01:00
|
|
|
test_must_fail git send-email \
|
2014-11-25 23:14:41 +01:00
|
|
|
--transfer-encoding=7bit \
|
|
|
|
--smtp-server="$(pwd)/fake.sendmail" \
|
|
|
|
email-using-8bit \
|
|
|
|
2>errors >out &&
|
git-send-email: add --transfer-encoding option
The thread at http://thread.gmane.org/gmane.comp.version-control.git/257392
details problems when applying patches with "git am" in a repository with
CRLF line endings. In the example in the thread, the repository originated
from "git-svn" so it is not possible to use core.eol and friends on it.
Right now, the best option is to use "git am --keep-cr". However, when
a patch create new files, the patch application process will reject the
new file because it finds a "/dev/null\r" string instead of "/dev/null".
The problem is that SMTP transport is CRLF-unsafe. Sending a patch by
email is the same as passing it through "dos2unix | unix2dos". The newly
introduced CRLFs are normally transparent because git-am strips them. The
keepcr=true setting preserves them, but it is mostly working by chance
and it would be very problematic to have a "git am" workflow in a
repository with mixed LF and CRLF line endings.
The MIME solution to this is the quoted-printable transfer enconding.
This is not something that we want to enable by default, since it makes
received emails horrible to look at. However, it is a very good match
for projects that store CRLF line endings in the repository.
The only disadvantage of quoted-printable is that quoted-printable
patches fail to apply if the maintainer uses "git am --keep-cr". This
is because the decoded patch will have two carriage returns at the end
of the line. Therefore, add support for base64 transfer encoding too,
which makes received emails downright impossible to look at outside
a MUA, but really just works.
The patch covers all bases, including users that still live in the late
80s, by also providing a 7bit content transfer encoding that refuses
to send emails with non-ASCII character in them. And finally, "8bit"
will add a Content-Transfer-Encoding header but otherwise do nothing.
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2014-11-25 15:00:27 +01:00
|
|
|
grep "cannot send message as 7bit" errors &&
|
|
|
|
test -z "$(ls msgtxt*)"
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success $PREREQ 'sendemail.transferencoding=8bit' '
|
|
|
|
clean_fake_sendmail &&
|
|
|
|
git send-email \
|
2014-11-25 23:14:41 +01:00
|
|
|
--transfer-encoding=8bit \
|
|
|
|
--smtp-server="$(pwd)/fake.sendmail" \
|
|
|
|
email-using-8bit \
|
|
|
|
2>errors >out &&
|
git-send-email: add --transfer-encoding option
The thread at http://thread.gmane.org/gmane.comp.version-control.git/257392
details problems when applying patches with "git am" in a repository with
CRLF line endings. In the example in the thread, the repository originated
from "git-svn" so it is not possible to use core.eol and friends on it.
Right now, the best option is to use "git am --keep-cr". However, when
a patch create new files, the patch application process will reject the
new file because it finds a "/dev/null\r" string instead of "/dev/null".
The problem is that SMTP transport is CRLF-unsafe. Sending a patch by
email is the same as passing it through "dos2unix | unix2dos". The newly
introduced CRLFs are normally transparent because git-am strips them. The
keepcr=true setting preserves them, but it is mostly working by chance
and it would be very problematic to have a "git am" workflow in a
repository with mixed LF and CRLF line endings.
The MIME solution to this is the quoted-printable transfer enconding.
This is not something that we want to enable by default, since it makes
received emails horrible to look at. However, it is a very good match
for projects that store CRLF line endings in the repository.
The only disadvantage of quoted-printable is that quoted-printable
patches fail to apply if the maintainer uses "git am --keep-cr". This
is because the decoded patch will have two carriage returns at the end
of the line. Therefore, add support for base64 transfer encoding too,
which makes received emails downright impossible to look at outside
a MUA, but really just works.
The patch covers all bases, including users that still live in the late
80s, by also providing a 7bit content transfer encoding that refuses
to send emails with non-ASCII character in them. And finally, "8bit"
will add a Content-Transfer-Encoding header but otherwise do nothing.
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2014-11-25 15:00:27 +01:00
|
|
|
sed '1,/^$/d' msgtxt1 >actual &&
|
|
|
|
sed '1,/^$/d' email-using-8bit >expected &&
|
|
|
|
test_cmp expected actual
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success $PREREQ 'setup expect' '
|
2014-11-26 00:03:45 +01:00
|
|
|
cat >expected <<-\EOF
|
|
|
|
Dieser Betreff enth=C3=A4lt auch einen Umlaut!
|
|
|
|
EOF
|
git-send-email: add --transfer-encoding option
The thread at http://thread.gmane.org/gmane.comp.version-control.git/257392
details problems when applying patches with "git am" in a repository with
CRLF line endings. In the example in the thread, the repository originated
from "git-svn" so it is not possible to use core.eol and friends on it.
Right now, the best option is to use "git am --keep-cr". However, when
a patch create new files, the patch application process will reject the
new file because it finds a "/dev/null\r" string instead of "/dev/null".
The problem is that SMTP transport is CRLF-unsafe. Sending a patch by
email is the same as passing it through "dos2unix | unix2dos". The newly
introduced CRLFs are normally transparent because git-am strips them. The
keepcr=true setting preserves them, but it is mostly working by chance
and it would be very problematic to have a "git am" workflow in a
repository with mixed LF and CRLF line endings.
The MIME solution to this is the quoted-printable transfer enconding.
This is not something that we want to enable by default, since it makes
received emails horrible to look at. However, it is a very good match
for projects that store CRLF line endings in the repository.
The only disadvantage of quoted-printable is that quoted-printable
patches fail to apply if the maintainer uses "git am --keep-cr". This
is because the decoded patch will have two carriage returns at the end
of the line. Therefore, add support for base64 transfer encoding too,
which makes received emails downright impossible to look at outside
a MUA, but really just works.
The patch covers all bases, including users that still live in the late
80s, by also providing a 7bit content transfer encoding that refuses
to send emails with non-ASCII character in them. And finally, "8bit"
will add a Content-Transfer-Encoding header but otherwise do nothing.
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2014-11-25 15:00:27 +01:00
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success $PREREQ '8-bit and sendemail.transferencoding=quoted-printable' '
|
|
|
|
clean_fake_sendmail &&
|
|
|
|
git send-email \
|
2014-11-25 23:14:41 +01:00
|
|
|
--transfer-encoding=quoted-printable \
|
|
|
|
--smtp-server="$(pwd)/fake.sendmail" \
|
|
|
|
email-using-8bit \
|
|
|
|
2>errors >out &&
|
git-send-email: add --transfer-encoding option
The thread at http://thread.gmane.org/gmane.comp.version-control.git/257392
details problems when applying patches with "git am" in a repository with
CRLF line endings. In the example in the thread, the repository originated
from "git-svn" so it is not possible to use core.eol and friends on it.
Right now, the best option is to use "git am --keep-cr". However, when
a patch create new files, the patch application process will reject the
new file because it finds a "/dev/null\r" string instead of "/dev/null".
The problem is that SMTP transport is CRLF-unsafe. Sending a patch by
email is the same as passing it through "dos2unix | unix2dos". The newly
introduced CRLFs are normally transparent because git-am strips them. The
keepcr=true setting preserves them, but it is mostly working by chance
and it would be very problematic to have a "git am" workflow in a
repository with mixed LF and CRLF line endings.
The MIME solution to this is the quoted-printable transfer enconding.
This is not something that we want to enable by default, since it makes
received emails horrible to look at. However, it is a very good match
for projects that store CRLF line endings in the repository.
The only disadvantage of quoted-printable is that quoted-printable
patches fail to apply if the maintainer uses "git am --keep-cr". This
is because the decoded patch will have two carriage returns at the end
of the line. Therefore, add support for base64 transfer encoding too,
which makes received emails downright impossible to look at outside
a MUA, but really just works.
The patch covers all bases, including users that still live in the late
80s, by also providing a 7bit content transfer encoding that refuses
to send emails with non-ASCII character in them. And finally, "8bit"
will add a Content-Transfer-Encoding header but otherwise do nothing.
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2014-11-25 15:00:27 +01:00
|
|
|
sed '1,/^$/d' msgtxt1 >actual &&
|
|
|
|
test_cmp expected actual
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success $PREREQ 'setup expect' '
|
2014-11-26 00:03:45 +01:00
|
|
|
cat >expected <<-\EOF
|
|
|
|
RGllc2VyIEJldHJlZmYgZW50aMOkbHQgYXVjaCBlaW5lbiBVbWxhdXQhCg==
|
|
|
|
EOF
|
git-send-email: add --transfer-encoding option
The thread at http://thread.gmane.org/gmane.comp.version-control.git/257392
details problems when applying patches with "git am" in a repository with
CRLF line endings. In the example in the thread, the repository originated
from "git-svn" so it is not possible to use core.eol and friends on it.
Right now, the best option is to use "git am --keep-cr". However, when
a patch create new files, the patch application process will reject the
new file because it finds a "/dev/null\r" string instead of "/dev/null".
The problem is that SMTP transport is CRLF-unsafe. Sending a patch by
email is the same as passing it through "dos2unix | unix2dos". The newly
introduced CRLFs are normally transparent because git-am strips them. The
keepcr=true setting preserves them, but it is mostly working by chance
and it would be very problematic to have a "git am" workflow in a
repository with mixed LF and CRLF line endings.
The MIME solution to this is the quoted-printable transfer enconding.
This is not something that we want to enable by default, since it makes
received emails horrible to look at. However, it is a very good match
for projects that store CRLF line endings in the repository.
The only disadvantage of quoted-printable is that quoted-printable
patches fail to apply if the maintainer uses "git am --keep-cr". This
is because the decoded patch will have two carriage returns at the end
of the line. Therefore, add support for base64 transfer encoding too,
which makes received emails downright impossible to look at outside
a MUA, but really just works.
The patch covers all bases, including users that still live in the late
80s, by also providing a 7bit content transfer encoding that refuses
to send emails with non-ASCII character in them. And finally, "8bit"
will add a Content-Transfer-Encoding header but otherwise do nothing.
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2014-11-25 15:00:27 +01:00
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success $PREREQ '8-bit and sendemail.transferencoding=base64' '
|
|
|
|
clean_fake_sendmail &&
|
|
|
|
git send-email \
|
2014-11-25 23:14:41 +01:00
|
|
|
--transfer-encoding=base64 \
|
|
|
|
--smtp-server="$(pwd)/fake.sendmail" \
|
|
|
|
email-using-8bit \
|
|
|
|
2>errors >out &&
|
git-send-email: add --transfer-encoding option
The thread at http://thread.gmane.org/gmane.comp.version-control.git/257392
details problems when applying patches with "git am" in a repository with
CRLF line endings. In the example in the thread, the repository originated
from "git-svn" so it is not possible to use core.eol and friends on it.
Right now, the best option is to use "git am --keep-cr". However, when
a patch create new files, the patch application process will reject the
new file because it finds a "/dev/null\r" string instead of "/dev/null".
The problem is that SMTP transport is CRLF-unsafe. Sending a patch by
email is the same as passing it through "dos2unix | unix2dos". The newly
introduced CRLFs are normally transparent because git-am strips them. The
keepcr=true setting preserves them, but it is mostly working by chance
and it would be very problematic to have a "git am" workflow in a
repository with mixed LF and CRLF line endings.
The MIME solution to this is the quoted-printable transfer enconding.
This is not something that we want to enable by default, since it makes
received emails horrible to look at. However, it is a very good match
for projects that store CRLF line endings in the repository.
The only disadvantage of quoted-printable is that quoted-printable
patches fail to apply if the maintainer uses "git am --keep-cr". This
is because the decoded patch will have two carriage returns at the end
of the line. Therefore, add support for base64 transfer encoding too,
which makes received emails downright impossible to look at outside
a MUA, but really just works.
The patch covers all bases, including users that still live in the late
80s, by also providing a 7bit content transfer encoding that refuses
to send emails with non-ASCII character in them. And finally, "8bit"
will add a Content-Transfer-Encoding header but otherwise do nothing.
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2014-11-25 15:00:27 +01:00
|
|
|
sed '1,/^$/d' msgtxt1 >actual &&
|
|
|
|
test_cmp expected actual
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success $PREREQ 'setup expect' '
|
2014-11-26 00:03:45 +01:00
|
|
|
cat >email-using-qp <<-\EOF
|
|
|
|
From fe6ecc66ece37198fe5db91fa2fc41d9f4fe5cc4 Mon Sep 17 00:00:00 2001
|
|
|
|
Message-Id: <bogus-message-id@example.com>
|
|
|
|
From: A U Thor <author@example.com>
|
|
|
|
Date: Sat, 12 Jun 2010 15:53:58 +0200
|
|
|
|
MIME-Version: 1.0
|
|
|
|
Content-Transfer-Encoding: quoted-printable
|
|
|
|
Content-Type: text/plain; charset=UTF-8
|
|
|
|
Subject: Nothing to see here.
|
git-send-email: add --transfer-encoding option
The thread at http://thread.gmane.org/gmane.comp.version-control.git/257392
details problems when applying patches with "git am" in a repository with
CRLF line endings. In the example in the thread, the repository originated
from "git-svn" so it is not possible to use core.eol and friends on it.
Right now, the best option is to use "git am --keep-cr". However, when
a patch create new files, the patch application process will reject the
new file because it finds a "/dev/null\r" string instead of "/dev/null".
The problem is that SMTP transport is CRLF-unsafe. Sending a patch by
email is the same as passing it through "dos2unix | unix2dos". The newly
introduced CRLFs are normally transparent because git-am strips them. The
keepcr=true setting preserves them, but it is mostly working by chance
and it would be very problematic to have a "git am" workflow in a
repository with mixed LF and CRLF line endings.
The MIME solution to this is the quoted-printable transfer enconding.
This is not something that we want to enable by default, since it makes
received emails horrible to look at. However, it is a very good match
for projects that store CRLF line endings in the repository.
The only disadvantage of quoted-printable is that quoted-printable
patches fail to apply if the maintainer uses "git am --keep-cr". This
is because the decoded patch will have two carriage returns at the end
of the line. Therefore, add support for base64 transfer encoding too,
which makes received emails downright impossible to look at outside
a MUA, but really just works.
The patch covers all bases, including users that still live in the late
80s, by also providing a 7bit content transfer encoding that refuses
to send emails with non-ASCII character in them. And finally, "8bit"
will add a Content-Transfer-Encoding header but otherwise do nothing.
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2014-11-25 15:00:27 +01:00
|
|
|
|
2014-11-26 00:03:45 +01:00
|
|
|
Dieser Betreff enth=C3=A4lt auch einen Umlaut!
|
|
|
|
EOF
|
git-send-email: add --transfer-encoding option
The thread at http://thread.gmane.org/gmane.comp.version-control.git/257392
details problems when applying patches with "git am" in a repository with
CRLF line endings. In the example in the thread, the repository originated
from "git-svn" so it is not possible to use core.eol and friends on it.
Right now, the best option is to use "git am --keep-cr". However, when
a patch create new files, the patch application process will reject the
new file because it finds a "/dev/null\r" string instead of "/dev/null".
The problem is that SMTP transport is CRLF-unsafe. Sending a patch by
email is the same as passing it through "dos2unix | unix2dos". The newly
introduced CRLFs are normally transparent because git-am strips them. The
keepcr=true setting preserves them, but it is mostly working by chance
and it would be very problematic to have a "git am" workflow in a
repository with mixed LF and CRLF line endings.
The MIME solution to this is the quoted-printable transfer enconding.
This is not something that we want to enable by default, since it makes
received emails horrible to look at. However, it is a very good match
for projects that store CRLF line endings in the repository.
The only disadvantage of quoted-printable is that quoted-printable
patches fail to apply if the maintainer uses "git am --keep-cr". This
is because the decoded patch will have two carriage returns at the end
of the line. Therefore, add support for base64 transfer encoding too,
which makes received emails downright impossible to look at outside
a MUA, but really just works.
The patch covers all bases, including users that still live in the late
80s, by also providing a 7bit content transfer encoding that refuses
to send emails with non-ASCII character in them. And finally, "8bit"
will add a Content-Transfer-Encoding header but otherwise do nothing.
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2014-11-25 15:00:27 +01:00
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success $PREREQ 'convert from quoted-printable to base64' '
|
|
|
|
clean_fake_sendmail &&
|
|
|
|
git send-email \
|
2014-11-25 23:14:41 +01:00
|
|
|
--transfer-encoding=base64 \
|
|
|
|
--smtp-server="$(pwd)/fake.sendmail" \
|
|
|
|
email-using-qp \
|
|
|
|
2>errors >out &&
|
git-send-email: add --transfer-encoding option
The thread at http://thread.gmane.org/gmane.comp.version-control.git/257392
details problems when applying patches with "git am" in a repository with
CRLF line endings. In the example in the thread, the repository originated
from "git-svn" so it is not possible to use core.eol and friends on it.
Right now, the best option is to use "git am --keep-cr". However, when
a patch create new files, the patch application process will reject the
new file because it finds a "/dev/null\r" string instead of "/dev/null".
The problem is that SMTP transport is CRLF-unsafe. Sending a patch by
email is the same as passing it through "dos2unix | unix2dos". The newly
introduced CRLFs are normally transparent because git-am strips them. The
keepcr=true setting preserves them, but it is mostly working by chance
and it would be very problematic to have a "git am" workflow in a
repository with mixed LF and CRLF line endings.
The MIME solution to this is the quoted-printable transfer enconding.
This is not something that we want to enable by default, since it makes
received emails horrible to look at. However, it is a very good match
for projects that store CRLF line endings in the repository.
The only disadvantage of quoted-printable is that quoted-printable
patches fail to apply if the maintainer uses "git am --keep-cr". This
is because the decoded patch will have two carriage returns at the end
of the line. Therefore, add support for base64 transfer encoding too,
which makes received emails downright impossible to look at outside
a MUA, but really just works.
The patch covers all bases, including users that still live in the late
80s, by also providing a 7bit content transfer encoding that refuses
to send emails with non-ASCII character in them. And finally, "8bit"
will add a Content-Transfer-Encoding header but otherwise do nothing.
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2014-11-25 15:00:27 +01:00
|
|
|
sed '1,/^$/d' msgtxt1 >actual &&
|
|
|
|
test_cmp expected actual
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success $PREREQ 'setup expect' "
|
2014-11-25 23:52:42 +01:00
|
|
|
tr -d '\\015' | tr '%' '\\015' >email-using-crlf <<EOF
|
git-send-email: add --transfer-encoding option
The thread at http://thread.gmane.org/gmane.comp.version-control.git/257392
details problems when applying patches with "git am" in a repository with
CRLF line endings. In the example in the thread, the repository originated
from "git-svn" so it is not possible to use core.eol and friends on it.
Right now, the best option is to use "git am --keep-cr". However, when
a patch create new files, the patch application process will reject the
new file because it finds a "/dev/null\r" string instead of "/dev/null".
The problem is that SMTP transport is CRLF-unsafe. Sending a patch by
email is the same as passing it through "dos2unix | unix2dos". The newly
introduced CRLFs are normally transparent because git-am strips them. The
keepcr=true setting preserves them, but it is mostly working by chance
and it would be very problematic to have a "git am" workflow in a
repository with mixed LF and CRLF line endings.
The MIME solution to this is the quoted-printable transfer enconding.
This is not something that we want to enable by default, since it makes
received emails horrible to look at. However, it is a very good match
for projects that store CRLF line endings in the repository.
The only disadvantage of quoted-printable is that quoted-printable
patches fail to apply if the maintainer uses "git am --keep-cr". This
is because the decoded patch will have two carriage returns at the end
of the line. Therefore, add support for base64 transfer encoding too,
which makes received emails downright impossible to look at outside
a MUA, but really just works.
The patch covers all bases, including users that still live in the late
80s, by also providing a 7bit content transfer encoding that refuses
to send emails with non-ASCII character in them. And finally, "8bit"
will add a Content-Transfer-Encoding header but otherwise do nothing.
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2014-11-25 15:00:27 +01:00
|
|
|
From fe6ecc66ece37198fe5db91fa2fc41d9f4fe5cc4 Mon Sep 17 00:00:00 2001
|
|
|
|
Message-Id: <bogus-message-id@example.com>
|
|
|
|
From: A U Thor <author@example.com>
|
|
|
|
Date: Sat, 12 Jun 2010 15:53:58 +0200
|
|
|
|
Content-Type: text/plain; charset=UTF-8
|
|
|
|
Subject: Nothing to see here.
|
|
|
|
|
|
|
|
Look, I have a CRLF and an = sign!%
|
|
|
|
EOF
|
|
|
|
"
|
|
|
|
|
|
|
|
test_expect_success $PREREQ 'setup expect' '
|
2014-11-26 00:03:45 +01:00
|
|
|
cat >expected <<-\EOF
|
|
|
|
Look, I have a CRLF and an =3D sign!=0D
|
|
|
|
EOF
|
git-send-email: add --transfer-encoding option
The thread at http://thread.gmane.org/gmane.comp.version-control.git/257392
details problems when applying patches with "git am" in a repository with
CRLF line endings. In the example in the thread, the repository originated
from "git-svn" so it is not possible to use core.eol and friends on it.
Right now, the best option is to use "git am --keep-cr". However, when
a patch create new files, the patch application process will reject the
new file because it finds a "/dev/null\r" string instead of "/dev/null".
The problem is that SMTP transport is CRLF-unsafe. Sending a patch by
email is the same as passing it through "dos2unix | unix2dos". The newly
introduced CRLFs are normally transparent because git-am strips them. The
keepcr=true setting preserves them, but it is mostly working by chance
and it would be very problematic to have a "git am" workflow in a
repository with mixed LF and CRLF line endings.
The MIME solution to this is the quoted-printable transfer enconding.
This is not something that we want to enable by default, since it makes
received emails horrible to look at. However, it is a very good match
for projects that store CRLF line endings in the repository.
The only disadvantage of quoted-printable is that quoted-printable
patches fail to apply if the maintainer uses "git am --keep-cr". This
is because the decoded patch will have two carriage returns at the end
of the line. Therefore, add support for base64 transfer encoding too,
which makes received emails downright impossible to look at outside
a MUA, but really just works.
The patch covers all bases, including users that still live in the late
80s, by also providing a 7bit content transfer encoding that refuses
to send emails with non-ASCII character in them. And finally, "8bit"
will add a Content-Transfer-Encoding header but otherwise do nothing.
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2014-11-25 15:00:27 +01:00
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success $PREREQ 'CRLF and sendemail.transferencoding=quoted-printable' '
|
|
|
|
clean_fake_sendmail &&
|
|
|
|
git send-email \
|
2014-11-25 23:14:41 +01:00
|
|
|
--transfer-encoding=quoted-printable \
|
|
|
|
--smtp-server="$(pwd)/fake.sendmail" \
|
|
|
|
email-using-crlf \
|
|
|
|
2>errors >out &&
|
git-send-email: add --transfer-encoding option
The thread at http://thread.gmane.org/gmane.comp.version-control.git/257392
details problems when applying patches with "git am" in a repository with
CRLF line endings. In the example in the thread, the repository originated
from "git-svn" so it is not possible to use core.eol and friends on it.
Right now, the best option is to use "git am --keep-cr". However, when
a patch create new files, the patch application process will reject the
new file because it finds a "/dev/null\r" string instead of "/dev/null".
The problem is that SMTP transport is CRLF-unsafe. Sending a patch by
email is the same as passing it through "dos2unix | unix2dos". The newly
introduced CRLFs are normally transparent because git-am strips them. The
keepcr=true setting preserves them, but it is mostly working by chance
and it would be very problematic to have a "git am" workflow in a
repository with mixed LF and CRLF line endings.
The MIME solution to this is the quoted-printable transfer enconding.
This is not something that we want to enable by default, since it makes
received emails horrible to look at. However, it is a very good match
for projects that store CRLF line endings in the repository.
The only disadvantage of quoted-printable is that quoted-printable
patches fail to apply if the maintainer uses "git am --keep-cr". This
is because the decoded patch will have two carriage returns at the end
of the line. Therefore, add support for base64 transfer encoding too,
which makes received emails downright impossible to look at outside
a MUA, but really just works.
The patch covers all bases, including users that still live in the late
80s, by also providing a 7bit content transfer encoding that refuses
to send emails with non-ASCII character in them. And finally, "8bit"
will add a Content-Transfer-Encoding header but otherwise do nothing.
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2014-11-25 15:00:27 +01:00
|
|
|
sed '1,/^$/d' msgtxt1 >actual &&
|
|
|
|
test_cmp expected actual
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success $PREREQ 'setup expect' '
|
2014-11-26 00:03:45 +01:00
|
|
|
cat >expected <<-\EOF
|
|
|
|
TG9vaywgSSBoYXZlIGEgQ1JMRiBhbmQgYW4gPSBzaWduIQ0K
|
|
|
|
EOF
|
git-send-email: add --transfer-encoding option
The thread at http://thread.gmane.org/gmane.comp.version-control.git/257392
details problems when applying patches with "git am" in a repository with
CRLF line endings. In the example in the thread, the repository originated
from "git-svn" so it is not possible to use core.eol and friends on it.
Right now, the best option is to use "git am --keep-cr". However, when
a patch create new files, the patch application process will reject the
new file because it finds a "/dev/null\r" string instead of "/dev/null".
The problem is that SMTP transport is CRLF-unsafe. Sending a patch by
email is the same as passing it through "dos2unix | unix2dos". The newly
introduced CRLFs are normally transparent because git-am strips them. The
keepcr=true setting preserves them, but it is mostly working by chance
and it would be very problematic to have a "git am" workflow in a
repository with mixed LF and CRLF line endings.
The MIME solution to this is the quoted-printable transfer enconding.
This is not something that we want to enable by default, since it makes
received emails horrible to look at. However, it is a very good match
for projects that store CRLF line endings in the repository.
The only disadvantage of quoted-printable is that quoted-printable
patches fail to apply if the maintainer uses "git am --keep-cr". This
is because the decoded patch will have two carriage returns at the end
of the line. Therefore, add support for base64 transfer encoding too,
which makes received emails downright impossible to look at outside
a MUA, but really just works.
The patch covers all bases, including users that still live in the late
80s, by also providing a 7bit content transfer encoding that refuses
to send emails with non-ASCII character in them. And finally, "8bit"
will add a Content-Transfer-Encoding header but otherwise do nothing.
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2014-11-25 15:00:27 +01:00
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success $PREREQ 'CRLF and sendemail.transferencoding=base64' '
|
|
|
|
clean_fake_sendmail &&
|
|
|
|
git send-email \
|
2014-11-25 23:14:41 +01:00
|
|
|
--transfer-encoding=base64 \
|
|
|
|
--smtp-server="$(pwd)/fake.sendmail" \
|
|
|
|
email-using-crlf \
|
|
|
|
2>errors >out &&
|
git-send-email: add --transfer-encoding option
The thread at http://thread.gmane.org/gmane.comp.version-control.git/257392
details problems when applying patches with "git am" in a repository with
CRLF line endings. In the example in the thread, the repository originated
from "git-svn" so it is not possible to use core.eol and friends on it.
Right now, the best option is to use "git am --keep-cr". However, when
a patch create new files, the patch application process will reject the
new file because it finds a "/dev/null\r" string instead of "/dev/null".
The problem is that SMTP transport is CRLF-unsafe. Sending a patch by
email is the same as passing it through "dos2unix | unix2dos". The newly
introduced CRLFs are normally transparent because git-am strips them. The
keepcr=true setting preserves them, but it is mostly working by chance
and it would be very problematic to have a "git am" workflow in a
repository with mixed LF and CRLF line endings.
The MIME solution to this is the quoted-printable transfer enconding.
This is not something that we want to enable by default, since it makes
received emails horrible to look at. However, it is a very good match
for projects that store CRLF line endings in the repository.
The only disadvantage of quoted-printable is that quoted-printable
patches fail to apply if the maintainer uses "git am --keep-cr". This
is because the decoded patch will have two carriage returns at the end
of the line. Therefore, add support for base64 transfer encoding too,
which makes received emails downright impossible to look at outside
a MUA, but really just works.
The patch covers all bases, including users that still live in the late
80s, by also providing a 7bit content transfer encoding that refuses
to send emails with non-ASCII character in them. And finally, "8bit"
will add a Content-Transfer-Encoding header but otherwise do nothing.
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2014-11-25 15:00:27 +01:00
|
|
|
sed '1,/^$/d' msgtxt1 >actual &&
|
|
|
|
test_cmp expected actual
|
|
|
|
'
|
|
|
|
|
|
|
|
|
2009-06-08 23:34:12 +02:00
|
|
|
# Note that the patches in this test are deliberately out of order; we
|
|
|
|
# want to make sure it works even if the cover-letter is not in the
|
|
|
|
# first mail.
|
2010-12-29 22:02:31 +01:00
|
|
|
test_expect_success $PREREQ 'refusing to send cover letter template' '
|
2009-06-08 23:34:12 +02:00
|
|
|
clean_fake_sendmail &&
|
|
|
|
rm -fr outdir &&
|
|
|
|
git format-patch --cover-letter -2 -o outdir &&
|
|
|
|
test_must_fail git send-email \
|
2014-11-25 23:14:41 +01:00
|
|
|
--from="Example <nobody@example.com>" \
|
|
|
|
--to=nobody@example.com \
|
|
|
|
--smtp-server="$(pwd)/fake.sendmail" \
|
|
|
|
outdir/0002-*.patch \
|
|
|
|
outdir/0000-*.patch \
|
|
|
|
outdir/0001-*.patch \
|
|
|
|
2>errors >out &&
|
2009-06-08 23:34:12 +02:00
|
|
|
grep "SUBJECT HERE" errors &&
|
|
|
|
test -z "$(ls msgtxt*)"
|
|
|
|
'
|
|
|
|
|
2010-12-29 22:02:31 +01:00
|
|
|
test_expect_success $PREREQ '--force sends cover letter template anyway' '
|
2009-06-08 23:34:12 +02:00
|
|
|
clean_fake_sendmail &&
|
|
|
|
rm -fr outdir &&
|
|
|
|
git format-patch --cover-letter -2 -o outdir &&
|
|
|
|
git send-email \
|
2014-11-25 23:14:41 +01:00
|
|
|
--force \
|
|
|
|
--from="Example <nobody@example.com>" \
|
|
|
|
--to=nobody@example.com \
|
|
|
|
--smtp-server="$(pwd)/fake.sendmail" \
|
|
|
|
outdir/0002-*.patch \
|
|
|
|
outdir/0000-*.patch \
|
|
|
|
outdir/0001-*.patch \
|
|
|
|
2>errors >out &&
|
2009-06-08 23:34:12 +02:00
|
|
|
! grep "SUBJECT HERE" errors &&
|
|
|
|
test -n "$(ls msgtxt*)"
|
|
|
|
'
|
|
|
|
|
2014-04-29 07:41:18 +02:00
|
|
|
test_cover_addresses () {
|
|
|
|
header="$1"
|
|
|
|
shift
|
|
|
|
clean_fake_sendmail &&
|
|
|
|
rm -fr outdir &&
|
|
|
|
git format-patch --cover-letter -2 -o outdir &&
|
|
|
|
cover=`echo outdir/0000-*.patch` &&
|
|
|
|
mv $cover cover-to-edit.patch &&
|
2014-06-10 06:07:59 +02:00
|
|
|
perl -pe "s/^From:/$header: extra\@address.com\nFrom:/" cover-to-edit.patch >"$cover" &&
|
2014-04-29 07:41:18 +02:00
|
|
|
git send-email \
|
2014-11-25 23:14:41 +01:00
|
|
|
--force \
|
|
|
|
--from="Example <nobody@example.com>" \
|
|
|
|
--no-to --no-cc \
|
|
|
|
"$@" \
|
|
|
|
--smtp-server="$(pwd)/fake.sendmail" \
|
|
|
|
outdir/0000-*.patch \
|
|
|
|
outdir/0001-*.patch \
|
|
|
|
outdir/0002-*.patch \
|
|
|
|
2>errors >out &&
|
2014-04-29 07:41:18 +02:00
|
|
|
grep "^$header: extra@address.com" msgtxt1 >to1 &&
|
|
|
|
grep "^$header: extra@address.com" msgtxt2 >to2 &&
|
|
|
|
grep "^$header: extra@address.com" msgtxt3 >to3 &&
|
|
|
|
test_line_count = 1 to1 &&
|
|
|
|
test_line_count = 1 to2 &&
|
|
|
|
test_line_count = 1 to3
|
|
|
|
}
|
|
|
|
|
|
|
|
test_expect_success $PREREQ 'to-cover adds To to all mail' '
|
|
|
|
test_cover_addresses "To" --to-cover
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success $PREREQ 'cc-cover adds Cc to all mail' '
|
|
|
|
test_cover_addresses "Cc" --cc-cover
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success $PREREQ 'tocover adds To to all mail' '
|
|
|
|
test_config sendemail.tocover true &&
|
|
|
|
test_cover_addresses "To"
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success $PREREQ 'cccover adds Cc to all mail' '
|
|
|
|
test_config sendemail.cccover true &&
|
|
|
|
test_cover_addresses "Cc"
|
|
|
|
'
|
|
|
|
|
send-email: Fix %config_path_settings handling
cec5dae (use new Git::config_path() for aliasesfile, 2011-09-30) broke
the expansion of aliases.
This was caused by treating %config_path_settings, newly introduced in
said patch, like %config_bool_settings instead of like %config_settings.
Copy from %config_settings, making it more readable.
While at it add basic test for expansion of aliases, and for path
expansion, which would catch this error.
Nb. there were a few issues that were responsible for this error:
1. %config_bool_settings and %config_settings despite similar name have
different semantic.
%config_bool_settings values are arrays where the first element is
(reference to) the variable to set, and second element is default
value... which admittedly is a bit cryptic. More readable if more
verbose option would be to use hash reference, e.g.:
my %config_bool_settings = (
"thread" => { variable => \$thread, default => 1},
[...]
%config_settings values are either either reference to scalar variable
or reference to array. In second case it means that option (or config
option) is multi-valued. BTW. this is similar to what Getopt::Long does.
2. In cec5dae (use new Git::config_path() for aliasesfile, 2011-09-30)
the setting "aliasesfile" was moved from %config_settings to newly
introduced %config_path_settings. But the loop that parses settings
from %config_path_settings was copy'n'pasted *wrongly* from
%config_bool_settings instead of from %config_settings.
It looks like cec5dae author cargo-culted this change...
3. 994d6c6 (send-email: address expansion for common mailers, 2006-05-14)
didn't add test for alias expansion to t9001-send-email.sh
Signed-off-by: Cord Seele <cowose@gmail.com>
Tested-by: Michael J Gruber <git@drmicha.warpmail.net>
Signed-off-by: Jakub Narebski <jnareb@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-10-14 22:53:31 +02:00
|
|
|
test_expect_success $PREREQ 'sendemail.aliasfiletype=mailrc' '
|
|
|
|
clean_fake_sendmail &&
|
|
|
|
echo "alias sbd somebody@example.org" >.mailrc &&
|
|
|
|
git config --replace-all sendemail.aliasesfile "$(pwd)/.mailrc" &&
|
|
|
|
git config sendemail.aliasfiletype mailrc &&
|
|
|
|
git send-email \
|
2014-11-25 23:14:41 +01:00
|
|
|
--from="Example <nobody@example.com>" \
|
|
|
|
--to=sbd \
|
|
|
|
--smtp-server="$(pwd)/fake.sendmail" \
|
|
|
|
outdir/0001-*.patch \
|
|
|
|
2>errors >out &&
|
send-email: Fix %config_path_settings handling
cec5dae (use new Git::config_path() for aliasesfile, 2011-09-30) broke
the expansion of aliases.
This was caused by treating %config_path_settings, newly introduced in
said patch, like %config_bool_settings instead of like %config_settings.
Copy from %config_settings, making it more readable.
While at it add basic test for expansion of aliases, and for path
expansion, which would catch this error.
Nb. there were a few issues that were responsible for this error:
1. %config_bool_settings and %config_settings despite similar name have
different semantic.
%config_bool_settings values are arrays where the first element is
(reference to) the variable to set, and second element is default
value... which admittedly is a bit cryptic. More readable if more
verbose option would be to use hash reference, e.g.:
my %config_bool_settings = (
"thread" => { variable => \$thread, default => 1},
[...]
%config_settings values are either either reference to scalar variable
or reference to array. In second case it means that option (or config
option) is multi-valued. BTW. this is similar to what Getopt::Long does.
2. In cec5dae (use new Git::config_path() for aliasesfile, 2011-09-30)
the setting "aliasesfile" was moved from %config_settings to newly
introduced %config_path_settings. But the loop that parses settings
from %config_path_settings was copy'n'pasted *wrongly* from
%config_bool_settings instead of from %config_settings.
It looks like cec5dae author cargo-culted this change...
3. 994d6c6 (send-email: address expansion for common mailers, 2006-05-14)
didn't add test for alias expansion to t9001-send-email.sh
Signed-off-by: Cord Seele <cowose@gmail.com>
Tested-by: Michael J Gruber <git@drmicha.warpmail.net>
Signed-off-by: Jakub Narebski <jnareb@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-10-14 22:53:31 +02:00
|
|
|
grep "^!somebody@example\.org!$" commandline1
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success $PREREQ 'sendemail.aliasfile=~/.mailrc' '
|
|
|
|
clean_fake_sendmail &&
|
|
|
|
echo "alias sbd someone@example.org" >~/.mailrc &&
|
|
|
|
git config --replace-all sendemail.aliasesfile "~/.mailrc" &&
|
|
|
|
git config sendemail.aliasfiletype mailrc &&
|
|
|
|
git send-email \
|
2014-11-25 23:14:41 +01:00
|
|
|
--from="Example <nobody@example.com>" \
|
|
|
|
--to=sbd \
|
|
|
|
--smtp-server="$(pwd)/fake.sendmail" \
|
|
|
|
outdir/0001-*.patch \
|
|
|
|
2>errors >out &&
|
send-email: Fix %config_path_settings handling
cec5dae (use new Git::config_path() for aliasesfile, 2011-09-30) broke
the expansion of aliases.
This was caused by treating %config_path_settings, newly introduced in
said patch, like %config_bool_settings instead of like %config_settings.
Copy from %config_settings, making it more readable.
While at it add basic test for expansion of aliases, and for path
expansion, which would catch this error.
Nb. there were a few issues that were responsible for this error:
1. %config_bool_settings and %config_settings despite similar name have
different semantic.
%config_bool_settings values are arrays where the first element is
(reference to) the variable to set, and second element is default
value... which admittedly is a bit cryptic. More readable if more
verbose option would be to use hash reference, e.g.:
my %config_bool_settings = (
"thread" => { variable => \$thread, default => 1},
[...]
%config_settings values are either either reference to scalar variable
or reference to array. In second case it means that option (or config
option) is multi-valued. BTW. this is similar to what Getopt::Long does.
2. In cec5dae (use new Git::config_path() for aliasesfile, 2011-09-30)
the setting "aliasesfile" was moved from %config_settings to newly
introduced %config_path_settings. But the loop that parses settings
from %config_path_settings was copy'n'pasted *wrongly* from
%config_bool_settings instead of from %config_settings.
It looks like cec5dae author cargo-culted this change...
3. 994d6c6 (send-email: address expansion for common mailers, 2006-05-14)
didn't add test for alias expansion to t9001-send-email.sh
Signed-off-by: Cord Seele <cowose@gmail.com>
Tested-by: Michael J Gruber <git@drmicha.warpmail.net>
Signed-off-by: Jakub Narebski <jnareb@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-10-14 22:53:31 +02:00
|
|
|
grep "^!someone@example\.org!$" commandline1
|
|
|
|
'
|
|
|
|
|
2014-12-04 20:11:30 +01:00
|
|
|
do_xmailer_test () {
|
|
|
|
expected=$1 params=$2 &&
|
|
|
|
git format-patch -1 &&
|
|
|
|
git send-email \
|
|
|
|
--from="Example <nobody@example.com>" \
|
|
|
|
--to=someone@example.com \
|
|
|
|
--smtp-server="$(pwd)/fake.sendmail" \
|
|
|
|
$params \
|
|
|
|
0001-*.patch \
|
|
|
|
2>errors >out &&
|
|
|
|
{ grep '^X-Mailer:' out || :; } >mailer &&
|
|
|
|
test_line_count = $expected mailer
|
|
|
|
}
|
|
|
|
|
|
|
|
test_expect_success $PREREQ '--[no-]xmailer without any configuration' '
|
|
|
|
do_xmailer_test 1 "--xmailer" &&
|
|
|
|
do_xmailer_test 0 "--no-xmailer"
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success $PREREQ '--[no-]xmailer with sendemail.xmailer=true' '
|
|
|
|
test_config sendemail.xmailer true &&
|
|
|
|
do_xmailer_test 1 "" &&
|
|
|
|
do_xmailer_test 0 "--no-xmailer" &&
|
|
|
|
do_xmailer_test 1 "--xmailer"
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success $PREREQ '--[no-]xmailer with sendemail.xmailer=false' '
|
|
|
|
test_config sendemail.xmailer false &&
|
|
|
|
do_xmailer_test 0 "" &&
|
|
|
|
do_xmailer_test 0 "--no-xmailer" &&
|
|
|
|
do_xmailer_test 1 "--xmailer"
|
|
|
|
'
|
|
|
|
|
2006-05-29 21:30:15 +02:00
|
|
|
test_done
|