debian/notmuch
1
0
Fork 0
mirror of https://git.notmuchmail.org/git/notmuch synced 2024-12-23 09:54:52 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions
notmuch/test/notmuch-test

545 lines
18 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
}
notmuch-test: Add a new add_message function. The previous generate_message function is what's needed when testing "notmuch new". But after that, we never want to generate a message without also adding it to the index. So create a new add_message function with this convenience.
2010-02-05 02:34:48 +01:00
# Generate a new message in the mail directory, with a unique message
# ID and subject. The message is not added to the index.
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
# 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
}
notmuch-test: Add a new add_message function. The previous generate_message function is what's needed when testing "notmuch new". But after that, we never want to generate a message without also adding it to the index. So create a new add_message function with this convenience.
2010-02-05 02:34:48 +01:00
# Generate a new message and add it to the index.
#
# All of the arguments and return values supported by generate_message
# are alos supported here, so see that function for details.
add_message ()
{
generate_message "$@"
$NOTMUCH new > /dev/null
}
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'
Switch from random to sequential thread identifiers. The sequential identifiers have the advantage of being guaranteed to be unique (until we overflow a 64-bit unsigned integer), and also take up half as much space in the "notmuch search" output (16 columns rather than 32). This change also has the side effect of fixing a bug where notmuch could block on /dev/random at startup (waiting for some entropy to appear). This bug was hit hard by the test suite, (which could easily exhaust the available entropy on common systems---resulting in large delays of the test suite).
2010-02-08 20:33:33 +01:00
NOTMUCH_THREAD_ID_SQUELCH='s/thread:................/thread:XXX/'
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 ()
{
args=$1
expected=$2
notmuch-test: Add several tests of "notmuch search" These tests were surprisingly simple to write---not much code at all and most of them worked the first time even with hand-prepared versions of the expected output.
2010-02-05 19:00:04 +01:00
output=$($NOTMUCH $args | grep -v -E -e "$NOTMUCH_IGNORED_OUTPUT_REGEXP" | sed -e "$NOTMUCH_THREAD_ID_SQUELCH" || true)
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
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 several tests of "notmuch search" These tests were surprisingly simple to write---not much code at all and most of them worked the first time even with hand-prepared versions of the expected output.
2010-02-05 19:00:04 +01:00
printf "\nTesting \"notmuch search\" in several variations:\n"
notmuch-test: Fix misalignment in output. Clean output is just so much easier to read (and validate).
2010-02-06 02:27:22 +01:00
printf " Search body...\t\t\t"
notmuch-test: Add several tests of "notmuch search" These tests were surprisingly simple to write---not much code at all and most of them worked the first time even with hand-prepared versions of the expected output.
2010-02-05 19:00:04 +01:00
add_message '[subject]="body search"' '[date]="Sat, 01 Jan 2000 12:00:00 -0000"' [body]=bodysearchtest
execute_expecting "search bodysearchtest" "thread:XXX 2000-01-01 [1/1] Notmuch Test Suite; body search (inbox unread)"
printf " Search by from:...\t\t"
add_message '[subject]="search by from"' '[date]="Sat, 01 Jan 2000 12:00:00 -0000"' [from]=searchbyfrom
execute_expecting "search from:searchbyfrom" "thread:XXX 2000-01-01 [1/1] searchbyfrom; search by from (inbox unread)"
printf " Search by to:...\t\t"
add_message '[subject]="search by to"' '[date]="Sat, 01 Jan 2000 12:00:00 -0000"' [to]=searchbyto
execute_expecting "search to:searchbyto" "thread:XXX 2000-01-01 [1/1] Notmuch Test Suite; search by to (inbox unread)"
printf " Search by subject:...\t\t"
add_message [subject]=subjectsearchtest '[date]="Sat, 01 Jan 2000 12:00:00 -0000"'
execute_expecting "search subject:subjectsearchtest" "thread:XXX 2000-01-01 [1/1] Notmuch Test Suite; subjectsearchtest (inbox unread)"
printf " Search by id:...\t\t"
add_message '[subject]="search by id"' '[date]="Sat, 01 Jan 2000 12:00:00 -0000"'
execute_expecting "search id:${gen_msg_id}" "thread:XXX 2000-01-01 [1/1] Notmuch Test Suite; search by id (inbox unread)"
printf " Search by tag:...\t\t"
add_message '[subject]="search by tag"' '[date]="Sat, 01 Jan 2000 12:00:00 -0000"'
$NOTMUCH tag +searchbytag id:${gen_msg_id}
execute_expecting "search tag:searchbytag" "thread:XXX 2000-01-01 [1/1] Notmuch Test Suite; search by tag (inbox searchbytag unread)"
printf " Search by thread:...\t\t"
add_message '[subject]="search by thread"' '[date]="Sat, 01 Jan 2000 12:00:00 -0000"'
thread_id=$($NOTMUCH search id:${gen_msg_id} | sed -e 's/thread:\([a-f0-9]*\).*/\1/')
execute_expecting "search thread:${thread_id}" "thread:XXX 2000-01-01 [1/1] Notmuch Test Suite; search by thread (inbox unread)"
printf " Search body (phrase)...\t"
add_message '[subject]="body search (phrase)"' '[date]="Sat, 01 Jan 2000 12:00:00 -0000"' '[body]="body search (phrase)"'
test: Add some negative results for the phrase searches. These results have all the same terms as the target phrase, but not in the expected order. They are designed to ensure that we actually test phrase searches. And as it turns out, we're not currently quoting the search terms properly, so the phrase-search tests now fail with this commit.
2010-03-11 18:52:08 +01:00
add_message '[subject]="negative result"' '[date]="Sat, 01 Jan 2000 12:00:00 -0000"' '[body]="This phrase should not match the body search"'
notmuch-test: Add several tests of "notmuch search" These tests were surprisingly simple to write---not much code at all and most of them worked the first time even with hand-prepared versions of the expected output.
2010-02-05 19:00:04 +01:00
execute_expecting "search 'body search (phrase)'" "thread:XXX 2000-01-01 [1/1] Notmuch Test Suite; body search (phrase) (inbox unread)"
printf " Search by from: (address)...\t"
add_message '[subject]="search by from (address)"' '[date]="Sat, 01 Jan 2000 12:00:00 -0000"' [from]=searchbyfrom@example.com
execute_expecting "search from:searchbyfrom@example.com" "thread:XXX 2000-01-01 [1/1] searchbyfrom@example.com; search by from (address) (inbox unread)"
printf " Search by from: (name)...\t"
add_message '[subject]="search by from (name)"' '[date]="Sat, 01 Jan 2000 12:00:00 -0000"' '[from]="Search By From Name <test@example.com>"'
execute_expecting "search from:'Search By From Name'" "thread:XXX 2000-01-01 [1/1] Search By From Name; search by from (name) (inbox unread)"
printf " Search by to: (address)...\t"
add_message '[subject]="search by to (address)"' '[date]="Sat, 01 Jan 2000 12:00:00 -0000"' [to]=searchbyto@example.com
execute_expecting "search to:searchbyto@example.com" "thread:XXX 2000-01-01 [1/1] Notmuch Test Suite; search by to (address) (inbox unread)"
printf " Search by to: (name)...\t"
add_message '[subject]="search by to (name)"' '[date]="Sat, 01 Jan 2000 12:00:00 -0000"' '[to]="Search By To Name <test@example.com>"'
execute_expecting "search to:'Search By To Name'" "thread:XXX 2000-01-01 [1/1] Notmuch Test Suite; search by to (name) (inbox unread)"
notmuch-test: Fix misalignment in output. Clean output is just so much easier to read (and validate).
2010-02-06 02:27:22 +01:00
printf " Search by subject: (phrase)...\t"
notmuch-test: Add several tests of "notmuch search" These tests were surprisingly simple to write---not much code at all and most of them worked the first time even with hand-prepared versions of the expected output.
2010-02-05 19:00:04 +01:00
add_message '[subject]="subject search test (phrase)"' '[date]="Sat, 01 Jan 2000 12:00:00 -0000"'
test: Add some negative results for the phrase searches. These results have all the same terms as the target phrase, but not in the expected order. They are designed to ensure that we actually test phrase searches. And as it turns out, we're not currently quoting the search terms properly, so the phrase-search tests now fail with this commit.
2010-03-11 18:52:08 +01:00
add_message '[subject]="this phrase should not match the subject search test"' '[date]="Sat, 01 Jan 2000 12:00:00 -0000"'
notmuch-test: Add several tests of "notmuch search" These tests were surprisingly simple to write---not much code at all and most of them worked the first time even with hand-prepared versions of the expected output.
2010-02-05 19:00:04 +01:00
execute_expecting "search subject:'subject search test (phrase)'" "thread:XXX 2000-01-01 [1/1] Notmuch Test Suite; subject search test (phrase) (inbox unread)"
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"
notmuch-test: Add a new add_message function. The previous generate_message function is what's needed when testing "notmuch new". But after that, we never want to generate a message without also adding it to the index. So create a new add_message function with this convenience.
2010-02-05 02:34:48 +01:00
add_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]="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
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: Test "notmuch reply" with multiple recipients The feature tested here is that we reply to both the sender and to others addresses on the To: line of the original message, but that we don't reply to our own address.
2010-02-04 21:03:30 +01:00
printf " Multiple recipients...\t\t"
notmuch-test: Add a new add_message function. The previous generate_message function is what's needed when testing "notmuch new". But after that, we never want to generate a message without also adding it to the index. So create a new add_message function with this convenience.
2010-02-05 02:34:48 +01:00
add_message '[from]="Sender <sender@example.com>"' \
'[to]="test_suite@notmuchmail.org, Someone Else <someone@example.com>"' \
[subject]=notmuch-reply-test \
'[date]="Tue, 05 Jan 2010 15:43:56 -0800"' \
'[body]="Multiple recipients"'
notmuch-test: Test "notmuch reply" with multiple recipients The feature tested here is that we reply to both the sender and to others addresses on the To: line of the original message, but that we don't reply to our own address.
2010-02-04 21:03:30 +01:00
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>, Someone Else <someone@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:
> Multiple recipients"
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"
notmuch-test: Add a new add_message function. The previous generate_message function is what's needed when testing "notmuch new". But after that, we never want to generate a message without also adding it to the index. So create a new add_message function with this convenience.
2010-02-05 02:34:48 +01:00
add_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-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
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: Add a new add_message function. The previous generate_message function is what's needed when testing "notmuch new". But after that, we never want to generate a message without also adding it to the index. So create a new add_message function with this convenience.
2010-02-05 02:34:48 +01:00
add_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"' \
'[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
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"
notmuch-test: Add a new add_message function. The previous generate_message function is what's needed when testing "notmuch new". But after that, we never want to generate a message without also adding it to the index. So create a new add_message function with this convenience.
2010-02-05 02:34:48 +01:00
add_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-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
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
notmuch-test: Test "notmuch reply" with a reply-to-munged mail This is a test for the recently added feature where we detect that the reply-to address already exists in the To: or Cc: header so will already be replied to. In this case we want to include the From: address in our reply, (where, otherwise we would use the Reply-To address *instead* of the address in the From header).
2010-02-04 21:08:13 +01:00
printf " Un-munging Reply-To...\t\t"
notmuch-test: Add a new add_message function. The previous generate_message function is what's needed when testing "notmuch new". But after that, we never want to generate a message without also adding it to the index. So create a new add_message function with this convenience.
2010-02-05 02:34:48 +01:00
add_message '[from]="Sender <sender@example.com>"' \
'[to]="Some List <list@example.com>"' \
[subject]=notmuch-reply-test \
'[date]="Tue, 05 Jan 2010 15:43:56 -0800"' \
'[body]="Un-munging Reply-To"' \
'[reply-to]="Evil Munging List <list@example.com>"'
notmuch-test: Test "notmuch reply" with a reply-to-munged mail This is a test for the recently added feature where we detect that the reply-to address already exists in the To: or Cc: header so will already be replied to. In this case we want to include the From: address in our reply, (where, otherwise we would use the Reply-To address *instead* of the address in the From header).
2010-02-04 21:08:13 +01:00
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>, Some List <list@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:
> Un-munging Reply-To"
notmuch-test: Add test to verify that uuencoded data is not indexed. As recently promised, no new features are being accepted to notmuch without corresponding new tests for the test suite.
2010-02-05 19:24:51 +01:00
printf "\nTesting handling of uuencoded data:\n"
add_message [subject]=uuencodetest '[date]="Sat, 01 Jan 2000 12:00:00 -0000"' \
'[body]="This message is used to ensure that notmuch correctly handles a
message containing a block of uuencoded data. First, we have a marker
this content beforeuudata . Then we beging the uunencoded data itself:
begin 644 bogus-uuencoded-data
M0123456789012345678901234567890123456789012345678901234567890
MOBVIOUSLY, THIS IS NOT ANY SORT OF USEFUL UUNECODED DATA.
MINSTEAD THIS IS JUST A WAY TO ENSURE THAT THIS BLOCK OF DATA
MIS CORRECTLY IGNORED WHEN NOTMUCH CREATES ITS INDEX. SO WE
MINCLUDE A DURINGUUDATA MARKER THAT SHOULD NOT RESULT IN ANY
MSEARCH RESULT.
\`
end
Finally, we have our afteruudata marker as well."'
printf " Ensure content before uu data is indexed..."
execute_expecting "search beforeuudata" "thread:XXX 2000-01-01 [1/1] Notmuch Test Suite; uuencodetest (inbox unread)"
printf " Ensure uu data is not indexed...\t"
execute_expecting "search DURINGUUDATA" ""
printf " Ensure content after uu data is indexed..."
execute_expecting "search afteruudata" "thread:XXX 2000-01-01 [1/1] Notmuch Test Suite; uuencodetest (inbox unread)"
notmuch-test: Add basic tests for "notmuch dump" and "notmuch restore" Our test-suite coverage keeps improving, (slowly).
2010-02-06 02:28:25 +01:00
printf "\nTesting \"notmuch dump\" and \"notmuch restore\":\n"
printf " Dumping all tags...\t\t"
$NOTMUCH dump dump.expected
echo " PASS"
printf " Clearing all tags...\t\t"
sed -e 's/(\([^(]*\))$/()/' < dump.expected > clear.expected
$NOTMUCH restore clear.expected
$NOTMUCH dump clear.actual
if diff clear.expected clear.actual > /dev/null; then
echo " PASS"
else
echo " FAIL"
echo " Expected output: See file clear.expected"
echo " Actual output: See file clear.actual"
fi
printf " Restoring original tags...\t"
$NOTMUCH restore dump.expected
$NOTMUCH dump dump.actual
if diff dump.expected dump.actual > /dev/null; then
echo " PASS"
else
echo " FAIL"
echo " Expected output: See file dump.expected"
echo " Actual output: See file dump.actual"
fi
printf " Restore with nothing to do...\t"
$NOTMUCH restore dump.expected
echo " PASS"
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