debian/notmuch
1
0
Fork 0
mirror of https://git.notmuchmail.org/git/notmuch synced 2024-11-22 10:58:10 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions
notmuch/test/notmuch-test

386 lines
10 KiB
Text
Raw Normal View History

notmuch-test: Use named-parameters for generate_message function This makes the test suite bash-specific, but that's not much of an issue for me, (if somebody else would prefer some other language then they can rewrite the test suite and maintain it). The advantage here is that we'll now be able to easily generate custom messages for testing operations that depend on the message content, (such as "notmuch reply", etc.).
2010-02-04 02:24:01 +01:00
#!/bin/bash
Add a very rough beginning of a test suite. This notmuch-test script simply runs a few different notmuch operations, (things that I found were useful while testing the rename-support code). It's not useful as a test suite yet, since it doesn't actually check the results of any operation, (the user of the suite has to know what the results should be and must manually verify them. So there's no integration with the build system yet, (no "make test" target). But I didn't want to lose what I had so far, so here it is.
2010-01-23 19:36:39 +01:00
set -e
find_notmuch_binary ()
{
dir=$1
while [ -n "$dir" ]; do
bin=$dir/notmuch
if [ -x $bin ]; then
echo $bin
return
fi
dir=$(dirname $dir)
if [ "$dir" = "/" ]; then
break
fi
done
echo notmuch
}
notmuch-test: Eliminate sleeps to speed up test suite run We were sleeping merely to ensure that our updates to the mail store would result in the mtime of the appropriate directories being updated. We make the test suite run faster by not sleeping, but instead explicitly updating the mtime of the directory to a future time with touch. We're careful to ensure that the time is not merely in the future compared to the current time, but also later than any previous update to the same directory mtime.
2010-02-04 20:31:01 +01:00
increment_mtime_amount=0
increment_mtime ()
{
dir=$1
increment_mtime_amount=$((increment_mtime_amount + 1))
touch -d "+${increment_mtime_amount} seconds" $dir
}
Add a very rough beginning of a test suite. This notmuch-test script simply runs a few different notmuch operations, (things that I found were useful while testing the rename-support code). It's not useful as a test suite yet, since it doesn't actually check the results of any operation, (the user of the suite has to know what the results should be and must manually verify them. So there's no integration with the build system yet, (no "make test" target). But I didn't want to lose what I had so far, so here it is.
2010-01-23 19:36:39 +01:00
# Generate a new message in the mail directory, with
# a unique message ID and subject.
#
notmuch-test: Add a basic test of "notmuch reply" Simply ensuring that the reply template is formatted as expected.
2010-02-04 20:33:56 +01:00
# After this function returns, the filename of the generated message
# is available as $gen_msg_filename and the message ID is available as
# $gen_msg_id .
notmuch-test: Use named-parameters for generate_message function This makes the test suite bash-specific, but that's not much of an issue for me, (if somebody else would prefer some other language then they can rewrite the test suite and maintain it). The advantage here is that we'll now be able to easily generate custom messages for testing operations that depend on the message content, (such as "notmuch reply", etc.).
2010-02-04 02:24:01 +01:00
#
# This function supports named parameters with the bash syntax for
# assigning a value to an associative array ([name]=value). The
# supported parameters are:
#
# [dir]=directory/of/choice
#
# Generate the message in directory 'directory/of/choice' within
# the mail store. The directory will be created if necessary.
notmuch-test: Allow custom headers when generating messages This provides the control that future tests will need, (for example, adding a CC field to ensure proper handling with "notmuch reply", etc.)
2010-02-04 17:39:23 +01:00
#
# [body]=text
#
# Text to use as the body of the email message
#
# '[from]="Some User <user@example.com>"'
# '[to]="Some User <user@example.com>"'
# '[subject]="Subject of email message"'
notmuch-test: Add a basic test of "notmuch reply" Simply ensuring that the reply template is formatted as expected.
2010-02-04 20:33:56 +01:00
# '[date]="RFC 822 Date"'
notmuch-test: Allow custom headers when generating messages This provides the control that future tests will need, (for example, adding a CC field to ensure proper handling with "notmuch reply", etc.)
2010-02-04 17:39:23 +01:00
#
# Values for email headers. If not provided, default values will
# be generated instead.
#
# '[cc]="Some User <user@example.com>"'
notmuch-test: Add "notmuch reply" test for reply-to support. This is the standard support of reply-to, (replying to that address rather than the from address). It has nothing to do with the proposed feature for extra-clever handling of a mail from a mailing-list that has munged the reply-to header.
2010-02-04 20:52:08 +01:00
# [reply-to]=some-address
notmuch-test: Allow custom headers when generating messages This provides the control that future tests will need, (for example, adding a CC field to ensure proper handling with "notmuch reply", etc.)
2010-02-04 17:39:23 +01:00
# [in-reply-to]=<message-id>
#
# Additional values for email headers. If these are not provided
# then the relevant headers will simply not appear in the
# message.
Add a very rough beginning of a test suite. This notmuch-test script simply runs a few different notmuch operations, (things that I found were useful while testing the rename-support code). It's not useful as a test suite yet, since it doesn't actually check the results of any operation, (the user of the suite has to know what the results should be and must manually verify them. So there's no integration with the build system yet, (no "make test" target). But I didn't want to lose what I had so far, so here it is.
2010-01-23 19:36:39 +01:00
gen_msg_cnt=0
gen_msg_filename=""
notmuch-test: Add a basic test of "notmuch reply" Simply ensuring that the reply template is formatted as expected.
2010-02-04 20:33:56 +01:00
gen_msg_id=""
Add a very rough beginning of a test suite. This notmuch-test script simply runs a few different notmuch operations, (things that I found were useful while testing the rename-support code). It's not useful as a test suite yet, since it doesn't actually check the results of any operation, (the user of the suite has to know what the results should be and must manually verify them. So there's no integration with the build system yet, (no "make test" target). But I didn't want to lose what I had so far, so here it is.
2010-01-23 19:36:39 +01:00
generate_message ()
{
notmuch-test: Use named-parameters for generate_message function This makes the test suite bash-specific, but that's not much of an issue for me, (if somebody else would prefer some other language then they can rewrite the test suite and maintain it). The advantage here is that we'll now be able to easily generate custom messages for testing operations that depend on the message content, (such as "notmuch reply", etc.).
2010-02-04 02:24:01 +01:00
# This is our (bash-specific) magic for doing named parameters
local -A template="($@)"
notmuch-test: Allow custom headers when generating messages This provides the control that future tests will need, (for example, adding a CC field to ensure proper handling with "notmuch reply", etc.)
2010-02-04 17:39:23 +01:00
local additional_headers
notmuch-test: Use named-parameters for generate_message function This makes the test suite bash-specific, but that's not much of an issue for me, (if somebody else would prefer some other language then they can rewrite the test suite and maintain it). The advantage here is that we'll now be able to easily generate custom messages for testing operations that depend on the message content, (such as "notmuch reply", etc.).
2010-02-04 02:24:01 +01:00
Add a very rough beginning of a test suite. This notmuch-test script simply runs a few different notmuch operations, (things that I found were useful while testing the rename-support code). It's not useful as a test suite yet, since it doesn't actually check the results of any operation, (the user of the suite has to know what the results should be and must manually verify them. So there's no integration with the build system yet, (no "make test" target). But I didn't want to lose what I had so far, so here it is.
2010-01-23 19:36:39 +01:00
gen_msg_cnt=$((gen_msg_cnt + 1))
gen_msg_name=msg-$(printf "%03d" $gen_msg_cnt)
notmuch-test: Add a basic test of "notmuch reply" Simply ensuring that the reply template is formatted as expected.
2010-02-04 20:33:56 +01:00
gen_msg_id="${gen_msg_name}@notmuch-test-suite"
Add a very rough beginning of a test suite. This notmuch-test script simply runs a few different notmuch operations, (things that I found were useful while testing the rename-support code). It's not useful as a test suite yet, since it doesn't actually check the results of any operation, (the user of the suite has to know what the results should be and must manually verify them. So there's no integration with the build system yet, (no "make test" target). But I didn't want to lose what I had so far, so here it is.
2010-01-23 19:36:39 +01:00
notmuch-test: Use named-parameters for generate_message function This makes the test suite bash-specific, but that's not much of an issue for me, (if somebody else would prefer some other language then they can rewrite the test suite and maintain it). The advantage here is that we'll now be able to easily generate custom messages for testing operations that depend on the message content, (such as "notmuch reply", etc.).
2010-02-04 02:24:01 +01:00
if [ -z "${template[dir]}" ]; then
Add a very rough beginning of a test suite. This notmuch-test script simply runs a few different notmuch operations, (things that I found were useful while testing the rename-support code). It's not useful as a test suite yet, since it doesn't actually check the results of any operation, (the user of the suite has to know what the results should be and must manually verify them. So there's no integration with the build system yet, (no "make test" target). But I didn't want to lose what I had so far, so here it is.
2010-01-23 19:36:39 +01:00
gen_msg_filename="${MAIL_DIR}/$gen_msg_name"
else
notmuch-test: Use named-parameters for generate_message function This makes the test suite bash-specific, but that's not much of an issue for me, (if somebody else would prefer some other language then they can rewrite the test suite and maintain it). The advantage here is that we'll now be able to easily generate custom messages for testing operations that depend on the message content, (such as "notmuch reply", etc.).
2010-02-04 02:24:01 +01:00
gen_msg_filename="${MAIL_DIR}/${template[dir]}/$gen_msg_name"
Add a very rough beginning of a test suite. This notmuch-test script simply runs a few different notmuch operations, (things that I found were useful while testing the rename-support code). It's not useful as a test suite yet, since it doesn't actually check the results of any operation, (the user of the suite has to know what the results should be and must manually verify them. So there's no integration with the build system yet, (no "make test" target). But I didn't want to lose what I had so far, so here it is.
2010-01-23 19:36:39 +01:00
mkdir -p $(dirname $gen_msg_filename)
fi
notmuch-test: Allow custom headers when generating messages This provides the control that future tests will need, (for example, adding a CC field to ensure proper handling with "notmuch reply", etc.)
2010-02-04 17:39:23 +01:00
if [ -z "${template[body]}" ]; then
template[body]="This is just a test message at ${gen_msg_filename}"
fi
if [ -z "${template[from]}" ]; then
template[from]="Notmuch Test Suite <test_suite@notmuchmail.org>"
fi
if [ -z "${template[to]}" ]; then
template[to]="Notmuch Test Suite <test_suite@notmuchmail.org>"
fi
if [ -z "${template[subject]}" ]; then
template[subject]="Test message ${gen_msg_filename}"
fi
notmuch-test: Add a basic test of "notmuch reply" Simply ensuring that the reply template is formatted as expected.
2010-02-04 20:33:56 +01:00
if [ -z "${template[date]}" ]; then
template[date]="Tue, 05 Jan 2010 15:43:57 -0800"
fi
notmuch-test: Allow custom headers when generating messages This provides the control that future tests will need, (for example, adding a CC field to ensure proper handling with "notmuch reply", etc.)
2010-02-04 17:39:23 +01:00
additional_headers=""
notmuch-test: Add "notmuch reply" test for reply-to support. This is the standard support of reply-to, (replying to that address rather than the from address). It has nothing to do with the proposed feature for extra-clever handling of a mail from a mailing-list that has munged the reply-to header.
2010-02-04 20:52:08 +01:00
if [ ! -z "${template[reply-to]}" ]; then
additional_headers="Reply-To: ${template[reply-to]}
notmuch-test: Allow custom headers when generating messages This provides the control that future tests will need, (for example, adding a CC field to ensure proper handling with "notmuch reply", etc.)
2010-02-04 17:39:23 +01:00
${additional_headers}"
fi
if [ ! -z "${template[in-reply-to]}" ]; then
additional_headers="In-Reply-To: ${template[in-reply-to]}
${additional_headers}"
fi
notmuch-test: Add "notmuch reply" test for reply-to support. This is the standard support of reply-to, (replying to that address rather than the from address). It has nothing to do with the proposed feature for extra-clever handling of a mail from a mailing-list that has munged the reply-to header.
2010-02-04 20:52:08 +01:00
if [ ! -z "${template[cc]}" ]; then
additional_headers="Cc: ${template[cc]}
${additional_headers}"
fi
Add a very rough beginning of a test suite. This notmuch-test script simply runs a few different notmuch operations, (things that I found were useful while testing the rename-support code). It's not useful as a test suite yet, since it doesn't actually check the results of any operation, (the user of the suite has to know what the results should be and must manually verify them. So there's no integration with the build system yet, (no "make test" target). But I didn't want to lose what I had so far, so here it is.
2010-01-23 19:36:39 +01:00
cat <<EOF >$gen_msg_filename
notmuch-test: Allow custom headers when generating messages This provides the control that future tests will need, (for example, adding a CC field to ensure proper handling with "notmuch reply", etc.)
2010-02-04 17:39:23 +01:00
From: ${template[from]}
To: ${template[to]}
notmuch-test: Add a basic test of "notmuch reply" Simply ensuring that the reply template is formatted as expected.
2010-02-04 20:33:56 +01:00
Message-Id: <${gen_msg_id}>
notmuch-test: Allow custom headers when generating messages This provides the control that future tests will need, (for example, adding a CC field to ensure proper handling with "notmuch reply", etc.)
2010-02-04 17:39:23 +01:00
Subject: ${template[subject]}
notmuch-test: Add a basic test of "notmuch reply" Simply ensuring that the reply template is formatted as expected.
2010-02-04 20:33:56 +01:00
Date: ${template[date]}
notmuch-test: Allow custom headers when generating messages This provides the control that future tests will need, (for example, adding a CC field to ensure proper handling with "notmuch reply", etc.)
2010-02-04 17:39:23 +01:00
${additional_headers}
${template[body]}
Add a very rough beginning of a test suite. This notmuch-test script simply runs a few different notmuch operations, (things that I found were useful while testing the rename-support code). It's not useful as a test suite yet, since it doesn't actually check the results of any operation, (the user of the suite has to know what the results should be and must manually verify them. So there's no integration with the build system yet, (no "make test" target). But I didn't want to lose what I had so far, so here it is.
2010-01-23 19:36:39 +01:00
EOF
notmuch-test: Eliminate sleeps to speed up test suite run We were sleeping merely to ensure that our updates to the mail store would result in the mtime of the appropriate directories being updated. We make the test suite run faster by not sleeping, but instead explicitly updating the mtime of the directory to a future time with touch. We're careful to ensure that the time is not merely in the future compared to the current time, but also later than any previous update to the same directory mtime.
2010-02-04 20:31:01 +01:00
# Ensure that the mtime of the containing directory is updated
increment_mtime $(dirname ${gen_msg_filename})
Add a very rough beginning of a test suite. This notmuch-test script simply runs a few different notmuch operations, (things that I found were useful while testing the rename-support code). It's not useful as a test suite yet, since it doesn't actually check the results of any operation, (the user of the suite has to know what the results should be and must manually verify them. So there's no integration with the build system yet, (no "make test" target). But I didn't want to lose what I had so far, so here it is.
2010-01-23 19:36:39 +01:00
}
Add actual testing to notmuch-test We verify that each command creates output exactly as expected (after ignoring variable output such as the report of how long an operation took).
2010-02-03 01:24:53 +01:00
NOTMUCH_IGNORED_OUTPUT_REGEXP='^Processed [0-9]*( total)? file|Found [0-9]* total file'
execute_expecting ()
{
args=$1
expected=$2
output=$($NOTMUCH $args | grep -v -E -e "$NOTMUCH_IGNORED_OUTPUT_REGEXP")
if [ "$output" = "$expected" ]; then
echo " PASS"
else
echo " FAIL"
echo " Expected output: $expected"
echo " Actual output: $output"
fi
}
Add a very rough beginning of a test suite. This notmuch-test script simply runs a few different notmuch operations, (things that I found were useful while testing the rename-support code). It's not useful as a test suite yet, since it doesn't actually check the results of any operation, (the user of the suite has to know what the results should be and must manually verify them. So there's no integration with the build system yet, (no "make test" target). But I didn't want to lose what I had so far, so here it is.
2010-01-23 19:36:39 +01:00
TEST_DIR=$(pwd)/test.$$
MAIL_DIR=${TEST_DIR}/mail
export NOTMUCH_CONFIG=${TEST_DIR}/notmuch-config
NOTMUCH=$(find_notmuch_binary $(pwd))
rm -rf ${TEST_DIR}
mkdir ${TEST_DIR}
cd ${TEST_DIR}
mkdir ${MAIL_DIR}
cat <<EOF > ${NOTMUCH_CONFIG}
[database]
path=${MAIL_DIR}
[user]
name=Notmuch Test Suite
primary_email=test_suite@notmuchmail.org
notmuch-test: Test "notmuch reply" from alternate address. When reply to a message addresses to an address configured in the other_email setting in the configuration file, the reply should use that address in the From header. Test this.
2010-02-04 20:39:31 +01:00
other_email=test_suite_other@notmuchmail.org
Add a very rough beginning of a test suite. This notmuch-test script simply runs a few different notmuch operations, (things that I found were useful while testing the rename-support code). It's not useful as a test suite yet, since it doesn't actually check the results of any operation, (the user of the suite has to know what the results should be and must manually verify them. So there's no integration with the build system yet, (no "make test" target). But I didn't want to lose what I had so far, so here it is.
2010-01-23 19:36:39 +01:00
EOF
Add actual testing to notmuch-test We verify that each command creates output exactly as expected (after ignoring variable output such as the report of how long an operation took).
2010-02-03 01:24:53 +01:00
printf "Testing \"notmuch new\" in several variations:\n"
printf " No new messages...\t\t"
execute_expecting new "No new mail."
Add a very rough beginning of a test suite. This notmuch-test script simply runs a few different notmuch operations, (things that I found were useful while testing the rename-support code). It's not useful as a test suite yet, since it doesn't actually check the results of any operation, (the user of the suite has to know what the results should be and must manually verify them. So there's no integration with the build system yet, (no "make test" target). But I didn't want to lose what I had so far, so here it is.
2010-01-23 19:36:39 +01:00
Add actual testing to notmuch-test We verify that each command creates output exactly as expected (after ignoring variable output such as the report of how long an operation took).
2010-02-03 01:24:53 +01:00
printf " Single new message...\t\t"
Add a very rough beginning of a test suite. This notmuch-test script simply runs a few different notmuch operations, (things that I found were useful while testing the rename-support code). It's not useful as a test suite yet, since it doesn't actually check the results of any operation, (the user of the suite has to know what the results should be and must manually verify them. So there's no integration with the build system yet, (no "make test" target). But I didn't want to lose what I had so far, so here it is.
2010-01-23 19:36:39 +01:00
generate_message
Add actual testing to notmuch-test We verify that each command creates output exactly as expected (after ignoring variable output such as the report of how long an operation took).
2010-02-03 01:24:53 +01:00
execute_expecting new "Added 1 new message to the database."
Add a very rough beginning of a test suite. This notmuch-test script simply runs a few different notmuch operations, (things that I found were useful while testing the rename-support code). It's not useful as a test suite yet, since it doesn't actually check the results of any operation, (the user of the suite has to know what the results should be and must manually verify them. So there's no integration with the build system yet, (no "make test" target). But I didn't want to lose what I had so far, so here it is.
2010-01-23 19:36:39 +01:00
Add actual testing to notmuch-test We verify that each command creates output exactly as expected (after ignoring variable output such as the report of how long an operation took).
2010-02-03 01:24:53 +01:00
printf " Multiple new messages...\t"
Add a very rough beginning of a test suite. This notmuch-test script simply runs a few different notmuch operations, (things that I found were useful while testing the rename-support code). It's not useful as a test suite yet, since it doesn't actually check the results of any operation, (the user of the suite has to know what the results should be and must manually verify them. So there's no integration with the build system yet, (no "make test" target). But I didn't want to lose what I had so far, so here it is.
2010-01-23 19:36:39 +01:00
generate_message
generate_message
Add actual testing to notmuch-test We verify that each command creates output exactly as expected (after ignoring variable output such as the report of how long an operation took).
2010-02-03 01:24:53 +01:00
execute_expecting new "Added 2 new messages to the database."
Add a very rough beginning of a test suite. This notmuch-test script simply runs a few different notmuch operations, (things that I found were useful while testing the rename-support code). It's not useful as a test suite yet, since it doesn't actually check the results of any operation, (the user of the suite has to know what the results should be and must manually verify them. So there's no integration with the build system yet, (no "make test" target). But I didn't want to lose what I had so far, so here it is.
2010-01-23 19:36:39 +01:00
Add actual testing to notmuch-test We verify that each command creates output exactly as expected (after ignoring variable output such as the report of how long an operation took).
2010-02-03 01:24:53 +01:00
printf " No new messages (non-empty DB)... "
execute_expecting new "No new mail."
Add a very rough beginning of a test suite. This notmuch-test script simply runs a few different notmuch operations, (things that I found were useful while testing the rename-support code). It's not useful as a test suite yet, since it doesn't actually check the results of any operation, (the user of the suite has to know what the results should be and must manually verify them. So there's no integration with the build system yet, (no "make test" target). But I didn't want to lose what I had so far, so here it is.
2010-01-23 19:36:39 +01:00
Add actual testing to notmuch-test We verify that each command creates output exactly as expected (after ignoring variable output such as the report of how long an operation took).
2010-02-03 01:24:53 +01:00
printf " New directories...\t\t"
Add a very rough beginning of a test suite. This notmuch-test script simply runs a few different notmuch operations, (things that I found were useful while testing the rename-support code). It's not useful as a test suite yet, since it doesn't actually check the results of any operation, (the user of the suite has to know what the results should be and must manually verify them. So there's no integration with the build system yet, (no "make test" target). But I didn't want to lose what I had so far, so here it is.
2010-01-23 19:36:39 +01:00
rm -rf ${MAIL_DIR}/* ${MAIL_DIR}/.notmuch
mkdir ${MAIL_DIR}/def
mkdir ${MAIL_DIR}/ghi
notmuch-test: Use named-parameters for generate_message function This makes the test suite bash-specific, but that's not much of an issue for me, (if somebody else would prefer some other language then they can rewrite the test suite and maintain it). The advantage here is that we'll now be able to easily generate custom messages for testing operations that depend on the message content, (such as "notmuch reply", etc.).
2010-02-04 02:24:01 +01:00
generate_message [dir]=def
Add a very rough beginning of a test suite. This notmuch-test script simply runs a few different notmuch operations, (things that I found were useful while testing the rename-support code). It's not useful as a test suite yet, since it doesn't actually check the results of any operation, (the user of the suite has to know what the results should be and must manually verify them. So there's no integration with the build system yet, (no "make test" target). But I didn't want to lose what I had so far, so here it is.
2010-01-23 19:36:39 +01:00
Add actual testing to notmuch-test We verify that each command creates output exactly as expected (after ignoring variable output such as the report of how long an operation took).
2010-02-03 01:24:53 +01:00
execute_expecting new "Added 1 new message to the database."
Add a very rough beginning of a test suite. This notmuch-test script simply runs a few different notmuch operations, (things that I found were useful while testing the rename-support code). It's not useful as a test suite yet, since it doesn't actually check the results of any operation, (the user of the suite has to know what the results should be and must manually verify them. So there's no integration with the build system yet, (no "make test" target). But I didn't want to lose what I had so far, so here it is.
2010-01-23 19:36:39 +01:00
Add actual testing to notmuch-test We verify that each command creates output exactly as expected (after ignoring variable output such as the report of how long an operation took).
2010-02-03 01:24:53 +01:00
printf " Alternate inode order...\t"
Add a very rough beginning of a test suite. This notmuch-test script simply runs a few different notmuch operations, (things that I found were useful while testing the rename-support code). It's not useful as a test suite yet, since it doesn't actually check the results of any operation, (the user of the suite has to know what the results should be and must manually verify them. So there's no integration with the build system yet, (no "make test" target). But I didn't want to lose what I had so far, so here it is.
2010-01-23 19:36:39 +01:00
rm -rf ${MAIL_DIR}/.notmuch
mv ${MAIL_DIR}/ghi ${MAIL_DIR}/abc
rm ${MAIL_DIR}/def/*
notmuch-test: Use named-parameters for generate_message function This makes the test suite bash-specific, but that's not much of an issue for me, (if somebody else would prefer some other language then they can rewrite the test suite and maintain it). The advantage here is that we'll now be able to easily generate custom messages for testing operations that depend on the message content, (such as "notmuch reply", etc.).
2010-02-04 02:24:01 +01:00
generate_message [dir]=abc
Add a very rough beginning of a test suite. This notmuch-test script simply runs a few different notmuch operations, (things that I found were useful while testing the rename-support code). It's not useful as a test suite yet, since it doesn't actually check the results of any operation, (the user of the suite has to know what the results should be and must manually verify them. So there's no integration with the build system yet, (no "make test" target). But I didn't want to lose what I had so far, so here it is.
2010-01-23 19:36:39 +01:00
Add actual testing to notmuch-test We verify that each command creates output exactly as expected (after ignoring variable output such as the report of how long an operation took).
2010-02-03 01:24:53 +01:00
execute_expecting new "Added 1 new message to the database."
Add a very rough beginning of a test suite. This notmuch-test script simply runs a few different notmuch operations, (things that I found were useful while testing the rename-support code). It's not useful as a test suite yet, since it doesn't actually check the results of any operation, (the user of the suite has to know what the results should be and must manually verify them. So there's no integration with the build system yet, (no "make test" target). But I didn't want to lose what I had so far, so here it is.
2010-01-23 19:36:39 +01:00
Add actual testing to notmuch-test We verify that each command creates output exactly as expected (after ignoring variable output such as the report of how long an operation took).
2010-02-03 01:24:53 +01:00
printf " Message moved in...\t\t"
Add a very rough beginning of a test suite. This notmuch-test script simply runs a few different notmuch operations, (things that I found were useful while testing the rename-support code). It's not useful as a test suite yet, since it doesn't actually check the results of any operation, (the user of the suite has to know what the results should be and must manually verify them. So there's no integration with the build system yet, (no "make test" target). But I didn't want to lose what I had so far, so here it is.
2010-01-23 19:36:39 +01:00
rm -rf ${MAIL_DIR}/* ${MAIL_DIR}/.notmuch
generate_message
tmp_msg_filename=tmp/$gen_msg_filename
mkdir -p $(dirname $tmp_msg_filename)
mv $gen_msg_filename $tmp_msg_filename
notmuch-test: Eliminate sleeps to speed up test suite run We were sleeping merely to ensure that our updates to the mail store would result in the mtime of the appropriate directories being updated. We make the test suite run faster by not sleeping, but instead explicitly updating the mtime of the directory to a future time with touch. We're careful to ensure that the time is not merely in the future compared to the current time, but also later than any previous update to the same directory mtime.
2010-02-04 20:31:01 +01:00
increment_mtime ${MAIL_DIR}
Add a very rough beginning of a test suite. This notmuch-test script simply runs a few different notmuch operations, (things that I found were useful while testing the rename-support code). It's not useful as a test suite yet, since it doesn't actually check the results of any operation, (the user of the suite has to know what the results should be and must manually verify them. So there's no integration with the build system yet, (no "make test" target). But I didn't want to lose what I had so far, so here it is.
2010-01-23 19:36:39 +01:00
$NOTMUCH new > /dev/null
mv $tmp_msg_filename $gen_msg_filename
notmuch-test: Eliminate sleeps to speed up test suite run We were sleeping merely to ensure that our updates to the mail store would result in the mtime of the appropriate directories being updated. We make the test suite run faster by not sleeping, but instead explicitly updating the mtime of the directory to a future time with touch. We're careful to ensure that the time is not merely in the future compared to the current time, but also later than any previous update to the same directory mtime.
2010-02-04 20:31:01 +01:00
increment_mtime ${MAIL_DIR}
Add actual testing to notmuch-test We verify that each command creates output exactly as expected (after ignoring variable output such as the report of how long an operation took).
2010-02-03 01:24:53 +01:00
execute_expecting new "Added 1 new message to the database."
Add a very rough beginning of a test suite. This notmuch-test script simply runs a few different notmuch operations, (things that I found were useful while testing the rename-support code). It's not useful as a test suite yet, since it doesn't actually check the results of any operation, (the user of the suite has to know what the results should be and must manually verify them. So there's no integration with the build system yet, (no "make test" target). But I didn't want to lose what I had so far, so here it is.
2010-01-23 19:36:39 +01:00
Add actual testing to notmuch-test We verify that each command creates output exactly as expected (after ignoring variable output such as the report of how long an operation took).
2010-02-03 01:24:53 +01:00
printf " Renamed message...\t\t"
Add a very rough beginning of a test suite. This notmuch-test script simply runs a few different notmuch operations, (things that I found were useful while testing the rename-support code). It's not useful as a test suite yet, since it doesn't actually check the results of any operation, (the user of the suite has to know what the results should be and must manually verify them. So there's no integration with the build system yet, (no "make test" target). But I didn't want to lose what I had so far, so here it is.
2010-01-23 19:36:39 +01:00
generate_message
$NOTMUCH new > /dev/null
mv $gen_msg_filename ${gen_msg_filename}-renamed
notmuch-test: Eliminate sleeps to speed up test suite run We were sleeping merely to ensure that our updates to the mail store would result in the mtime of the appropriate directories being updated. We make the test suite run faster by not sleeping, but instead explicitly updating the mtime of the directory to a future time with touch. We're careful to ensure that the time is not merely in the future compared to the current time, but also later than any previous update to the same directory mtime.
2010-02-04 20:31:01 +01:00
increment_mtime ${MAIL_DIR}
Add actual testing to notmuch-test We verify that each command creates output exactly as expected (after ignoring variable output such as the report of how long an operation took).
2010-02-03 01:24:53 +01:00
execute_expecting new "No new mail. Detected 1 file rename."
Add a very rough beginning of a test suite. This notmuch-test script simply runs a few different notmuch operations, (things that I found were useful while testing the rename-support code). It's not useful as a test suite yet, since it doesn't actually check the results of any operation, (the user of the suite has to know what the results should be and must manually verify them. So there's no integration with the build system yet, (no "make test" target). But I didn't want to lose what I had so far, so here it is.
2010-01-23 19:36:39 +01:00
Add actual testing to notmuch-test We verify that each command creates output exactly as expected (after ignoring variable output such as the report of how long an operation took).
2010-02-03 01:24:53 +01:00
printf " Deleted message...\t\t"
Add a very rough beginning of a test suite. This notmuch-test script simply runs a few different notmuch operations, (things that I found were useful while testing the rename-support code). It's not useful as a test suite yet, since it doesn't actually check the results of any operation, (the user of the suite has to know what the results should be and must manually verify them. So there's no integration with the build system yet, (no "make test" target). But I didn't want to lose what I had so far, so here it is.
2010-01-23 19:36:39 +01:00
rm ${gen_msg_filename}-renamed
notmuch-test: Eliminate sleeps to speed up test suite run We were sleeping merely to ensure that our updates to the mail store would result in the mtime of the appropriate directories being updated. We make the test suite run faster by not sleeping, but instead explicitly updating the mtime of the directory to a future time with touch. We're careful to ensure that the time is not merely in the future compared to the current time, but also later than any previous update to the same directory mtime.
2010-02-04 20:31:01 +01:00
increment_mtime ${MAIL_DIR}
Add actual testing to notmuch-test We verify that each command creates output exactly as expected (after ignoring variable output such as the report of how long an operation took).
2010-02-03 01:24:53 +01:00
execute_expecting new "No new mail. Removed 1 message."
Add a very rough beginning of a test suite. This notmuch-test script simply runs a few different notmuch operations, (things that I found were useful while testing the rename-support code). It's not useful as a test suite yet, since it doesn't actually check the results of any operation, (the user of the suite has to know what the results should be and must manually verify them. So there's no integration with the build system yet, (no "make test" target). But I didn't want to lose what I had so far, so here it is.
2010-01-23 19:36:39 +01:00
Add actual testing to notmuch-test We verify that each command creates output exactly as expected (after ignoring variable output such as the report of how long an operation took).
2010-02-03 01:24:53 +01:00
printf " Renamed directory...\t\t"
Add a very rough beginning of a test suite. This notmuch-test script simply runs a few different notmuch operations, (things that I found were useful while testing the rename-support code). It's not useful as a test suite yet, since it doesn't actually check the results of any operation, (the user of the suite has to know what the results should be and must manually verify them. So there's no integration with the build system yet, (no "make test" target). But I didn't want to lose what I had so far, so here it is.
2010-01-23 19:36:39 +01:00
notmuch-test: Use named-parameters for generate_message function This makes the test suite bash-specific, but that's not much of an issue for me, (if somebody else would prefer some other language then they can rewrite the test suite and maintain it). The advantage here is that we'll now be able to easily generate custom messages for testing operations that depend on the message content, (such as "notmuch reply", etc.).
2010-02-04 02:24:01 +01:00
generate_message [dir]=dir
generate_message [dir]=dir
generate_message [dir]=dir
Add a very rough beginning of a test suite. This notmuch-test script simply runs a few different notmuch operations, (things that I found were useful while testing the rename-support code). It's not useful as a test suite yet, since it doesn't actually check the results of any operation, (the user of the suite has to know what the results should be and must manually verify them. So there's no integration with the build system yet, (no "make test" target). But I didn't want to lose what I had so far, so here it is.
2010-01-23 19:36:39 +01:00
Add actual testing to notmuch-test We verify that each command creates output exactly as expected (after ignoring variable output such as the report of how long an operation took).
2010-02-03 01:24:53 +01:00
$NOTMUCH new > /dev/null
Add a very rough beginning of a test suite. This notmuch-test script simply runs a few different notmuch operations, (things that I found were useful while testing the rename-support code). It's not useful as a test suite yet, since it doesn't actually check the results of any operation, (the user of the suite has to know what the results should be and must manually verify them. So there's no integration with the build system yet, (no "make test" target). But I didn't want to lose what I had so far, so here it is.
2010-01-23 19:36:39 +01:00
mv ${MAIL_DIR}/dir ${MAIL_DIR}/dir-renamed
notmuch-test: Eliminate sleeps to speed up test suite run We were sleeping merely to ensure that our updates to the mail store would result in the mtime of the appropriate directories being updated. We make the test suite run faster by not sleeping, but instead explicitly updating the mtime of the directory to a future time with touch. We're careful to ensure that the time is not merely in the future compared to the current time, but also later than any previous update to the same directory mtime.
2010-02-04 20:31:01 +01:00
increment_mtime ${MAIL_DIR}
Add a very rough beginning of a test suite. This notmuch-test script simply runs a few different notmuch operations, (things that I found were useful while testing the rename-support code). It's not useful as a test suite yet, since it doesn't actually check the results of any operation, (the user of the suite has to know what the results should be and must manually verify them. So there's no integration with the build system yet, (no "make test" target). But I didn't want to lose what I had so far, so here it is.
2010-01-23 19:36:39 +01:00
Add actual testing to notmuch-test We verify that each command creates output exactly as expected (after ignoring variable output such as the report of how long an operation took).
2010-02-03 01:24:53 +01:00
execute_expecting new "No new mail. Detected 3 file renames."
Add a very rough beginning of a test suite. This notmuch-test script simply runs a few different notmuch operations, (things that I found were useful while testing the rename-support code). It's not useful as a test suite yet, since it doesn't actually check the results of any operation, (the user of the suite has to know what the results should be and must manually verify them. So there's no integration with the build system yet, (no "make test" target). But I didn't want to lose what I had so far, so here it is.
2010-01-23 19:36:39 +01:00
Add actual testing to notmuch-test We verify that each command creates output exactly as expected (after ignoring variable output such as the report of how long an operation took).
2010-02-03 01:24:53 +01:00
printf " Deleted directory...\t\t"
Add a very rough beginning of a test suite. This notmuch-test script simply runs a few different notmuch operations, (things that I found were useful while testing the rename-support code). It's not useful as a test suite yet, since it doesn't actually check the results of any operation, (the user of the suite has to know what the results should be and must manually verify them. So there's no integration with the build system yet, (no "make test" target). But I didn't want to lose what I had so far, so here it is.
2010-01-23 19:36:39 +01:00
rm -rf ${MAIL_DIR}/dir-renamed
notmuch-test: Eliminate sleeps to speed up test suite run We were sleeping merely to ensure that our updates to the mail store would result in the mtime of the appropriate directories being updated. We make the test suite run faster by not sleeping, but instead explicitly updating the mtime of the directory to a future time with touch. We're careful to ensure that the time is not merely in the future compared to the current time, but also later than any previous update to the same directory mtime.
2010-02-04 20:31:01 +01:00
increment_mtime ${MAIL_DIR}
Add a very rough beginning of a test suite. This notmuch-test script simply runs a few different notmuch operations, (things that I found were useful while testing the rename-support code). It's not useful as a test suite yet, since it doesn't actually check the results of any operation, (the user of the suite has to know what the results should be and must manually verify them. So there's no integration with the build system yet, (no "make test" target). But I didn't want to lose what I had so far, so here it is.
2010-01-23 19:36:39 +01:00
Add actual testing to notmuch-test We verify that each command creates output exactly as expected (after ignoring variable output such as the report of how long an operation took).
2010-02-03 01:24:53 +01:00
execute_expecting new "No new mail. Removed 3 messages."
Add a very rough beginning of a test suite. This notmuch-test script simply runs a few different notmuch operations, (things that I found were useful while testing the rename-support code). It's not useful as a test suite yet, since it doesn't actually check the results of any operation, (the user of the suite has to know what the results should be and must manually verify them. So there's no integration with the build system yet, (no "make test" target). But I didn't want to lose what I had so far, so here it is.
2010-01-23 19:36:39 +01:00
Add actual testing to notmuch-test We verify that each command creates output exactly as expected (after ignoring variable output such as the report of how long an operation took).
2010-02-03 01:24:53 +01:00
printf " New directory (at end of list)... "
Add a very rough beginning of a test suite. This notmuch-test script simply runs a few different notmuch operations, (things that I found were useful while testing the rename-support code). It's not useful as a test suite yet, since it doesn't actually check the results of any operation, (the user of the suite has to know what the results should be and must manually verify them. So there's no integration with the build system yet, (no "make test" target). But I didn't want to lose what I had so far, so here it is.
2010-01-23 19:36:39 +01:00
notmuch-test: Use named-parameters for generate_message function This makes the test suite bash-specific, but that's not much of an issue for me, (if somebody else would prefer some other language then they can rewrite the test suite and maintain it). The advantage here is that we'll now be able to easily generate custom messages for testing operations that depend on the message content, (such as "notmuch reply", etc.).
2010-02-04 02:24:01 +01:00
generate_message [dir]=zzz
generate_message [dir]=zzz
generate_message [dir]=zzz
Add a very rough beginning of a test suite. This notmuch-test script simply runs a few different notmuch operations, (things that I found were useful while testing the rename-support code). It's not useful as a test suite yet, since it doesn't actually check the results of any operation, (the user of the suite has to know what the results should be and must manually verify them. So there's no integration with the build system yet, (no "make test" target). But I didn't want to lose what I had so far, so here it is.
2010-01-23 19:36:39 +01:00
Add actual testing to notmuch-test We verify that each command creates output exactly as expected (after ignoring variable output such as the report of how long an operation took).
2010-02-03 01:24:53 +01:00
execute_expecting new "Added 3 new messages to the database."
Add a very rough beginning of a test suite. This notmuch-test script simply runs a few different notmuch operations, (things that I found were useful while testing the rename-support code). It's not useful as a test suite yet, since it doesn't actually check the results of any operation, (the user of the suite has to know what the results should be and must manually verify them. So there's no integration with the build system yet, (no "make test" target). But I didn't want to lose what I had so far, so here it is.
2010-01-23 19:36:39 +01:00
Add actual testing to notmuch-test We verify that each command creates output exactly as expected (after ignoring variable output such as the report of how long an operation took).
2010-02-03 01:24:53 +01:00
printf " Deleted directory (end of list)... "
Add a very rough beginning of a test suite. This notmuch-test script simply runs a few different notmuch operations, (things that I found were useful while testing the rename-support code). It's not useful as a test suite yet, since it doesn't actually check the results of any operation, (the user of the suite has to know what the results should be and must manually verify them. So there's no integration with the build system yet, (no "make test" target). But I didn't want to lose what I had so far, so here it is.
2010-01-23 19:36:39 +01:00
rm -rf ${MAIL_DIR}/zzz
notmuch-test: Eliminate sleeps to speed up test suite run We were sleeping merely to ensure that our updates to the mail store would result in the mtime of the appropriate directories being updated. We make the test suite run faster by not sleeping, but instead explicitly updating the mtime of the directory to a future time with touch. We're careful to ensure that the time is not merely in the future compared to the current time, but also later than any previous update to the same directory mtime.
2010-02-04 20:31:01 +01:00
increment_mtime ${MAIL_DIR}
Add a very rough beginning of a test suite. This notmuch-test script simply runs a few different notmuch operations, (things that I found were useful while testing the rename-support code). It's not useful as a test suite yet, since it doesn't actually check the results of any operation, (the user of the suite has to know what the results should be and must manually verify them. So there's no integration with the build system yet, (no "make test" target). But I didn't want to lose what I had so far, so here it is.
2010-01-23 19:36:39 +01:00
Add actual testing to notmuch-test We verify that each command creates output exactly as expected (after ignoring variable output such as the report of how long an operation took).
2010-02-03 01:24:53 +01:00
execute_expecting new "No new mail. Removed 3 messages."
Add a very rough beginning of a test suite. This notmuch-test script simply runs a few different notmuch operations, (things that I found were useful while testing the rename-support code). It's not useful as a test suite yet, since it doesn't actually check the results of any operation, (the user of the suite has to know what the results should be and must manually verify them. So there's no integration with the build system yet, (no "make test" target). But I didn't want to lose what I had so far, so here it is.
2010-01-23 19:36:39 +01:00
Add actual testing to notmuch-test We verify that each command creates output exactly as expected (after ignoring variable output such as the report of how long an operation took).
2010-02-03 01:24:53 +01:00
printf " New symlink to directory...\t"
Add a very rough beginning of a test suite. This notmuch-test script simply runs a few different notmuch operations, (things that I found were useful while testing the rename-support code). It's not useful as a test suite yet, since it doesn't actually check the results of any operation, (the user of the suite has to know what the results should be and must manually verify them. So there's no integration with the build system yet, (no "make test" target). But I didn't want to lose what I had so far, so here it is.
2010-01-23 19:36:39 +01:00
rm -rf ${MAIL_DIR}/.notmuch
mv ${MAIL_DIR} ${TEST_DIR}/actual_maildir
mkdir ${MAIL_DIR}
ln -s ${TEST_DIR}/actual_maildir ${MAIL_DIR}/symlink
Add actual testing to notmuch-test We verify that each command creates output exactly as expected (after ignoring variable output such as the report of how long an operation took).
2010-02-03 01:24:53 +01:00
execute_expecting new "Added 1 new message to the database."
Add a very rough beginning of a test suite. This notmuch-test script simply runs a few different notmuch operations, (things that I found were useful while testing the rename-support code). It's not useful as a test suite yet, since it doesn't actually check the results of any operation, (the user of the suite has to know what the results should be and must manually verify them. So there's no integration with the build system yet, (no "make test" target). But I didn't want to lose what I had so far, so here it is.
2010-01-23 19:36:39 +01:00
Add actual testing to notmuch-test We verify that each command creates output exactly as expected (after ignoring variable output such as the report of how long an operation took).
2010-02-03 01:24:53 +01:00
printf " New symlink to a file...\t"
Add a very rough beginning of a test suite. This notmuch-test script simply runs a few different notmuch operations, (things that I found were useful while testing the rename-support code). It's not useful as a test suite yet, since it doesn't actually check the results of any operation, (the user of the suite has to know what the results should be and must manually verify them. So there's no integration with the build system yet, (no "make test" target). But I didn't want to lose what I had so far, so here it is.
2010-01-23 19:36:39 +01:00
generate_message
external_msg_filename=${TEST_DIR}/external/$(basename $gen_msg_filename)
mkdir -p $(dirname $external_msg_filename)
mv $gen_msg_filename $external_msg_filename
ln -s $external_msg_filename $gen_msg_filename
notmuch-test: Eliminate sleeps to speed up test suite run We were sleeping merely to ensure that our updates to the mail store would result in the mtime of the appropriate directories being updated. We make the test suite run faster by not sleeping, but instead explicitly updating the mtime of the directory to a future time with touch. We're careful to ensure that the time is not merely in the future compared to the current time, but also later than any previous update to the same directory mtime.
2010-02-04 20:31:01 +01:00
increment_mtime ${MAIL_DIR}
Add actual testing to notmuch-test We verify that each command creates output exactly as expected (after ignoring variable output such as the report of how long an operation took).
2010-02-03 01:24:53 +01:00
execute_expecting new "Added 1 new message to the database."
Add a very rough beginning of a test suite. This notmuch-test script simply runs a few different notmuch operations, (things that I found were useful while testing the rename-support code). It's not useful as a test suite yet, since it doesn't actually check the results of any operation, (the user of the suite has to know what the results should be and must manually verify them. So there's no integration with the build system yet, (no "make test" target). But I didn't want to lose what I had so far, so here it is.
2010-01-23 19:36:39 +01:00
Add actual testing to notmuch-test We verify that each command creates output exactly as expected (after ignoring variable output such as the report of how long an operation took).
2010-02-03 01:24:53 +01:00
printf " New two-level directory...\t"
Add a very rough beginning of a test suite. This notmuch-test script simply runs a few different notmuch operations, (things that I found were useful while testing the rename-support code). It's not useful as a test suite yet, since it doesn't actually check the results of any operation, (the user of the suite has to know what the results should be and must manually verify them. So there's no integration with the build system yet, (no "make test" target). But I didn't want to lose what I had so far, so here it is.
2010-01-23 19:36:39 +01:00
notmuch-test: Use named-parameters for generate_message function This makes the test suite bash-specific, but that's not much of an issue for me, (if somebody else would prefer some other language then they can rewrite the test suite and maintain it). The advantage here is that we'll now be able to easily generate custom messages for testing operations that depend on the message content, (such as "notmuch reply", etc.).
2010-02-04 02:24:01 +01:00
generate_message [dir]=two/levels
generate_message [dir]=two/levels
generate_message [dir]=two/levels
Add a very rough beginning of a test suite. This notmuch-test script simply runs a few different notmuch operations, (things that I found were useful while testing the rename-support code). It's not useful as a test suite yet, since it doesn't actually check the results of any operation, (the user of the suite has to know what the results should be and must manually verify them. So there's no integration with the build system yet, (no "make test" target). But I didn't want to lose what I had so far, so here it is.
2010-01-23 19:36:39 +01:00
Add actual testing to notmuch-test We verify that each command creates output exactly as expected (after ignoring variable output such as the report of how long an operation took).
2010-02-03 01:24:53 +01:00
execute_expecting new "Added 3 new messages to the database."
Add a very rough beginning of a test suite. This notmuch-test script simply runs a few different notmuch operations, (things that I found were useful while testing the rename-support code). It's not useful as a test suite yet, since it doesn't actually check the results of any operation, (the user of the suite has to know what the results should be and must manually verify them. So there's no integration with the build system yet, (no "make test" target). But I didn't want to lose what I had so far, so here it is.
2010-01-23 19:36:39 +01:00
Add actual testing to notmuch-test We verify that each command creates output exactly as expected (after ignoring variable output such as the report of how long an operation took).
2010-02-03 01:24:53 +01:00
printf " Deleted two-level directory... "
Add a very rough beginning of a test suite. This notmuch-test script simply runs a few different notmuch operations, (things that I found were useful while testing the rename-support code). It's not useful as a test suite yet, since it doesn't actually check the results of any operation, (the user of the suite has to know what the results should be and must manually verify them. So there's no integration with the build system yet, (no "make test" target). But I didn't want to lose what I had so far, so here it is.
2010-01-23 19:36:39 +01:00
rm -rf ${MAIL_DIR}/two
notmuch-test: Eliminate sleeps to speed up test suite run We were sleeping merely to ensure that our updates to the mail store would result in the mtime of the appropriate directories being updated. We make the test suite run faster by not sleeping, but instead explicitly updating the mtime of the directory to a future time with touch. We're careful to ensure that the time is not merely in the future compared to the current time, but also later than any previous update to the same directory mtime.
2010-02-04 20:31:01 +01:00
increment_mtime ${MAIL_DIR}
Add a very rough beginning of a test suite. This notmuch-test script simply runs a few different notmuch operations, (things that I found were useful while testing the rename-support code). It's not useful as a test suite yet, since it doesn't actually check the results of any operation, (the user of the suite has to know what the results should be and must manually verify them. So there's no integration with the build system yet, (no "make test" target). But I didn't want to lose what I had so far, so here it is.
2010-01-23 19:36:39 +01:00
Add actual testing to notmuch-test We verify that each command creates output exactly as expected (after ignoring variable output such as the report of how long an operation took).
2010-02-03 01:24:53 +01:00
execute_expecting new "No new mail. Removed 3 messages."
Add a very rough beginning of a test suite. This notmuch-test script simply runs a few different notmuch operations, (things that I found were useful while testing the rename-support code). It's not useful as a test suite yet, since it doesn't actually check the results of any operation, (the user of the suite has to know what the results should be and must manually verify them. So there's no integration with the build system yet, (no "make test" target). But I didn't want to lose what I had so far, so here it is.
2010-01-23 19:36:39 +01:00
notmuch-test: Add a basic test of "notmuch reply" Simply ensuring that the reply template is formatted as expected.
2010-02-04 20:33:56 +01:00
printf "\nTesting \"notmuch reply\" in several variations:\n"
printf " Basic reply...\t\t\t"
generate_message '[from]="Sender <sender@example.com>"' \
[to]=test_suite@notmuchmail.org \
[subject]=notmuch-reply-test \
'[date]="Tue, 05 Jan 2010 15:43:56 -0800"' \
notmuch-test: Add "notmuch reply" test for reply-to support. This is the standard support of reply-to, (replying to that address rather than the from address). It has nothing to do with the proposed feature for extra-clever handling of a mail from a mailing-list that has munged the reply-to header.
2010-02-04 20:52:08 +01:00
'[body]="basic reply test"'
notmuch-test: Add a basic test of "notmuch reply" Simply ensuring that the reply template is formatted as expected.
2010-02-04 20:33:56 +01:00
$NOTMUCH new > /dev/null
execute_expecting "reply id:${gen_msg_id}" "From: Notmuch Test Suite <test_suite@notmuchmail.org>
Subject: Re: notmuch-reply-test
To: Sender <sender@example.com>
Bcc: test_suite@notmuchmail.org
In-Reply-To: <${gen_msg_id}>
References: <${gen_msg_id}>
On Tue, 05 Jan 2010 15:43:56 -0800, Sender <sender@example.com> wrote:
notmuch-test: Add "notmuch reply" test for reply-to support. This is the standard support of reply-to, (replying to that address rather than the from address). It has nothing to do with the proposed feature for extra-clever handling of a mail from a mailing-list that has munged the reply-to header.
2010-02-04 20:52:08 +01:00
> basic reply test"
notmuch-test: Add a basic test of "notmuch reply" Simply ensuring that the reply template is formatted as expected.
2010-02-04 20:33:56 +01:00
notmuch-test: Add test for "notmuch reply" with a CC header. A simple test to help round out the set of tested features.
2010-02-04 20:55:57 +01:00
printf " Reply with CC...\t\t"
generate_message '[from]="Sender <sender@example.com>"' \
[to]=test_suite@notmuchmail.org \
'[cc]="Other Parties <cc@example.com>"' \
[subject]=notmuch-reply-test \
'[date]="Tue, 05 Jan 2010 15:43:56 -0800"' \
'[body]="reply with CC"'
$NOTMUCH new > /dev/null
execute_expecting "reply id:${gen_msg_id}" "From: Notmuch Test Suite <test_suite@notmuchmail.org>
Subject: Re: notmuch-reply-test
To: Sender <sender@example.com>
Cc: Other Parties <cc@example.com>
Bcc: test_suite@notmuchmail.org
In-Reply-To: <${gen_msg_id}>
References: <${gen_msg_id}>
On Tue, 05 Jan 2010 15:43:56 -0800, Sender <sender@example.com> wrote:
> reply with CC"
notmuch-test: Add "notmuch reply" test for reply-to support. This is the standard support of reply-to, (replying to that address rather than the from address). It has nothing to do with the proposed feature for extra-clever handling of a mail from a mailing-list that has munged the reply-to header.
2010-02-04 20:52:08 +01:00
printf " Reply from alternate address..."
notmuch-test: Test "notmuch reply" from alternate address. When reply to a message addresses to an address configured in the other_email setting in the configuration file, the reply should use that address in the From header. Test this.
2010-02-04 20:39:31 +01:00
generate_message '[from]="Sender <sender@example.com>"' \
[to]=test_suite_other@notmuchmail.org \
[subject]=notmuch-reply-test \
'[date]="Tue, 05 Jan 2010 15:43:56 -0800"' \
notmuch-test: Add "notmuch reply" test for reply-to support. This is the standard support of reply-to, (replying to that address rather than the from address). It has nothing to do with the proposed feature for extra-clever handling of a mail from a mailing-list that has munged the reply-to header.
2010-02-04 20:52:08 +01:00
'[body]="reply from alternate address"'
notmuch-test: Test "notmuch reply" from alternate address. When reply to a message addresses to an address configured in the other_email setting in the configuration file, the reply should use that address in the From header. Test this.
2010-02-04 20:39:31 +01:00
$NOTMUCH new > /dev/null
execute_expecting "reply id:${gen_msg_id}" "From: Notmuch Test Suite <test_suite_other@notmuchmail.org>
Subject: Re: notmuch-reply-test
To: Sender <sender@example.com>
Bcc: test_suite@notmuchmail.org
In-Reply-To: <${gen_msg_id}>
References: <${gen_msg_id}>
On Tue, 05 Jan 2010 15:43:56 -0800, Sender <sender@example.com> wrote:
notmuch-test: Add "notmuch reply" test for reply-to support. This is the standard support of reply-to, (replying to that address rather than the from address). It has nothing to do with the proposed feature for extra-clever handling of a mail from a mailing-list that has munged the reply-to header.
2010-02-04 20:52:08 +01:00
> reply from alternate address"
printf " Support for Reply-To...\t"
generate_message '[from]="Sender <sender@example.com>"' \
[to]=test_suite@notmuchmail.org \
[subject]=notmuch-reply-test \
'[date]="Tue, 05 Jan 2010 15:43:56 -0800"' \
'[body]="support for reply-to"' \
'[reply-to]="Sender <elsewhere@example.com>"'
$NOTMUCH new > /dev/null
execute_expecting "reply id:${gen_msg_id}" "From: Notmuch Test Suite <test_suite@notmuchmail.org>
Subject: Re: notmuch-reply-test
To: Sender <elsewhere@example.com>
Bcc: test_suite@notmuchmail.org
In-Reply-To: <${gen_msg_id}>
References: <${gen_msg_id}>
On Tue, 05 Jan 2010 15:43:56 -0800, Sender <sender@example.com> wrote:
> support for reply-to"
notmuch-test: Test "notmuch reply" from alternate address. When reply to a message addresses to an address configured in the other_email setting in the configuration file, the reply should use that address in the From header. Test this.
2010-02-04 20:39:31 +01:00
Add a very rough beginning of a test suite. This notmuch-test script simply runs a few different notmuch operations, (things that I found were useful while testing the rename-support code). It's not useful as a test suite yet, since it doesn't actually check the results of any operation, (the user of the suite has to know what the results should be and must manually verify them. So there's no integration with the build system yet, (no "make test" target). But I didn't want to lose what I had so far, so here it is.
2010-01-23 19:36:39 +01:00
cat <<EOF
Notmuch test suite complete.
Intermediate state can be examined in:
${TEST_DIR}
EOF
Reference in a new issue Copy permalink