maryjane
/
syncevolution
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
syncevolution/test/ClientTest.cpp

8369 lines
346 KiB
C++
Raw Blame History

/*
* Copyright (C) 2008 Funambol, Inc.
* Copyright (C) 2008-2009 Patrick Ohly <patrick.ohly@gmx.de>
* Copyright (C) 2009 Intel Corporation
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) version 3.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
* 02110-1301 USA
*/
/** @cond API */
/** @addtogroup ClientTest */
/** @{ */
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif
#ifdef ENABLE_INTEGRATION_TESTS
#include "ClientTest.h"
#include "test.h"
#include "ClientTestAssert.h"
#include <SyncSource.h>
#include <TransportAgent.h>
#include <Logging.h>
#include <syncevo/util.h>
#include <syncevo/SyncContext.h>
#include <VolatileConfigNode.h>
#include <syncevo/Cmdline.h>
#include <synthesis/dataconversion.h>
#include <memory>
#include <vector>
#include <set>
#include <utility>
#include <sstream>
#include <iomanip>
#include <fstream>
#include <iostream>
#include <algorithm>
#include <stdarg.h>
#include <fcntl.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <boost/bind.hpp>
#include <boost/tokenizer.hpp>
#include <boost/assign.hpp>
#include <boost/lambda/lambda.hpp>
#include <boost/lambda/bind.hpp>
#include <boost/lambda/if.hpp>
#include <boost/lambda/casts.hpp>
#include <boost/lambda/switch.hpp>
#include <boost/typeof/typeof.hpp>
#include <pcrecpp.h>
#include <syncevo/declarations.h>
namespace CppUnit {
/**
* behaves like an int and can be compared against one in ASSERT_EQUAL,
* but includes the item list when being printed
*/
struct ItemCount
{
SyncEvo::SyncSourceChanges::Items_t m_items;
ItemCount() {}
ItemCount(const SyncEvo::SyncSourceChanges::Items_t &items) : m_items(items) {}
int size() const { return m_items.size(); }
operator int () const { return size(); }
};
static std::ostream &operator << (ostream &out, const ItemCount &count)
{
out << count.size() << " ( ";
BOOST_FOREACH(const std::string &id, count.m_items) {
out << id << " ";
}
out << ")";
return out;
}
template<> struct assertion_traits<ItemCount>
{
template <class E> static bool equal(const E &expected, const ItemCount &count) { return expected == count; }
static std::string toString(const ItemCount &count)
{
std::ostringstream out;
out << count;
return out.str();
}
};
/** comparison between arbitrary type A and B */
template <class A, class B>
void assertEquals(const A& expected,
const B& actual,
SourceLine sourceLine,
const std::string &message)
{
if (!assertion_traits<B>::equal(expected,actual)) {
Asserter::failNotEqual(assertion_traits<A>::toString(expected),
assertion_traits<B>::toString(actual),
sourceLine,
message);
}
}
}
SE_BEGIN_CXX
/**
* A command line using keyring as configured, but no interactive
* password lookup. The base Cmdline class uses a generic SyncContext
* which uses a SimpleUserInterface without keyring support.
*/
class TestCmdline : public Cmdline
{
public:
// If we could inherit the Cmdline constructor, life would be a lot
// easier... because we can't, we have to copy-and-paste the code
// and rely on protected inheritance of Cmdline members.
TestCmdline(const char *arg, ...) :
Cmdline(std::vector<std::string>())
{
va_list argList;
va_start(argList, arg);
for (const char *curr = arg;
curr;
curr = va_arg(argList, const char *)) {
m_args.push_back(curr);
}
va_end(argList);
m_argc = m_args.size();
m_argvArray.reset(new const char *[m_args.size()]);
for (int i = 0; i < m_argc; i++) {
m_argvArray[i] = m_args[i].c_str();
}
m_argv = m_argvArray.get();
}
virtual SyncContext *createSyncClient() {
std::unique_ptr<SyncContext> context(new SyncContext(m_server, true));
boost::shared_ptr<SimpleUserInterface> ui(new SimpleUserInterface(context->getKeyring()));
context->setUserInterface(ui);
return context.release();
}
};
static set<ClientTest::Cleanup_t> cleanupSet;
/**
* true when running as server,
* relevant for sources instantiated by us
* and testConversion, which does not work in
* server mode (Synthesis engine not in the right
* state when we try to run the test)
*/
static bool isServerMode()
{
const char *serverMode = getenv("CLIENT_TEST_MODE");
return serverMode && !strcmp(serverMode, "server");
}
/**
* CLIENT_TEST_SERVER env variable or "" if unset
*/
std::string currentServer()
{
const char *tmp = getenv("CLIENT_TEST_SERVER");
return tmp ? tmp : "";
}
/**
* This function checks whether the data on the server is accessible
* directly. This is the case for tests where the server side is
* syncevo-http-server or the sync is local. In both cases, this
* method checks the config of <server>_1 (the first client's sync config)
* to find the peer and the uri of the given local source. The peer
* is expected to a source under that name (no alias!).
*
* CLIENT_TEST_SERVER must be set. <server>_1 must exist and (if
* syncing via HTTP) have a deviceId that matches a remoteDeviceId in
* the config used by syncevo-http-server.
*
* @return pair of <peer sync config> + <peer source name>; sync config name empty if not found
*/
std::pair<std::string, std::string> getPeerConfig(const std::string &source)
{
static const char LOCAL_SYNC[] = "local://";
SyncConfig local(currentServer() + "_1");
std::vector<std::string> syncURLs = local.getSyncURL();
boost::shared_ptr<PersistentSyncSourceConfig> sourceConfig(local.getSyncSourceConfig(source));
std::string uri = sourceConfig->getURI();
if (uri.empty()) {
uri = source;
}
std::string peerConfig;
if (syncURLs.size() == 1) {
const std::string &syncURL = syncURLs.front();
if (boost::starts_with(syncURL, LOCAL_SYNC)) {
// Local sync. "target-config" is implied and may be relevant
// later when using the peer source.
peerConfig = syncURL.substr(strlen(LOCAL_SYNC));
if (boost::starts_with(peerConfig, "@")) {
peerConfig = "target-config" + peerConfig;
}
}
}
if (peerConfig.empty()) {
// Check for local HTTP server.
std::string deviceId = local.getDevID();
BOOST_FOREACH (const StringPair &peer, SyncConfig::getConfigs()) {
SyncConfig remote(peer.first);
if (remote.getRemoteDevID() == deviceId) {
peerConfig = peer.first;
break;
}
}
}
return std::make_pair(peerConfig, uri);
}
/**
* Tests involving a specific peer use testcases/synctests/<server
* name>/<source name>/<test name>/<aspect>, where <aspect> is test
* specific. The resulting string typically references a directory
* with individual items. <aspect> can be empty.
*/
std::string getPeerTestdata(const std::string &source, const std::string &test, const std::string &aspect)
{
std::string path = StringPrintf("testcases/synctests/%s/%s/%s/%s",
currentServer().c_str(),
source.c_str(),
test.c_str(),
aspect.c_str());
return path;
}
/**
* CLIENT_TEST_NUM_ITEMS env variable or 100
*/
int defNumItems()
{
char *numitems = getenv("CLIENT_TEST_NUM_ITEMS");
return numitems ? atoi(numitems) : 100;
}
static SyncMode RefreshFromPeerMode()
{
return isServerMode() ? SYNC_REFRESH_FROM_CLIENT : SYNC_REFRESH_FROM_SERVER;
}
static SyncMode RefreshFromLocalMode()
{
return isServerMode() ? SYNC_REFRESH_FROM_SERVER : SYNC_REFRESH_FROM_CLIENT;
}
static SyncMode OneWayFromPeerMode()
{
return isServerMode() ? SYNC_ONE_WAY_FROM_CLIENT : SYNC_ONE_WAY_FROM_SERVER;
}
static SyncMode OneWayFromLocalMode()
{
return isServerMode() ? SYNC_ONE_WAY_FROM_SERVER : SYNC_ONE_WAY_FROM_CLIENT;
}
/**
* remove a certain property from buffer, return removed line
*/
static string stripProperty(std::string &data, const std::string &prop)
{
std::string res;
size_t start = data.find(prop);
if (start != data.npos) {
size_t end = data.find('\n', start);
if (end != data.npos) {
size_t len = end + 1 - start;
res = data.substr(start, len);
data.erase(start, len);
}
}
return res;
}
/**
* insert a property (must include line end) before the end of an item
*/
static void insertProperty(std::string &data,
const std::string &prop,
const std::string &endProp = "END:VEVENT")
{
size_t pos = data.find(endProp);
data.insert(pos, prop);
}
/**
* remove parameter in all properties
*/
static void stripParameters(std::string &data,
const std::string &param)
{
while (true) {
size_t start = data.find(";" + param + "=");
if (start == data.npos) {
break;
}
size_t end = data.find_first_of(";:", start + 1);
if (end == data.npos) {
break;
}
data.erase(start, end - start);
}
}
static void stripComponent(std::string &data,
const std::string &comp)
{
size_t start = data.find("BEGIN:" + comp);
if (start != data.npos) {
size_t end = data.find("END:" + comp);
if (end != data.npos) {
end = data.find('\n', end);
if (end != data.npos) {
data.erase(start, end + 1 - start);
}
}
}
}
/**
* Using this pointer automates the open()/beginSync()/endSync()/close()
* life cycle: it automatically calls these functions when a new
* pointer is assigned or deleted.
*
* Anchors are stored globally in a hash which uses the tracking node
* name as key. This name happens to be the unique file path that
* is created for each source (see TestEvolution::createSource() and
* SyncConfig::getSyncSourceNodes()).
*/
class TestingSyncSourcePtr : public std::unique_ptr<TestingSyncSource>
{
typedef std::unique_ptr<TestingSyncSource> base_t;
bool m_active;
static StringMap m_anchors;
static std::string m_testName;
public:
TestingSyncSourcePtr() : m_active(false) {}
TestingSyncSourcePtr(const TestingSyncSourcePtr &other) : m_active(false) {
CPPUNIT_ASSERT(!other.get());
}
~TestingSyncSourcePtr()
{
// We can skip the full cleanup if the test has already failed.
// Also avoids letting an exception escape from the
// destructor during exception handling (= program aborted!)
// when the endSync() call invoked by reset() needs to
// report a proble. CT_ASSERT_NO_THROW() itself catches that
// exception, but then forwards it, and thus does not
// prevent the exception from escaping.
if (!std::uncaught_exception()) {
CT_ASSERT_NO_THROW(reset(NULL));
}
}
// Not implemented, only declared to keep cppcheck happy.
TestingSyncSourcePtr &operator = (const TestingSyncSourcePtr &other);
enum Flags {
SLOW, /**< erase anchor, start accessing database from scratch */
INCREMENTAL /**< allow source to do incremental data read */
};
void reset(TestingSyncSource *source = NULL, Flags flags = INCREMENTAL)
{
if (get() && m_active) {
stopAccess();
}
// avoid deleting the instance that we are setting
// (shouldn't happen)
if (get() != source) {
base_t::reset(source);
}
if (source) {
startAccess(flags);
}
}
/**
* done automatically as part of reset(), only to be called
* after an explicit stopAccess()
*/
void startAccess(Flags flags = INCREMENTAL)
{
CT_ASSERT(get());
CT_ASSERT(!m_active);
int delay = atoi(getEnv("CLIENT_TEST_SOURCE_DELAY", "0"));
if (delay) {
CLIENT_TEST_LOG("CLIENT_TEST_SOURCE_DELAY: sleep for %d seconds", delay);
sleep(delay);
}
CT_ASSERT_NO_THROW(get()->open());
string node = get()->getTrackingNode()->getName();
string anchor = m_anchors[node];
if (flags == SLOW) {
anchor = "";
}
get()->beginSync(anchor, "");
if (isServerMode()) {
CT_ASSERT_NO_THROW(get()->enableServerMode());
}
// the replaced m_endSession callback was invoked here,
// which shouldn't have been necessary - not calling
// m_endDataWrite post-signal at the moment
// CT_ASSERT_NO_THROW(get()->getOperations().m_endDataWrite.getPostSignal()());
m_active = true;
}
/**
* finish change tracking, source must be activated again
* with startAccess()
*/
void stopAccess()
{
CT_ASSERT(get());
CT_ASSERT(m_active);
m_active = false;
char *dummy = const_cast<char *>("testing-source");
CT_ASSERT_NO_THROW(get()->getOperations().m_endDataWrite.getPostSignal()(*get(), OPERATION_FINISHED, sysync::LOCERR_OK, true, &dummy));
string node = get()->getTrackingNode()->getName();
string anchor;
CT_ASSERT_NO_THROW(anchor = get()->endSync(true));
m_anchors[node] = anchor;
CT_ASSERT_NO_THROW(get()->close());
}
};
StringMap TestingSyncSourcePtr::m_anchors;
std::string TestingSyncSourcePtr::m_testName;
bool SyncOptions::defaultWBXML()
{
const char *t = getenv("CLIENT_TEST_XML");
if (t && (!strcmp(t, "1") || !strcasecmp(t, "t"))) {
// use XML
return false;
} else {
return true;
}
}
std::list<std::string> listItemsOfType(TestingSyncSource *source, int state)
{
std::list<std::string> res;
BOOST_FOREACH(const string &luid, source->getItems(SyncSourceChanges::State(state))) {
res.push_back(luid);
}
return res;
}
static std::list<std::string> listNewItems(TestingSyncSource *source) { return listItemsOfType(source, SyncSourceChanges::NEW); }
static std::list<std::string> listUpdatedItems(TestingSyncSource *source) { return listItemsOfType(source, SyncSourceChanges::UPDATED); }
static std::list<std::string> listDeletedItems(TestingSyncSource *source) { return listItemsOfType(source, SyncSourceChanges::DELETED); }
static std::list<std::string> listItems(TestingSyncSource *source) { return listItemsOfType(source, SyncSourceChanges::ANY); }
static CppUnit::ItemCount countItemsOfType(TestingSyncSource *source, int type) { return source->getItems(SyncSourceChanges::State(type)); }
static CppUnit::ItemCount countNewItems(TestingSyncSource *source) { return countItemsOfType(source, SyncSourceChanges::NEW); }
static CppUnit::ItemCount countUpdatedItems(TestingSyncSource *source) { return countItemsOfType(source, SyncSourceChanges::UPDATED); }
static CppUnit::ItemCount countDeletedItems(TestingSyncSource *source) { return countItemsOfType(source, SyncSourceChanges::DELETED); }
static CppUnit::ItemCount countItems(TestingSyncSource *source) { return countItemsOfType(source, SyncSourceChanges::ANY); }
/** insert new item, return LUID */
static std::string importItem(TestingSyncSource *source, const ClientTestConfig &config, std::string &data)
{
CT_ASSERT(source);
if (data.size()) {
SyncSourceRaw::InsertItemResult res;
SOURCE_ASSERT_NO_FAILURE(source, res = source->insertItemRaw("", config.m_mangleItem(data, false, "")));
CT_ASSERT(!res.m_luid.empty());
return res.m_luid;
} else {
return "";
}
}
/** overwrite existing item */
static void updateItem(TestingSyncSource *source, std::string &data, const std::string &luid)
{
CT_ASSERT(source);
CT_ASSERT(!data.empty());
CT_ASSERT(!luid.empty());
SyncSourceRaw::InsertItemResult res;
SOURCE_ASSERT_NO_FAILURE(source, res = source->insertItemRaw(luid, data));
CT_ASSERT_EQUAL(luid, res.m_luid);
}
/** remove existing item */
static void removeItem(TestingSyncSource *source, const std::string &luid)
{
CT_ASSERT(source);
CT_ASSERT(!luid.empty());
SOURCE_ASSERT_NO_FAILURE(source, source->deleteItem(luid));
}
static void restoreStorage(const ClientTest::Config &config, ClientTest &client)
{
}
static void backupStorage(const ClientTest::Config &config, ClientTest &client)
{
}
/** adds the supported tests to the instance itself */
void LocalTests::addTests() {
if (config.m_createSourceA) {
ADD_TEST(LocalTests, testOpen);
ADD_TEST(LocalTests, testIterateTwice);
ADD_TEST(LocalTests, testDelete404);
ADD_TEST(LocalTests, testReadItem404);
if (!config.m_insertItem.empty()) {
ADD_TEST(LocalTests, testSimpleInsert);
ADD_TEST(LocalTests, testLocalDeleteAll);
ADD_TEST(LocalTests, testComplexInsert);
if (config.m_uniqueID) {
ADD_TEST(LocalTests, testInsertTwice);
}
if (!config.m_updateItem.empty()) {
ADD_TEST(LocalTests, testLocalUpdate);
if (config.m_createSourceB) {
ADD_TEST(LocalTests, testChanges);
ADD_TEST(LocalTests, testChangesMultiCycles);
if (!config.m_linkedSources.empty()) {
ADD_TEST(LocalTests, testLinkedSources);
}
}
}
if (config.m_import &&
config.m_dump &&
config.m_compare &&
!config.m_testcases.empty()) {
ADD_TEST(LocalTests, testImport);
ADD_TEST(LocalTests, testImportDelete);
if (!config.m_essentialProperties.empty()) {
ADD_TEST(LocalTests, testRemoveProperties);
}
}
if (!config.m_templateItem.empty()) {
ADD_TEST(LocalTests, testManyChanges);
}
// create a sub-suite for each set of linked items
for (int i = 0; i < (int)config.m_linkedItems.size(); i++) {
const ClientTestConfig::LinkedItems_t &items = config.m_linkedItems[i];
CppUnit::TestSuite *linked = new CppUnit::TestSuite(getName() + "::LinkedItems" + items.m_name);
ADD_TEST_TO_SUITE(linked, LocalTests, testLinkedItemsParent);
if (config.m_linkedItemsRelaxedSemantic) {
ADD_TEST_TO_SUITE(linked, LocalTests, testLinkedItemsChild);
}
ADD_TEST_TO_SUITE(linked, LocalTests, testLinkedItemsParentChild);
if (items[1].find("RECURRENCE-ID") != items[1].npos &&
config.m_sourceKnowsItemSemantic) {
ADD_TEST_TO_SUITE(linked, LocalTests, testLinkedItemsInsertBothUpdateChildNoIDs);
}
if (config.m_linkedItemsRelaxedSemantic) {
ADD_TEST_TO_SUITE(linked, LocalTests, testLinkedItemsChildParent);
}
if (config.m_linkedItemsRelaxedSemantic) {
ADD_TEST_TO_SUITE(linked, LocalTests, testLinkedItemsChildChangesParent);
}
if (config.m_linkedItemsRelaxedSemantic) {
ADD_TEST_TO_SUITE(linked, LocalTests, testLinkedItemsRemoveParentFirst);
}
ADD_TEST_TO_SUITE(linked, LocalTests, testLinkedItemsRemoveNormal);
if (config.m_sourceKnowsItemSemantic) {
ADD_TEST_TO_SUITE(linked, LocalTests, testLinkedItemsInsertParentTwice);
if (config.m_linkedItemsRelaxedSemantic) {
ADD_TEST_TO_SUITE(linked, LocalTests, testLinkedItemsInsertChildTwice);
}
}
ADD_TEST_TO_SUITE(linked, LocalTests, testLinkedItemsParentUpdate);
if (config.m_linkedItemsRelaxedSemantic) {
ADD_TEST_TO_SUITE(linked, LocalTests, testLinkedItemsUpdateChild);
if (items[1].find("RECURRENCE-ID") != items[1].npos &&
config.m_sourceKnowsItemSemantic) {
ADD_TEST_TO_SUITE(linked, LocalTests, testLinkedItemsUpdateChildNoIDs);
}
}
ADD_TEST_TO_SUITE(linked, LocalTests, testLinkedItemsInsertBothUpdateChild);
ADD_TEST_TO_SUITE(linked, LocalTests, testLinkedItemsInsertBothUpdateParent);
// tests independent of data, only add to default item set
if (i == 0) {
ADD_TEST_TO_SUITE(linked, LocalTests, testLinkedItemsSingle404);
ADD_TEST_TO_SUITE(linked, LocalTests, testLinkedItemsMany404);
}
addTest(linked);
}
// Create a sub-suite for each set of linked items.
// items.size() can be fairly large for these tests,
// so avoid testing all possible combinations.
BOOST_FOREACH(const ClientTestConfig::LinkedItems_t &items,
config.m_linkedItemsSubset) {
CppUnit::TestSuite *linked = new CppUnit::TestSuite(getName() + "::LinkedItems" + items.m_name);
int stride = (items.size() + 4) / 5;
for (int start = 0;
(size_t)start < items.size();
start += stride ) {
for (int skip = 0;
!skip || (size_t)(start + skip + 1) < items.size();
skip++) {
ADD_TEST_TO_SUITE_SUFFIX(linked, LocalTests, testSubset,
StringPrintf("Start%dSkip%d", start, skip));
}
// add a test which uses start, start + 1 and last item
// if that leads to a gap (EXDATE)
if (start > 0 && items.size() - start > 3) {
ADD_TEST_TO_SUITE_SUFFIX(linked, LocalTests, testSubset,
StringPrintf("Start%dExdate", start));
}
}
addTest(linked);
}
}
}
}
std::string LocalTests::insert(const CreateSource &createSource, const std::string &data, bool relaxed, std::string *inserted, const std::string &uniqueUIDSuffix) {
restoreStorage(config, client);
// create source
TestingSyncSourcePtr source;
SOURCE_ASSERT_NO_FAILURE(source.get(), source.reset(createSource()));
// count number of already existing items
int numItems = 0;
CT_ASSERT_NO_THROW(numItems = countItems(source.get()));
SyncSourceRaw::InsertItemResult res;
std::string mangled = config.m_mangleItem(data, false, uniqueUIDSuffix);
if (inserted) {
*inserted = mangled;
}
SOURCE_ASSERT_NO_FAILURE(source.get(), res = source->insertItemRaw("", mangled));
CT_ASSERT(!res.m_luid.empty());
bool updated = false;
if (res.m_state == ITEM_NEEDS_MERGE) {
// conflict detected, overwrite existing item as done in the past
std::string luid = res.m_luid;
SOURCE_ASSERT_NO_FAILURE(source.get(), res = source->insertItemRaw(luid, mangled));
CT_ASSERT_EQUAL(luid, res.m_luid);
CT_ASSERT(res.m_state == ITEM_OKAY);
updated = true;
}
// delete source again
CT_ASSERT_NO_THROW(source.reset());
if (!relaxed) {
// two possible results:
// - a new item was added
// - the item was matched against an existing one
SOURCE_ASSERT_NO_FAILURE(source.get(), source.reset(createSource()));
CT_ASSERT_EQUAL(numItems + ((res.m_state == ITEM_REPLACED || res.m_state == ITEM_MERGED || updated) ? 0 : 1),
countItems(source.get()));
CT_ASSERT_EQUAL(0, countNewItems(source.get()));
CT_ASSERT_EQUAL(0, countUpdatedItems(source.get()));
CT_ASSERT_EQUAL(0, countDeletedItems(source.get()));
}
backupStorage(config, client);
return res.m_luid;
}
/** deletes specific item locally via sync source */
static std::string updateItem(const CreateSource &createSource, const ClientTestConfig &config, const std::string &uid, const std::string &data, std::string *updated = NULL) {
std::string newuid;
CT_ASSERT(createSource.createSource);
// create source
TestingSyncSourcePtr source;
SOURCE_ASSERT_NO_FAILURE(source.get(), source.reset(createSource()));
// insert item
SyncSourceRaw::InsertItemResult res;
std::string mangled;
CT_ASSERT_NO_THROW(mangled = config.m_mangleItem(data, true, ""));
if (updated) {
*updated = mangled;
}
SOURCE_ASSERT_NO_FAILURE(source.get(), res = source->insertItemRaw(uid, mangled.c_str()));
SOURCE_ASSERT(source.get(), !res.m_luid.empty());
return res.m_luid;
}
/** updates specific item locally via sync source */
static void removeItem(const CreateSource &createSource, const std::string &luid)
{
CT_ASSERT(createSource.createSource);
// create source
TestingSyncSourcePtr source;
SOURCE_ASSERT_NO_FAILURE(source.get(), source.reset(createSource()));
// remove item
SOURCE_ASSERT_NO_FAILURE(source.get(), source->deleteItem(luid));
}
void LocalTests::update(const CreateSource &createSource, const std::string &data, bool check, const std::string &uniqueUIDSuffix) {
CT_ASSERT(createSource.createSource);
restoreStorage(config, client);
// create source
TestingSyncSourcePtr source;
SOURCE_ASSERT_NO_FAILURE(source.get(), source.reset(createSource()));
// get existing item, then update it
SyncSourceChanges::Items_t::const_iterator it;
SOURCE_ASSERT_NO_FAILURE(source.get(), it = source->getAllItems().begin());
CT_ASSERT(it != source->getAllItems().end());
string luid = *it;
SyncSourceRaw::InsertItemResult res;
std::string mangled = config.m_mangleItem(data, true, uniqueUIDSuffix);
SOURCE_ASSERT_NO_FAILURE(source.get(), res = source->insertItemRaw(luid, mangled));
CT_ASSERT_NO_THROW(source.reset());
CT_ASSERT_EQUAL(luid, res.m_luid);
CT_ASSERT_EQUAL(ITEM_OKAY, res.m_state);
if (!check) {
return;
}
// check that the right changes are reported when reopening the source
SOURCE_ASSERT_NO_FAILURE(source.get(), source.reset(createSource()));
CT_ASSERT_EQUAL(1, countItems(source.get()));
CT_ASSERT_EQUAL(0, countNewItems(source.get()));
CT_ASSERT_EQUAL(0, countUpdatedItems(source.get()));
CT_ASSERT_EQUAL(0, countDeletedItems(source.get()));
SOURCE_ASSERT_NO_FAILURE(source.get(), it = source->getAllItems().begin());
CT_ASSERT(it != source->getAllItems().end());
CT_ASSERT_EQUAL(luid, *it);
backupStorage(config, client);
}
void LocalTests::update(const CreateSource &createSource, const std::string &data, const std::string &luid) {
CT_ASSERT(createSource.createSource);
restoreStorage(config, client);
// create source
TestingSyncSourcePtr source;
SOURCE_ASSERT_NO_FAILURE(source.get(), source.reset(createSource()));
// update it
SOURCE_ASSERT_NO_FAILURE(source.get(), source->insertItemRaw(luid, config.m_mangleItem(data, true, "")));
backupStorage(config, client);
}
/** deletes all items locally via sync source */
void LocalTests::deleteAll(const CreateSource &createSource) {
CT_ASSERT(createSource.createSource);
restoreStorage(config, client);
// create source
TestingSyncSourcePtr source;
SOURCE_ASSERT_NO_FAILURE(source.get(), source.reset(createSource()));
// delete all items
SOURCE_ASSERT_NO_FAILURE(source.get(), source->removeAllItems());
CT_ASSERT_NO_THROW(source.reset());
// check that all items are gone
SOURCE_ASSERT_NO_FAILURE(source.get(), source.reset(createSource()));
SOURCE_ASSERT_MESSAGE(
"should be empty now",
source.get(),
countItems(source.get()) == 0);
CT_ASSERT_EQUAL( 0, countNewItems(source.get()) );
CT_ASSERT_EQUAL( 0, countUpdatedItems(source.get()) );
CT_ASSERT_EQUAL( 0, countDeletedItems(source.get()) );
backupStorage(config, client);
}
/** deletes specific item locally via sync source */
static void deleteItem(const CreateSource &createSource, const std::string &uid) {
CT_ASSERT(createSource.createSource);
// create source
TestingSyncSourcePtr source;
SOURCE_ASSERT_NO_FAILURE(source.get(), source.reset(createSource()));
// delete item
SOURCE_ASSERT_NO_FAILURE(source.get(), source->deleteItem(uid));
}
/**
* takes two databases, exports them,
* then compares them using synccompare
*
* @param refFile existing file with source reference items, NULL uses a dump of sync source A instead
* @param copy a sync source which contains the copied items, begin/endSync will be called
* @param raiseAssert raise assertion if comparison yields differences (defaults to true)
*/
bool LocalTests::compareDatabases(const char *refFile, TestingSyncSource &copy, bool raiseAssert) {
CT_ASSERT(config.m_dump);
std::string sourceFile, copyFile;
if (refFile) {
sourceFile = refFile;
} else {
sourceFile = getCurrentTest() + ".A.test.dat";
simplifyFilename(sourceFile);
TestingSyncSourcePtr source;
SOURCE_ASSERT_NO_FAILURE(source.get(), source.reset(createSourceA()));
SOURCE_ASSERT_EQUAL(source.get(), 0, config.m_dump(client, *source.get(), sourceFile));
CT_ASSERT_NO_THROW(source.reset());
}
copyFile = getCurrentTest() + ".B.test.dat";
simplifyFilename(copyFile);
CT_ASSERT_EQUAL(0, config.m_dump(client, copy, copyFile));
return compareDatabases(sourceFile, copyFile);
}
bool LocalTests::compareDatabases(const std::string &refFile, const std::string &actualFile, bool raiseAssert)
{
bool equal = false;
CT_ASSERT_NO_THROW(equal = config.m_compare(client, refFile.c_str(), actualFile.c_str()));
CT_ASSERT(!raiseAssert || equal);
return equal;
}
/**
* compare data in source with vararg list of std::string pointers, NULL terminated
*/
void LocalTests::compareDatabases(TestingSyncSource *copy,
...)
{
std::string sourceFile = getCurrentTest() + ".ref.test.dat";
simplifyFilename(sourceFile);
ofstream out(sourceFile.c_str());
va_list ap;
va_start(ap, copy);
std::string *item;
while ((item = va_arg(ap, std::string *)) != NULL) {
out << *item;
}
va_end(ap);
out.close();
compareDatabases(sourceFile.c_str(), *copy);
}
void LocalTests::compareDatabasesRef(TestingSyncSource &copy,
const std::list<std::string> &items)
{
std::string sourceFile = getCurrentTest() + ".ref.test.dat";
simplifyFilename(sourceFile);
ofstream out(sourceFile.c_str());
BOOST_FOREACH(const std::string &item, items) {
out << item;
}
out.close();
compareDatabases(sourceFile.c_str(), copy);
}
std::string LocalTests::createItem(int item, const std::string &revision, int size)
{
std::string data = config.m_mangleItem(config.m_templateItem, false, "");
std::stringstream prefix;
// string to be inserted at start of unique properties;
// avoid adding white space (not sure whether it is valid for UID)
prefix << std::setfill('0') << std::setw(3) << item << "-";
BOOST_FOREACH (std::string curProp,
boost::tokenizer< boost::char_separator<char> >(config.m_uniqueProperties,
boost::char_separator<char>(":"))) {
std::string property;
// property is expected to not start directly at the
// beginning
property = "\n";
property += curProp;
property += ":";
size_t off = data.find(property);
if (off != data.npos) {
data.insert(off + property.size(), prefix.str());
}
}
boost::replace_all(data, "<<UNIQUE>>", prefix.str());
boost::replace_all(data, "<<REVISION>>", revision);
if (size > 0 && (int)data.size() < size) {
int additionalBytes = size - (int)data.size();
int added = 0;
/* vCard 2.1 and vCal 1.0 need quoted-printable line breaks */
bool quoted = data.find("VERSION:1.0") != data.npos ||
data.find("VERSION:2.1") != data.npos;
size_t toreplace = 1;
CT_ASSERT(!config.m_sizeProperty.empty());
/* stuff the item so that it reaches at least that size */
size_t off = data.find(config.m_sizeProperty);
CT_ASSERT(off != data.npos);
std::stringstream stuffing;
if (quoted) {
stuffing << ";ENCODING=QUOTED-PRINTABLE:";
} else {
stuffing << ":";
}
// insert after the first line, it often acts as the summary
if (data.find("BEGIN:VJOURNAL") != data.npos) {
size_t start = data.find(":", off);
CT_ASSERT( start != data.npos );
size_t eol = data.find("\\n", off);
CT_ASSERT( eol != data.npos );
stuffing << data.substr(start + 1, eol - start + 1);
toreplace += eol - start + 1;
}
while(added < additionalBytes) {
int linelen = 0;
while(added + 4 < additionalBytes &&
linelen < 60) {
stuffing << 'x';
added++;
linelen++;
}
// insert line breaks to allow folding
if (quoted) {
stuffing << "x=0D=0Ax";
added += 8;
} else {
stuffing << "x\\nx";
added += 4;
}
}
off = data.find(":", off);
data.replace(off, toreplace, stuffing.str());
}
return data;
}
/**
* insert artificial items, number of them 100
* unless passed explicitly
*
* @param createSource a factory for the sync source that is to be used
* @param startIndex IDs are generated starting with this value
* @param numItems number of items to be inserted if non-null, otherwise config.numItems is used
* @param size minimum size for new items
* @return LUIDs of all inserted items
*/
std::list<std::string> LocalTests::insertManyItems(const CreateSource &createSource, int startIndex, int numItems, int size) {
std::list<std::string> luids;
CT_ASSERT(!config.m_templateItem.empty());
restoreStorage(config, client);
TestingSyncSourcePtr source;
SOURCE_ASSERT_NO_FAILURE(source.get(), source.reset(createSourceA()));
CT_ASSERT(startIndex > 1 || !countItems(source.get()));
int firstIndex = startIndex;
if (firstIndex < 0) {
firstIndex = 1;
}
int lastIndex = firstIndex + (numItems >= 1 ? numItems : defNumItems()) - 1;
for (int item = firstIndex; item <= lastIndex; item++) {
std::string data = createItem(item, "", size);
luids.push_back(importItem(source.get(), config, data));
}
backupStorage(config, client);
return luids;
}
std::list<std::string> LocalTests::insertManyItems(TestingSyncSource *source, int startIndex, int numItems, int size) {
std::list<std::string> luids;
CT_ASSERT(!config.m_templateItem.empty());
CT_ASSERT(startIndex > 1 || !countItems(source));
int firstIndex = startIndex;
if (firstIndex < 0) {
firstIndex = 1;
}
int lastIndex = firstIndex + (numItems >= 1 ? numItems : defNumItems()) - 1;
for (int item = firstIndex; item <= lastIndex; item++) {
std::string data = createItem(item, "", size);
luids.push_back(importItem(source, config, data));
}
return luids;
}
void LocalTests::updateManyItems(const CreateSource &createSource, int startIndex, int numItems, int size,
int revision,
std::list<std::string> &luids,
int offset)
{
CT_ASSERT(!config.m_templateItem.empty());
restoreStorage(config, client);
TestingSyncSourcePtr source;
SOURCE_ASSERT_NO_FAILURE(source.get(), source.reset(createSourceA()));
int firstIndex = startIndex;
if (firstIndex < 0) {
firstIndex = 1;
}
int lastIndex = firstIndex + (numItems >= 1 ? numItems : defNumItems()) - 1;
std::string revstring = StringPrintf("REVISION #%d", revision);
std::list<std::string>::const_iterator it = luids.begin();
for (int i = 0; i < offset && it != luids.end(); i++, ++it) {}
for (int item = firstIndex;
item <= lastIndex && it != luids.end();
item++, ++it) {
std::string data = createItem(item, revstring, size);
updateItem(source.get(), data, *it);
}
backupStorage(config, client);
}
void LocalTests::removeManyItems(const CreateSource &createSource, int numItems,
std::list<std::string> &luids,
int offset)
{
restoreStorage(config, client);
TestingSyncSourcePtr source;
SOURCE_ASSERT_NO_FAILURE(source.get(), source.reset(createSourceA()));
std::list<std::string>::const_iterator it = luids.begin();
for (int i = 0; i < offset && it != luids.end(); i++, ++it) {}
for (int item = 0;
item < numItems && it != luids.end();
item++, ++it) {
removeItem(source.get(), *it);
}
backupStorage(config, client);
}
// update every single item in the database
void LocalTests::updateData(const CreateSource &createSource) {
// check additional requirements
CT_ASSERT(config.m_update);
TestingSyncSourcePtr source;
SOURCE_ASSERT_NO_FAILURE(source.get(), source.reset(createSource()));
BOOST_FOREACH(const string &luid, source->getAllItems()) {
string item;
CT_ASSERT_NO_THROW(source->readItemRaw(luid, item));
CT_ASSERT_NO_THROW(config.m_update(item));
CT_ASSERT_NO_THROW(source->insertItemRaw(luid, item));
}
CT_ASSERT_NO_THROW(source.reset());
}
// creating sync source
void LocalTests::testOpen() {
// check requirements
CT_ASSERT(config.m_createSourceA);
// Intentionally use the plain unique_ptr here and
// call open directly. That way it is a bit more clear
// what happens and where it fails, if it fails.
std::unique_ptr<TestingSyncSource> source;
CT_ASSERT_NO_THROW(source.reset(createSourceA()));
// got a sync source?
CT_ASSERT(source.get() != 0);
// can it be opened?
SOURCE_ASSERT_NO_FAILURE(source.get(), source->open());
// delete it
CT_ASSERT_NO_THROW(source.reset());
}
// restart scanning of items
void LocalTests::testIterateTwice() {
// check requirements
CT_ASSERT(config.m_createSourceA);
// open source
TestingSyncSourcePtr source;
SOURCE_ASSERT_NO_FAILURE(source.get(), source.reset(createSourceA()));
SOURCE_ASSERT_MESSAGE(
"iterating twice should produce identical results",
source.get(),
countItems(source.get()) == countItems(source.get()));
}
// deleteItem() must raise 404 for unknown item
void LocalTests::testDelete404() {
// check requirements
CT_ASSERT(config.m_createSourceA);
// open source
TestingSyncSourcePtr source;
SOURCE_ASSERT_NO_FAILURE(source.get(), source.reset(createSourceA()));
SyncMLStatus status = STATUS_OK;
try {
source->deleteItem("no-such-item");
} catch (const StatusException &ex) {
status = ex.syncMLStatus();
}
CT_ASSERT_EQUAL(STATUS_NOT_FOUND, status);
}
// deleteItem() must raise 404 for unknown item
void LocalTests::testReadItem404() {
// check requirements
CT_ASSERT(config.m_createSourceA);
// open source
TestingSyncSourcePtr source;
SOURCE_ASSERT_NO_FAILURE(source.get(), source.reset(createSourceA()));
SyncMLStatus status = STATUS_OK;
try {
std::string data;
source->readItem("no-such-item", data);
} catch (const StatusException &ex) {
status = ex.syncMLStatus();
}
CT_ASSERT_EQUAL(STATUS_NOT_FOUND, status);
}
void LocalTests::doInsert(bool withUID)
{
// check requirements
CT_ASSERT(!config.m_insertItem.empty());
CT_ASSERT(!config.m_createSourceA.empty());
std::string item = config.m_insertItem;
if (!withUID) {
CT_ASSERT_NO_THROW(stripProperty(item, "UID"));
}
CT_ASSERT_NO_THROW(insert(createSourceA, item));
}
// insert one contact without clearing the source first
void LocalTests::testSimpleInsert() {
// Insert the item without the UID. There is no guarantee that the
// item wasn't already inserted before (database not cleaned by
// test) and some backends (CalDAV) will catch an attempt to
// add the same item twice.
doInsert(false);
}
// delete all items
void LocalTests::testLocalDeleteAll() {
// check requirements
CT_ASSERT(!config.m_insertItem.empty());
CT_ASSERT(config.m_createSourceA);
// make sure there is something to delete, then delete again
std::string item = config.m_insertItem;
CT_ASSERT_NO_THROW(stripProperty(item, "UID"));
CT_ASSERT_NO_THROW(insert(createSourceA, item));
CT_ASSERT_NO_THROW(deleteAll(createSourceA));
}
// clean database, then insert
void LocalTests::testComplexInsert() {
CT_ASSERT(config.m_createSourceA);
CT_ASSERT_NO_THROW(deleteAll(createSourceA));
CT_ASSERT_NO_THROW(doInsert());
CT_ASSERT_NO_THROW(testIterateTwice());
}
// insert the same item (identified by UID) twice => either
// ITEM_NEEDS_MERGE, ITEM_REPLACED or ITEM_MERGED are acceptable
void LocalTests::testInsertTwice() {
CT_ASSERT(config.m_createSourceA);
CT_ASSERT(!config.m_insertItem.empty());
CT_ASSERT(config.m_insertItem.find("\nUID:") != std::string::npos);
CT_ASSERT_NO_THROW(deleteAll(createSourceA));
// create source
TestingSyncSourcePtr source;
SOURCE_ASSERT_NO_FAILURE(source.get(), source.reset(createSourceA()));
// mangle data once
std::string data = config.m_mangleItem(config.m_insertItem, false, "");
// insert new item
SyncSourceRaw::InsertItemResult first;
SOURCE_ASSERT_NO_FAILURE(source.get(), first = source->insertItemRaw("", data));
CT_ASSERT_EQUAL(ITEM_OKAY, first.m_state);
// and again
SyncSourceRaw::InsertItemResult second;
SOURCE_ASSERT_NO_FAILURE(source.get(), second = source->insertItemRaw("", data));
CLIENT_TEST_LOG("item %s",
second.m_state == ITEM_NEEDS_MERGE ? "needs to be merged" :
second.m_state == ITEM_REPLACED ? "was replaced" :
second.m_state == ITEM_MERGED ? "was merged" :
second.m_state == ITEM_OKAY ? "was added, which is broken!" :
"unknown result ?!");
if (config.m_sourceKnowsItemSemantic) {
CT_ASSERT(second.m_state == ITEM_NEEDS_MERGE || second.m_state == ITEM_REPLACED || second.m_state == ITEM_MERGED);
CT_ASSERT_EQUAL(first.m_luid, second.m_luid);
} else {
CT_ASSERT(second.m_state == ITEM_OKAY);
CT_ASSERT(first.m_luid != second.m_luid);
}
if (second.m_state == ITEM_REPLACED || second.m_state == ITEM_MERGED) {
CT_ASSERT(first.m_revision != second.m_revision);
}
}
// clean database, insert item, update it
void LocalTests::testLocalUpdate() {
// check additional requirements
CT_ASSERT(!config.m_updateItem.empty());
CT_ASSERT(config.m_createSourceA);
CT_ASSERT_NO_THROW(deleteAll(createSourceA));
CT_ASSERT_NO_THROW(doInsert());
CT_ASSERT_NO_THROW(update(createSourceA, config.m_updateItem));
}
// Complex sequence of changes, with one restarted instance of source
// B to observe the changes or multiple instances of it.
// Changes are made both via source A and via source B itself.
void LocalTests::doChanges(bool restart) {
SyncSourceChanges::Items_t::const_iterator it, it2;
// check additional requirements
CT_ASSERT(config.m_createSourceB);
CT_ASSERT(config.m_createSourceA);
CLIENT_TEST_LOG("clean via source A");
CT_ASSERT_NO_THROW(deleteAll(createSourceA));
CLIENT_TEST_LOG("insert item via source A");
CT_ASSERT_NO_THROW(doInsert());
CLIENT_TEST_LOG("clean changes in sync source B by creating and closing it");
TestingSyncSourcePtr source;
SOURCE_ASSERT_NO_FAILURE(source.get(), source.reset(createSourceB()));
CT_ASSERT_NO_THROW(restart ? source.stopAccess() : source.reset());
CLIENT_TEST_LOG("no new changes now in source B");
SOURCE_ASSERT_NO_FAILURE(source.get(), restart ? source.startAccess() : source.reset(createSourceB()));
SOURCE_ASSERT_EQUAL(source.get(), 1, countItems(source.get()));
SOURCE_ASSERT_EQUAL(source.get(), 0, countNewItems(source.get()));
SOURCE_ASSERT_EQUAL(source.get(), 0, countUpdatedItems(source.get()));
SOURCE_ASSERT_EQUAL(source.get(), 0, countDeletedItems(source.get()));
string item;
string luid;
SOURCE_ASSERT_NO_FAILURE(source.get(), it = source->getAllItems().begin());
CT_ASSERT(it != source->getAllItems().end());
luid = *it;
// It is not required for incremental syncing that sources must be
// able to return unchanged items. For example, ActiveSyncSource doesn't support
// it because it gets only IDs and data of added or updated items.
// Don't test it.
// SOURCE_ASSERT_NO_FAILURE(source.get(), source->readItem(*it, item));
CT_ASSERT_NO_THROW(restart ? source.stopAccess() : source.reset());
CLIENT_TEST_LOG("delete item again via sync source A");
CT_ASSERT_NO_THROW(deleteAll(createSourceA));
CLIENT_TEST_LOG("check for deleted item via source B");
SOURCE_ASSERT_NO_FAILURE(source.get(), restart ? source.startAccess() : source.reset(createSourceB()));
SOURCE_ASSERT_EQUAL(source.get(), 0, countItems(source.get()));
SOURCE_ASSERT_EQUAL(source.get(), 0, countNewItems(source.get()));
SOURCE_ASSERT_EQUAL(source.get(), 0, countUpdatedItems(source.get()));
SOURCE_ASSERT_EQUAL(source.get(), 1, countDeletedItems(source.get()));
SOURCE_ASSERT_NO_FAILURE(source.get(), it = source->getDeletedItems().begin());
CT_ASSERT(it != source->getDeletedItems().end());
CT_ASSERT(!it->empty());
CT_ASSERT_EQUAL(luid, *it);
CT_ASSERT_NO_THROW(restart ? source.stopAccess() : source.reset());
// Now make changes via source B directly: these changes are not to be
// reported back. Google CalDAV is very strict about UID/SEQUENCE,
// work around that by not reusing a UID inside this test.
SOURCE_ASSERT_NO_FAILURE(source.get(), restart ? source.startAccess() : source.reset(createSourceB()));
// add
std::string mangled = config.m_mangleItem(config.m_insertItem, false, "-B");
SyncSourceRaw::InsertItemResult res;
SOURCE_ASSERT_NO_FAILURE(source.get(), res = source->insertItemRaw("", mangled));
CT_ASSERT(!res.m_luid.empty());
CT_ASSERT_NO_THROW(restart ? source.stopAccess() : source.reset());
// update
SOURCE_ASSERT_NO_FAILURE(source.get(), restart ? source.startAccess() : source.reset(createSourceB()));
SOURCE_ASSERT_EQUAL(source.get(), 1, countItems(source.get()));
SOURCE_ASSERT_EQUAL(source.get(), 0, countNewItems(source.get()));
SOURCE_ASSERT_EQUAL(source.get(), 0, countUpdatedItems(source.get()));
SOURCE_ASSERT_EQUAL(source.get(), 0, countDeletedItems(source.get()));
mangled = config.m_mangleItem(config.m_updateItem, false, "-B");
SOURCE_ASSERT_NO_FAILURE(source.get(), res = source->insertItemRaw(res.m_luid, mangled));
CT_ASSERT_NO_THROW(restart ? source.stopAccess() : source.reset());
// delete
SOURCE_ASSERT_NO_FAILURE(source.get(), restart ? source.startAccess() : source.reset(createSourceB()));
SOURCE_ASSERT_EQUAL(source.get(), 1, countItems(source.get()));
SOURCE_ASSERT_EQUAL(source.get(), 0, countNewItems(source.get()));
SOURCE_ASSERT_EQUAL(source.get(), 0, countUpdatedItems(source.get()));
SOURCE_ASSERT_EQUAL(source.get(), 0, countDeletedItems(source.get()));
SOURCE_ASSERT_NO_FAILURE(source.get(), source->deleteItem(res.m_luid));
CT_ASSERT_NO_THROW(restart ? source.stopAccess() : source.reset());
SOURCE_ASSERT_NO_FAILURE(source.get(), restart ? source.startAccess() : source.reset(createSourceB()));
SOURCE_ASSERT_EQUAL(source.get(), 0, countItems(source.get()));
SOURCE_ASSERT_EQUAL(source.get(), 0, countNewItems(source.get()));
SOURCE_ASSERT_EQUAL(source.get(), 0, countUpdatedItems(source.get()));
SOURCE_ASSERT_EQUAL(source.get(), 0, countDeletedItems(source.get()));
CT_ASSERT_NO_THROW(restart ? source.stopAccess() : source.reset());
CLIENT_TEST_LOG("insert another item via source A");
CT_ASSERT_NO_THROW(insert(createSourceA, config.m_insertItem, false, NULL, "-C"));
CLIENT_TEST_LOG("check for new item via source B");
SOURCE_ASSERT_NO_FAILURE(source.get(), restart ? source.startAccess() : source.reset(createSourceB()));
SOURCE_ASSERT_EQUAL(source.get(), 1, countItems(source.get()));
SOURCE_ASSERT_EQUAL(source.get(), 1, countNewItems(source.get()));
SOURCE_ASSERT_EQUAL(source.get(), 0, countUpdatedItems(source.get()));
SOURCE_ASSERT_EQUAL(source.get(), 0, countDeletedItems(source.get()));
SOURCE_ASSERT_NO_FAILURE(source.get(), it = source->getAllItems().begin());
CT_ASSERT(it != source->getAllItems().end());
luid = *it;
SOURCE_ASSERT_NO_FAILURE(source.get(), source->readItem(*it, item));
string newItem;
SOURCE_ASSERT_NO_FAILURE(source.get(), it = source->getNewItems().begin());
CT_ASSERT(it != source->getNewItems().end());
SOURCE_ASSERT_NO_FAILURE(source.get(), source->readItem(*it, item));
CT_ASSERT_EQUAL(luid, *it);
CT_ASSERT_NO_THROW(restart ? source.stopAccess() : source.reset());
CLIENT_TEST_LOG("update item via source A");
CT_ASSERT_NO_THROW(update(createSourceA, config.m_updateItem, "-C"));
CLIENT_TEST_LOG("check for updated item via source B");
SOURCE_ASSERT_NO_FAILURE(source.get(), restart ? source.startAccess() : source.reset(createSourceB()));
SOURCE_ASSERT_EQUAL(source.get(), 1, countItems(source.get()));
SOURCE_ASSERT_EQUAL(source.get(), 0, countNewItems(source.get()));
SOURCE_ASSERT_EQUAL(source.get(), 1, countUpdatedItems(source.get()));
SOURCE_ASSERT_EQUAL(source.get(), 0, countDeletedItems(source.get()));
string updatedItem;
SOURCE_ASSERT_NO_FAILURE(source.get(), it = source->getUpdatedItems().begin());
CT_ASSERT(it != source->getUpdatedItems().end());
SOURCE_ASSERT_NO_FAILURE(source.get(), source->readItem(*it, updatedItem));
CT_ASSERT_EQUAL(luid, *it);
CT_ASSERT_NO_THROW(restart ? source.stopAccess() : source.reset());
CLIENT_TEST_LOG("one item, no changes in source B");
SOURCE_ASSERT_NO_FAILURE(source.get(), restart ? source.startAccess() : source.reset(createSourceB()));
SOURCE_ASSERT_EQUAL(source.get(), 1, countItems(source.get()));
SOURCE_ASSERT_EQUAL(source.get(), 0, countNewItems(source.get()));
SOURCE_ASSERT_EQUAL(source.get(), 0, countUpdatedItems(source.get()));
SOURCE_ASSERT_EQUAL(source.get(), 0, countDeletedItems(source.get()));
CT_ASSERT_NO_THROW(restart ? source.stopAccess() : source.reset());
CLIENT_TEST_LOG("start anew in both sources");
CT_ASSERT_NO_THROW(deleteAll(createSourceA));
SOURCE_ASSERT_NO_FAILURE(source.get(), restart ? source.startAccess() : source.reset(createSourceB()));
CT_ASSERT_NO_THROW(restart ? source.stopAccess() : source.reset());
CLIENT_TEST_LOG("create and update an item in source A");
// Must use a UID different than the one used before despite that data being gone,
// to keep Google CalDAV server happy.
CT_ASSERT_NO_THROW(insert(createSourceA, config.m_insertItem, false, NULL, "-D"));
CT_ASSERT_NO_THROW(update(createSourceA, config.m_updateItem, "-D"));
CLIENT_TEST_LOG("should only be listed as new or updated in source B, but not both");
SOURCE_ASSERT_NO_FAILURE(source.get(), restart ? source.startAccess() : source.reset(createSourceB()));
SOURCE_ASSERT_EQUAL(source.get(), 1, countItems(source.get()));
SOURCE_ASSERT_EQUAL(source.get(), 1, countNewItems(source.get()) + countUpdatedItems(source.get()));
SOURCE_ASSERT_EQUAL(source.get(), 0, countDeletedItems(source.get()));
CT_ASSERT_NO_THROW(restart ? source.stopAccess() : source.reset());
CLIENT_TEST_LOG("start anew once more in both sources");
CT_ASSERT_NO_THROW(deleteAll(createSourceA));
SOURCE_ASSERT_NO_FAILURE(source.get(), restart ? source.startAccess() : source.reset(createSourceB()));
CT_ASSERT_NO_THROW(restart ? source.stopAccess() : source.reset());
CLIENT_TEST_LOG("create, delete and recreate an item in source A");
CT_ASSERT_NO_THROW(insert(createSourceA, config.m_insertItem, false, NULL, "-E"));
CT_ASSERT_NO_THROW(deleteAll(createSourceA));
CT_ASSERT_NO_THROW(insert(createSourceA, config.m_insertItem, false, NULL, "-F"));
CLIENT_TEST_LOG("should only be listed as new or updated in source B, even if\n "
"(as for calendar with UID) the same LUID gets reused");
SOURCE_ASSERT_NO_FAILURE(source.get(), restart ? source.startAccess() : source.reset(createSourceB()));
SOURCE_ASSERT_EQUAL(source.get(), 1, countItems(source.get()));
SOURCE_ASSERT_EQUAL(source.get(), 1, countNewItems(source.get()) + countUpdatedItems(source.get()));
if (countDeletedItems(source.get()) == 1) {
// It's not nice, but acceptable to send the LUID of a deleted item to a
// server which has never seen that LUID. The LUID must not be the same as
// the one we list as new or updated, though.
SOURCE_ASSERT_NO_FAILURE(source.get(), it = source->getDeletedItems().begin());
CT_ASSERT(it != source->getDeletedItems().end());
SOURCE_ASSERT_NO_FAILURE(source.get(), it2 = source->getNewItems().begin());
if (it2 == source->getNewItems().end()) {
SOURCE_ASSERT_NO_FAILURE(source.get(), it2 = source->getUpdatedItems().begin());
CT_ASSERT(it2 != source->getUpdatedItems().end());
}
CT_ASSERT(*it != *it2);
} else {
SOURCE_ASSERT_EQUAL(source.get(), 0, countDeletedItems(source.get()));
}
CT_ASSERT_NO_THROW(source.reset());
}
// complex sequence of changes, with source B instantiated anew
// after each change
void LocalTests::testChanges()
{
doChanges(false);
}
// complex sequence of changes, with source B only instantiated once
// and restarted multiple times
void LocalTests::testChangesMultiCycles()
{
doChanges(true);
}
// Make changes in one source and verify that other linked
// sources do not see and report any changes in their view
// of the shared database. Source A of the other sources
// is created once and is restarted, source B is created
// from scratch after each change.
void LocalTests::testLinkedSources()
{
// make changes in each of the sources (doesn't have t be
// the current one)
BOOST_FOREACH (LocalTests *main, m_linkedSources) {
CLIENT_TEST_LOG("making changes in %s", main->getSourceName().c_str());
// first delete via *all* sources
BOOST_FOREACH (LocalTests *test, m_linkedSources) {
CLIENT_TEST_LOG("clean via source A of %s", test->getSourceName().c_str());
CT_ASSERT_NO_THROW(test->deleteAll(test->createSourceA));
// reset change tracking in source B
TestingSyncSourcePtr sourceB;
SOURCE_ASSERT_NO_FAILURE(sourceB.get(), sourceB.reset(test->createSourceB()));
}
std::map<std::string, TestingSyncSourcePtr> sourcesA;
BOOST_FOREACH (LocalTests *test, m_linkedSources) {
if (test == main) {
continue;
}
TestingSyncSourcePtr &source = sourcesA[test->getSourceName()];
CLIENT_TEST_LOG("creating source A of %s", test->getSourceName().c_str());
SOURCE_ASSERT_NO_FAILURE(source.get(), source.reset(test->createSourceA()));
CT_ASSERT_NO_THROW(source.stopAccess());
}
// insert one item
CLIENT_TEST_LOG("inserting into %s", main->getSourceName().c_str());
CT_ASSERT_NO_THROW(main->doInsert());
BOOST_FOREACH (LocalTests *test, m_linkedSources) {
if (test == main) {
continue;
}
TestingSyncSourcePtr &source = sourcesA[test->getSourceName()];
CLIENT_TEST_LOG("checking %s after insertion into %s",
test->getSourceName().c_str(),
main->getSourceName().c_str());
SOURCE_ASSERT_NO_FAILURE(source.get(), source.startAccess());
SOURCE_ASSERT_EQUAL(source.get(), 0, countItems(source.get()));
SOURCE_ASSERT_EQUAL(source.get(), 0, countNewItems(source.get()));
SOURCE_ASSERT_EQUAL(source.get(), 0, countUpdatedItems(source.get()));
SOURCE_ASSERT_EQUAL(source.get(), 0, countDeletedItems(source.get()));
SOURCE_ASSERT_NO_FAILURE(source.get(), source.stopAccess());
TestingSyncSourcePtr sourceB;
SOURCE_ASSERT_NO_FAILURE(sourceB.get(), sourceB.reset(test->createSourceB()));
SOURCE_ASSERT_EQUAL(sourceB.get(), 0, countItems(sourceB.get()));
SOURCE_ASSERT_EQUAL(sourceB.get(), 0, countNewItems(sourceB.get()));
SOURCE_ASSERT_EQUAL(sourceB.get(), 0, countUpdatedItems(sourceB.get()));
SOURCE_ASSERT_EQUAL(sourceB.get(), 0, countDeletedItems(sourceB.get()));
}
// update one item
CLIENT_TEST_LOG("updating in %s", main->getSourceName().c_str());
CT_ASSERT_NO_THROW(main->update(main->createSourceA, main->config.m_updateItem));
BOOST_FOREACH (LocalTests *test, m_linkedSources) {
if (test == main) {
continue;
}
TestingSyncSourcePtr &source = sourcesA[test->getSourceName()];
CLIENT_TEST_LOG("checking %s after update into %s",
test->getSourceName().c_str(),
main->getSourceName().c_str());
SOURCE_ASSERT_NO_FAILURE(source.get(), source.startAccess());
SOURCE_ASSERT_EQUAL(source.get(), 0, countItems(source.get()));
SOURCE_ASSERT_EQUAL(source.get(), 0, countNewItems(source.get()));
SOURCE_ASSERT_EQUAL(source.get(), 0, countUpdatedItems(source.get()));
SOURCE_ASSERT_EQUAL(source.get(), 0, countDeletedItems(source.get()));
SOURCE_ASSERT_NO_FAILURE(source.get(), source.stopAccess());
TestingSyncSourcePtr sourceB;
SOURCE_ASSERT_NO_FAILURE(sourceB.get(), sourceB.reset(test->createSourceB()));
SOURCE_ASSERT_EQUAL(sourceB.get(), 0, countItems(sourceB.get()));
SOURCE_ASSERT_EQUAL(sourceB.get(), 0, countNewItems(sourceB.get()));
SOURCE_ASSERT_EQUAL(sourceB.get(), 0, countUpdatedItems(sourceB.get()));
SOURCE_ASSERT_EQUAL(sourceB.get(), 0, countDeletedItems(sourceB.get()));
}
// delete one item
CLIENT_TEST_LOG("deleting in %s", main->getSourceName().c_str());
CT_ASSERT_NO_THROW(main->deleteAll(main->createSourceA));
BOOST_FOREACH (LocalTests *test, m_linkedSources) {
if (test == main) {
continue;
}
TestingSyncSourcePtr &source = sourcesA[test->getSourceName()];
CLIENT_TEST_LOG("checking %s after delete in %s",
test->getSourceName().c_str(),
main->getSourceName().c_str());
SOURCE_ASSERT_NO_FAILURE(source.get(), source.startAccess());
SOURCE_ASSERT_EQUAL(source.get(), 0, countItems(source.get()));
SOURCE_ASSERT_EQUAL(source.get(), 0, countNewItems(source.get()));
SOURCE_ASSERT_EQUAL(source.get(), 0, countUpdatedItems(source.get()));
SOURCE_ASSERT_EQUAL(source.get(), 0, countDeletedItems(source.get()));
SOURCE_ASSERT_NO_FAILURE(source.get(), source.stopAccess());
TestingSyncSourcePtr sourceB;
SOURCE_ASSERT_NO_FAILURE(sourceB.get(), sourceB.reset(test->createSourceB()));
SOURCE_ASSERT_EQUAL(sourceB.get(), 0, countItems(sourceB.get()));
SOURCE_ASSERT_EQUAL(sourceB.get(), 0, countNewItems(sourceB.get()));
SOURCE_ASSERT_EQUAL(sourceB.get(), 0, countUpdatedItems(sourceB.get()));
SOURCE_ASSERT_EQUAL(sourceB.get(), 0, countDeletedItems(sourceB.get()));
}
}
}
// clean database, import file, then export again and compare
void LocalTests::doImport(const std::string &testcases) {
// check additional requirements
CT_ASSERT(config.m_import);
CT_ASSERT(config.m_dump);
CT_ASSERT(config.m_compare);
CT_ASSERT(!testcases.empty());
CT_ASSERT(config.m_createSourceA);
CT_ASSERT_NO_THROW(deleteAll(createSourceA));
// import via sync source A
TestingSyncSourcePtr source;
SOURCE_ASSERT_NO_FAILURE(source.get(), source.reset(createSourceA()));
restoreStorage(config, client);
std::string actualData;
std::string importFailures = config.m_import(client, *source.get(), config, testcases, actualData, NULL);
backupStorage(config, client);
CT_ASSERT_NO_THROW(source.reset());
// export again and compare against original file,
// without relying on change tracking (because
// Google ActiveSync has problems with Fetch,
// which would be needed for a data dump whenr
// using the incremental approach)
TestingSyncSourcePtr copy;
SOURCE_ASSERT_NO_FAILURE(copy.get(), copy.reset(createSourceA(), TestingSyncSourcePtr::SLOW));
bool equal = compareDatabases(actualData.c_str(), *copy.get(), false);
CT_ASSERT_NO_THROW(source.reset());
if (importFailures.empty()) {
CT_ASSERT_MESSAGE("imported and exported data equal", equal);
} else {
CT_ASSERT_EQUAL(std::string(""), importFailures);
}
}
void LocalTests::testImport() {
doImport(config.m_testcases);
}
// same as testImport() with immediate delete
void LocalTests::testImportDelete() {
CT_ASSERT_NO_THROW(testImport());
// delete again, because it was observed that this did not
// work right with calendars in SyncEvolution
CT_ASSERT_NO_THROW(deleteAll(createSourceA));
}
// clean database, import file, update with minimized test data (= all
// non-essential properties removed), compare: verifies that updates
// can remove data
void LocalTests::testRemoveProperties() {
// check additional requirements
CT_ASSERT(config.m_import);
CT_ASSERT(config.m_dump);
CT_ASSERT(config.m_compare);
CT_ASSERT(!config.m_testcases.empty());
CT_ASSERT(config.m_createSourceA);
CT_ASSERT_NO_THROW(deleteAll(createSourceA));
// import via sync source A
TestingSyncSourcePtr source;
SOURCE_ASSERT_NO_FAILURE(source.get(), source.reset(createSourceA()));
restoreStorage(config, client);
std::string testcases;
std::list<std::string> luids;
std::string importFailures = config.m_import(client, *source.get(), config, config.m_testcases, testcases, &luids);
backupStorage(config, client);
CT_ASSERT_NO_THROW(source.reset());
// don't check for correct importing - that is done in testImport
// reduce data
std::list<std::string> items;
std::string dummy;
CT_ASSERT_NO_THROW(ClientTest::getItems(testcases, items, dummy));
static const pcrecpp::RE bodyre("^BEGIN:(VCARD|VEVENT|VTODO|VJOURNAL)\\r?\\n(.*)^(END:\\g1)",
pcrecpp::RE_Options().set_multiline(true).set_dotall(true));
std::string updated = getCurrentTest();
updated += ".updated.";
updated += config.m_sourceName;
updated += ".dat";
simplifyFilename(updated);
ofstream out(updated.c_str());
BOOST_FOREACH (std::string &item, items) {
std::string kind;
pcrecpp::StringPiece body;
CT_ASSERT(bodyre.PartialMatch(item, &kind, &body));
static const pcrecpp::RE propre("^((\\S[^;:]*).*\\n(?:\\s.*\\n)*)",
pcrecpp::RE_Options().set_multiline(true));
pcrecpp::StringPiece input(body);
pcrecpp::StringPiece prop;
std::string propname;
std::list<std::string> result;
while (propre.Consume(&input, &prop, &propname)) {
if (config.m_essentialProperties.find(propname) != config.m_essentialProperties.end()) {
result.push_back(prop.as_string());
}
}
item.replace(body.data() - item.c_str(), body.size(),
boost::join(result, ""));
out << item << "\n";
}
out.close();
// update
SOURCE_ASSERT_NO_FAILURE(source.get(), source.reset(createSourceA()));
std::string updateFailures = config.m_import(client, *source.get(), config, updated, dummy, &luids);
CT_ASSERT_NO_THROW(source.reset());
// compare
TestingSyncSourcePtr copy;
SOURCE_ASSERT_NO_FAILURE(copy.get(), copy.reset(createSourceA(), TestingSyncSourcePtr::SLOW));
std::unique_ptr<ScopedEnvChange> envProps;
if (currentServer() == "googlecontacts") {
// Google CardDAV server does not remove X- properties when
// they are not sent at all. TODO (?): send them as empty
// properties.
envProps.reset(new ScopedEnvChange("CLIENT_TEST_STRIP_PROPERTIES", "(X-.*)"));
}
bool equal = compareDatabases(updated.c_str(), *copy.get(), false);
CT_ASSERT_NO_THROW(source.reset());
if (importFailures.empty() && updateFailures.empty()) {
CT_ASSERT_MESSAGE("imported and exported data equal", equal);
} else {
CT_ASSERT_EQUAL(std::string(""), importFailures + updateFailures);
}
}
// test change tracking with large number of items
void LocalTests::testManyChanges() {
// check additional requirements
CT_ASSERT(!config.m_templateItem.empty());
CT_ASSERT_NO_THROW(deleteAll(createSourceA));
// check that everything is empty, also resets change counter of sync source B
TestingSyncSourcePtr copy;
SOURCE_ASSERT_NO_FAILURE(copy.get(), copy.reset(createSourceB()));
SOURCE_ASSERT_EQUAL(copy.get(), 0, countItems(copy.get()));
CT_ASSERT_NO_THROW(copy.reset());
// now insert plenty of items
int numItems;
CT_ASSERT_NO_THROW(numItems = insertManyItems(createSourceA).size());
// check that exactly this number of items is listed as new
SOURCE_ASSERT_NO_FAILURE(copy.get(), copy.reset(createSourceB()));
SOURCE_ASSERT_EQUAL(copy.get(), numItems, countItems(copy.get()));
SOURCE_ASSERT_EQUAL(copy.get(), numItems, countNewItems(copy.get()));
SOURCE_ASSERT_EQUAL(copy.get(), 0, countUpdatedItems(copy.get()));
SOURCE_ASSERT_EQUAL(copy.get(), 0, countDeletedItems(copy.get()));
CT_ASSERT_NO_THROW(copy.reset());
// delete all items
CT_ASSERT_NO_THROW(deleteAll(createSourceA));
// verify again
SOURCE_ASSERT_NO_FAILURE(copy.get(), copy.reset(createSourceB()));
SOURCE_ASSERT_EQUAL(copy.get(), 0, countItems(copy.get()));
SOURCE_ASSERT_EQUAL(copy.get(), 0, countNewItems(copy.get()));
SOURCE_ASSERT_EQUAL(copy.get(), 0, countUpdatedItems(copy.get()));
SOURCE_ASSERT_EQUAL(copy.get(), numItems, countDeletedItems(copy.get()));
CT_ASSERT_NO_THROW(copy.reset());
}
template<class T, class V> int countEqual(const T &container,
const V &value) {
return count(container.begin(),
container.end(),
value);
}
// test inserting, removing and updating of parent + child item in
// various order plus change tracking
void LocalTests::testLinkedItemsParent() {
ClientTestConfig::LinkedItems_t items = getParentChildData();
CT_ASSERT_NO_THROW(deleteAll(createSourceA));
std::string parent, child;
std::string parentData;
TestingSyncSourcePtr copy;
// check that everything is empty, also resets change counter of sync source B
SOURCE_ASSERT_NO_FAILURE(copy.get(), copy.reset(createSourceB()));
SOURCE_ASSERT_EQUAL(copy.get(), 0, countItems(copy.get()));
CT_ASSERT_NO_THROW(copy.reset());
// now insert main item
CT_ASSERT_NO_THROW(parent = insert(createSourceA, items[0], false, &parentData));
// check that exactly the parent is listed as new
SOURCE_ASSERT_NO_FAILURE(copy.get(), copy.reset(createSourceB()));
CT_ASSERT_NO_THROW(compareDatabases(copy.get(), &parentData, (void *)NULL));
SOURCE_ASSERT_EQUAL(copy.get(), 1, countItems(copy.get()));
SOURCE_ASSERT_EQUAL(copy.get(), 1, countNewItems(copy.get()));
SOURCE_ASSERT_EQUAL(copy.get(), 0, countUpdatedItems(copy.get()));
SOURCE_ASSERT_EQUAL(copy.get(), 0, countDeletedItems(copy.get()));
if (!config.m_sourceLUIDsAreVolatile) {
SOURCE_ASSERT_EQUAL(copy.get(), 1, countEqual(listItems(copy.get()), parent));
}
CT_ASSERT_NO_THROW(copy.reset());
if (getenv("CLIENT_TEST_LINKED_ITEMS_NO_DELETE")) {
return;
}
// delete all items
CT_ASSERT_NO_THROW(deleteAll(createSourceA));
// verify again
SOURCE_ASSERT_NO_FAILURE(copy.get(), copy.reset(createSourceB()));
SOURCE_ASSERT_EQUAL(copy.get(), 0, countItems(copy.get()));
SOURCE_ASSERT_EQUAL(copy.get(), 0, countNewItems(copy.get()));
SOURCE_ASSERT_EQUAL(copy.get(), 0, countUpdatedItems(copy.get()));
SOURCE_ASSERT_EQUAL(copy.get(), 1, countDeletedItems(copy.get()));
if (!config.m_sourceLUIDsAreVolatile) {
SOURCE_ASSERT_EQUAL(copy.get(), 1, countEqual(listDeletedItems(copy.get()), parent));
}
}
// test inserting, removing and updating of parent + child item in
// various order plus change tracking
void LocalTests::testLinkedItemsChild() {
ClientTestConfig::LinkedItems_t items = getParentChildData();
CT_ASSERT_NO_THROW(deleteAll(createSourceA));
std::string parent, child;
std::string childData;
TestingSyncSourcePtr copy;
// check that everything is empty, also resets change counter of sync source B
SOURCE_ASSERT_NO_FAILURE(copy.get(), copy.reset(createSourceB()));
SOURCE_ASSERT_EQUAL(copy.get(), 0, countItems(copy.get()));
CT_ASSERT_NO_THROW(copy.reset());
// same as above for child item
CT_ASSERT_NO_THROW(child = insert(createSourceA, items[1], false, &childData));
SOURCE_ASSERT_NO_FAILURE(copy.get(), copy.reset(createSourceB()));
CT_ASSERT_NO_THROW(compareDatabases(copy.get(), &childData, (void *)NULL));
SOURCE_ASSERT_EQUAL(copy.get(), 1, countItems(copy.get()));
SOURCE_ASSERT_EQUAL(copy.get(), 1, countNewItems(copy.get()));
SOURCE_ASSERT_EQUAL(copy.get(), 0, countUpdatedItems(copy.get()));
SOURCE_ASSERT_EQUAL(copy.get(), 0, countDeletedItems(copy.get()));
if (!config.m_sourceLUIDsAreVolatile) {
SOURCE_ASSERT_EQUAL(copy.get(), 1, countEqual(listItems(copy.get()), child));
}
CT_ASSERT_NO_THROW(copy.reset());
if (getenv("CLIENT_TEST_LINKED_ITEMS_NO_DELETE")) {
return;
}
CT_ASSERT_NO_THROW(deleteAll(createSourceA));
SOURCE_ASSERT_NO_FAILURE(copy.get(), copy.reset(createSourceB()));
SOURCE_ASSERT_EQUAL(copy.get(), 0, countItems(copy.get()));
SOURCE_ASSERT_EQUAL(copy.get(), 0, countNewItems(copy.get()));
SOURCE_ASSERT_EQUAL(copy.get(), 0, countUpdatedItems(copy.get()));
SOURCE_ASSERT_EQUAL(copy.get(), 1, countDeletedItems(copy.get()));
if (!config.m_sourceLUIDsAreVolatile) {
SOURCE_ASSERT_EQUAL(copy.get(), 1, countEqual(listDeletedItems(copy.get()), child));
}
}
// test inserting, removing and updating of parent + child item in
// various order plus change tracking
void LocalTests::testLinkedItemsParentChild() {
ClientTestConfig::LinkedItems_t items = getParentChildData();
CT_ASSERT_NO_THROW(deleteAll(createSourceA));
std::string parent, child;
std::string parentData, childData;
TestingSyncSourcePtr copy;
// check that everything is empty, also resets change counter of sync source B
SOURCE_ASSERT_NO_FAILURE(copy.get(), copy.reset(createSourceB()));
SOURCE_ASSERT_EQUAL(copy.get(), 0, countItems(copy.get()));
CT_ASSERT_NO_THROW(copy.reset());
// insert parent first, then child
CT_ASSERT_NO_THROW(parent = insert(createSourceA, items[0], false, &parentData));
CT_ASSERT_NO_THROW(child = insert(createSourceA, items[1], false, &childData));
SOURCE_ASSERT_NO_FAILURE(copy.get(), copy.reset(createSourceB()));
CT_ASSERT_NO_THROW(compareDatabases(copy.get(), &parentData, &childData, (void *)NULL));
SOURCE_ASSERT_EQUAL(copy.get(), 2, countItems(copy.get()));
SOURCE_ASSERT_EQUAL(copy.get(), 2, countNewItems(copy.get()));
SOURCE_ASSERT_EQUAL(copy.get(), 0, countUpdatedItems(copy.get()));
SOURCE_ASSERT_EQUAL(copy.get(), 0, countDeletedItems(copy.get()));
if (!config.m_sourceLUIDsAreVolatile) {
SOURCE_ASSERT_EQUAL(copy.get(), 1, countEqual(listItems(copy.get()), child));
SOURCE_ASSERT_EQUAL(copy.get(), 1, countEqual(listItems(copy.get()), parent));
}
CT_ASSERT_NO_THROW(copy.reset());
if (config.m_supportsReccurenceEXDates) {
TestingSyncSourcePtr source;
SOURCE_ASSERT_NO_FAILURE(source.get(), source.reset(createSourceA()));
CLIENT_TEST_LOG("retrieve parent as reported to the Synthesis engine, check for X-SYNCEVOLUTION-EXDATE-DETACHED");
std::string parentDataEngine;
CT_ASSERT_NO_THROW(source->readItem(parent, parentDataEngine));
size_t pos = childData.find("RECURRENCE-ID");
CT_ASSERT(pos != childData.npos);
size_t end = childData.find_first_of("\r\n", pos);
CT_ASSERT(end != childData.npos);
std::string exdate = childData.substr(pos, end - pos);
boost::replace_first(exdate, "RECURRENCE-ID", "X-SYNCEVOLUTION-EXDATE-DETACHED");
// not generated because not needed by Synthesis engine
boost::replace_first(exdate, ";VALUE=DATE", "");
pos = parentDataEngine.find(exdate);
CT_ASSERT_MESSAGE(exdate + " not found in:\n" + parentDataEngine, pos != parentDataEngine.npos);
}
if (config.m_supportsReccurenceEXDates) {
TestingSyncSourcePtr source;
SOURCE_ASSERT_NO_FAILURE(source.get(), source.reset(createSourceA()));
CLIENT_TEST_LOG("retrieve parent as reported to the Synthesis engine, check for X-SYNCEVOLUTION-EXDATE-DETACHED");
std::string parentDataEngine;
CT_ASSERT_NO_THROW(source->readItem(parent, parentDataEngine));
size_t pos = childData.find("RECURRENCE-ID");
CT_ASSERT(pos != childData.npos);
size_t end = childData.find_first_of("\r\n", pos);
CT_ASSERT(end != childData.npos);
std::string exdate = childData.substr(pos, end - pos);
boost::replace_first(exdate, "RECURRENCE-ID", "X-SYNCEVOLUTION-EXDATE-DETACHED");
// not generated because not needed by Synthesis engine
boost::replace_first(exdate, ";VALUE=DATE", "");
pos = parentDataEngine.find(exdate);
CT_ASSERT_MESSAGE(exdate + " not found in:\n" + parentDataEngine, pos != parentDataEngine.npos);
}
if (getenv("CLIENT_TEST_LINKED_ITEMS_NO_DELETE")) {
return;
}
CT_ASSERT_NO_THROW(deleteAll(createSourceA));
SOURCE_ASSERT_NO_FAILURE(copy.get(), copy.reset(createSourceB()));
SOURCE_ASSERT_EQUAL(copy.get(), 0, countItems(copy.get()));
SOURCE_ASSERT_EQUAL(copy.get(), 0, countNewItems(copy.get()));
SOURCE_ASSERT_EQUAL(copy.get(), 0, countUpdatedItems(copy.get()));
SOURCE_ASSERT_EQUAL(copy.get(), 2, countDeletedItems(copy.get()));
if (!config.m_sourceLUIDsAreVolatile) {
SOURCE_ASSERT_EQUAL(copy.get(), 1, countEqual(listDeletedItems(copy.get()), child));
SOURCE_ASSERT_EQUAL(copy.get(), 1, countEqual(listDeletedItems(copy.get()), parent));
}
}
// test inserting, removing and updating of parent + child item in
// various order plus change tracking
void LocalTests::testLinkedItemsChildParent() {
ClientTestConfig::LinkedItems_t items = getParentChildData();
CT_ASSERT_NO_THROW(deleteAll(createSourceA));
std::string parent, child;
std::string parentData, childData;
TestingSyncSourcePtr copy;
// check that everything is empty, also resets change counter of sync source B
SOURCE_ASSERT_NO_FAILURE(copy.get(), copy.reset(createSourceB()));
SOURCE_ASSERT_EQUAL(copy.get(), 0, countItems(copy.get()));
CT_ASSERT_NO_THROW(copy.reset());
// insert child first, then parent
CT_ASSERT_NO_THROW(child = insert(createSourceA, items[1], false, &parentData));
CT_ASSERT_NO_THROW(parent = insert(createSourceA, items[0], true, &childData));
SOURCE_ASSERT_NO_FAILURE(copy.get(), copy.reset(createSourceB()));
CT_ASSERT_NO_THROW(compareDatabases(copy.get(), &parentData, &childData, (void *)NULL));
SOURCE_ASSERT_EQUAL(copy.get(), 2, countItems(copy.get()));
SOURCE_ASSERT_EQUAL(copy.get(), 2, countNewItems(copy.get()));
SOURCE_ASSERT_EQUAL(copy.get(), 0, countUpdatedItems(copy.get()));
SOURCE_ASSERT_EQUAL(copy.get(), 0, countDeletedItems(copy.get()));
if (!config.m_sourceLUIDsAreVolatile) {
SOURCE_ASSERT_EQUAL(copy.get(), 1, countEqual(listItems(copy.get()), child));
SOURCE_ASSERT_EQUAL(copy.get(), 1, countEqual(listItems(copy.get()), parent));
}
CT_ASSERT_NO_THROW(copy.reset());
if (getenv("CLIENT_TEST_LINKED_ITEMS_NO_DELETE")) {
return;
}
CT_ASSERT_NO_THROW(deleteAll(createSourceA));
SOURCE_ASSERT_NO_FAILURE(copy.get(), copy.reset(createSourceB()));
SOURCE_ASSERT_EQUAL(copy.get(), 0, countItems(copy.get()));
SOURCE_ASSERT_EQUAL(copy.get(), 0, countNewItems(copy.get()));
SOURCE_ASSERT_EQUAL(copy.get(), 0, countUpdatedItems(copy.get()));
SOURCE_ASSERT_EQUAL(copy.get(), 2, countDeletedItems(copy.get()));
if (!config.m_sourceLUIDsAreVolatile) {
SOURCE_ASSERT_EQUAL(copy.get(), 1, countEqual(listDeletedItems(copy.get()), child));
SOURCE_ASSERT_EQUAL(copy.get(), 1, countEqual(listDeletedItems(copy.get()), parent));
}
}
// test inserting, removing and updating of parent + child item in
// various order plus change tracking
void LocalTests::testLinkedItemsChildChangesParent() {
ClientTestConfig::LinkedItems_t items = getParentChildData();
CT_ASSERT_NO_THROW(deleteAll(createSourceA));
std::string parent, child;
std::string parentData, childData;
TestingSyncSourcePtr copy;
// check that everything is empty, also resets change counter of sync source B
SOURCE_ASSERT_NO_FAILURE(copy.get(), copy.reset(createSourceB()));
SOURCE_ASSERT_EQUAL(copy.get(), 0, countItems(copy.get()));
CT_ASSERT_NO_THROW(copy.reset());
// insert child first, check changes, then insert the parent
CT_ASSERT_NO_THROW(child = insert(createSourceA, items[1], false, &childData));
SOURCE_ASSERT_NO_FAILURE(copy.get(), copy.reset(createSourceB()));
CT_ASSERT_NO_THROW(compareDatabases(copy.get(), &childData, (void *)NULL));
SOURCE_ASSERT_EQUAL(copy.get(), 1, countItems(copy.get()));
SOURCE_ASSERT_EQUAL(copy.get(), 1, countNewItems(copy.get()));
SOURCE_ASSERT_EQUAL(copy.get(), 0, countUpdatedItems(copy.get()));
SOURCE_ASSERT_EQUAL(copy.get(), 0, countDeletedItems(copy.get()));
if (!config.m_sourceLUIDsAreVolatile) {
SOURCE_ASSERT_EQUAL(copy.get(), 1, countEqual(listItems(copy.get()), child));
}
CT_ASSERT_NO_THROW(copy.reset());
CT_ASSERT_NO_THROW(parent = insert(createSourceA, items[0], true, &parentData));
SOURCE_ASSERT_NO_FAILURE(copy.get(), copy.reset(createSourceB()));
CT_ASSERT_NO_THROW(compareDatabases(copy.get(), &parentData, &childData, (void *)NULL));
SOURCE_ASSERT_EQUAL(copy.get(), 2, countItems(copy.get()));
SOURCE_ASSERT_EQUAL(copy.get(), 1, countNewItems(copy.get()));
if (!config.m_sourceLUIDsAreVolatile) {
SOURCE_ASSERT_EQUAL(copy.get(), 1, countEqual(listNewItems(copy.get()), parent));
}
// relaxed semantic: the child item might be considered updated now if
// it had to be modified when inserting the parent
SOURCE_ASSERT(copy.get(), 1 >= countUpdatedItems(copy.get()));
SOURCE_ASSERT_EQUAL(copy.get(), 0, countDeletedItems(copy.get()));
if (!config.m_sourceLUIDsAreVolatile) {
SOURCE_ASSERT_EQUAL(copy.get(), 1, countEqual(listItems(copy.get()), child));
SOURCE_ASSERT_EQUAL(copy.get(), 1, countEqual(listItems(copy.get()), parent));
}
CT_ASSERT_NO_THROW(copy.reset());
if (getenv("CLIENT_TEST_LINKED_ITEMS_NO_DELETE")) {
return;
}
CT_ASSERT_NO_THROW(deleteAll(createSourceA));
SOURCE_ASSERT_NO_FAILURE(copy.get(), copy.reset(createSourceB()));
SOURCE_ASSERT_EQUAL(copy.get(), 0, countItems(copy.get()));
SOURCE_ASSERT_EQUAL(copy.get(), 0, countNewItems(copy.get()));
SOURCE_ASSERT_EQUAL(copy.get(), 0, countUpdatedItems(copy.get()));
SOURCE_ASSERT_EQUAL(copy.get(), 2, countDeletedItems(copy.get()));
if (!config.m_sourceLUIDsAreVolatile) {
SOURCE_ASSERT_EQUAL(copy.get(), 1, countEqual(listDeletedItems(copy.get()), child));
SOURCE_ASSERT_EQUAL(copy.get(), 1, countEqual(listDeletedItems(copy.get()), parent));
}
}
// test inserting, removing and updating of parent + child item in
// various order plus change tracking
void LocalTests::testLinkedItemsRemoveParentFirst() {
ClientTestConfig::LinkedItems_t items = getParentChildData();
CT_ASSERT_NO_THROW(deleteAll(createSourceA));
std::string parent, child;
std::string parentData, childData;
TestingSyncSourcePtr copy;
// check that everything is empty, also resets change counter of sync source B
SOURCE_ASSERT_NO_FAILURE(copy.get(), copy.reset(createSourceB()));
SOURCE_ASSERT_EQUAL(copy.get(), 0, countItems(copy.get()));
CT_ASSERT_NO_THROW(copy.reset());
// insert both items, remove parent, then child
CT_ASSERT_NO_THROW(parent = insert(createSourceA, items[0], false, &parentData));
CT_ASSERT_NO_THROW(child = insert(createSourceA, items[1], false, &childData));
SOURCE_ASSERT_NO_FAILURE(copy.get(), copy.reset(createSourceB()));
CT_ASSERT_NO_THROW(compareDatabases(copy.get(), &parentData, &childData, (void *)NULL));
SOURCE_ASSERT_EQUAL(copy.get(), 2, countItems(copy.get()));
SOURCE_ASSERT_EQUAL(copy.get(), 2, countNewItems(copy.get()));
SOURCE_ASSERT_EQUAL(copy.get(), 0, countUpdatedItems(copy.get()));
SOURCE_ASSERT_EQUAL(copy.get(), 0, countDeletedItems(copy.get()));
if (!config.m_sourceLUIDsAreVolatile) {
SOURCE_ASSERT_EQUAL(copy.get(), 1, countEqual(listItems(copy.get()), child));
SOURCE_ASSERT_EQUAL(copy.get(), 1, countEqual(listItems(copy.get()), parent));
}
CT_ASSERT_NO_THROW(copy.reset());
CT_ASSERT_NO_THROW(deleteItem(createSourceA, parent));
SOURCE_ASSERT_NO_FAILURE(copy.get(), copy.reset(createSourceB()));
CT_ASSERT_NO_THROW(compareDatabases(copy.get(), &childData, (void *)NULL));
SOURCE_ASSERT_EQUAL(copy.get(), 1, countItems(copy.get()));
SOURCE_ASSERT_EQUAL(copy.get(), 0, countNewItems(copy.get()));
// deleting the parent may or may not modify the child
SOURCE_ASSERT(copy.get(), 1 >= countUpdatedItems(copy.get()));
SOURCE_ASSERT_EQUAL(copy.get(), 1, countDeletedItems(copy.get()));
if (!config.m_sourceLUIDsAreVolatile) {
SOURCE_ASSERT_EQUAL(copy.get(), 1, countEqual(listDeletedItems(copy.get()), parent));
}
CT_ASSERT_NO_THROW(copy.reset());
if (getenv("CLIENT_TEST_LINKED_ITEMS_NO_DELETE")) {
return;
}
CT_ASSERT_NO_THROW(deleteItem(createSourceA, child));
SOURCE_ASSERT_NO_FAILURE(copy.get(), copy.reset(createSourceB()));
SOURCE_ASSERT_EQUAL(copy.get(), 0, countItems(copy.get()));
SOURCE_ASSERT_EQUAL(copy.get(), 0, countNewItems(copy.get()));
SOURCE_ASSERT_EQUAL(copy.get(), 0, countUpdatedItems(copy.get()));
SOURCE_ASSERT_EQUAL(copy.get(), 1, countDeletedItems(copy.get()));
if (!config.m_sourceLUIDsAreVolatile) {
SOURCE_ASSERT_EQUAL(copy.get(), 1, countEqual(listDeletedItems(copy.get()), child));
}
CT_ASSERT_NO_THROW(copy.reset());
}
// test inserting, removing and updating of parent + child item in
// various order plus change tracking
void LocalTests::testLinkedItemsRemoveNormal() {
ClientTestConfig::LinkedItems_t items = getParentChildData();
CT_ASSERT_NO_THROW(deleteAll(createSourceA));
std::string parent, child;
std::string parentData, childData;
TestingSyncSourcePtr source, copy;
// check that everything is empty, also resets change counter of sync source B
SOURCE_ASSERT_NO_FAILURE(copy.get(), copy.reset(createSourceB()));
SOURCE_ASSERT_EQUAL(copy.get(), 0, countItems(copy.get()));
CT_ASSERT_NO_THROW(copy.reset());
// insert both items, remove child, then parent
CT_ASSERT_NO_THROW(parent = insert(createSourceA, items[0], false, &parentData));
CT_ASSERT_NO_THROW(child = insert(createSourceA, items[1], false, &childData));
SOURCE_ASSERT_NO_FAILURE(copy.get(), copy.reset(createSourceB()));
CT_ASSERT_NO_THROW(compareDatabases(copy.get(), &parentData, &childData, (void *)NULL));
SOURCE_ASSERT_EQUAL(copy.get(), 2, countItems(copy.get()));
SOURCE_ASSERT_EQUAL(copy.get(), 2, countNewItems(copy.get()));
SOURCE_ASSERT_EQUAL(copy.get(), 0, countUpdatedItems(copy.get()));
SOURCE_ASSERT_EQUAL(copy.get(), 0, countDeletedItems(copy.get()));
if (!config.m_sourceLUIDsAreVolatile) {
SOURCE_ASSERT_EQUAL(copy.get(), 1, countEqual(listItems(copy.get()), child));
SOURCE_ASSERT_EQUAL(copy.get(), 1, countEqual(listItems(copy.get()), parent));
}
CT_ASSERT_NO_THROW(copy.reset());
CT_ASSERT_NO_THROW(deleteItem(createSourceA, child));
// The removal of the child fails with Exchange (BMC #22849).
// Skip the testing, proceed to full removal.
if (currentServer() != "exchange") {
SOURCE_ASSERT_NO_FAILURE(source.get(), source.reset(createSourceA()));
if (getCurrentTest().find("::eds_event::") != std::string::npos) {
bool usingEDSLT36;
#ifdef EVOLUTION_COMPATIBILITY
// Need to check at runtime.
// We are using EDS < 3.6 if (and only if) we found the right libs.
usingEDSLT36 = EDSAbiHaveEcal;
#elif defined(USE_EDS_CLIENT)
// Detected at runtime: new EDS API.
usingEDSLT36 = false;
#else
// Detected at runtime: old EDS API.
usingEDSLT36 = true;
#endif
if (usingEDSLT36) {
// hack: ignore EDS < 3.6 side effect of adding EXDATE to parent, see http://bugs.meego.com/show_bug.cgi?id=10906
size_t pos = parentData.rfind("DTSTART");
parentData.insert(pos,
getCurrentTest().find("LinkedItemsAllDay") == std::string::npos ?
"EXDATE:20080413T090000\n" :
"EXDATE:20080413\n");
}
}
CT_ASSERT_NO_THROW(compareDatabases(source.get(), &parentData, (void *)NULL));
SOURCE_ASSERT_EQUAL(source.get(), 1, countItems(source.get()));
SOURCE_ASSERT_EQUAL(source.get(), 0, countNewItems(source.get()));
SOURCE_ASSERT_EQUAL(source.get(), 0, countUpdatedItems(source.get()));
SOURCE_ASSERT_EQUAL(source.get(), 0, countDeletedItems(source.get()));
CT_ASSERT_NO_THROW(source.reset());
SOURCE_ASSERT_NO_FAILURE(copy.get(), copy.reset(createSourceB()));
SOURCE_ASSERT_EQUAL(copy.get(), 1, countItems(copy.get()));
SOURCE_ASSERT_EQUAL(copy.get(), 0, countNewItems(copy.get()));
// parent might have been updated
int updated = false;
CT_ASSERT_NO_THROW(updated = countUpdatedItems(copy.get()));
SOURCE_ASSERT(copy.get(), 0 <= updated && updated <= 1);
SOURCE_ASSERT_EQUAL(copy.get(), 1, countDeletedItems(copy.get()));
if (!config.m_sourceLUIDsAreVolatile) {
SOURCE_ASSERT_EQUAL(copy.get(), 1, countEqual(listDeletedItems(copy.get()), child));
}
CT_ASSERT_NO_THROW(copy.reset());
}
CT_ASSERT_NO_THROW(deleteItem(createSourceA, parent));
SOURCE_ASSERT_NO_FAILURE(copy.get(), copy.reset(createSourceB()));
SOURCE_ASSERT_EQUAL(copy.get(), 0, countItems(copy.get()));
SOURCE_ASSERT_EQUAL(copy.get(), 0, countNewItems(copy.get()));
SOURCE_ASSERT_EQUAL(copy.get(), 0, countUpdatedItems(copy.get()));
SOURCE_ASSERT_EQUAL(copy.get(),
// Exchange did not actually remove child above, done now.
currentServer() != "exchange" ? 1 : 2,
countDeletedItems(copy.get()));
if (!config.m_sourceLUIDsAreVolatile) {
SOURCE_ASSERT_EQUAL(copy.get(), 1, countEqual(listDeletedItems(copy.get()), parent));
}
CT_ASSERT_NO_THROW(copy.reset());
}
// test inserting, removing and updating of parent + child item in
// various order plus change tracking
void LocalTests::testLinkedItemsInsertParentTwice() {
ClientTestConfig::LinkedItems_t items = getParentChildData();
CT_ASSERT_NO_THROW(deleteAll(createSourceA));
std::string parent, child;
std::string parentData, childData;
TestingSyncSourcePtr copy;
// check that everything is empty, also resets change counter of sync source B
SOURCE_ASSERT_NO_FAILURE(copy.get(), copy.reset(createSourceB()));
SOURCE_ASSERT_EQUAL(copy.get(), 0, countItems(copy.get()));
CT_ASSERT_NO_THROW(copy.reset());
// add parent twice (should be turned into update)
CT_ASSERT_NO_THROW(parent = insert(createSourceA, items[0], false, &parentData));
SOURCE_ASSERT_NO_FAILURE(copy.get(), copy.reset(createSourceB()));
CT_ASSERT_NO_THROW(compareDatabases(copy.get(), &parentData, (void *)NULL));
SOURCE_ASSERT_EQUAL(copy.get(), 1, countItems(copy.get()));
SOURCE_ASSERT_EQUAL(copy.get(), 1, countNewItems(copy.get()));
SOURCE_ASSERT_EQUAL(copy.get(), 0, countUpdatedItems(copy.get()));
SOURCE_ASSERT_EQUAL(copy.get(), 0, countDeletedItems(copy.get()));
if (!config.m_sourceLUIDsAreVolatile) {
SOURCE_ASSERT_EQUAL(copy.get(), 1, countEqual(listItems(copy.get()), parent));
}
CT_ASSERT_NO_THROW(copy.reset());
CT_ASSERT_NO_THROW(parent = insert(createSourceA, items[0], false, &parentData));
SOURCE_ASSERT_NO_FAILURE(copy.get(), copy.reset(createSourceB()));
CT_ASSERT_NO_THROW(compareDatabases(copy.get(), &parentData, (void *)NULL));
SOURCE_ASSERT_EQUAL(copy.get(), 1, countItems(copy.get()));
SOURCE_ASSERT_EQUAL(copy.get(), 0, countNewItems(copy.get()));
SOURCE_ASSERT_EQUAL(copy.get(), 1, countUpdatedItems(copy.get()));
SOURCE_ASSERT_EQUAL(copy.get(), 0, countDeletedItems(copy.get()));
if (!config.m_sourceLUIDsAreVolatile) {
SOURCE_ASSERT_EQUAL(copy.get(), 1, countEqual(listUpdatedItems(copy.get()), parent));
}
CT_ASSERT_NO_THROW(copy.reset());
if (getenv("CLIENT_TEST_LINKED_ITEMS_NO_DELETE")) {
return;
}
CT_ASSERT_NO_THROW(deleteItem(createSourceA, parent));
SOURCE_ASSERT_NO_FAILURE(copy.get(), copy.reset(createSourceB()));
SOURCE_ASSERT_EQUAL(copy.get(), 0, countItems(copy.get()));
SOURCE_ASSERT_EQUAL(copy.get(), 0, countNewItems(copy.get()));
SOURCE_ASSERT_EQUAL(copy.get(), 0, countUpdatedItems(copy.get()));
SOURCE_ASSERT_EQUAL(copy.get(), 1, countDeletedItems(copy.get()));
if (!config.m_sourceLUIDsAreVolatile) {
SOURCE_ASSERT_EQUAL(copy.get(), 1, countEqual(listDeletedItems(copy.get()), parent));
}
}
// test inserting, removing and updating of parent + child item in
// various order plus change tracking
void LocalTests::testLinkedItemsInsertChildTwice() {
ClientTestConfig::LinkedItems_t items = getParentChildData();
CT_ASSERT_NO_THROW(deleteAll(createSourceA));
std::string parent, child;
std::string parentData, childData;
TestingSyncSourcePtr copy;
// check that everything is empty, also resets change counter of sync source B
SOURCE_ASSERT_NO_FAILURE(copy.get(), copy.reset(createSourceB()));
SOURCE_ASSERT_EQUAL(copy.get(), 0, countItems(copy.get()));
CT_ASSERT_NO_THROW(copy.reset());
// add child twice (should be turned into update)
CT_ASSERT_NO_THROW(child = insert(createSourceA, items[1], false, &childData));
SOURCE_ASSERT_NO_FAILURE(copy.get(), copy.reset(createSourceB()));
CT_ASSERT_NO_THROW(compareDatabases(copy.get(), &childData, (void *)NULL));
SOURCE_ASSERT_EQUAL(copy.get(), 1, countItems(copy.get()));
SOURCE_ASSERT_EQUAL(copy.get(), 1, countNewItems(copy.get()));
SOURCE_ASSERT_EQUAL(copy.get(), 0, countUpdatedItems(copy.get()));
SOURCE_ASSERT_EQUAL(copy.get(), 0, countDeletedItems(copy.get()));
if (!config.m_sourceLUIDsAreVolatile) {
SOURCE_ASSERT_EQUAL(copy.get(), 1, countEqual(listItems(copy.get()), child));
}
CT_ASSERT_NO_THROW(copy.reset());
CT_ASSERT_NO_THROW(child = insert(createSourceA, items[1]));
SOURCE_ASSERT_NO_FAILURE(copy.get(), copy.reset(createSourceB()));
CT_ASSERT_NO_THROW(compareDatabases(copy.get(), &childData, (void *)NULL));
SOURCE_ASSERT_EQUAL(copy.get(), 1, countItems(copy.get()));
SOURCE_ASSERT_EQUAL(copy.get(), 0, countNewItems(copy.get()));
SOURCE_ASSERT_EQUAL(copy.get(), 1, countUpdatedItems(copy.get()));
SOURCE_ASSERT_EQUAL(copy.get(), 0, countDeletedItems(copy.get()));
if (!config.m_sourceLUIDsAreVolatile) {
SOURCE_ASSERT_EQUAL(copy.get(), 1, countEqual(listUpdatedItems(copy.get()), child));
}
CT_ASSERT_NO_THROW(copy.reset());
if (getenv("CLIENT_TEST_LINKED_ITEMS_NO_DELETE")) {
return;
}
CT_ASSERT_NO_THROW(deleteItem(createSourceA, child));
SOURCE_ASSERT_NO_FAILURE(copy.get(), copy.reset(createSourceB()));
SOURCE_ASSERT_EQUAL(copy.get(), 0, countItems(copy.get()));
SOURCE_ASSERT_EQUAL(copy.get(), 0, countNewItems(copy.get()));
SOURCE_ASSERT_EQUAL(copy.get(), 0, countUpdatedItems(copy.get()));
SOURCE_ASSERT_EQUAL(copy.get(), 1, countDeletedItems(copy.get()));
if (!config.m_sourceLUIDsAreVolatile) {
SOURCE_ASSERT_EQUAL(copy.get(), 1, countEqual(listDeletedItems(copy.get()), child));
}
}
// test inserting, removing and updating of parent + child item in
// various order plus change tracking
void LocalTests::testLinkedItemsParentUpdate() {
ClientTestConfig::LinkedItems_t items = getParentChildData();
CT_ASSERT_NO_THROW(deleteAll(createSourceA));
std::string parent, child;
std::string parentData, childData;
TestingSyncSourcePtr copy;
// check that everything is empty, also resets change counter of sync source B
SOURCE_ASSERT_NO_FAILURE(copy.get(), copy.reset(createSourceB()));
SOURCE_ASSERT_EQUAL(copy.get(), 0, countItems(copy.get()));
CT_ASSERT_NO_THROW(copy.reset());
// add parent, then update it
CT_ASSERT_NO_THROW(parent = insert(createSourceA, items[0], false, &parentData));
SOURCE_ASSERT_NO_FAILURE(copy.get(), copy.reset(createSourceB()));
CT_ASSERT_NO_THROW(compareDatabases(copy.get(), &parentData, (void *)NULL));
SOURCE_ASSERT_EQUAL(copy.get(), 1, countItems(copy.get()));
SOURCE_ASSERT_EQUAL(copy.get(), 1, countNewItems(copy.get()));
SOURCE_ASSERT_EQUAL(copy.get(), 0, countUpdatedItems(copy.get()));
SOURCE_ASSERT_EQUAL(copy.get(), 0, countDeletedItems(copy.get()));
if (!config.m_sourceLUIDsAreVolatile) {
SOURCE_ASSERT_EQUAL(copy.get(), 1, countEqual(listItems(copy.get()), parent));
}
CT_ASSERT_NO_THROW(copy.reset());
CT_ASSERT_NO_THROW(parent = updateItem(createSourceA, config, parent, items[0], &parentData));
SOURCE_ASSERT_NO_FAILURE(copy.get(), copy.reset(createSourceB()));
CT_ASSERT_NO_THROW(compareDatabases(copy.get(), &parentData, (void *)NULL));
SOURCE_ASSERT_EQUAL(copy.get(), 1, countItems(copy.get()));
SOURCE_ASSERT_EQUAL(copy.get(), 0, countNewItems(copy.get()));
SOURCE_ASSERT_EQUAL(copy.get(), 1, countUpdatedItems(copy.get()));
SOURCE_ASSERT_EQUAL(copy.get(), 0, countDeletedItems(copy.get()));
if (!config.m_sourceLUIDsAreVolatile) {
SOURCE_ASSERT_EQUAL(copy.get(), 1, countEqual(listUpdatedItems(copy.get()), parent));
}
CT_ASSERT_NO_THROW(copy.reset());
if (getenv("CLIENT_TEST_LINKED_ITEMS_NO_DELETE")) {
return;
}
CT_ASSERT_NO_THROW(deleteItem(createSourceA, parent));
SOURCE_ASSERT_NO_FAILURE(copy.get(), copy.reset(createSourceB()));
SOURCE_ASSERT_EQUAL(copy.get(), 0, countItems(copy.get()));
SOURCE_ASSERT_EQUAL(copy.get(), 0, countNewItems(copy.get()));
SOURCE_ASSERT_EQUAL(copy.get(), 0, countUpdatedItems(copy.get()));
SOURCE_ASSERT_EQUAL(copy.get(), 1, countDeletedItems(copy.get()));
if (!config.m_sourceLUIDsAreVolatile) {
SOURCE_ASSERT_EQUAL(copy.get(), 1, countEqual(listDeletedItems(copy.get()), parent));
}
CT_ASSERT_NO_THROW(copy.reset());
}
// test inserting, removing and updating of parent + child item in
// various order plus change tracking
void LocalTests::testLinkedItemsUpdateChild() {
ClientTestConfig::LinkedItems_t items = getParentChildData();
CT_ASSERT_NO_THROW(deleteAll(createSourceA));
std::string parent, child;
std::string parentData, childData;
TestingSyncSourcePtr copy;
// check that everything is empty, also resets change counter of sync source B
SOURCE_ASSERT_NO_FAILURE(copy.get(), copy.reset(createSourceB()));
SOURCE_ASSERT_EQUAL(copy.get(), 0, countItems(copy.get()));
CT_ASSERT_NO_THROW(copy.reset());
// add child, then update it
CT_ASSERT_NO_THROW(child = insert(createSourceA, items[1], false, &childData));
SOURCE_ASSERT_NO_FAILURE(copy.get(), copy.reset(createSourceB()));
CT_ASSERT_NO_THROW(compareDatabases(copy.get(), &childData, (void *)NULL));
SOURCE_ASSERT_EQUAL(copy.get(), 1, countItems(copy.get()));
SOURCE_ASSERT_EQUAL(copy.get(), 1, countNewItems(copy.get()));
SOURCE_ASSERT_EQUAL(copy.get(), 0, countUpdatedItems(copy.get()));
SOURCE_ASSERT_EQUAL(copy.get(), 0, countDeletedItems(copy.get()));
if (!config.m_sourceLUIDsAreVolatile) {
SOURCE_ASSERT_EQUAL(copy.get(), 1, countEqual(listItems(copy.get()), child));
}
CT_ASSERT_NO_THROW(copy.reset());
CT_ASSERT_NO_THROW(child = updateItem(createSourceA, config, child, items[1], &childData));
SOURCE_ASSERT_NO_FAILURE(copy.get(), copy.reset(createSourceB()));
CT_ASSERT_NO_THROW(compareDatabases(copy.get(), &childData, (void *)NULL));
SOURCE_ASSERT_EQUAL(copy.get(), 1, countItems(copy.get()));
SOURCE_ASSERT_EQUAL(copy.get(), 0, countNewItems(copy.get()));
SOURCE_ASSERT_EQUAL(copy.get(), 1, countUpdatedItems(copy.get()));
SOURCE_ASSERT_EQUAL(copy.get(), 0, countDeletedItems(copy.get()));
if (!config.m_sourceLUIDsAreVolatile) {
SOURCE_ASSERT_EQUAL(copy.get(), 1, countEqual(listUpdatedItems(copy.get()), child));
}
CT_ASSERT_NO_THROW(copy.reset());
if (getenv("CLIENT_TEST_LINKED_ITEMS_NO_DELETE")) {
return;
}
CT_ASSERT_NO_THROW(deleteItem(createSourceA, child));
SOURCE_ASSERT_NO_FAILURE(copy.get(), copy.reset(createSourceB()));
SOURCE_ASSERT_EQUAL(copy.get(), 0, countItems(copy.get()));
SOURCE_ASSERT_EQUAL(copy.get(), 0, countNewItems(copy.get()));
SOURCE_ASSERT_EQUAL(copy.get(), 0, countUpdatedItems(copy.get()));
SOURCE_ASSERT_EQUAL(copy.get(), 1, countDeletedItems(copy.get()));
if (!config.m_sourceLUIDsAreVolatile) {
SOURCE_ASSERT_EQUAL(copy.get(), 1, countEqual(listDeletedItems(copy.get()), child));
}
}
// test inserting, removing and updating of parent + child item in
// various order plus change tracking
void LocalTests::testLinkedItemsInsertBothUpdateChild() {
ClientTestConfig::LinkedItems_t items = getParentChildData();
CT_ASSERT_NO_THROW(deleteAll(createSourceA));
std::string parent, child;
std::string parentData, childData;
TestingSyncSourcePtr copy;
// check that everything is empty, also resets change counter of sync source B
SOURCE_ASSERT_NO_FAILURE(copy.get(), copy.reset(createSourceB()));
SOURCE_ASSERT_EQUAL(copy.get(), 0, countItems(copy.get()));
CT_ASSERT_NO_THROW(copy.reset());
// add parent and child, then update child
CT_ASSERT_NO_THROW(parent = insert(createSourceA, items[0], false, &parentData));
CT_ASSERT_NO_THROW(child = insert(createSourceA, items[1], false, &childData));
SOURCE_ASSERT_NO_FAILURE(copy.get(), copy.reset(createSourceB()));
CT_ASSERT_NO_THROW(compareDatabases(copy.get(), &parentData, &childData, (void *)NULL));
SOURCE_ASSERT_EQUAL(copy.get(), 2, countItems(copy.get()));
SOURCE_ASSERT_EQUAL(copy.get(), 2, countNewItems(copy.get()));
SOURCE_ASSERT_EQUAL(copy.get(), 0, countUpdatedItems(copy.get()));
SOURCE_ASSERT_EQUAL(copy.get(), 0, countDeletedItems(copy.get()));
if (!config.m_sourceLUIDsAreVolatile) {
SOURCE_ASSERT_EQUAL(copy.get(), 1, countEqual(listItems(copy.get()), child));
SOURCE_ASSERT_EQUAL(copy.get(), 1, countEqual(listItems(copy.get()), parent));
}
CT_ASSERT_NO_THROW(copy.reset());
CT_ASSERT_NO_THROW(child = updateItem(createSourceA, config, child, items[1], &childData));
// child has to be listed as modified, parent may be
SOURCE_ASSERT_NO_FAILURE(copy.get(), copy.reset(createSourceB()));
CT_ASSERT_NO_THROW(compareDatabases(copy.get(), &parentData, &childData, (void *)NULL));
SOURCE_ASSERT_EQUAL(copy.get(), 2, countItems(copy.get()));
SOURCE_ASSERT_EQUAL(copy.get(), 0, countNewItems(copy.get()));
SOURCE_ASSERT(copy.get(), 1 <= countUpdatedItems(copy.get()));
SOURCE_ASSERT(copy.get(), 2 >= countUpdatedItems(copy.get()));
SOURCE_ASSERT_EQUAL(copy.get(), 0, countDeletedItems(copy.get()));
if (!config.m_sourceLUIDsAreVolatile) {
SOURCE_ASSERT_EQUAL(copy.get(), 1, countEqual(listUpdatedItems(copy.get()), child));
}
CT_ASSERT_NO_THROW(copy.reset());
if (getenv("CLIENT_TEST_LINKED_ITEMS_NO_DELETE")) {
return;
}
CT_ASSERT_NO_THROW(deleteItem(createSourceA, parent));
CT_ASSERT_NO_THROW(deleteItem(createSourceA, child));
SOURCE_ASSERT_NO_FAILURE(copy.get(), copy.reset(createSourceB()));
SOURCE_ASSERT_EQUAL(copy.get(), 0, countItems(copy.get()));
SOURCE_ASSERT_EQUAL(copy.get(), 0, countNewItems(copy.get()));
SOURCE_ASSERT_EQUAL(copy.get(), 0, countUpdatedItems(copy.get()));
SOURCE_ASSERT_EQUAL(copy.get(), 2, countDeletedItems(copy.get()));
if (!config.m_sourceLUIDsAreVolatile) {
SOURCE_ASSERT_EQUAL(copy.get(), 1, countEqual(listDeletedItems(copy.get()), parent));
SOURCE_ASSERT_EQUAL(copy.get(), 1, countEqual(listDeletedItems(copy.get()), child));
}
CT_ASSERT_NO_THROW(copy.reset());
}
// test inserting, removing and updating of parent + child item in
// various order plus change tracking
void LocalTests::testLinkedItemsInsertBothUpdateParent() {
ClientTestConfig::LinkedItems_t items = getParentChildData();
CT_ASSERT_NO_THROW(deleteAll(createSourceA));
std::string parent, child;
std::string parentData, childData;
TestingSyncSourcePtr copy;
// check that everything is empty, also resets change counter of sync source B
SOURCE_ASSERT_NO_FAILURE(copy.get(), copy.reset(createSourceB()));
SOURCE_ASSERT_EQUAL(copy.get(), 0, countItems(copy.get()));
CT_ASSERT_NO_THROW(copy.reset());
// add parent and child, then update parent
CT_ASSERT_NO_THROW(parent = insert(createSourceA, items[0], false, &parentData));
CT_ASSERT_NO_THROW(child = insert(createSourceA, items[1], false, &childData));
SOURCE_ASSERT_NO_FAILURE(copy.get(), copy.reset(createSourceB()));
CT_ASSERT_NO_THROW(compareDatabases(copy.get(), &parentData, &childData, (void *)NULL));
SOURCE_ASSERT_EQUAL(copy.get(), 2, countItems(copy.get()));
SOURCE_ASSERT_EQUAL(copy.get(), 2, countNewItems(copy.get()));
SOURCE_ASSERT_EQUAL(copy.get(), 0, countUpdatedItems(copy.get()));
SOURCE_ASSERT_EQUAL(copy.get(), 0, countDeletedItems(copy.get()));
if (!config.m_sourceLUIDsAreVolatile) {
SOURCE_ASSERT_EQUAL(copy.get(), 1, countEqual(listItems(copy.get()), child));
SOURCE_ASSERT_EQUAL(copy.get(), 1, countEqual(listItems(copy.get()), parent));
}
CT_ASSERT_NO_THROW(copy.reset());
CT_ASSERT_NO_THROW(parent = updateItem(createSourceA, config, parent, items[0], &parentData));
// parent has to be listed as modified, child may be
SOURCE_ASSERT_NO_FAILURE(copy.get(), copy.reset(createSourceB()));
CT_ASSERT_NO_THROW(compareDatabases(copy.get(), &parentData, &childData, (void *)NULL));
SOURCE_ASSERT_EQUAL(copy.get(), 2, countItems(copy.get()));
SOURCE_ASSERT_EQUAL(copy.get(), 0, countNewItems(copy.get()));
SOURCE_ASSERT(copy.get(), 1 <= countUpdatedItems(copy.get()));
SOURCE_ASSERT(copy.get(), 2 >= countUpdatedItems(copy.get()));
SOURCE_ASSERT_EQUAL(copy.get(), 0, countDeletedItems(copy.get()));
if (!config.m_sourceLUIDsAreVolatile) {
SOURCE_ASSERT_EQUAL(copy.get(), 1, countEqual(listUpdatedItems(copy.get()), parent));
}
CT_ASSERT_NO_THROW(copy.reset());
if (getenv("CLIENT_TEST_LINKED_ITEMS_NO_DELETE")) {
return;
}
CT_ASSERT_NO_THROW(deleteItem(createSourceA, parent));
CT_ASSERT_NO_THROW(deleteItem(createSourceA, child));
SOURCE_ASSERT_NO_FAILURE(copy.get(), copy.reset(createSourceB()));
SOURCE_ASSERT_EQUAL(copy.get(), 0, countItems(copy.get()));
SOURCE_ASSERT_EQUAL(copy.get(), 0, countNewItems(copy.get()));
SOURCE_ASSERT_EQUAL(copy.get(), 0, countUpdatedItems(copy.get()));
SOURCE_ASSERT_EQUAL(copy.get(), 2, countDeletedItems(copy.get()));
if (!config.m_sourceLUIDsAreVolatile) {
SOURCE_ASSERT_EQUAL(copy.get(), 1, countEqual(listDeletedItems(copy.get()), parent));
SOURCE_ASSERT_EQUAL(copy.get(), 1, countEqual(listDeletedItems(copy.get()), child));
}
}
// - insert parent and child
// - update child *without* UID and RECURRENCE-ID: source expected to re-insert them
void LocalTests::testLinkedItemsInsertBothUpdateChildNoIDs() {
ClientTestConfig::LinkedItems_t items = getParentChildData();
CT_ASSERT_NO_THROW(deleteAll(createSourceA));
std::string parent, child;
std::string parentData, childData;
TestingSyncSourcePtr copy;
// add parent and child, then update child
CT_ASSERT_NO_THROW(parent = insert(createSourceA, items[0], false, &parentData));
CT_ASSERT_NO_THROW(child = insert(createSourceA, items[1], false, &childData));
// remove UID and RECURRENCE-ID before updating
std::string reducedChildData = items[1];
std::string uid;
CT_ASSERT_NO_THROW(uid = stripProperty(reducedChildData, "UID"));
std::string rid;
CT_ASSERT_NO_THROW(rid = stripProperty(reducedChildData, "RECURRENCE-ID"));
CT_ASSERT_NO_THROW(child = updateItem(createSourceA, config, child, reducedChildData, &childData));
// compare
SOURCE_ASSERT_NO_FAILURE(copy.get(), copy.reset(createSourceA()));
CT_ASSERT_NO_THROW(insertProperty(childData, uid, "END:VEVENT"));
CT_ASSERT_NO_THROW(insertProperty(childData, rid, "END:VEVENT"));
CT_ASSERT_NO_THROW(compareDatabases(copy.get(), &parentData, &childData, (void *)NULL));
}
// - insert child
// - update child *without* UID and RECURRENCE-ID: source expected to re-insert them
void LocalTests::testLinkedItemsUpdateChildNoIDs() {
ClientTestConfig::LinkedItems_t items = getParentChildData();
CT_ASSERT_NO_THROW(deleteAll(createSourceA));
std::string child;
std::string childData;
TestingSyncSourcePtr copy;
// add child, then update child
CT_ASSERT_NO_THROW(child = insert(createSourceA, items[1], false, &childData));
// remove UID and RECURRENCE-ID before updating
std::string reducedChildData = items[1];
std::string uid;
CT_ASSERT_NO_THROW(uid = stripProperty(reducedChildData, "UID"));
std::string rid;
CT_ASSERT_NO_THROW(rid = stripProperty(reducedChildData, "RECURRENCE-ID"));
CT_ASSERT_NO_THROW(child = updateItem(createSourceA, config, child, reducedChildData, &childData));
// compare
SOURCE_ASSERT_NO_FAILURE(copy.get(), copy.reset(createSourceA()));
CT_ASSERT_NO_THROW(insertProperty(childData, uid, "END:VEVENT"));
CT_ASSERT_NO_THROW(insertProperty(childData, rid, "END:VEVENT"));
CT_ASSERT_NO_THROW(compareDatabases(copy.get(), &childData, (void *)NULL));
}
// insert parent, try to delete or retrieve non-existent child:
// must report 404
void LocalTests::testLinkedItemsSingle404() {
ClientTestConfig::LinkedItems_t items = getParentChildData();
CT_ASSERT_NO_THROW(deleteAll(createSourceA));
std::string parent, child;
// now insert main item
CT_ASSERT_NO_THROW(parent = insert(createSourceA, items[0], false));
// fake subid: works for CalDAV and EDS
child = parent + "no-such-subitem";
// read
TestingSyncSourcePtr source;
SOURCE_ASSERT_NO_FAILURE(source.get(), source.reset((createSourceA())));
SyncMLStatus status = STATUS_OK;
CT_ASSERT_NO_THROW(try {
std::string data;
source->readItem(child, data);
} catch (const StatusException &ex) {
status = ex.syncMLStatus();
}
);
CT_ASSERT_EQUAL(STATUS_NOT_FOUND, status);
// delete
status = STATUS_OK;
CT_ASSERT_NO_THROW(try {
source->deleteItem(child);
} catch (const StatusException &ex) {
status = ex.syncMLStatus();
}
);
CT_ASSERT_EQUAL(STATUS_NOT_FOUND, status);
}
// insert parent and child, try to delete or retrieve non-existent child:
// must report 404
void LocalTests::testLinkedItemsMany404() {
ClientTestConfig::LinkedItems_t items = getParentChildData();
CT_ASSERT_NO_THROW(deleteAll(createSourceA));
std::string parent, child;
// now insert two items
CT_ASSERT_NO_THROW(parent = insert(createSourceA, items[0], false));
CT_ASSERT_NO_THROW(child = insert(createSourceA, items[1], false));
// fake subid: works for CalDAV and EDS
child = parent + "no-such-subitem";
// read
TestingSyncSourcePtr source;
SOURCE_ASSERT_NO_FAILURE(source.get(), source.reset(createSourceA()));
SyncMLStatus status = STATUS_OK;
CT_ASSERT_NO_THROW(try {
std::string data;
source->readItem(child, data);
} catch (const StatusException &ex) {
status = ex.syncMLStatus();
}
);
CT_ASSERT_EQUAL(STATUS_NOT_FOUND, status);
// delete
status = STATUS_OK;
CT_ASSERT_NO_THROW(try {
source->deleteItem(child);
} catch (const StatusException &ex) {
status = ex.syncMLStatus();
}
);
CT_ASSERT_EQUAL(STATUS_NOT_FOUND, status);
}
// Is run as Client::Source::LinkedItems<testdata>::testSubsetStart<start>Skip<skip>
// where start = first detached recurrence to send and skip = detached recurrences
// to skip before adding the next one (=> 0 = send all).
//
// "Exdate" instead of Skip<skip> is special: it picks the <start>, <start> + 1 and last
// item, which typically leads to an irregular pattern and requires adding EXDATEs
// in the activesyncd.
void LocalTests::testSubset()
{
ClientTestConfig::LinkedItems_t items = getParentChildData();
int start, skip;
std::string test = getCurrentTest();
pcrecpp::RE re("testSubsetStart(\\d+)(?:Skip(\\d+)|(Exdate))");
std::string exdate, optSkip;
CT_ASSERT(re.PartialMatch(test, &start, &optSkip, &exdate));
if (exdate.empty()) {
// skip case
CT_ASSERT(!optSkip.empty());
skip = atoi(optSkip.c_str());
} else {
// EXDATE case
CT_ASSERT_EQUAL(std::string("Exdate"), exdate);
skip = -1;
}
CT_ASSERT(items.size() > (size_t)start);
CT_ASSERT(skip >= -1);
// check that everything is empty, also resets change counter of sync source B
CT_ASSERT_NO_THROW(deleteAll(createSourceA));
TestingSyncSourcePtr copy;
SOURCE_ASSERT_NO_FAILURE(copy.get(), copy.reset(createSourceB()));
SOURCE_ASSERT_EQUAL(copy.get(), 0, countItems(copy.get()));
CT_ASSERT_NO_THROW(copy.reset());
// insert parent first, then child
std::list<std::string> sent;
int i = start;
while ((size_t)i < items.size() &&
((start == 0 && skip == 0) || /* _0_0 really uses all items (stress test) */
skip == -1 || /* _x_e already is limited to 3 items */
i - start < 5)) { /* avoid huge number of items per test */
std::string data;
std::string message = StringPrintf("start %d, skip %d, at %d of %d",
start, skip, i, (int)items.size());
CT_ASSERT_NO_THROW_MESSAGE(message, insert(createSourceA, items[i], false, &data));
sent.push_back(data);
SOURCE_ASSERT_NO_FAILURE(copy.get(), copy.reset(createSourceB()));
std::list<std::string> actual(sent);
if (items.m_testLinkedItemsSubsetAdditional) {
std::string event = items.m_testLinkedItemsSubsetAdditional(start, skip, i, items.size());
if (!event.empty()) {
actual.push_back(event);
}
}
CT_ASSERT_NO_THROW_MESSAGE(message, compareDatabasesRef(*copy, actual));
if (skip >= 0) {
// skip intermediate items
i += skip + 1;
} else if (i == start) {
// go to second item
i++;
} else if (i == start + 1) {
// go to last item
CT_ASSERT((size_t)i != items.size() - 1);
i = items.size() - 1;
} else {
// done with first, second and last item
break;
}
}
}
ClientTestConfig::LinkedItems_t LocalTests::getParentChildData()
{
// extract suffix and use it as index for our config
std::string test = getCurrentTest();
const std::string testname = "LinkedItems";
size_t off = test.find(testname);
CT_ASSERT(off != test.npos);
off += testname.size();
size_t end = test.find(':', off);
CT_ASSERT(end != test.npos);
std::string name = test.substr(off, end - off);
BOOST_FOREACH(const ClientTestConfig::LinkedItems_t &items, config.m_linkedItems) {
if (items.m_name == name) {
return items;
}
}
BOOST_FOREACH(const ClientTestConfig::LinkedItems_t &items, config.m_linkedItemsSubset) {
if (items.m_name == name) {
return items;
}
}
CT_ASSERT_MESSAGE("linked items test data not found", false);
return ClientTestConfig::LinkedItems_t();
}
SyncTests::SyncTests(const std::string &name, ClientTest &cl, std::vector<int> sourceIndices, bool isClientA) :
CppUnit::TestSuite(name),
client(cl) {
sourceArray = new int[sourceIndices.size() + 1];
int offset = 0;
for (std::vector<int>::iterator it = sourceIndices.begin();
it != sourceIndices.end();
++it) {
ClientTest::Config config;
client.getSyncSourceConfig(*it, config);
if (!config.m_sourceName.empty()) {
sourceArray[sources.size()+offset] = *it;
if (!config.m_subConfigs.empty()) {
vector<string> subs;
boost::split (subs, config.m_subConfigs, boost::is_any_of(","));
offset++;
ClientTest::Config subConfig;
BOOST_FOREACH (string sub, subs) {
client.getSourceConfig (sub, subConfig);
sources.push_back(std::pair<int,LocalTests *>(*it, cl.createLocalTests(sub, client.getLocalSourcePosition(sub), subConfig)));
offset--;
}
} else {
sources.push_back(std::pair<int,LocalTests *>(*it, cl.createLocalTests(config.m_sourceName, client.getLocalSourcePosition(config.m_sourceName), config)));
}
}
}
sourceArray[sources.size()+ offset] = -1;
// check whether we have a second client
ClientTest *clientB = cl.getClientB();
if (clientB) {
accessClientB = clientB->createSyncTests(name, sourceIndices, false);
} else {
accessClientB = 0;
}
}
SyncTests::~SyncTests() {
for (source_it it = sources.begin();
it != sources.end();
++it) {
delete it->second;
}
delete [] sourceArray;
if (accessClientB) {
delete accessClientB;
}
}
/** adds the supported tests to the instance itself */
void SyncTests::addTests(bool isFirstSource) {
if (sources.size()) {
const ClientTest::Config &config(sources[0].second->config);
// run this test first, even if it is more complex:
// if it works, all the following tests will run with
// the server in a deterministic state
if (config.m_createSourceA) {
if (!config.m_insertItem.empty()) {
ADD_TEST(SyncTests, testDeleteAllRefresh);
}
}
ADD_TEST(SyncTests, testTwoWaySync);
ADD_TEST(SyncTests, testSlowSync);
ADD_TEST(SyncTests, testRefreshFromServerSync);
ADD_TEST(SyncTests, testRefreshFromClientSync);
ADD_TEST(SyncTests, testRefreshFromRemoteSync);
ADD_TEST(SyncTests, testRefreshFromLocalSync);
// testTimeout is independent of the actual peer; all it needs
// is a SyncML client config. Can't test for that explicitly
// here, so only rule out the test if we run in server mode.
if (isFirstSource &&
(!getenv("CLIENT_TEST_MODE") ||
strcmp(getenv("CLIENT_TEST_MODE"), "server"))) {
ADD_TEST(SyncTests, testTimeout);
}
if (config.m_compare &&
!config.m_testcases.empty() &&
!isServerMode()) {
ADD_TEST(SyncTests, testConversion);
}
if (config.m_createSourceA) {
if (!config.m_insertItem.empty()) {
ADD_TEST(SyncTests, testRefreshFromServerSemantic);
ADD_TEST(SyncTests, testRefreshFromClientSemantic);
ADD_TEST(SyncTests, testRefreshStatus);
// This test works regardless whether the peer can
// restart: if restarts are not possible, it checks
// that they don't occur. The rest of the tests then
// only make sense when restarting works.
ADD_TEST(SyncTests, testTwoWayRestart);
if (getenv("CLIENT_TEST_PEER_CAN_RESTART")) {
ADD_TEST(SyncTests, testSlowRestart);
ADD_TEST(SyncTests, testRefreshFromLocalRestart);
ADD_TEST(SyncTests, testOneWayFromLocalRestart);
ADD_TEST(SyncTests, testRefreshFromRemoteRestart);
ADD_TEST(SyncTests, testOneWayFromRemoteRestart);
ADD_TEST(SyncTests, testManyRestarts);
}
if (accessClientB &&
config.m_dump &&
config.m_compare) {
ADD_TEST(SyncTests, testCopy);
ADD_TEST(SyncTests, testDelete);
ADD_TEST(SyncTests, testAddUpdate);
ADD_TEST(SyncTests, testManyItems);
ADD_TEST(SyncTests, testManyDeletes);
ADD_TEST(SyncTests, testSlowSyncSemantic);
ADD_TEST(SyncTests, testComplexRefreshFromServerSemantic);
ADD_TEST(SyncTests, testDeleteBothSides);
if (config.m_updateItem.find("UID:") != std::string::npos &&
config.m_updateItem.find("LAST-MODIFIED:") != std::string::npos &&
sources.size() == 1) {
ADD_TEST(SyncTests, testAddBothSides);
ADD_TEST(SyncTests, testAddBothSidesRefresh);
}
// only add when testing individual source,
// test data not guaranteed to be available for all sources
if (sources.size() == 1 &&
!config.m_linkedItems.empty()) {
ADD_TEST(SyncTests, testLinkedItemsParentChild);
if (config.m_linkedItemsRelaxedSemantic) {
ADD_TEST(SyncTests, testLinkedItemsChild);
ADD_TEST(SyncTests, testLinkedItemsChildParent);
}
}
if (!config.m_updateItem.empty()) {
ADD_TEST(SyncTests, testUpdate);
}
if (!config.m_complexUpdateItem.empty()) {
ADD_TEST(SyncTests, testComplexUpdate);
}
if (!config.m_mergeItem1.empty() &&
!config.m_mergeItem2.empty()) {
ADD_TEST(SyncTests, testMerge);
}
if (config.m_import) {
ADD_TEST(SyncTests, testTwinning);
ADD_TEST(SyncTests, testItems);
ADD_TEST(SyncTests, testItemsXML);
if (config.m_update) {
ADD_TEST(SyncTests, testExtensions);
}
}
if (!config.m_templateItem.empty()) {
ADD_TEST(SyncTests, testMaxMsg);
ADD_TEST(SyncTests, testLargeObject);
ADD_TEST(SyncTests, testOneWayFromServer);
ADD_TEST(SyncTests, testOneWayFromClient);
ADD_TEST(SyncTests, testOneWayFromRemote);
ADD_TEST(SyncTests, testOneWayFromLocal);
}
}
}
// Tests which depend on item manipulation in the peer.
// These tests get enabled if their testdata is found in
// testcases/synctests/<server name> and if we are
// currently testing only a single source. The tests will
// fail if SyncEvolution was not configured correctly for
// them (see getPeerConfig()).
if (sources.size() == 1) {
const std::string sourceName = config.m_sourceName;
#define ADD_PEER_TEST(_x) if (isDir(getPeerTestdata(sourceName, #_x, ""))) { ADD_TEST(SyncTests, _x); }
ADD_PEER_TEST(testDownload);
ADD_PEER_TEST(testUpload);
ADD_PEER_TEST(testUpdateLocalWins);
ADD_PEER_TEST(testUpdateRemoteWins);
}
}
if (config.m_retrySync &&
!config.m_insertItem.empty() &&
!config.m_updateItem.empty() &&
accessClientB &&
config.m_dump &&
config.m_compare) {
CppUnit::TestSuite *retryTests = new CppUnit::TestSuite(getName() + "::Retry");
ADD_TEST_TO_SUITE(retryTests, SyncTests, testInterruptResumeClientAdd);
ADD_TEST_TO_SUITE(retryTests, SyncTests, testInterruptResumeClientRemove);
ADD_TEST_TO_SUITE(retryTests, SyncTests, testInterruptResumeClientUpdate);
ADD_TEST_TO_SUITE(retryTests, SyncTests, testInterruptResumeServerAdd);
ADD_TEST_TO_SUITE(retryTests, SyncTests, testInterruptResumeServerRemove);
ADD_TEST_TO_SUITE(retryTests, SyncTests, testInterruptResumeServerUpdate);
ADD_TEST_TO_SUITE(retryTests, SyncTests, testInterruptResumeClientAddBig);
ADD_TEST_TO_SUITE(retryTests, SyncTests, testInterruptResumeClientUpdateBig);
ADD_TEST_TO_SUITE(retryTests, SyncTests, testInterruptResumeServerAddBig);
ADD_TEST_TO_SUITE(retryTests, SyncTests, testInterruptResumeServerUpdateBig);
ADD_TEST_TO_SUITE(retryTests, SyncTests, testInterruptResumeFull);
addTest(FilterTest(retryTests));
}
if (config.m_suspendSync &&
!config.m_insertItem.empty() &&
!config.m_updateItem.empty() &&
accessClientB &&
config.m_dump &&
config.m_compare) {
CppUnit::TestSuite *suspendTests = new CppUnit::TestSuite(getName() + "::Suspend");
ADD_TEST_TO_SUITE(suspendTests, SyncTests, testUserSuspendClientAdd);
ADD_TEST_TO_SUITE(suspendTests, SyncTests, testUserSuspendClientRemove);
ADD_TEST_TO_SUITE(suspendTests, SyncTests, testUserSuspendClientUpdate);
ADD_TEST_TO_SUITE(suspendTests, SyncTests, testUserSuspendServerAdd);
ADD_TEST_TO_SUITE(suspendTests, SyncTests, testUserSuspendServerRemove);
ADD_TEST_TO_SUITE(suspendTests, SyncTests, testUserSuspendServerUpdate);
ADD_TEST_TO_SUITE(suspendTests, SyncTests, testUserSuspendClientAddBig);
ADD_TEST_TO_SUITE(suspendTests, SyncTests, testUserSuspendClientUpdateBig);
ADD_TEST_TO_SUITE(suspendTests, SyncTests, testUserSuspendServerAddBig);
ADD_TEST_TO_SUITE(suspendTests, SyncTests, testUserSuspendServerUpdateBig);
ADD_TEST_TO_SUITE(suspendTests, SyncTests, testUserSuspendFull);
addTest(FilterTest(suspendTests));
}
if (config.m_resendSync &&
!config.m_insertItem.empty() &&
!config.m_updateItem.empty() &&
accessClientB &&
config.m_dump &&
config.m_compare) {
CppUnit::TestSuite *resendTests = new CppUnit::TestSuite(getName() + "::Resend");
ADD_TEST_TO_SUITE(resendTests, SyncTests, testResendClientAdd);
ADD_TEST_TO_SUITE(resendTests, SyncTests, testResendClientRemove);
ADD_TEST_TO_SUITE(resendTests, SyncTests, testResendClientUpdate);
ADD_TEST_TO_SUITE(resendTests, SyncTests, testResendServerAdd);
ADD_TEST_TO_SUITE(resendTests, SyncTests, testResendServerRemove);
ADD_TEST_TO_SUITE(resendTests, SyncTests, testResendServerUpdate);
ADD_TEST_TO_SUITE(resendTests, SyncTests, testResendFull);
addTest(FilterTest(resendTests));
}
if (getenv("CLIENT_TEST_RESEND_PROXY") &&
!config.m_insertItem.empty() &&
!config.m_updateItem.empty() &&
accessClientB &&
config.m_dump &&
config.m_compare) {
CppUnit::TestSuite *resendTests = new CppUnit::TestSuite(getName() + "::ResendProxy");
ADD_TEST_TO_SUITE(resendTests, SyncTests, testResendProxyClientAdd);
ADD_TEST_TO_SUITE(resendTests, SyncTests, testResendProxyClientRemove);
ADD_TEST_TO_SUITE(resendTests, SyncTests, testResendProxyClientUpdate);
ADD_TEST_TO_SUITE(resendTests, SyncTests, testResendProxyServerAdd);
ADD_TEST_TO_SUITE(resendTests, SyncTests, testResendProxyServerRemove);
ADD_TEST_TO_SUITE(resendTests, SyncTests, testResendProxyServerUpdate);
ADD_TEST_TO_SUITE(resendTests, SyncTests, testResendProxyFull);
addTest(FilterTest(resendTests));
}
}
}
bool SyncTests::compareDatabases(const char *refFileBase, bool raiseAssert) {
source_it it1;
source_it it2;
bool equal = true;
CT_ASSERT(accessClientB);
for (it1 = sources.begin(), it2 = accessClientB->sources.begin();
it1 != sources.end() && it2 != accessClientB->sources.end();
++it1, ++it2) {
TestingSyncSourcePtr copy;
SOURCE_ASSERT_NO_FAILURE(copy.get(), copy.reset(it2->second->createSourceB()));
if (refFileBase) {
std::string refFile = refFileBase;
refFile += it1->second->config.m_sourceName;
refFile += ".dat";
simplifyFilename(refFile);
if (!it1->second->compareDatabases(refFile.c_str(), *copy.get(), raiseAssert)) {
equal = false;
}
} else {
if (!it1->second->compareDatabases(NULL, *copy.get(), raiseAssert)) {
equal = false;
}
}
CT_ASSERT_NO_THROW(copy.reset());
}
CT_ASSERT(it1 == sources.end());
CT_ASSERT(it2 == accessClientB->sources.end());
CT_ASSERT(!raiseAssert || equal);
return equal;
}
/** deletes all items locally and on server */
void SyncTests::deleteAll(DeleteAllMode mode) {
SyncPrefix prefix("deleteall", *this);
const char *value = getenv ("CLIENT_TEST_DELETE_REFRESH");
if (value) {
mode = DELETE_ALL_REFRESH;
}
switch(mode) {
case DELETE_ALL_SYNC:
// a refresh from server would slightly reduce the amount of data exchanged, but not all servers support it
CT_ASSERT_NO_THROW(allSourcesDeleteAll());
doSync(__FILE__, __LINE__, "init", SyncOptions(SYNC_SLOW));
// now that client and server are in sync, delete locally and sync again
CT_ASSERT_NO_THROW(allSourcesDeleteAll());
doSync(__FILE__, __LINE__,
"twoway",
SyncOptions(SYNC_TWO_WAY,
CheckSyncReport(0,0,0, 0,0,-1, true, SYNC_TWO_WAY)));
break;
case DELETE_ALL_REFRESH:
// delete locally and then tell the server to "copy" the empty databases
CT_ASSERT_NO_THROW(allSourcesDeleteAll());
doSync(__FILE__, __LINE__,
"refreshserver",
SyncOptions(RefreshFromLocalMode(),
CheckSyncReport(0,0,0, 0,0,-1, true, SYNC_REFRESH_FROM_LOCAL)));
break;
}
}
/** get both clients in sync with empty server, then copy one item from client A to B */
void SyncTests::doCopy() {
SyncPrefix copy("copy", *this);
// check requirements
CT_ASSERT(accessClientB);
CT_ASSERT_NO_THROW(deleteAll());
accessClientB->deleteAll();
bool allowLocalUpdate = getenv("CLIENT_TEST_MAY_COPY_BACK") != NULL;
// insert into first database, copy to server
CT_ASSERT_NO_THROW(allSourcesInsert());
doSync(__FILE__, __LINE__,
"send",
SyncOptions(SYNC_TWO_WAY,
CheckSyncReport(0, allowLocalUpdate? -1 : 0, 0, 1,0,0, true, SYNC_TWO_WAY)));
// copy into second database
accessClientB->doSync(__FILE__, __LINE__,
"recv",
SyncOptions(SYNC_TWO_WAY,
CheckSyncReport(1,0,0, 0,0,0, true, SYNC_TWO_WAY)));
CT_ASSERT_NO_THROW(compareDatabases());
}
/**
* Replicate server database locally. Works with all servers
* (including those which do not support refresh sync) because the
* Synthesis engine will do a local delete + slow sync (by default)
* and a real refresh sync only when asked to explicitly (Funambol).
*/
void SyncTests::refreshClient(SyncOptions options) {
doSync(__FILE__, __LINE__,
"refresh",
options
.setSyncMode(SYNC_REFRESH_FROM_REMOTE)
.setCheckReport(CheckSyncReport(-1,0,-1, 0,0,0, true, SYNC_REFRESH_FROM_REMOTE)));
}
// delete all items, locally and on server using refresh-from-client sync
void SyncTests::testDeleteAllRefresh() {
// start with clean local data
CT_ASSERT_NO_THROW(allSourcesDeleteAll());
// copy something to server first; doesn't matter whether it has the
// item already or not, as long as it exists there afterwards
CT_ASSERT_NO_THROW(allSourcesInsert());
doSync(__FILE__, __LINE__, "insert", SyncOptions(SYNC_SLOW));
// now ensure we can delete it
deleteAll(DELETE_ALL_REFRESH);
// nothing stored locally?
for (source_it it = sources.begin(); it != sources.end(); ++it) {
TestingSyncSourcePtr source;
SOURCE_ASSERT_NO_FAILURE(source.get(), source.reset(it->second->createSourceA()));
SOURCE_ASSERT_EQUAL(source.get(), 0, countItems(source.get()));
CT_ASSERT_NO_THROW(source.reset());
}
// make sure server really deleted everything
doSync(__FILE__, __LINE__,
"check",
SyncOptions(SYNC_SLOW,
CheckSyncReport(0,0,0, 0,0,0, true, SYNC_SLOW)));
for (source_it it = sources.begin(); it != sources.end(); ++it) {
TestingSyncSourcePtr source;
SOURCE_ASSERT_NO_FAILURE(source.get(), source.reset(it->second->createSourceA()));
SOURCE_ASSERT_EQUAL(source.get(), 0, countItems(source.get()));
CT_ASSERT_NO_THROW(source.reset());
}
}
// refresh-from-server sync, regardless of peer's role
void SyncTests::testRefreshFromServerSync()
{
doSync(__FILE__, __LINE__,
SyncOptions(SYNC_REFRESH_FROM_SERVER,
CheckSyncReport(-1,-1,-1, -1,-1,-1, true,
isServerMode() ? SYNC_REFRESH_FROM_LOCAL : SYNC_REFRESH_FROM_REMOTE)));
}
// do a refresh-from-client sync, regardless of peer's role
void SyncTests::testRefreshFromClientSync()
{
doSync(__FILE__, __LINE__,
SyncOptions(SYNC_REFRESH_FROM_CLIENT,
CheckSyncReport(-1,-1,-1, -1,-1,-1, true,
isServerMode() ? SYNC_REFRESH_FROM_REMOTE : SYNC_REFRESH_FROM_LOCAL)));
}
// do a refresh-from-remote sync, regardless of peer's role
void SyncTests::testRefreshFromRemoteSync()
{
doSync(__FILE__, __LINE__,
SyncOptions(SYNC_REFRESH_FROM_REMOTE,
CheckSyncReport(-1,-1,-1, -1,-1,-1, true, SYNC_REFRESH_FROM_REMOTE)));
}
// do a refresh-from-local sync, regardless of peer's role
void SyncTests::testRefreshFromLocalSync()
{
doSync(__FILE__, __LINE__,
SyncOptions(SYNC_REFRESH_FROM_LOCAL,
CheckSyncReport(-1,-1,-1, -1,-1,-1, true, SYNC_REFRESH_FROM_LOCAL)));
}
// delete all items, locally and on server using two-way sync
void SyncTests::testDeleteAllSync()
{
CT_ASSERT_NO_THROW(deleteAll(DELETE_ALL_SYNC));
}
// test that a refresh sync from an empty server leads to an empty datatbase
// and no changes are sent to server during next two-way sync
void SyncTests::testRefreshFromServerSemantic() {
// clean client and server
CT_ASSERT_NO_THROW(deleteAll());
// insert item, then refresh from empty server
CT_ASSERT_NO_THROW(allSourcesInsert());
doSync(__FILE__, __LINE__,
"refresh",
SyncOptions(RefreshFromPeerMode(),
CheckSyncReport(0,0,-1, 0,0,0, true, SYNC_REFRESH_FROM_REMOTE)));
// check
for (source_it it = sources.begin(); it != sources.end(); ++it) {
TestingSyncSourcePtr source;
SOURCE_ASSERT_NO_FAILURE(source.get(), source.reset(it->second->createSourceA()));
SOURCE_ASSERT_EQUAL(source.get(), 0, countItems(source.get()));
CT_ASSERT_NO_THROW(source.reset());
}
doSync(__FILE__, __LINE__,
"two-way",
SyncOptions(SYNC_TWO_WAY,
CheckSyncReport(0,0,0, 0,0,0, true, SYNC_TWO_WAY)));
}
// test that a refresh sync from an empty client leads to an empty datatbase
// and no changes are sent to server during next two-way sync
void SyncTests::testRefreshFromClientSemantic() {
// clean client and server
CT_ASSERT_NO_THROW(deleteAll());
// insert item, send to server
CT_ASSERT_NO_THROW(allSourcesInsert());
doSync(__FILE__, __LINE__,
"send",
SyncOptions(SYNC_TWO_WAY,
CheckSyncReport(0,0,0, 1,0,0, true, SYNC_TWO_WAY)));
// delete locally
CT_ASSERT_NO_THROW(allSourcesDeleteAll());
// refresh from client
doSync(__FILE__, __LINE__,
"refresh",
SyncOptions(RefreshFromLocalMode(),
CheckSyncReport(0,0,0, 0,0,0, true, SYNC_REFRESH_FROM_LOCAL)));
// check
doSync(__FILE__, __LINE__,
"check",
SyncOptions(RefreshFromPeerMode(),
CheckSyncReport(0,0,0, 0,0,0, true, SYNC_REFRESH_FROM_REMOTE)));
}
// tests the following sequence of events:
// - insert item
// - delete all items
// - insert one other item
// - refresh from client
// => no items should now be listed as new, updated or deleted for this client during another sync
void SyncTests::testRefreshStatus() {
CT_ASSERT_NO_THROW(allSourcesInsert(false));
CT_ASSERT_NO_THROW(allSourcesDeleteAll());
CT_ASSERT_NO_THROW(allSourcesInsert());
doSync(__FILE__, __LINE__,
"refresh-from-client",
SyncOptions(RefreshFromLocalMode(),
CheckSyncReport(0,0,0, -1,-1,-1, /* strictly speaking 1,0,0, but not sure exactly what the server will be told */
true, SYNC_REFRESH_FROM_LOCAL)));
doSync(__FILE__, __LINE__,
"two-way",
SyncOptions(SYNC_TWO_WAY,
CheckSyncReport(0,0,0, 0,0,0, true, SYNC_TWO_WAY)));
}
static void log(const char *text)
{
CLIENT_TEST_LOG("%s", text);
}
static void logSyncSourceReport(const SyncSource *source)
{
CLIENT_TEST_LOG("source %s, start of cycle #%d: local new/mod/del/conflict %d/%d/%d/%d, remote %d/%d/%d/%d, mode %s",
source->getName().c_str(),
source->getRestarts(),
source->getItemStat(SyncSourceReport::ITEM_LOCAL, SyncSourceReport::ITEM_ADDED, SyncSource::ITEM_TOTAL),
source->getItemStat(SyncSourceReport::ITEM_LOCAL, SyncSourceReport::ITEM_UPDATED, SyncSource::ITEM_TOTAL),
source->getItemStat(SyncSourceReport::ITEM_LOCAL, SyncSourceReport::ITEM_REMOVED, SyncSource::ITEM_TOTAL),
source->getItemStat(SyncSourceReport::ITEM_LOCAL, SyncSourceReport::ITEM_ANY, SyncSource::ITEM_REJECT),
source->getItemStat(SyncSourceReport::ITEM_REMOTE, SyncSourceReport::ITEM_ADDED, SyncSource::ITEM_TOTAL),
source->getItemStat(SyncSourceReport::ITEM_REMOTE, SyncSourceReport::ITEM_UPDATED, SyncSource::ITEM_TOTAL),
source->getItemStat(SyncSourceReport::ITEM_REMOTE, SyncSourceReport::ITEM_REMOVED, SyncSource::ITEM_TOTAL),
source->getItemStat(SyncSourceReport::ITEM_REMOTE, SyncSourceReport::ITEM_ANY, SyncSource::ITEM_REJECT),
PrettyPrintSyncMode(source->getFinalSyncMode()).c_str());
}
/**
* Helper function, to be used inside a SyncOptions start callback
* to connect all sources instantiated for a sync with the given
* pre-operation signal.
*/
template<class W, class M, class S>
bool connectSourceSignal(SyncContext &context,
W SyncSource::Operations::*operation,
M getSignal,
const S &slot)
{
BOOST_FOREACH(const SyncSource *source, *context.getSources()) {
((source->getOperations().*operation).*getSignal)().connect(slot);
}
return false;
}
void SyncTests::doRestartSync(SyncMode mode)
{
CT_ASSERT_NO_THROW(deleteAll());
int startCount = 0;
bool needToConnect = true;
typedef std::map<std::string, SyncSourceReport> Reports_t;
typedef std::map<int, Reports_t> Cycles_t;
Cycles_t results;
// Triggered for every m_startDataRead.
//
// It records the current source statistics for later checking and
// logs it.
//
// Also requests a restart at the very beginning, once. Must be
// done before m_endDataWrite, because then it might be too late
// to restart.
boost::function<SyncSource::Operations::StartDataRead_t::PreSignal::signature_type> start =
(boost::lambda::if_then(boost::lambda::bind(&Cycles_t::empty, boost::ref(results)),
(boost::lambda::bind(log, "requesting restart"),
boost::lambda::bind(SyncContext::requestAnotherSync))),
(boost::lambda::var(results)[boost::lambda::bind(&SyncSource::getRestarts, &boost::lambda::_1)]
[boost::lambda::bind(&SyncSource::getName, &boost::lambda::_1)] =
boost::lambda::_1),
boost::lambda::bind(logSyncSourceReport,
&boost::lambda::_1),
boost::lambda::constant(STATUS_OK)
);
// Triggered at the end of each m_endDataWrite.
//
// Adds a new item or (in later syncs) updates/deletes
// it. Because the cycle is other, those changes won't
// interfere with the cycle. Doing real concurrent
// changes is something for another tests...
boost::function<SyncSource::Operations::EndDataWrite_t::PostSignal::signature_type> end =
boost::bind(boost::function<SyncMLStatus ()>(
(boost::lambda::if_then(++boost::lambda::var(startCount) == sources.size(),
(boost::lambda::bind(log, "inserting one item"),
boost::lambda::bind(&SyncTests::allSourcesInsert, this, true))),
boost::lambda::constant(STATUS_OK)
)));
SyncOptions::Callback_t setup =
(boost::lambda::if_then(boost::lambda::var(needToConnect),
(boost::lambda::var(needToConnect) = false,
boost::lambda::bind(connectSourceSignal<SyncSource::Operations::StartDataRead_t,
BOOST_TYPEOF(&SyncSource::Operations::StartDataRead_t::getPreSignal),
BOOST_TYPEOF(start)>,
boost::lambda::_1,
&SyncSource::Operations::m_startDataRead,
&SyncSource::Operations::StartDataRead_t::getPreSignal,
boost::cref(start)),
boost::lambda::bind(connectSourceSignal<SyncSource::Operations::EndDataWrite_t,
BOOST_TYPEOF(&SyncSource::Operations::EndDataWrite_t::getPostSignal),
BOOST_TYPEOF(end)>,
boost::lambda::_1,
&SyncSource::Operations::m_endDataWrite,
&SyncSource::Operations::EndDataWrite_t::getPostSignal,
boost::cref(end))
)),
boost::lambda::constant(false)
);
bool canRestart = getenv("CLIENT_TEST_PEER_CAN_RESTART") != NULL &&
!isServerMode();
CT_ASSERT_NO_THROW(doSync(__FILE__, __LINE__,
"add",
SyncOptions(mode,
CheckSyncReport(0,
0,
// TODO (?): should the item added after the initial refresh-from-remote be deleted in the second cycle?
// Right now it isn't, because the second sync is
// a one-way-from-remote.
mode == SYNC_REFRESH_FROM_REMOTE ? /* 1 */ 0 : 0,
// nothing transferred when item only exists locally
// and not transferring to peer
!canRestart ? 0 :
(mode == SYNC_ONE_WAY_FROM_REMOTE ||
mode == SYNC_REFRESH_FROM_REMOTE) ? 0 : 1,
0,
0,
true, mode)
.setRestarts(canRestart ? 1 : 0))
.setStartCallback(setup)
));
// two cycles if restarted, one otherwise
CT_ASSERT_EQUAL((size_t)(canRestart ? 2 : 1), results.size());
// nothing transfered before first or second cycle
BOOST_FOREACH(const Cycles_t::value_type &cycle, results) {
CT_ASSERT_EQUAL(sources.size(), cycle.second.size());
BOOST_FOREACH(const Reports_t::value_type &entry, cycle.second) {
CT_ASSERT_NO_THROW(CheckSyncReport(0,0, 0,
0,0,0)
.setRestarts(cycle.first)
.check(entry.first, entry.second));
}
}
// one item exists now, in all cases
// (but see remark about refresh-from-remote!)
BOOST_FOREACH(source_array_t::value_type &source_pair, sources) {
TestingSyncSourcePtr source;
SOURCE_ASSERT_NO_FAILURE(source.get(), source.reset(source_pair.second->createSourceA()));
CT_ASSERT_EQUAL(1, countItems(source.get()));
}
if (mode == SYNC_REFRESH_FROM_REMOTE ||
!canRestart) {
// Can't continue testing for refresh-from-remote, because the
// item was never sent to remote and will be gone locally
// after the next refresh-from-remote (prevents updating and
// deleting it locally).
// Without restart support further tests don't make much sense.
// We already verified above that a restart request was
// correctly rejected/ignored.
return;
}
// update item while the sync runs
#ifndef __clang_analyzer__
needToConnect = true;
#endif
startCount = 0;
results.clear();
end =
boost::bind(boost::function<SyncMLStatus ()>(
(boost::lambda::if_then(++boost::lambda::var(startCount) == sources.size(),
(boost::lambda::bind(log, "update one item"),
boost::lambda::bind(&SyncTests::allSourcesUpdate, this))),
STATUS_OK)
));
CT_ASSERT_NO_THROW(doSync(__FILE__, __LINE__,
"update",
SyncOptions(mode,
CheckSyncReport(0,0,0,
// refresh-from-local and slow sync transfer existing item
// in first cycle anew
(mode == SYNC_REFRESH_FROM_LOCAL ||
mode == SYNC_SLOW) ? 1 : 0,
// nothing transferred when item only exists locally
// and not transferring to peer
mode == SYNC_ONE_WAY_FROM_REMOTE ? 0 : 1,
0,
true, mode)
.setRestarts(1))
.setStartCallback(setup)
));
// two cycles
CT_ASSERT_EQUAL((size_t)2, results.size());
// nothing transfered before first or second cycle
BOOST_FOREACH(const Cycles_t::value_type &cycle, results) {
CLIENT_TEST_LOG("checking cycle #%d", cycle.first);
CT_ASSERT_EQUAL(sources.size(), cycle.second.size());
BOOST_FOREACH(const Reports_t::value_type &entry, cycle.second) {
CT_ASSERT_NO_THROW(CheckSyncReport(0,0,0,
// refresh-from-local and slow sync transfer existing item
// in first cycle anew
(cycle.first == 1 &&
(mode == SYNC_REFRESH_FROM_LOCAL ||
mode == SYNC_SLOW)) ? 1 : 0,
0,0)
.setRestarts(cycle.first)
.check(entry.first, entry.second));
}
}
// one item exists now, in all cases
// (but see remark about refresh-from-remote!)
BOOST_FOREACH(source_array_t::value_type &source_pair, sources) {
TestingSyncSourcePtr source;
SOURCE_ASSERT_NO_FAILURE(source.get(), source.reset(source_pair.second->createSourceA()));
CT_ASSERT_EQUAL(1, countItems(source.get()));
}
// delete item while the sync runs
#ifndef __clang_analyzer__
needToConnect = true;
#endif
startCount = 0;
results.clear();
end =
boost::bind(boost::function<SyncMLStatus ()>(
(boost::lambda::if_then(++boost::lambda::var(startCount) == sources.size(),
(boost::lambda::bind(log, "delete one item"),
boost::lambda::bind(&SyncTests::allSourcesDeleteAll, this))),
STATUS_OK)
));
CT_ASSERT_NO_THROW(doSync(__FILE__, __LINE__,
"delete",
SyncOptions(mode,
CheckSyncReport(0,0,0,
// refresh-from-local and slow sync transfer existing item
// in first cycle anew
(mode == SYNC_REFRESH_FROM_LOCAL ||
mode == SYNC_SLOW) ? 1 : 0,
0,
// nothing transferred when item only existed locally
// and not transferring to peer
mode == SYNC_ONE_WAY_FROM_REMOTE ? 0 : 1,
true, mode)
.setRestarts(1))
.setStartCallback(setup)
));
// two cycles
CT_ASSERT_EQUAL((size_t)2, results.size());
// nothing transfered before first or second cycle
BOOST_FOREACH(const Cycles_t::value_type &cycle, results) {
CT_ASSERT_EQUAL(sources.size(), cycle.second.size());
BOOST_FOREACH(const Reports_t::value_type &entry, cycle.second) {
CT_ASSERT_NO_THROW(CheckSyncReport(0,0, 0,
// refresh-from-local and slow sync transfer existing item
// in first cycle anew
(cycle.first == 1 &&
(mode == SYNC_REFRESH_FROM_LOCAL ||
mode == SYNC_SLOW)) ? 1 : 0,
0,0)
.setRestarts(cycle.first)
.check(entry.first, entry.second));
}
}
// no item exists now, in all cases
BOOST_FOREACH(source_array_t::value_type &source_pair, sources) {
TestingSyncSourcePtr source;
SOURCE_ASSERT_NO_FAILURE(source.get(), source.reset(source_pair.second->createSourceA()));
CT_ASSERT_EQUAL(0, countItems(source.get()));
}
}
// two-way sync when both sides are empty,
// insert item locally while sync runs, restart
// => one item sent to peer
void SyncTests::testTwoWayRestart()
{
CT_ASSERT_NO_THROW(doRestartSync(SYNC_TWO_WAY));
}
// slow sync when both sides are empty,
// insert item locally while sync runs, restart
// => one item sent to peer
void SyncTests::testSlowRestart()
{
CT_ASSERT_NO_THROW(doRestartSync(SYNC_SLOW));
}
// refresh-from-local sync when both sides are empty,
// insert item locally while sync runs, restart
// => one item sent to peer
void SyncTests::testRefreshFromLocalRestart()
{
CT_ASSERT_NO_THROW(doRestartSync(SYNC_REFRESH_FROM_LOCAL));
}
// one-way-from-local sync when both sides are empty,
// insert item locally while sync runs, restart
// => one item sent to peer
void SyncTests::testOneWayFromLocalRestart()
{
CT_ASSERT_NO_THROW(doRestartSync(SYNC_ONE_WAY_FROM_LOCAL));
}
// refresh-from-remote sync when both sides are empty,
// insert item locally while sync runs, restart
// => *nothing* sent to peer
void SyncTests::testRefreshFromRemoteRestart()
{
CT_ASSERT_NO_THROW(doRestartSync(SYNC_REFRESH_FROM_REMOTE));
}
// one-way-from-remote sync when both sides are empty,
// insert item locally while sync runs, restart
// => *nothing* sent to peer
void SyncTests::testOneWayFromRemoteRestart()
{
CT_ASSERT_NO_THROW(doRestartSync(SYNC_ONE_WAY_FROM_REMOTE));
}
// Start with empty database, refresh peer.
// Then add 1, 2, 4, 8 items in four cycles,
// update them the same way, and finally delete them.
// Results in 12 cycles with different changes and
// one empty, final cycle.
void SyncTests::testManyRestarts()
{
CT_ASSERT_NO_THROW(deleteAll());
int startCount = 0;
bool needToConnect = true;
typedef std::map<std::string, SyncSourceReport> Reports_t;
typedef std::map<int, Reports_t> Cycles_t;
Cycles_t results;
std::map<int, std::list<std::string> > luids;
// Triggered for every m_startDataRead.
//
// It records the current source statistics for later checking,
// logs it, and does the item changes.
boost::function<SyncSource::Operations::StartDataRead_t::PreSignal::signature_type> start =
(boost::lambda::if_then(boost::lambda::var(startCount) % sources.size() == 0,
(
boost::lambda::switch_statement(boost::lambda::var(startCount) / sources.size(),
boost::lambda::case_statement<0>(
(boost::lambda::bind(log, "insert 1 item, restart"),
boost::lambda::bind(&SyncTests::allSourcesInsertMany, this, 1, 1, boost::ref(luids)),
boost::lambda::bind(SyncContext::requestAnotherSync)
)),
boost::lambda::case_statement<1>(
(boost::lambda::bind(log, "insert 2 items, restart"),
boost::lambda::bind(&SyncTests::allSourcesInsertMany, this, 2, 2, boost::ref(luids)),
boost::lambda::bind(SyncContext::requestAnotherSync)
)),
boost::lambda::case_statement<2>(
(boost::lambda::bind(log, "insert 4 items, restart"),
boost::lambda::bind(&SyncTests::allSourcesInsertMany, this, 4, 4, boost::ref(luids)),
boost::lambda::bind(SyncContext::requestAnotherSync)
)),
boost::lambda::case_statement<3>(
(boost::lambda::bind(log, "insert 8 items, restart"),
boost::lambda::bind(&SyncTests::allSourcesInsertMany, this, 8, 8, boost::ref(luids)),
boost::lambda::bind(SyncContext::requestAnotherSync)
)),
boost::lambda::case_statement<4>(
(boost::lambda::bind(log, "update 1 item, restart"),
boost::lambda::bind(&SyncTests::allSourcesUpdateMany, this, 1, 1, 1, boost::ref(luids), 0),
boost::lambda::bind(SyncContext::requestAnotherSync)
)),
boost::lambda::case_statement<5>(
(boost::lambda::bind(log, "update 2 items, restart"),
boost::lambda::bind(&SyncTests::allSourcesUpdateMany, this, 2, 2, 1, boost::ref(luids), 1),
boost::lambda::bind(SyncContext::requestAnotherSync)
)),
boost::lambda::case_statement<6>(
(boost::lambda::bind(log, "update 4 items, restart"),
boost::lambda::bind(&SyncTests::allSourcesUpdateMany, this, 4, 4, 1, boost::ref(luids), 3),
boost::lambda::bind(SyncContext::requestAnotherSync)
)),
boost::lambda::case_statement<7>(
(boost::lambda::bind(log, "update 8 items, restart"),
boost::lambda::bind(&SyncTests::allSourcesUpdateMany, this, 8, 8, 1, boost::ref(luids), 7),
boost::lambda::bind(SyncContext::requestAnotherSync)
))
),
// must break up switch statement, it only has a limited number of case slots
boost::lambda::switch_statement(boost::lambda::var(startCount) / sources.size(),
boost::lambda::case_statement<8>(
(boost::lambda::bind(log, "delete 1 item, restart"),
boost::lambda::bind(&SyncTests::allSourcesRemoveMany, this, 1, boost::ref(luids), 0),
boost::lambda::bind(SyncContext::requestAnotherSync)
)),
boost::lambda::case_statement<9>(
(boost::lambda::bind(log, "delete 2 items, restart"),
boost::lambda::bind(&SyncTests::allSourcesRemoveMany, this, 2, boost::ref(luids), 1),
boost::lambda::bind(SyncContext::requestAnotherSync)
)),
boost::lambda::case_statement<10>(
(boost::lambda::bind(log, "delete 4 items, restart"),
boost::lambda::bind(&SyncTests::allSourcesRemoveMany, this, 4, boost::ref(luids), 3),
boost::lambda::bind(SyncContext::requestAnotherSync)
)),
boost::lambda::case_statement<11>(
(boost::lambda::bind(log, "delete 8 items, restart"),
boost::lambda::bind(&SyncTests::allSourcesRemoveMany, this, 8, boost::ref(luids), 7),
boost::lambda::bind(SyncContext::requestAnotherSync)
))
)
)
),
(boost::lambda::var(results)[boost::lambda::bind(&SyncSource::getRestarts, &boost::lambda::_1)]
[boost::lambda::bind(&SyncSource::getName, &boost::lambda::_1)] = boost::lambda::_1
),
boost::lambda::bind(logSyncSourceReport,
&boost::lambda::_1),
++boost::lambda::var(startCount),
boost::lambda::constant(STATUS_OK)
);
SyncOptions::Callback_t setup =
(boost::lambda::if_then(boost::lambda::var(needToConnect),
(boost::lambda::var(needToConnect) = false,
boost::lambda::bind(connectSourceSignal<SyncSource::Operations::StartDataRead_t,
BOOST_TYPEOF(&SyncSource::Operations::StartDataRead_t::getPreSignal),
BOOST_TYPEOF(start)>,
boost::lambda::_1,
&SyncSource::Operations::m_startDataRead,
&SyncSource::Operations::StartDataRead_t::getPreSignal,
boost::cref(start))
)),
boost::lambda::constant(false)
);
CT_ASSERT_NO_THROW(doSync(__FILE__, __LINE__,
SyncOptions(SYNC_TWO_WAY,
CheckSyncReport(0,
0,
0,
15,
15,
15,
true, SYNC_TWO_WAY)
.setRestarts(12))
.setStartCallback(setup)
));
// 13 cycles
CT_ASSERT_EQUAL((size_t)13, results.size());
static const int changes[13][3] = {
{ 0, 0, 0 }, // nothing before first cycle
{ 1, 0, 0 }, // result of first cycle
{ 3, 0, 0 }, // statistics are cummulative: first + second
{ 7, 0, 0 },
{ 15, 0, 0 },
{ 15, 1, 0 },
{ 15, 3, 0 },
{ 15, 7, 0 },
{ 15, 15, 0 },
{ 15, 15, 1 },
{ 15, 15, 3 },
{ 15, 15, 7 },
{ 15, 15, 15 }
};
BOOST_FOREACH(const Cycles_t::value_type &cycle, results) {
CT_ASSERT_EQUAL(sources.size(), cycle.second.size());
BOOST_FOREACH(const Reports_t::value_type &entry, cycle.second) {
const int *c = changes[cycle.first];
CLIENT_TEST_LOG("Checking stats before cycle #%d, source %s: expected remote %d/%d/%d",
cycle.first, entry.first.c_str(),
c[0], c[1], c[2]);
CT_ASSERT_NO_THROW(CheckSyncReport(0,0,0,
c[0], c[1], c[2])
.setRestarts(cycle.first)
.check(entry.first, entry.second));
}
}
// no item exists now
BOOST_FOREACH(source_array_t::value_type &source_pair, sources) {
TestingSyncSourcePtr source;
SOURCE_ASSERT_NO_FAILURE(source.get(), source.reset(source_pair.second->createSourceA()));
CT_ASSERT_EQUAL(0, countItems(source.get()));
}
}
// test that a two-way sync copies an item from one address book into the other
void SyncTests::testCopy()
{
CT_ASSERT_NO_THROW(doCopy());
CT_ASSERT_NO_THROW(compareDatabases());
}
// test that a two-way sync copies updates from database to the other client,
// using simple data commonly supported by servers
void SyncTests::testUpdate() {
CT_ASSERT(sources.begin() != sources.end());
CT_ASSERT(!sources.begin()->second->config.m_updateItem.empty());
// setup client A, B and server so that they all contain the same item
CT_ASSERT_NO_THROW(doCopy());
for (source_it it = sources.begin(); it != sources.end(); ++it) {
CT_ASSERT_NO_THROW(it->second->update(it->second->createSourceA, it->second->config.m_updateItem));
}
doSync(__FILE__, __LINE__,
"update",
SyncOptions(SYNC_TWO_WAY,
CheckSyncReport(0,0,0, 0,1,0, true, SYNC_TWO_WAY)));
accessClientB->doSync(__FILE__, __LINE__,
"update",
SyncOptions(SYNC_TWO_WAY,
CheckSyncReport(0,1,0, 0,0,0, true, SYNC_TWO_WAY)));
CT_ASSERT_NO_THROW(compareDatabases());
}
// test that a two-way sync copies updates from database to the other client,
// using data that some, but not all servers support, like adding a second
// phone number to a contact
void SyncTests::testComplexUpdate() {
// setup client A, B and server so that they all contain the same item
CT_ASSERT_NO_THROW(doCopy());
for (source_it it = sources.begin(); it != sources.end(); ++it) {
it->second->update(it->second->createSourceA,
/* this test might get executed with some sources which have
a complex update item while others don't: use the normal update item
for them or even just the same item */
!it->second->config.m_complexUpdateItem.empty() ? it->second->config.m_complexUpdateItem :
!it->second->config.m_updateItem.empty() ? it->second->config.m_updateItem :
it->second->config.m_insertItem
);
}
doSync(__FILE__, __LINE__,
"update",
SyncOptions(SYNC_TWO_WAY,
CheckSyncReport(0,0,0, 0,1,0, true, SYNC_TWO_WAY)));
accessClientB->doSync(__FILE__, __LINE__,
"update",
SyncOptions(SYNC_TWO_WAY,
CheckSyncReport(0,1,0, 0,0,0, true, SYNC_TWO_WAY)));
CT_ASSERT_NO_THROW(compareDatabases());
}
// test that a two-way sync deletes the copy of an item in the other database
void SyncTests::testDelete() {
// setup client A, B and server so that they all contain the same item
CT_ASSERT_NO_THROW(doCopy());
// delete it on A
CT_ASSERT_NO_THROW(allSourcesDeleteAll());
// transfer change from A to server to B
doSync(__FILE__, __LINE__,
"delete",
SyncOptions(SYNC_TWO_WAY,
CheckSyncReport(0,0,0, 0,0,1, true, SYNC_TWO_WAY)));
accessClientB->doSync(__FILE__, __LINE__,
"delete",
SyncOptions(SYNC_TWO_WAY,
CheckSyncReport(0,0,1, 0,0,0, true, SYNC_TWO_WAY)));
// check client B: shouldn't have any items now
for (source_it it = sources.begin(); it != sources.end(); ++it) {
TestingSyncSourcePtr copy;
SOURCE_ASSERT_NO_FAILURE(copy.get(), copy.reset(it->second->createSourceA()));
SOURCE_ASSERT_EQUAL(copy.get(), 0, countItems(copy.get()));
CT_ASSERT_NO_THROW(copy.reset());
}
}
// test what the server does when it finds that different
// fields of the same item have been modified
void SyncTests::testMerge() {
// setup client A, B and server so that they all contain the same item
CT_ASSERT_NO_THROW(doCopy());
// update in client A
for (source_it it = sources.begin(); it != sources.end(); ++it) {
CT_ASSERT_NO_THROW(it->second->update(it->second->createSourceA, it->second->config.m_mergeItem1));
}
// update in client B
for (source_it it = accessClientB->sources.begin(); it != accessClientB->sources.end(); ++it) {
CT_ASSERT_NO_THROW(it->second->update(it->second->createSourceA, it->second->config.m_mergeItem2));
}
// send change to server from client A (no conflict)
doSync(__FILE__, __LINE__,
"update",
SyncOptions(SYNC_TWO_WAY,
CheckSyncReport(0,0,0, 0,1,0, true, SYNC_TWO_WAY)));
// Now the changes from client B (conflict!).
// There are several possible outcomes:
// - client item completely replaces server item
// - server item completely replaces client item (update on client)
// - server merges and updates client
accessClientB->doSync(__FILE__, __LINE__,
"conflict",
SyncOptions(SYNC_TWO_WAY,
CheckSyncReport(-1,-1,-1, -1,-1,-1, true, SYNC_TWO_WAY)));
// figure out how the conflict during ".conflict" was handled
for (source_it it = accessClientB->sources.begin(); it != accessClientB->sources.end(); ++it) {
TestingSyncSourcePtr copy;
SOURCE_ASSERT_NO_FAILURE(copy.get(), copy.reset(it->second->createSourceA()));
int numItems = 0;
SOURCE_ASSERT_NO_FAILURE(copy.get(), numItems = countItems(copy.get()));
CT_ASSERT(numItems >= 1);
CT_ASSERT(numItems <= 2);
std::cerr << " \"" << it->second->config.m_sourceName << ": " << (numItems == 1 ? "conflicting items were merged" : "both of the conflicting items were preserved") << "\" ";
std::cerr.flush();
CT_ASSERT_NO_THROW(copy.reset());
}
// now pull the same changes into client A
doSync(__FILE__, __LINE__,
"refresh",
SyncOptions(SYNC_TWO_WAY,
CheckSyncReport(-1,-1,-1, 0,0,0, true, SYNC_TWO_WAY)));
// client A and B should have identical data now
CT_ASSERT_NO_THROW(compareDatabases());
// Furthermore, it should be identical with the server.
// Be extra careful and pull that data anew and compare once more.
doSync(__FILE__, __LINE__,
"check",
SyncOptions(RefreshFromPeerMode(),
CheckSyncReport(-1,-1,-1, -1,-1,-1, true, SYNC_REFRESH_FROM_REMOTE)));
CT_ASSERT_NO_THROW(compareDatabases());
}
// test what the server does when it has to execute a slow sync
// with identical data on client and server:
// expected behaviour is that nothing changes
void SyncTests::testTwinning() {
// clean server and client A
CT_ASSERT_NO_THROW(deleteAll());
// import test data
for (source_it it = sources.begin(); it != sources.end(); ++it) {
CT_ASSERT_NO_THROW(it->second->testImport());
}
// send to server
doSync(__FILE__, __LINE__, "send", SyncOptions(SYNC_TWO_WAY));
// ensure that client has the same data, thus ignoring data conversion
// issues (those are covered by testItems())
CT_ASSERT_NO_THROW(refreshClient());
// copy to client B to have another copy
CT_ASSERT_NO_THROW(accessClientB->refreshClient());
// slow sync should not change anything
doSync(__FILE__, __LINE__, "twinning", SyncOptions(SYNC_SLOW));
// check
CT_ASSERT_NO_THROW(compareDatabases());
}
// tests one-way sync from peer:
// - get both clients and server in sync with no items anywhere
// - add one item on first client, copy to server
// - add a different item on second client, one-way-from-server
// - two-way sync with first client
// => one item on first client, two on second
// - delete on first client, sync that to second client
// via two-way sync + one-way-from-server
// => one item left on second client (the one inserted locally)
void SyncTests::doOneWayFromRemote(SyncMode oneWayFromRemote) {
// no items anywhere
CT_ASSERT_NO_THROW(deleteAll());
CT_ASSERT_NO_THROW(accessClientB->refreshClient());
// check that everything is empty, also resets change tracking
// in second sources of each client
for (source_it it = sources.begin(); it != sources.end(); ++it) {
if (it->second->config.m_createSourceB) {
TestingSyncSourcePtr source;
SOURCE_ASSERT_NO_FAILURE(source.get(), source.reset(it->second->createSourceB()));
SOURCE_ASSERT_EQUAL(source.get(), 0, countItems(source.get()));
CT_ASSERT_NO_THROW(source.reset());
}
}
for (source_it it = accessClientB->sources.begin(); it != accessClientB->sources.end(); ++it) {
if (it->second->config.m_createSourceB) {
TestingSyncSourcePtr source;
SOURCE_ASSERT_NO_FAILURE(source.get(), source.reset(it->second->createSourceB()));
SOURCE_ASSERT_EQUAL(source.get(), 0, countItems(source.get()));
CT_ASSERT_NO_THROW(source.reset());
}
}
// add one item on first client, copy to server, and check change tracking via second source
for (source_it it = sources.begin(); it != sources.end(); ++it) {
CT_ASSERT_NO_THROW(it->second->insertManyItems(it->second->createSourceA, 200, 1));
}
doSync(__FILE__, __LINE__,
"send",
SyncOptions(SYNC_TWO_WAY,
CheckSyncReport(0,0,0, 1,0,0, true, SYNC_TWO_WAY)));
for (source_it it = sources.begin(); it != sources.end(); ++it) {
if (it->second->config.m_createSourceB) {
TestingSyncSourcePtr source;
SOURCE_ASSERT_NO_FAILURE(source.get(), source.reset(it->second->createSourceB()));
SOURCE_ASSERT_EQUAL(source.get(), 1, countItems(source.get()));
SOURCE_ASSERT_EQUAL(source.get(), 1, countNewItems(source.get()));
SOURCE_ASSERT_EQUAL(source.get(), 0, countDeletedItems(source.get()));
SOURCE_ASSERT_EQUAL(source.get(), 0, countUpdatedItems(source.get()));
CT_ASSERT_NO_THROW(source.reset());
}
}
// add a different item on second client, one-way-from-server
// => one item added locally, none sent to server
for (source_it it = accessClientB->sources.begin(); it != accessClientB->sources.end(); ++it) {
CT_ASSERT_NO_THROW(it->second->insertManyItems(it->second->createSourceA, 2, 1));
if (it->second->config.m_createSourceB) {
TestingSyncSourcePtr source;
SOURCE_ASSERT_NO_FAILURE(source.get(), source.reset(it->second->createSourceB()));
SOURCE_ASSERT_EQUAL(source.get(), 1, countItems(source.get()));
SOURCE_ASSERT_EQUAL(source.get(), 1, countNewItems(source.get()));
SOURCE_ASSERT_EQUAL(source.get(), 0, countDeletedItems(source.get()));
SOURCE_ASSERT_EQUAL(source.get(), 0, countUpdatedItems(source.get()));
CT_ASSERT_NO_THROW(source.reset());
}
}
accessClientB->doSync(__FILE__, __LINE__,
"recv",
SyncOptions(oneWayFromRemote,
CheckSyncReport(1,0,0, 0,0,0, true, SYNC_ONE_WAY_FROM_REMOTE)));
for (source_it it = accessClientB->sources.begin(); it != accessClientB->sources.end(); ++it) {
if (it->second->config.m_createSourceB) {
TestingSyncSourcePtr source;
SOURCE_ASSERT_NO_FAILURE(source.get(), source.reset(it->second->createSourceB()));
SOURCE_ASSERT_EQUAL(source.get(), 2, countItems(source.get()));
SOURCE_ASSERT_EQUAL(source.get(), 1, countNewItems(source.get()));
SOURCE_ASSERT_EQUAL(source.get(), 0, countDeletedItems(source.get()));
SOURCE_ASSERT_EQUAL(source.get(), 0, countUpdatedItems(source.get()));
CT_ASSERT_NO_THROW(source.reset());
}
}
// two-way sync with first client for verification
// => no changes
doSync(__FILE__, __LINE__,
"check",
SyncOptions(SYNC_TWO_WAY,
CheckSyncReport(0,0,0, 0,0,0, true, SYNC_TWO_WAY)));
for (source_it it = sources.begin(); it != sources.end(); ++it) {
if (it->second->config.m_createSourceB) {
TestingSyncSourcePtr source;
SOURCE_ASSERT_NO_FAILURE(source.get(), source.reset(it->second->createSourceB()));
SOURCE_ASSERT_EQUAL(source.get(), 1, countItems(source.get()));
SOURCE_ASSERT_EQUAL(source.get(), 0, countNewItems(source.get()));
SOURCE_ASSERT_EQUAL(source.get(), 0, countDeletedItems(source.get()));
SOURCE_ASSERT_EQUAL(source.get(), 0, countUpdatedItems(source.get()));
CT_ASSERT_NO_THROW(source.reset());
}
}
// delete items on clientA, sync to server
for (source_it it = sources.begin(); it != sources.end(); ++it) {
CT_ASSERT_NO_THROW(it->second->deleteAll(it->second->createSourceA));
if (it->second->config.m_createSourceB) {
TestingSyncSourcePtr source;
SOURCE_ASSERT_NO_FAILURE(source.get(), source.reset(it->second->createSourceB()));
SOURCE_ASSERT_EQUAL(source.get(), 0, countItems(source.get()));
SOURCE_ASSERT_EQUAL(source.get(), 0, countNewItems(source.get()));
SOURCE_ASSERT_EQUAL(source.get(), 1, countDeletedItems(source.get()));
SOURCE_ASSERT_EQUAL(source.get(), 0, countUpdatedItems(source.get()));
CT_ASSERT_NO_THROW(source.reset());
}
}
doSync(__FILE__, __LINE__,
"delete",
SyncOptions(SYNC_TWO_WAY,
CheckSyncReport(0,0,0, 0,0,1, true, SYNC_TWO_WAY)));
for (source_it it = sources.begin(); it != sources.end(); ++it) {
if (it->second->config.m_createSourceB) {
TestingSyncSourcePtr source;
SOURCE_ASSERT_NO_FAILURE(source.get(), source.reset(it->second->createSourceB()));
SOURCE_ASSERT_EQUAL(source.get(), 0, countItems(source.get()));
SOURCE_ASSERT_EQUAL(source.get(), 0, countNewItems(source.get()));
SOURCE_ASSERT_EQUAL(source.get(), 0, countDeletedItems(source.get()));
SOURCE_ASSERT_EQUAL(source.get(), 0, countUpdatedItems(source.get()));
CT_ASSERT_NO_THROW(source.reset());
}
}
// sync the same change to second client
// => one item left (the one inserted locally)
accessClientB->doSync(__FILE__, __LINE__,
"delete",
SyncOptions(oneWayFromRemote,
CheckSyncReport(0,0,1, 0,0,0, true, SYNC_ONE_WAY_FROM_REMOTE)));
for (source_it it = accessClientB->sources.begin(); it != accessClientB->sources.end(); ++it) {
if (it->second->config.m_createSourceB) {
TestingSyncSourcePtr source;
SOURCE_ASSERT_NO_FAILURE(source.get(), source.reset(it->second->createSourceB()));
SOURCE_ASSERT_EQUAL(source.get(), 1, countItems(source.get()));
SOURCE_ASSERT_EQUAL(source.get(), 0, countNewItems(source.get()));
SOURCE_ASSERT_EQUAL(source.get(), 1, countDeletedItems(source.get()));
SOURCE_ASSERT_EQUAL(source.get(), 0, countUpdatedItems(source.get()));
CT_ASSERT_NO_THROW(source.reset());
}
}
}
// one-way-from-remote test with one-way-from-client/server, depending
// on role of remote side
void SyncTests::testOneWayFromServer()
{
CT_ASSERT_NO_THROW(doOneWayFromRemote(OneWayFromPeerMode()));
}
void SyncTests::testOneWayFromRemote()
{
CT_ASSERT_NO_THROW(doOneWayFromRemote(SYNC_ONE_WAY_FROM_REMOTE));
}
// tests one-way sync from local side:
// - get both clients and server in sync with no items anywhere
// - add one item on first client, copy to server
// - add a different item on second client, one-way-from-client
// - two-way sync with first client
// => two items on first client, one on second
// - delete on second client, sync that to first client
// via one-way-from-client, two-way
// => one item left on first client (the one inserted locally)
void SyncTests::doOneWayFromLocal(SyncMode oneWayFromLocal) {
// no items anywhere
CT_ASSERT_NO_THROW(deleteAll());
CT_ASSERT_NO_THROW(accessClientB->deleteAll());
// check that everything is empty, also resets change tracking
// in second sources of each client
for (source_it it = sources.begin(); it != sources.end(); ++it) {
if (it->second->config.m_createSourceB) {
TestingSyncSourcePtr source;
SOURCE_ASSERT_NO_FAILURE(source.get(), source.reset(it->second->createSourceB()));
SOURCE_ASSERT_EQUAL(source.get(), 0, countItems(source.get()));
CT_ASSERT_NO_THROW(source.reset());
}
}
for (source_it it = accessClientB->sources.begin(); it != accessClientB->sources.end(); ++it) {
if (it->second->config.m_createSourceB) {
TestingSyncSourcePtr source;
SOURCE_ASSERT_NO_FAILURE(source.get(), source.reset(it->second->createSourceB()));
SOURCE_ASSERT_EQUAL(source.get(), 0, countItems(source.get()));
CT_ASSERT_NO_THROW(source.reset());
}
}
// add one item on first client, copy to server, and check change tracking via second source
for (source_it it = sources.begin(); it != sources.end(); ++it) {
CT_ASSERT_NO_THROW(it->second->insertManyItems(it->second->createSourceA, 1, 1));
}
doSync(__FILE__, __LINE__,
"send",
SyncOptions(SYNC_TWO_WAY,
CheckSyncReport(0,0,0, 1,0,0, true, SYNC_TWO_WAY)));
for (source_it it = sources.begin(); it != sources.end(); ++it) {
if (it->second->config.m_createSourceB) {
TestingSyncSourcePtr source;
SOURCE_ASSERT_NO_FAILURE(source.get(), source.reset(it->second->createSourceB()));
SOURCE_ASSERT_EQUAL(source.get(), 1, countItems(source.get()));
SOURCE_ASSERT_EQUAL(source.get(), 1, countNewItems(source.get()));
SOURCE_ASSERT_EQUAL(source.get(), 0, countDeletedItems(source.get()));
SOURCE_ASSERT_EQUAL(source.get(), 0, countUpdatedItems(source.get()));
CT_ASSERT_NO_THROW(source.reset());
}
}
// add a different item on second client, one-way-from-client
// => no item added locally, one sent to server
for (source_it it = accessClientB->sources.begin(); it != accessClientB->sources.end(); ++it) {
CT_ASSERT_NO_THROW(it->second->insertManyItems(it->second->createSourceA, 2, 1));
if (it->second->config.m_createSourceB) {
TestingSyncSourcePtr source;
SOURCE_ASSERT_NO_FAILURE(source.get(), source.reset(it->second->createSourceB()));
SOURCE_ASSERT_EQUAL(source.get(), 1, countItems(source.get()));
SOURCE_ASSERT_EQUAL(source.get(), 1, countNewItems(source.get()));
SOURCE_ASSERT_EQUAL(source.get(), 0, countDeletedItems(source.get()));
SOURCE_ASSERT_EQUAL(source.get(), 0, countUpdatedItems(source.get()));
CT_ASSERT_NO_THROW(source.reset());
}
}
accessClientB->doSync(__FILE__, __LINE__,
"send",
SyncOptions(oneWayFromLocal,
CheckSyncReport(0,0,0, 1,0,0, true, SYNC_ONE_WAY_FROM_LOCAL)));
for (source_it it = accessClientB->sources.begin(); it != accessClientB->sources.end(); ++it) {
if (it->second->config.m_createSourceB) {
TestingSyncSourcePtr source;
SOURCE_ASSERT_NO_FAILURE(source.get(), source.reset(it->second->createSourceB()));
SOURCE_ASSERT_EQUAL(source.get(), 1, countItems(source.get()));
SOURCE_ASSERT_EQUAL(source.get(), 0, countNewItems(source.get()));
SOURCE_ASSERT_EQUAL(source.get(), 0, countDeletedItems(source.get()));
SOURCE_ASSERT_EQUAL(source.get(), 0, countUpdatedItems(source.get()));
CT_ASSERT_NO_THROW(source.reset());
}
}
// two-way sync with client A for verification
// => receive one item
doSync(__FILE__, __LINE__,
"check",
SyncOptions(SYNC_TWO_WAY,
CheckSyncReport(1,0,0, 0,0,0, true, SYNC_TWO_WAY)));
for (source_it it = sources.begin(); it != sources.end(); ++it) {
if (it->second->config.m_createSourceB) {
TestingSyncSourcePtr source;
SOURCE_ASSERT_NO_FAILURE(source.get(), source.reset(it->second->createSourceB()));
SOURCE_ASSERT_EQUAL(source.get(), 2, countItems(source.get()));
SOURCE_ASSERT_EQUAL(source.get(), 1, countNewItems(source.get()));
SOURCE_ASSERT_EQUAL(source.get(), 0, countDeletedItems(source.get()));
SOURCE_ASSERT_EQUAL(source.get(), 0, countUpdatedItems(source.get()));
CT_ASSERT_NO_THROW(source.reset());
}
}
// delete items on client B, sync to server
for (source_it it = accessClientB->sources.begin(); it != accessClientB->sources.end(); ++it) {
CT_ASSERT_NO_THROW(it->second->deleteAll(it->second->createSourceA));
if (it->second->config.m_createSourceB) {
TestingSyncSourcePtr source;
SOURCE_ASSERT_NO_FAILURE(source.get(), source.reset(it->second->createSourceB()));
SOURCE_ASSERT_EQUAL(source.get(), 0, countItems(source.get()));
SOURCE_ASSERT_EQUAL(source.get(), 0, countNewItems(source.get()));
SOURCE_ASSERT_EQUAL(source.get(), 1, countDeletedItems(source.get()));
SOURCE_ASSERT_EQUAL(source.get(), 0, countUpdatedItems(source.get()));
CT_ASSERT_NO_THROW(source.reset());
}
}
accessClientB->doSync(__FILE__, __LINE__,
"delete",
SyncOptions(oneWayFromLocal,
CheckSyncReport(0,0,0, 0,0,1, true, SYNC_ONE_WAY_FROM_LOCAL)));
for (source_it it = accessClientB->sources.begin(); it != accessClientB->sources.end(); ++it) {
if (it->second->config.m_createSourceB) {
TestingSyncSourcePtr source;
SOURCE_ASSERT_NO_FAILURE(source.get(), source.reset(it->second->createSourceB()));
SOURCE_ASSERT_EQUAL(source.get(), 0, countItems(source.get()));
SOURCE_ASSERT_EQUAL(source.get(), 0, countNewItems(source.get()));
SOURCE_ASSERT_EQUAL(source.get(), 0, countDeletedItems(source.get()));
SOURCE_ASSERT_EQUAL(source.get(), 0, countUpdatedItems(source.get()));
CT_ASSERT_NO_THROW(source.reset());
}
}
// sync the same change to client A
// => one item left (the one inserted locally)
doSync(__FILE__, __LINE__,
"delete",
SyncOptions(SYNC_TWO_WAY,
CheckSyncReport(0,0,1, 0,0,0, true, SYNC_TWO_WAY)));
for (source_it it = sources.begin(); it != sources.end(); ++it) {
if (it->second->config.m_createSourceB) {
TestingSyncSourcePtr source;
SOURCE_ASSERT_NO_FAILURE(source.get(), source.reset(it->second->createSourceB()));
SOURCE_ASSERT_EQUAL(source.get(), 1, countItems(source.get()));
SOURCE_ASSERT_EQUAL(source.get(), 0, countNewItems(source.get()));
SOURCE_ASSERT_EQUAL(source.get(), 1, countDeletedItems(source.get()));
SOURCE_ASSERT_EQUAL(source.get(), 0, countUpdatedItems(source.get()));
CT_ASSERT_NO_THROW(source.reset());
}
}
}
// do a two-way sync without additional checks,
// may or may not actually be done in two-way mode
void SyncTests::testTwoWaySync()
{
doSync(__FILE__, __LINE__, SyncOptions(SYNC_TWO_WAY));
}
void SyncTests::testSlowSync()
{
doSync(__FILE__, __LINE__,
SyncOptions(SYNC_SLOW,
CheckSyncReport(-1,-1,-1, -1,-1,-1, true, SYNC_SLOW)));
}
// one-way-from-local test with one-way-from-client/server, depending
// on role of local side
void SyncTests::testOneWayFromClient()
{
CT_ASSERT_NO_THROW(doOneWayFromLocal(OneWayFromLocalMode()));
}
// do a slow sync without additional checks
void SyncTests::testOneWayFromLocal()
{
CT_ASSERT_NO_THROW(doOneWayFromLocal(SYNC_ONE_WAY_FROM_LOCAL));
}
// get engine ready, then use it to convert our test items
// to and from the internal field list
void SyncTests::testConversion() {
bool success = false;
SyncOptions::Callback_t callback = boost::bind(&SyncTests::doConversionCallback, this, &success, _1, _2);
doSync(__FILE__, __LINE__,
SyncOptions(SYNC_TWO_WAY, CheckSyncReport(-1,-1,-1, -1,-1,-1, false))
.setStartCallback(callback));
CT_ASSERT(success);
}
bool SyncTests::doConversionCallback(bool *success,
SyncContext &syncClient,
SyncOptions &options) {
*success = false;
for (source_it it = sources.begin(); it != sources.end(); ++it) {
const ClientTest::Config *config = &it->second->config;
TestingSyncSource *source = static_cast<TestingSyncSource *>(syncClient.findSource(config->m_sourceName));
CT_ASSERT(source);
std::string type = source->getNativeDatatypeName();
if (type.empty()) {
continue;
}
std::list<std::string> items;
std::string testcases;
ClientTest::getItems(config->m_testcases, items, testcases);
std::string converted = getCurrentTest();
converted += ".converted.";
converted += config->m_sourceName;
converted += ".dat";
simplifyFilename(converted);
std::ofstream out(converted.c_str());
BOOST_FOREACH(const string &item, items) {
string convertedItem = item;
if(!sysync::DataConversion(syncClient.getSession().get(),
type.c_str(),
type.c_str(),
convertedItem)) {
SE_LOG_ERROR(NULL, "failed parsing as %s:\n%s",
type.c_str(),
item.c_str());
} else {
out << convertedItem << "\n";
}
}
out.close();
// The test used peer-specific test cases, but the actual
// result does not depend on the peer because we haven't
// received the peer's DevInf at the point where we
// import/export the test cases (=> don't apply peer-specific
// synccompare workarounds).
//
// Due to the lack of DevInf, properties and parameters which
// need to be enabled via DevInf get lost (= filter them out).
ScopedEnvChange env("CLIENT_TEST_SERVER", "");
ScopedEnvChange envParams("CLIENT_TEST_STRIP_PARAMETERS", "X-EVOLUTION-UI-SLOT");
CT_ASSERT(config->m_compare(client, testcases, converted));
}
// abort sync after completing the test successfully (no exception so far!)
*success = true;
return true;
}
// imports test data, transmits it from client A to the server to
// client B and then compares which of the data has been transmitted
void SyncTests::testItems() {
// clean server and first test database
CT_ASSERT_NO_THROW(deleteAll());
// import data
for (source_it it = sources.begin(); it != sources.end(); ++it) {
CT_ASSERT_NO_THROW(it->second->testImport());
}
// transfer from client A to server to client B
doSync(__FILE__, __LINE__, "send", SyncOptions(SYNC_TWO_WAY).setWBXML(true));
CT_ASSERT_NO_THROW(accessClientB->refreshClient(SyncOptions().setWBXML(true)));
CT_ASSERT_NO_THROW(compareDatabases());
}
// creates several items, transmits them back and forth and
// then compares which of them have been preserved
void SyncTests::testItemsXML() {
// clean server and first test database
CT_ASSERT_NO_THROW(deleteAll());
// import data
for (source_it it = sources.begin(); it != sources.end(); ++it) {
CT_ASSERT_NO_THROW(it->second->testImport());
}
// transfer from client A to server to client B using the non-default XML format
doSync(__FILE__, __LINE__, "send", SyncOptions(SYNC_TWO_WAY).setWBXML(false));
CT_ASSERT_NO_THROW(accessClientB->refreshClient(SyncOptions().setWBXML(false)));
CT_ASSERT_NO_THROW(compareDatabases());
}
// imports test data, transmits it from client A to the server to
// client B, update on B and transfers back to the server,
// then compares against reference data that has the same changes
// applied on A
void SyncTests::testExtensions() {
// clean server and first test database
CT_ASSERT_NO_THROW(deleteAll());
// import data and create reference data
for (source_it it = sources.begin(); it != sources.end(); ++it) {
CT_ASSERT_NO_THROW(it->second->testImport());
string refDir = getCurrentTest() + "." + it->second->config.m_sourceName + ".ref.dat";
simplifyFilename(refDir);
rm_r(refDir);
mkdir_p(refDir);
TestingSyncSourcePtr source;
int counter = 0;
SOURCE_ASSERT_NO_FAILURE(source.get(), source.reset(it->second->createSourceB()));
BOOST_FOREACH(const string &luid, source->getAllItems()) {
string item;
source->readItemRaw(luid, item);
CT_ASSERT_NO_THROW(it->second->config.m_update(item));
ofstream out(StringPrintf("%s/%d", refDir.c_str(), counter).c_str());
out.write(item.c_str(), item.size());
counter++;
}
CT_ASSERT_NO_THROW(source.reset());
}
// transfer from client A to server to client B
doSync(__FILE__, __LINE__, "send", SyncOptions(SYNC_TWO_WAY));
CT_ASSERT_NO_THROW(accessClientB->refreshClient(SyncOptions()));
// update on client B
for (source_it it = accessClientB->sources.begin(); it != accessClientB->sources.end(); ++it) {
CT_ASSERT_NO_THROW(it->second->updateData(it->second->createSourceB));
}
// send back
accessClientB->doSync(__FILE__, __LINE__, "update", SyncOptions(SYNC_TWO_WAY));
doSync(__FILE__, __LINE__, "patch", SyncOptions(SYNC_TWO_WAY));
bool equal = true;
for (source_it it = sources.begin(); it != sources.end(); ++it) {
string refDir = getCurrentTest() + "." + it->second->config.m_sourceName + ".ref.dat";
simplifyFilename(refDir);
TestingSyncSourcePtr source;
SOURCE_ASSERT_NO_FAILURE(source.get(), source.reset(it->second->createSourceB()));
// Compare data in source A against reference data *without*
// telling synccompare to ignore known data loss for the
// server. CLIENT_TEST_SERVER is relevant for finding the
// right source config and thus setting it must come after the
// createSourceB() call.
ScopedEnvChange env("CLIENT_TEST_SERVER", "");
ScopedEnvChange envParams("CLIENT_TEST_STRIP_PARAMETERS", "X-EVOLUTION-UI-SLOT");
// X-EVOLUTION-FILE-AS is not preserved correctly with EDS due
// to setting it on incoming items. It is not always set as already stored
// locally, so when writing back, the new, artificially generated value overwrites
// the one chosen by the user. Not ideal, but the alternative (not setting it on
// incoming items) is worse.
ScopedEnvChange envProps("CLIENT_TEST_STRIP_PROPERTIES", "(PHOTO|FN|X-EVOLUTION-FILE-AS)");
if (!it->second->compareDatabases(refDir.c_str(), *source, false)) {
equal = false;
}
}
CT_ASSERT(equal);
}
// tests the following sequence of events:
// - both clients in sync with server
// - client 1 adds item
// - client 1 updates the same item
// - client 2 gets item: the client should be asked to add the item
//
// However it has been observed that sometimes the item was sent as "update"
// for a non-existant local item. This is a server bug, the client does not
// have to handle that. See
// http://forge.objectweb.org/tracker/?func=detail&atid=100096&aid=305018&group_id=96
void SyncTests::testAddUpdate() {
// clean server and both test databases
CT_ASSERT_NO_THROW(deleteAll());
accessClientB->refreshClient();
// add item
for (source_it it = sources.begin(); it != sources.end(); ++it) {
CT_ASSERT_NO_THROW(it->second->insert(it->second->createSourceA, it->second->config.m_insertItem, false));
}
doSync(__FILE__, __LINE__,
"add",
SyncOptions(SYNC_TWO_WAY,
CheckSyncReport(0,0,0, 1,0,0, true, SYNC_TWO_WAY)));
// update it
for (source_it it = sources.begin(); it != sources.end(); ++it) {
CT_ASSERT_NO_THROW(it->second->update(it->second->createSourceB, it->second->config.m_updateItem));
}
doSync(__FILE__, __LINE__,
"update",
SyncOptions(SYNC_TWO_WAY,
CheckSyncReport(0,0,0, 0,1,0, true, SYNC_TWO_WAY)));
// now download the updated item into the second client
accessClientB->doSync(__FILE__, __LINE__,
"recv",
SyncOptions(SYNC_TWO_WAY,
CheckSyncReport(1,0,0, 0,0,0, true, SYNC_TWO_WAY)));
// compare the two databases
CT_ASSERT_NO_THROW(compareDatabases());
}
// test copying with maxMsg and no large object support
void SyncTests::testMaxMsg()
{
CT_ASSERT_NO_THROW(doVarSizes(true, false));
}
// test copying with maxMsg and large object support
void SyncTests::testLargeObject()
{
CT_ASSERT_NO_THROW(doVarSizes(true, true));
}
//
// stress tests: execute some of the normal operations,
// but with large number of artificially generated items
//
// two-way sync with clean client/server,
// followed by slow sync and comparison
// via second client
void SyncTests::testManyItems() {
// clean server and client A
CT_ASSERT_NO_THROW(deleteAll());
// import artificial data: make them large to generate some
// real traffic and test buffer handling
int num_items = defNumItems();
for (source_it it = sources.begin(); it != sources.end(); ++it) {
CT_ASSERT_NO_THROW(it->second->insertManyItems(it->second->createSourceA, 0, num_items, 2000));
}
// send data to server
doSync(__FILE__, __LINE__,
"send",
SyncOptions(SYNC_TWO_WAY,
CheckSyncReport(0,0,0, num_items,0,0, true, SYNC_TWO_WAY),
SyncOptions::DEFAULT_MAX_MSG_SIZE,
SyncOptions::DEFAULT_MAX_OBJ_SIZE,
true));
// ensure that client has the same data, ignoring data conversion
// issues (those are covered by testItems())
CT_ASSERT_NO_THROW(refreshClient());
// also copy to second client
accessClientB->refreshClient();
// slow sync now should not change anything
doSync(__FILE__, __LINE__,
"twinning",
SyncOptions(SYNC_SLOW,
CheckSyncReport(-1,-1,-1, -1,-1,-1, true, SYNC_SLOW),
SyncOptions::DEFAULT_MAX_MSG_SIZE,
SyncOptions::DEFAULT_MAX_OBJ_SIZE,
true));
// compare
CT_ASSERT_NO_THROW(compareDatabases());
}
/**
* Tell server to delete plenty of items.
*/
void SyncTests::testManyDeletes() {
// clean server and client A
CT_ASSERT_NO_THROW(deleteAll());
// import artificial data: make them small, we just want
// many of them
int num_items = defNumItems();
for (source_it it = sources.begin(); it != sources.end(); ++it) {
CT_ASSERT_NO_THROW(it->second->insertManyItems(it->second->createSourceA, 0, num_items, 100));
}
// send data to server
doSync(__FILE__, __LINE__,
"send",
SyncOptions(SYNC_TWO_WAY,
CheckSyncReport(0,0,0, num_items,0,0, true, SYNC_TWO_WAY),
64 * 1024, 64 * 1024, true));
// ensure that client has the same data, ignoring data conversion
// issues (those are covered by testItems())
CT_ASSERT_NO_THROW(refreshClient());
// also copy to second client
accessClientB->refreshClient();
// slow sync now should not change anything
doSync(__FILE__, __LINE__,
"twinning",
SyncOptions(SYNC_SLOW,
CheckSyncReport(-1,-1,-1, -1,-1,-1, true, SYNC_SLOW),
64 * 1024, 64 * 1024, true));
// compare
CT_ASSERT_NO_THROW(compareDatabases());
// delete everything locally
CT_ASSERT_NO_THROW(allSourcesDeleteAll());
doSync(__FILE__, __LINE__,
"delete-server",
SyncOptions(SYNC_TWO_WAY,
CheckSyncReport(0,0,0, 0,0,num_items, true, SYNC_TWO_WAY),
10 * 1024));
// Reporting locally deleted items depends on sync mode
// recognition, see SyncContext.cpp.
const char* checkSyncModeStr = getenv("CLIENT_TEST_NOCHECK_SYNCMODE");
// update second client
accessClientB->doSync(__FILE__, __LINE__,
"delete-client",
SyncOptions(RefreshFromPeerMode(),
checkSyncModeStr ? CheckSyncReport() :
CheckSyncReport(0,0,num_items, 0,0,0, true, SYNC_REFRESH_FROM_REMOTE),
10 * 1024));
}
/**
* - get client A, server, client B in sync with one item
* - force slow sync in A: must not duplicate items, but may update it locally
* - refresh client B (in case that the item was updated)
* - delete item in B and server via two-way sync
* - refresh-from-server in B to check that item is gone
* - two-way in A: must delete the item
*/
void SyncTests::testSlowSyncSemantic()
{
// set up one item everywhere
CT_ASSERT_NO_THROW(doCopy());
// slow in A
doSync(__FILE__, __LINE__,
"slow",
SyncOptions(SYNC_SLOW,
CheckSyncReport(0,-1,0, -1,-1,0, true, SYNC_SLOW)));
// refresh B, delete item
accessClientB->doSync(__FILE__, __LINE__,
"refresh",
SyncOptions(SYNC_TWO_WAY,
CheckSyncReport(0,-1,0, 0,0,0, true, SYNC_TWO_WAY)));
CT_ASSERT_NO_THROW(accessClientB->allSourcesDeleteAll());
accessClientB->doSync(__FILE__, __LINE__,
"delete",
SyncOptions(SYNC_TWO_WAY,
CheckSyncReport(0,0,0, 0,0,1, true, SYNC_TWO_WAY)));
accessClientB->doSync(__FILE__, __LINE__,
"check",
SyncOptions(RefreshFromPeerMode(),
CheckSyncReport(0,0,0, 0,0,0, true, SYNC_REFRESH_FROM_REMOTE)));
// now the item should also be deleted on A
doSync(__FILE__, __LINE__,
"delete",
SyncOptions(SYNC_TWO_WAY,
CheckSyncReport(0,0,1, 0,0,0, true, SYNC_TWO_WAY)));
}
/**
* check that refresh-from-server works correctly:
* - create the same item on A, server, B via testCopy()
* - refresh B (one item deleted, one created)
* - delete item on A and server
* - refresh B (one item deleted)
*/
void SyncTests::testComplexRefreshFromServerSemantic()
{
CT_ASSERT_NO_THROW(testCopy());
// Reporting locally deleted items depends on sync mode
// recognition, see SyncContext.cpp.
const char* checkSyncModeStr = getenv("CLIENT_TEST_NOCHECK_SYNCMODE");
// check refresh with one item on server
const char *value = getenv ("CLIENT_TEST_NOREFRESH");
// If refresh_from_server or refresh_from_client (depending on this is a
// server or client) is not supported, we can still test via slow sync.
if (value) {
accessClientB->refreshClient();
} else {
accessClientB->doSync(__FILE__, __LINE__,
"refresh-one",
SyncOptions(RefreshFromPeerMode(),
checkSyncModeStr ? CheckSyncReport() :
CheckSyncReport(1,0,1, 0,0,0, true, SYNC_REFRESH_FROM_REMOTE)));
}
// delete that item via A, check again
CT_ASSERT_NO_THROW(allSourcesDeleteAll());
doSync(__FILE__, __LINE__,
"delete-item",
SyncOptions(SYNC_TWO_WAY,
CheckSyncReport(0,0,0, 0,0,1, true, SYNC_TWO_WAY)));
if (value) {
accessClientB->refreshClient();
} else {
accessClientB->doSync(__FILE__, __LINE__,
"refresh-none",
SyncOptions(RefreshFromPeerMode(),
checkSyncModeStr ? CheckSyncReport() :
CheckSyncReport(0,0,1, 0,0,0, true, SYNC_REFRESH_FROM_REMOTE)));
}
}
/**
* - create the same item on A, server, B via testCopy()
* - delete on both sides
* - sync A
* - sync B
*
* Must not fail, even though the Synthesis engine will ask the backends
* for deletion of an already deleted item.
*/
void SyncTests::testDeleteBothSides()
{
CT_ASSERT_NO_THROW(testCopy());
CT_ASSERT_NO_THROW(allSourcesDeleteAll());
CT_ASSERT_NO_THROW(accessClientB->allSourcesDeleteAll());
doSync(__FILE__, __LINE__,
"delete-item-A",
SyncOptions(SYNC_TWO_WAY,
CheckSyncReport(0,0,0, 0,0,1, true, SYNC_TWO_WAY)));
for (source_it it = sources.begin(); it != sources.end(); ++it) {
if (it->second->config.m_createSourceB) {
TestingSyncSourcePtr source;
SOURCE_ASSERT_NO_FAILURE(source.get(), source.reset(it->second->createSourceB()));
SOURCE_ASSERT_EQUAL(source.get(), 0, countItems(source.get()));
CT_ASSERT_NO_THROW(source.reset());
}
}
// it is undefined whether the item is meant to be reported as deleted again here:
// a SyncML client test will mark it as deleted, local sync as server won't
accessClientB->doSync(__FILE__, __LINE__,
"delete-item-B",
SyncOptions(SYNC_TWO_WAY,
CheckSyncReport(0,0,0, 0,0,-1, true, SYNC_TWO_WAY)));
for (source_it it = accessClientB->sources.begin(); it != accessClientB->sources.end(); ++it) {
if (it->second->config.m_createSourceB) {
TestingSyncSourcePtr source;
SOURCE_ASSERT_NO_FAILURE(source.get(), source.reset(it->second->createSourceB()));
SOURCE_ASSERT_EQUAL(source.get(), 0, countItems(source.get()));
CT_ASSERT_NO_THROW(source.reset());
}
}
}
/**
* - clean A, server, B
* - create an item on A
* - sync A
* - create a modified version of the item on B
* - sync B
*
* Depends on UID and LAST-MODIFIED in item data, i.e., iCalendar 2.0.
* Uses the normal "insertItem" test case. Only works for a single source.
*
* The server must not duplicate the item *and* preserve the modified
* properties.
*
* Temporary: because conflict resolution is server-dependent, such a strict
* test fails. For example, with SyncEvolution 1.2 as server, DESCRIPTION and
* LOCATION end up being concatenated (merge=lines mode). The test now avoids
* using different data, with the expected outcome that only one item
* is present at the end and no unnecessary data transfers happen (only true
* for SyncEvolution server).
*
* A similar situation occurs on the client side, but it is harder to
* trigger: the updated item must be added to the client's database
* after it has reported its changes. Because if it happens earlier,
* it would send an Add to the server and the server would have to
* resolve the add<->add conflict, as in this test here.
*/
// using updated item data makes the test harder to pass:
// server must use exactly the right item, which currently
// is not the case for SyncEvolution
bool addBothSidesUsesUpdateItem = true;
// SyncEvolution passes with addBothSidesUsesUpdateItem == true
// if we avoid changes to those properties in the iCalendar test
// set which currently use merge=lines.
bool addBothSidesNoMergeLines=true;
// if true, relax expectations for updates from server:
// may or may not send one
bool addBothSidesMayUpdate = false;
// if true, then accept that the Synthesis server mode counts
// Add commands as "added items" even if they are turned into updates
bool addBothSidesAddStatsBroken = false;
// if true, then the peer is a SyncML server which does not
// support UID/RECURRENCE-ID and thus doesn't detect
// duplicates itself; the client needs to do that
bool addBothSidesServerIsDumb = getenv("CLIENT_TEST_ADD_BOTH_SIDES_SERVER_IS_DUMB") != NULL;
static void testAddBothSidesFixUpdateItem(std::string &updateItem)
{
if (addBothSidesNoMergeLines) {
// VEVENT
boost::replace_all(updateItem, "LOCATION:big meeting room", "LOCATION:my office");
boost::replace_all(updateItem, "DESCRIPTION:nice to see you", "DESCRIPTION:let's talk<<REVISION>>");
// VJOURNAL
boost::replace_all(updateItem, "DESCRIPTION:Summary\\nBody text", "DESCRIPTION:Summary Modified\\nBody text");
// VTODO
boost::replace_all(updateItem, "DESCRIPTION:to be done", "DESCRIPTION:to be done<<REVISION>>");
}
}
void SyncTests::testAddBothSides()
{
CT_ASSERT_NO_THROW(deleteAll());
accessClientB->deleteAll();
std::string insertItem = sources[0].second->config.m_insertItem;
std::string updateItem = sources[0].second->config.m_updateItem;
testAddBothSidesFixUpdateItem(updateItem);
CT_ASSERT_NO_THROW(sources[0].second->insert(sources[0].second->createSourceA,
insertItem));
doSync(__FILE__, __LINE__,
"send-old",
SyncOptions(SYNC_TWO_WAY,
CheckSyncReport(0,0,0, 1,0,0, true, SYNC_TWO_WAY)));
// insert updated item data on B
std::string data;
CT_ASSERT_NO_THROW(accessClientB->sources[0].second->insert(accessClientB->sources[0].second->createSourceA,
addBothSidesUsesUpdateItem ?
updateItem:
insertItem,
false,
&data));
// As far as the client knows, it is adding an item;
// server not expected to send back an update (our data was more recent
// and completely overwrites the server's data).
// When acting as server, we do the duplicate detection and thus know
// more about the actual outcome.
accessClientB->doSync(__FILE__, __LINE__,
"send-update",
SyncOptions(SYNC_TWO_WAY,
isServerMode() ?
CheckSyncReport(addBothSidesAddStatsBroken ? -1 : 0,0,0,
0,
addBothSidesMayUpdate ? -1 :
addBothSidesUsesUpdateItem ? 1 : 0,
0,
true, SYNC_TWO_WAY) :
addBothSidesServerIsDumb ?
CheckSyncReport(addBothSidesServerIsDumb ? 1 : 0,
addBothSidesMayUpdate ? -1 : 0,
0,
// client got one redundant item from
// server, had to receive it, match against
// its own copy, then tell the server to
// update one copy and delete the other;
// no update necessary on server because
// it already had the latest copy
1,0,1, true, SYNC_TWO_WAY).setRestarts(1) :
CheckSyncReport(0,
addBothSidesMayUpdate ? -1 : 0,
0,
// client doesn't know that the add
// was an update, in contrast to server
1,0,0, true, SYNC_TWO_WAY)));
// update sent to client A
doSync(__FILE__, __LINE__,
"update",
SyncOptions(SYNC_TWO_WAY,
(!isServerMode() && addBothSidesServerIsDumb) ?
// server had to be told to update old item
// and delete redundant one, which is what it now
// also tells us here
CheckSyncReport(1,0,1,
0,0,0, true, SYNC_TWO_WAY) :
CheckSyncReport(0,
addBothSidesMayUpdate ? -1 :
addBothSidesUsesUpdateItem ? 1 : 0,
0,
0,0,0, true, SYNC_TWO_WAY)));
// nothing necessary for client B
accessClientB->doSync(__FILE__, __LINE__,
"nop",
SyncOptions(SYNC_TWO_WAY,
CheckSyncReport(0,0,0, 0,0,0, true, SYNC_TWO_WAY)));
// now compare client A against reference data
TestingSyncSourcePtr copy;
SOURCE_ASSERT_NO_FAILURE(copy.get(), copy.reset(sources[0].second->createSourceB()));
sources[0].second->compareDatabases(copy.get(), &data, (void *)NULL);
CT_ASSERT_NO_THROW(copy.reset());
}
/**
* compared to testAddBothSides the age of the items is reversed now;
* a server which always copies the client's data passes testAddBothSides
* but fails here
*/
void SyncTests::testAddBothSidesRefresh()
{
CT_ASSERT_NO_THROW(deleteAll());
accessClientB->deleteAll();
std::string insertItem = sources[0].second->config.m_insertItem;
std::string updateItem = sources[0].second->config.m_updateItem;
testAddBothSidesFixUpdateItem(updateItem);
// insert initial item data on B
CT_ASSERT_NO_THROW(accessClientB->sources[0].second->insert(accessClientB->sources[0].second->createSourceA,
insertItem));
// sleep one second to ensure that it's mangled LAST-MODIFIED is older than
// the one from the next item, inserted on A
sleep(1);
// more recent data sent to server first
std::string data;
CT_ASSERT_NO_THROW(sources[0].second->insert(sources[0].second->createSourceA,
addBothSidesUsesUpdateItem ?
updateItem :
insertItem,
false,
&data));
doSync(__FILE__, __LINE__,
"send-new",
SyncOptions(SYNC_TWO_WAY,
CheckSyncReport(0,0,0, 1,0,0, true, SYNC_TWO_WAY)));
// As far as the client knows, it is adding an item;
// server expected to send back an update (client's data was out-dated);
// When acting as server, we do the duplicate detection and thus
// know more about the actual outcome.
accessClientB->doSync(__FILE__, __LINE__,
"send-old",
SyncOptions(SYNC_TWO_WAY,
isServerMode() ?
CheckSyncReport(addBothSidesAddStatsBroken ? -1 : 0,
addBothSidesMayUpdate ? -1 :
addBothSidesUsesUpdateItem ? 1 : 0,
0,
0,
addBothSidesMayUpdate ? -1 : 0,
0,
true, SYNC_TWO_WAY) :
// When the server is dumb, it
// will just accept the added
// item and send us an <Add>
// with an item that has the
// same UID as the one it just
// received. The client then
// must start a second sync and
// fix the server by sending an update
// (of the old version) and a delete (of the
// new one)
addBothSidesServerIsDumb ?
CheckSyncReport(1,0,0,
1,1,1, true, SYNC_TWO_WAY).setRestarts(1) :
CheckSyncReport(0,
addBothSidesMayUpdate ? -1 :
addBothSidesUsesUpdateItem ? 1 : 0,
0,
// client doesn't know that add was
// an update
1,0,0, true, SYNC_TWO_WAY)));
// potentially send update to A
doSync(__FILE__, __LINE__,
"nopA",
SyncOptions(SYNC_TWO_WAY,
(!isServerMode() && addBothSidesServerIsDumb) ?
// receives extra changes because dumb server had to be fixed
CheckSyncReport(1,0,1, 0,0,0, true, SYNC_TWO_WAY) :
CheckSyncReport(0,addBothSidesMayUpdate ? -1 : 0,0, 0,0,0, true, SYNC_TWO_WAY)));
// nothing necessary for client B (already synchronized completely above in one sync)
accessClientB->doSync(__FILE__, __LINE__,
"nopB",
SyncOptions(SYNC_TWO_WAY,
CheckSyncReport(0,0,0, 0,0,0, true, SYNC_TWO_WAY)));
// now compare client A against reference data
TestingSyncSourcePtr copy;
SOURCE_ASSERT_NO_FAILURE(copy.get(), copy.reset(sources[0].second->createSourceB()));
sources[0].second->compareDatabases(copy.get(), &data, (void *)NULL);
CT_ASSERT_NO_THROW(copy.reset());
}
/**
* - adds parent on client A
* - syncs A
* - adds unrelated item via client B (necessary to trigger corner cases in
* change tracking, see BMC #22329)
* - syncs B
* - adds child on client A
* - syncs A and B
* - compares
*/
void SyncTests::testLinkedItemsParentChild()
{
// clean server, client A and client B
CT_ASSERT_NO_THROW(deleteAll());
accessClientB->refreshClient();
// create and copy parent item
for (source_it it = sources.begin(); it != sources.end(); ++it) {
CT_ASSERT(!it->second->config.m_linkedItems.empty());
CT_ASSERT(it->second->config.m_linkedItems[0].size() >= 2);
TestingSyncSourcePtr source;
CT_ASSERT_NO_THROW(it->second->insert(it->second->createSourceA,
it->second->config.m_linkedItems[0][0],
false));
}
doSync(__FILE__, __LINE__,
"send-parent",
SyncOptions(SYNC_TWO_WAY,
CheckSyncReport(0,0,0, 1,0,0, true, SYNC_TWO_WAY)));
// create independent item, refresh client B and server
for (source_it it = accessClientB->sources.begin(); it != accessClientB->sources.end(); ++it) {
CT_ASSERT_NO_THROW(it->second->insert(it->second->createSourceA,
it->second->config.m_insertItem,
false));
}
accessClientB->doSync(__FILE__, __LINE__,
"recv-parent",
SyncOptions(SYNC_TWO_WAY,
CheckSyncReport(1,0,0, 1,0,0, true, SYNC_TWO_WAY)));
// add child on client A
for (source_it it = sources.begin(); it != sources.end(); ++it) {
CT_ASSERT(!it->second->config.m_linkedItems.empty());
CT_ASSERT(it->second->config.m_linkedItems[0].size() >= 2);
TestingSyncSourcePtr source;
CT_ASSERT_NO_THROW(it->second->insert(it->second->createSourceA,
it->second->config.m_linkedItems[0][1],
false));
}
// parent may or may not be considered updated
doSync(__FILE__, __LINE__,
"send-child",
SyncOptions(SYNC_TWO_WAY,
CheckSyncReport(1,0,0, 1,-1,0, true, SYNC_TWO_WAY)));
// parent may or may not be considered updated here
accessClientB->doSync(__FILE__, __LINE__,
"recv-child",
SyncOptions(SYNC_TWO_WAY,
CheckSyncReport(1,-1,0, 0,0,0, true, SYNC_TWO_WAY)));
// final comparison
CT_ASSERT_NO_THROW(compareDatabases());
}
/**
* - adds child on client A
* - syncs A
* - syncs B
* - compare
*/
void SyncTests::testLinkedItemsChild()
{
// clean server, client A and client B
CT_ASSERT_NO_THROW(deleteAll());
accessClientB->refreshClient();
// create and copy child item
for (source_it it = sources.begin(); it != sources.end(); ++it) {
CT_ASSERT(!it->second->config.m_linkedItems.empty());
CT_ASSERT(it->second->config.m_linkedItems[0].size() >= 2);
TestingSyncSourcePtr source;
CT_ASSERT_NO_THROW(it->second->insert(it->second->createSourceA,
it->second->config.m_linkedItems[0][1],
false));
}
doSync(__FILE__, __LINE__,
"send",
SyncOptions(SYNC_TWO_WAY,
CheckSyncReport(0,0,0, 1,0,0, true, SYNC_TWO_WAY)));
accessClientB->doSync(__FILE__, __LINE__,
"recv",
SyncOptions(SYNC_TWO_WAY,
CheckSyncReport(1,0,0, 0,0,0, true, SYNC_TWO_WAY)));
// final comparison
CT_ASSERT_NO_THROW(compareDatabases());
}
/**
* - adds child on client A
* - syncs A and B
* - adds parent on client A
* - syncs A and B
* - compares
*/
void SyncTests::testLinkedItemsChildParent()
{
// clean server, client A and client B
CT_ASSERT_NO_THROW(deleteAll());
accessClientB->refreshClient();
// create and copy child item
for (source_it it = sources.begin(); it != sources.end(); ++it) {
CT_ASSERT(!it->second->config.m_linkedItems[0].empty());
CT_ASSERT(it->second->config.m_linkedItems[0].size() >= 2);
TestingSyncSourcePtr source;
CT_ASSERT_NO_THROW(it->second->insert(it->second->createSourceA,
it->second->config.m_linkedItems[0][1],
false));
}
doSync(__FILE__, __LINE__,
"send-child",
SyncOptions(SYNC_TWO_WAY,
CheckSyncReport(0,0,0, 1,0,0, true, SYNC_TWO_WAY)));
accessClientB->doSync(__FILE__, __LINE__,
"recv-child",
SyncOptions(SYNC_TWO_WAY,
CheckSyncReport(1,0,0, 0,0,0, true, SYNC_TWO_WAY)));
// add parent on client A
for (source_it it = sources.begin(); it != sources.end(); ++it) {
CT_ASSERT(!it->second->config.m_linkedItems.empty());
CT_ASSERT(it->second->config.m_linkedItems[0].size() >= 2);
TestingSyncSourcePtr source;
// relaxed change checks because child event is also modified
CT_ASSERT_NO_THROW(it->second->insert(it->second->createSourceA,
it->second->config.m_linkedItems[0][0],
true));
}
// child may or may not be considered updated
doSync(__FILE__, __LINE__,
"send-parent",
SyncOptions(SYNC_TWO_WAY,
CheckSyncReport(0,0,0, 1,-1,0, true, SYNC_TWO_WAY)));
// child may or may not be considered updated here
accessClientB->doSync(__FILE__, __LINE__,
"recv-parent",
SyncOptions(SYNC_TWO_WAY,
CheckSyncReport(1,-1,0, 0,0,0, true, SYNC_TWO_WAY)));
// final comparison
CT_ASSERT_NO_THROW(compareDatabases());
}
/**
* implements testMaxMsg(), testLargeObject(), testLargeObjectEncoded()
* using a sequence of items with varying sizes
*/
void SyncTests::doVarSizes(bool withMaxMsgSize,
bool withLargeObject) {
int maxMsgSize = 8 * 1024;
const char* maxItemSize = getenv("CLIENT_TEST_MAX_ITEMSIZE");
int tmpSize = maxItemSize ? atoi(maxItemSize) : 0;
if(tmpSize > 0)
maxMsgSize = tmpSize;
// clean server and client A
CT_ASSERT_NO_THROW(deleteAll());
// insert items, doubling their size, then restart with small size
for (source_it it = sources.begin(); it != sources.end(); ++it) {
int item = 1;
restoreStorage(it->second->config, client);
TestingSyncSourcePtr source;
SOURCE_ASSERT_NO_FAILURE(source.get(), source.reset(it->second->createSourceA()));
for (int i = 0; i < 2; i++ ) {
int size = 1;
while (size < 2 * maxMsgSize) {
CT_ASSERT_NO_THROW(it->second->insertManyItems(source.get(), item, 1, it->second->config.m_templateItem.size() + 10 + size));
size *= 2;
item++;
}
}
backupStorage(it->second->config, client);
}
// transfer to server
doSync(__FILE__, __LINE__,
"send",
SyncOptions(SYNC_TWO_WAY,
CheckSyncReport(0,0,0, -1,0,0, true, SYNC_TWO_WAY), // number of items sent to server depends on source
withMaxMsgSize ? SyncOptions::DEFAULT_MAX_MSG_SIZE: 0,
withMaxMsgSize ? SyncOptions::DEFAULT_MAX_OBJ_SIZE : 0,
withLargeObject));
// copy to second client
const char *value = getenv ("CLIENT_TEST_NOREFRESH");
// If refresh_from_server or refresh_from_client (depending on this is a
// server or client) is not supported, we can still test via slow sync.
if (value) {
accessClientB->refreshClient();
} else {
accessClientB->doSync(__FILE__, __LINE__,
"recv",
SyncOptions(RefreshFromPeerMode(),
CheckSyncReport(-1,0,-1, 0,0,0, true, SYNC_REFRESH_FROM_REMOTE), // number of items received from server depends on source
withLargeObject ? maxMsgSize : withMaxMsgSize ? maxMsgSize * 100 /* large enough so that server can sent the largest item */ : 0,
withMaxMsgSize ? maxMsgSize * 100 : 0,
withLargeObject));
}
// compare
CT_ASSERT_NO_THROW(compareDatabases());
}
/**
* Send message to server, then pretend that we timed out at exactly
* one specific message, specified via m_interruptAtMessage. The
* caller is expected to resend the message, without aborting the
* session. That resend and all following message will get through
* again.
*
* Each send() is counted as one message, starting at 1 for the first
* message.
*/
class TransportResendInjector : public TransportWrapper{
private:
int timeout;
public:
TransportResendInjector()
:TransportWrapper() {
const char *s = getenv("CLIENT_TEST_RESEND_TIMEOUT");
timeout = s ? atoi(s) : 0;
}
~TransportResendInjector() {
}
virtual int getResendFailureThreshold() { return 0; }
virtual void send(const char *data, size_t len)
{
m_messageCount++;
if (m_interruptAtMessage >= 0 &&
m_messageCount == m_interruptAtMessage+1) {
m_wrappedAgent->send(data, len);
m_status = m_wrappedAgent->wait();
//trigger client side resend
sleep (timeout);
m_status = TIME_OUT;
}
else
{
m_wrappedAgent->send(data, len);
m_status = m_wrappedAgent->wait();
}
}
virtual void getReply(const char *&data, size_t &len, std::string &contentType) {
if (m_status == FAILED) {
data = "";
len = 0;
} else {
m_wrappedAgent->getReply(data, len, contentType);
}
}
};
/**
* Stop sending at m_interruptAtMessage. The caller is forced to abort
* the current session and will recover by retrying in another
* session.
*
* Each send() increments the counter by two, so that 1 aborts before
* the first message and 2 after it.
*/
class TransportFaultInjector : public TransportWrapper{
public:
TransportFaultInjector()
:TransportWrapper() {
}
~TransportFaultInjector() {
}
virtual void send(const char *data, size_t len)
{
if (m_interruptAtMessage == m_messageCount) {
SE_LOG_DEBUG(NULL, "TransportFaultInjector: interrupt before sending message #%d", m_messageCount);
}
m_messageCount++;
if (m_interruptAtMessage >= 0 &&
m_messageCount > m_interruptAtMessage) {
throw string("TransportFaultInjector: interrupt before send");
}
m_wrappedAgent->send(data, len);
m_status = m_wrappedAgent->wait();
if (m_interruptAtMessage == m_messageCount) {
SE_LOG_DEBUG(NULL, "TransportFaultInjector: interrupt after receiving reply #%d", m_messageCount);
}
m_messageCount++;
if (m_interruptAtMessage >= 0 &&
m_messageCount > m_interruptAtMessage) {
m_status = FAILED;
}
}
virtual void getReply(const char *&data, size_t &len, std::string &contentType) {
if (m_status == FAILED) {
data = "";
len = 0;
} else {
m_wrappedAgent->getReply(data, len, contentType);
}
}
};
/**
* Swallow data at various points:
* - between "client sent data" and "server receives data"
* - after "server received data" and before "server sends reply"
* - after "server has sent reply"
*
* The client deals with it by resending. This is similar to
* TransportResendInjector and the ::Resend tests, but more thorough,
* and stresses the HTTP server more (needs to deal with "reply not
* delivered" error).
*
* Each send() increments the counter by three, so that 0 aborts
* before the first message, 1 after sending it, and 2 after receiving
* its reply.
*
* Swallowing data is implemented via the proxy.py script. This is
* necessary because the wrapped agent has no API to trigger the second
* error scenario. The wrapped agent is told to use a specific port
* on localhost, with the base port passing message and reply through,
* "base + 1" intercepting the message, etc.
*
* Because of the use of a proxy, this cannot be used to test servers
* where a real proxy is needed.
*/
class TransportResendProxy : public TransportWrapper {
private:
int port;
public:
TransportResendProxy() : TransportWrapper() {
const char *s = getenv("CLIENT_TEST_RESEND_PROXY");
port = s ? atoi(s) : 0;
}
virtual int getResendFailureThreshold() { return 2; }
virtual void send(const char *data, size_t len)
{
HTTPTransportAgent *agent = dynamic_cast<HTTPTransportAgent *>(m_wrappedAgent.get());
CT_ASSERT(agent);
m_messageCount += 3;
if (m_interruptAtMessage >= 0 &&
m_interruptAtMessage < m_messageCount &&
m_interruptAtMessage >= m_messageCount - 3) {
int offset = m_interruptAtMessage - m_messageCount + 4;
SE_LOG_DEBUG(NULL, "TransportResendProxy: interrupt %s",
offset == 1 ? "before sending message" :
offset == 2 ? "directly after sending message" :
"after receiving reply");
agent->setProxy(StringPrintf("http://127.0.0.1:%d",
offset + port));
} else {
agent->setProxy("");
}
agent->send(data, len);
m_status = agent->wait();
}
virtual void getReply(const char *&data, size_t &len, std::string &contentType) {
if (m_status == FAILED) {
data = "";
len = 0;
} else {
m_wrappedAgent->getReply(data, len, contentType);
}
}
};
/**
* Emulates a user suspend just after receving response
* from server.
*/
class UserSuspendInjector : public TransportWrapper{
public:
UserSuspendInjector()
:TransportWrapper() {
}
~UserSuspendInjector() {
}
virtual void send(const char *data, size_t len)
{
m_wrappedAgent->send(data, len);
m_status = m_wrappedAgent->wait();
}
virtual void getReply(const char *&data, size_t &len, std::string &contentType) {
if (m_status == FAILED) {
data = "";
len = 0;
} else {
if (m_interruptAtMessage == m_messageCount) {
SE_LOG_DEBUG(NULL, "UserSuspendInjector: user suspend after getting reply #%d", m_messageCount);
}
m_messageCount++;
if (m_interruptAtMessage >= 0 &&
m_messageCount > m_interruptAtMessage) {
m_options->m_isSuspended = SuspendFlags::getSuspendFlags().suspend();
}
m_wrappedAgent->getReply(data, len, contentType);
}
}
};
/**
* This function covers different error scenarios that can occur
* during real synchronization. To pass, clients must either force a
* slow synchronization after a failed synchronization or implement
* the error handling described in the design guide (track server's
* status for added/updated/deleted items and resend unacknowledged
* changes).
*
* The items used during these tests are synthetic. They are
* constructed so that normally a server should be able to handle
* twinning during a slow sync correctly.
*
* Errors are injected into a synchronization by wrapping the normal
* HTTP transport agent. The wrapper enumerates messages sent between
* client and server (i.e., one message exchange increments the
* counter by two), starting from zero. It "cuts" the connection before
* sending out the next message to the server respectively after the
* server has replied, but before returning the reply to the client.
* The first case simulates a lost message from the client to the server
* and the second case a lost message from the server to the client.
*
* The expected result is the same as in an uninterrupted sync, which
* is done once at the beginning.
*
* Each test goes through the following steps:
* - client A and B reset local data store
* - client A creates 3 new items, remembers LUIDs
* - refresh-from-client A sync
* - refresh-from-client B sync
* - client B creates 3 different items, remembers LUIDs
* - client B syncs
* - client A syncs => A, B, server are in sync
* - client A modifies his items (depends on test) and
* sends changes to server => server has changes for B
* - client B modifies his items (depends on test)
* - client B syncs, transport wrapper simulates lost message n
* - client B syncs again, resuming synchronization if possible or
* slow sync otherwise (responsibility of the client!)
* - client A syncs (not tested yet: A should be sent exactly the changes made by B)
* - test that A and B contain same items
* - test that A contains the same items as the uninterrupted reference run
* - repeat the steps above ranging starting with lost message 0 until no
* message got lost
*
* Set the CLIENT_TEST_INTERRUPT_AT env variable to a message number
* >= 0 to execute one uninterrupted run and then interrupt at that
* message. Set to -1 to just do the uninterrupted run.
*/
void SyncTests::doInterruptResume(int changes,
boost::shared_ptr<TransportWrapper> wrapper)
{
int interruptAtMessage = -1;
const char *t = getenv("CLIENT_TEST_INTERRUPT_AT");
int requestedInterruptAt = t ? atoi(t) : -2;
const char *s = getenv("CLIENT_TEST_INTERRUPT_SLEEP");
int sleep_t = s ? atoi(s) : 0;
size_t i;
std::string refFileBase = getCurrentTest() + ".ref.";
bool equal = true;
bool resend = wrapper->getResendFailureThreshold() != -1;
bool suspend = dynamic_cast <UserSuspendInjector *> (wrapper.get()) != NULL;
bool interrupt = dynamic_cast <TransportFaultInjector *> (wrapper.get()) != NULL;
// better be large enough for complete DevInf, 20000 is already a
// bit small when running with many stores
size_t maxMsgSize = 20000;
size_t changedItemSize = (changes & BIG) ?
5 * maxMsgSize / 2 : // large enough to be split over three messages
0;
// After running the uninterrupted sync, we remember the number
// of sent messages. We never interrupt between sending our
// own last message and receiving the servers last reply,
// because the server is unable to detect that we didn't get
// the reply. It will complete the session whereas the client
// suspends, leading to an unexpected slow sync the next time.
int maxMsgNum = 0;
while (true) {
char buffer[80];
sprintf(buffer, "%d", interruptAtMessage);
const char *prefix = interruptAtMessage == -1 ? "complete" : buffer;
SyncPrefix prefixA(prefix, *this);
SyncPrefix prefixB(prefix, *accessClientB);
std::vector< std::list<std::string> > clientAluids;
std::vector< std::list<std::string> > clientBluids;
// create new items in client A and sync to server
clientAluids.resize(sources.size());
for (i = 0; i < sources.size(); i++) {
sources[i].second->deleteAll(sources[i].second->createSourceA);
clientAluids[i] =
sources[i].second->insertManyItems(sources[i].second->createSourceA,
1, 3, 0);
}
doSync(__FILE__, __LINE__, "fromA", SyncOptions(RefreshFromLocalMode()));
// init client B and add its items to server and client A
accessClientB->doSync(__FILE__, __LINE__, "initB", SyncOptions(RefreshFromPeerMode()));
clientBluids.resize(sources.size());
for (i = 0; i < sources.size(); i++) {
clientBluids[i] =
accessClientB->sources[i].second->insertManyItems(accessClientB->sources[i].second->createSourceA,
11, 3, 0);
}
accessClientB->doSync(__FILE__, __LINE__, "fromB", SyncOptions(SYNC_TWO_WAY));
doSync(__FILE__, __LINE__, "updateA", SyncOptions(SYNC_TWO_WAY));
// => client A, B and server in sync with a total of six items
// make changes as requested on client A and sync to server
for (i = 0; i < sources.size(); i++) {
if (changes & SERVER_ADD) {
sources[i].second->insertManyItems(sources[i].second->createSourceA,
4, 1, changedItemSize);
}
if (changes & SERVER_REMOVE) {
// remove second item
removeItem(sources[i].second->createSourceA,
*(++clientAluids[i].begin()));
}
if (changes & SERVER_UPDATE) {
// update third item
updateItem(sources[i].second->createSourceA,
sources[i].second->config,
*(++ ++clientAluids[i].begin()),
sources[i].second->createItem(3, "updated", changedItemSize).c_str());
}
}
// send using the same mode as in the interrupted sync with client B
if (changes & (SERVER_ADD|SERVER_REMOVE|SERVER_UPDATE)) {
doSync(__FILE__, __LINE__, "changesFromA", SyncOptions(SYNC_TWO_WAY).setMaxMsgSize(maxMsgSize));
}
// make changes as requested on client B
for (i = 0; i < sources.size(); i++) {
if (changes & CLIENT_ADD) {
accessClientB->sources[i].second->insertManyItems(accessClientB->sources[i].second->createSourceA,
14, 1, changedItemSize);
}
if (changes & CLIENT_REMOVE) {
// remove second item
removeItem(accessClientB->sources[i].second->createSourceA,
*(++clientBluids[i].begin()));
}
if (changes & CLIENT_UPDATE) {
// update third item
updateItem(accessClientB->sources[i].second->createSourceA,
accessClientB->sources[i].second->config,
*(++ ++clientBluids[i].begin()),
accessClientB->sources[i].second->createItem(13, "updated", changedItemSize).c_str());
}
}
// Now do an interrupted sync between B and server.
// The explicit delete of the TransportAgent is suppressed
// by overloading the delete operator.
int wasInterrupted;
{
CheckSyncReport check(-1, -1, -1, -1, -1, -1, false);
if (resend && interruptAtMessage > wrapper->getResendFailureThreshold()) {
// resend tests must succeed, except for the first
// message in the session, which is not resent
check.mustSucceed = true;
}
SyncOptions options(SYNC_TWO_WAY, check);
options.setTransportAgent(wrapper);
options.setMaxMsgSize(maxMsgSize);
// disable resending completely or shorten the resend
// interval to speed up testing
options.setRetryInterval(resend ? 10 : 0);
wrapper->setInterruptAtMessage(interruptAtMessage);
accessClientB->doSync(__FILE__, __LINE__, "changesFromB", options);
wasInterrupted = interruptAtMessage != -1 &&
wrapper->getMessageCount() <= interruptAtMessage;
if (!maxMsgNum) {
maxMsgNum = wrapper->getMessageCount();
}
wrapper->rewind();
}
if (interruptAtMessage != -1) {
if (wasInterrupted) {
// uninterrupted sync, done
break;
}
// continue, wait until server timeout
if(sleep_t)
sleep (sleep_t);
// no need for resend tests, unless they were interrupted at the first message
if (!resend || interruptAtMessage <= wrapper->getResendFailureThreshold()) {
SyncReport report;
accessClientB->doSync(__FILE__, __LINE__,
"retryB",
SyncOptions(SYNC_TWO_WAY,
CheckSyncReport().setMode(SYNC_TWO_WAY).setReport(&report)));
// Suspending at first and last message doesn't need a
// resume, everything else does. When multiple sources
// are involved, some may suspend, some may not, so we
// cannot check.
if (suspend &&
interruptAtMessage != 0 &&
interruptAtMessage + 1 != maxMsgNum &&
report.size() == 1) {
BOOST_FOREACH(const SyncReport::SourceReport_t &sourceReport, report) {
CT_ASSERT(sourceReport.second.isResumeSync());
}
}
}
}
// copy changes to client A
doSync(__FILE__, __LINE__, "toA", SyncOptions(SYNC_TWO_WAY));
// compare client A and B
if (interruptAtMessage != -1 &&
!compareDatabases(refFileBase.c_str(), false)) {
equal = false;
std::cerr << "====> comparison of client B against reference file(s) failed after interrupting at message #" <<
interruptAtMessage << std::endl;
std::cerr.flush();
}
if (!compareDatabases(NULL, false)) {
equal = false;
std::cerr << "====> comparison of client A and B failed after interrupting at message #" <<
interruptAtMessage << std::endl;
std::cerr.flush();
}
// save reference files from uninterrupted run?
if (interruptAtMessage == -1) {
for (source_it it = sources.begin();
it != sources.end();
++it) {
std::string refFile = refFileBase;
refFile += it->second->config.m_sourceName;
refFile += ".dat";
simplifyFilename(refFile);
TestingSyncSourcePtr source;
SOURCE_ASSERT_NO_FAILURE(source.get(), source.reset(it->second->createSourceA()));
SOURCE_ASSERT_EQUAL(source.get(), 0, it->second->config.m_dump(client, *source.get(), refFile.c_str()));
CT_ASSERT_NO_THROW(source.reset());
}
}
// pick next iteration
if (requestedInterruptAt == -1) {
// user requested to stop after first iteration
break;
} else if (requestedInterruptAt >= 0) {
// only do one interrupted run of the test
if (requestedInterruptAt == interruptAtMessage) {
break;
} else {
interruptAtMessage = requestedInterruptAt;
}
} else {
// interrupt one message later than before
interruptAtMessage++;
if (interrupt &&
interruptAtMessage + 1 >= maxMsgNum) {
// Don't interrupt before the server's last reply,
// because then the server thinks we completed the
// session when we think we didn't, which leads to a
// slow sync. Testing that is better done with a
// specific test.
break;
}
if (interruptAtMessage >= maxMsgNum) {
// next run would not interrupt at all, stop now
break;
}
}
}
CT_ASSERT(equal);
}
void SyncTests::testInterruptResumeClientAdd()
{
CT_ASSERT_NO_THROW(doInterruptResume(CLIENT_ADD, boost::shared_ptr<TransportWrapper> (new TransportFaultInjector())));
}
void SyncTests::testInterruptResumeClientRemove()
{
CT_ASSERT_NO_THROW(doInterruptResume(CLIENT_REMOVE, boost::shared_ptr<TransportWrapper> (new TransportFaultInjector())));
}
void SyncTests::testInterruptResumeClientUpdate()
{
CT_ASSERT_NO_THROW(doInterruptResume(CLIENT_UPDATE, boost::shared_ptr<TransportWrapper> (new TransportFaultInjector())));
}
void SyncTests::testInterruptResumeServerAdd()
{
CT_ASSERT_NO_THROW(doInterruptResume(SERVER_ADD, boost::shared_ptr<TransportWrapper> (new TransportFaultInjector())));
}
void SyncTests::testInterruptResumeServerRemove()
{
CT_ASSERT_NO_THROW(doInterruptResume(SERVER_REMOVE, boost::shared_ptr<TransportWrapper> (new TransportFaultInjector())));
}
void SyncTests::testInterruptResumeServerUpdate()
{
CT_ASSERT_NO_THROW(doInterruptResume(SERVER_UPDATE, boost::shared_ptr<TransportWrapper> (new TransportFaultInjector())));
}
void SyncTests::testInterruptResumeClientAddBig()
{
CT_ASSERT_NO_THROW(doInterruptResume(CLIENT_ADD|BIG, boost::shared_ptr<TransportWrapper> (new TransportFaultInjector())));
}
void SyncTests::testInterruptResumeClientUpdateBig()
{
CT_ASSERT_NO_THROW(doInterruptResume(CLIENT_UPDATE|BIG, boost::shared_ptr<TransportWrapper> (new TransportFaultInjector())));
}
void SyncTests::testInterruptResumeServerAddBig()
{
CT_ASSERT_NO_THROW(doInterruptResume(SERVER_ADD|BIG, boost::shared_ptr<TransportWrapper> (new TransportFaultInjector())));
}
void SyncTests::testInterruptResumeServerUpdateBig()
{
CT_ASSERT_NO_THROW(doInterruptResume(SERVER_UPDATE|BIG, boost::shared_ptr<TransportWrapper> (new TransportFaultInjector())));
}
void SyncTests::testInterruptResumeFull()
{
CT_ASSERT_NO_THROW(doInterruptResume(CLIENT_ADD|CLIENT_REMOVE|CLIENT_UPDATE|
SERVER_ADD|SERVER_REMOVE|SERVER_UPDATE, boost::shared_ptr<TransportWrapper> (new TransportFaultInjector())));
}
void SyncTests::testUserSuspendClientAdd()
{
CT_ASSERT_NO_THROW(doInterruptResume(CLIENT_ADD, boost::shared_ptr<TransportWrapper> (new UserSuspendInjector())));
}
void SyncTests::testUserSuspendClientRemove()
{
CT_ASSERT_NO_THROW(doInterruptResume(CLIENT_REMOVE, boost::shared_ptr<TransportWrapper> (new UserSuspendInjector())));
}
void SyncTests::testUserSuspendClientUpdate()
{
CT_ASSERT_NO_THROW(doInterruptResume(CLIENT_UPDATE, boost::shared_ptr<TransportWrapper> (new UserSuspendInjector())));
}
void SyncTests::testUserSuspendServerAdd()
{
CT_ASSERT_NO_THROW(doInterruptResume(SERVER_ADD, boost::shared_ptr<TransportWrapper> (new UserSuspendInjector())));
}
void SyncTests::testUserSuspendServerRemove()
{
CT_ASSERT_NO_THROW(doInterruptResume(SERVER_REMOVE, boost::shared_ptr<TransportWrapper> (new UserSuspendInjector())));
}
void SyncTests::testUserSuspendServerUpdate()
{
CT_ASSERT_NO_THROW(doInterruptResume(SERVER_UPDATE, boost::shared_ptr<TransportWrapper> (new UserSuspendInjector())));
}
void SyncTests::testUserSuspendClientAddBig()
{
CT_ASSERT_NO_THROW(doInterruptResume(CLIENT_ADD|BIG, boost::shared_ptr<TransportWrapper> (new UserSuspendInjector())));
}
void SyncTests::testUserSuspendClientUpdateBig()
{
CT_ASSERT_NO_THROW(doInterruptResume(CLIENT_UPDATE|BIG, boost::shared_ptr<TransportWrapper> (new UserSuspendInjector())));
}
void SyncTests::testUserSuspendServerAddBig()
{
CT_ASSERT_NO_THROW(doInterruptResume(SERVER_ADD|BIG, boost::shared_ptr<TransportWrapper> (new UserSuspendInjector())));
}
void SyncTests::testUserSuspendServerUpdateBig()
{
CT_ASSERT_NO_THROW(doInterruptResume(SERVER_UPDATE|BIG, boost::shared_ptr<TransportWrapper> (new UserSuspendInjector())));
}
void SyncTests::testUserSuspendFull()
{
CT_ASSERT_NO_THROW(doInterruptResume(CLIENT_ADD|CLIENT_REMOVE|CLIENT_UPDATE|
SERVER_ADD|SERVER_REMOVE|SERVER_UPDATE, boost::shared_ptr<TransportWrapper> (new UserSuspendInjector())));
}
void SyncTests::testResendClientAdd()
{
CT_ASSERT_NO_THROW(doInterruptResume(CLIENT_ADD, boost::shared_ptr<TransportWrapper> (new TransportResendInjector())));
}
void SyncTests::testResendClientRemove()
{
CT_ASSERT_NO_THROW(doInterruptResume(CLIENT_REMOVE, boost::shared_ptr<TransportWrapper> (new TransportResendInjector())));
}
void SyncTests::testResendClientUpdate()
{
CT_ASSERT_NO_THROW(doInterruptResume(CLIENT_UPDATE, boost::shared_ptr<TransportWrapper> (new TransportResendInjector())));
}
void SyncTests::testResendServerAdd()
{
CT_ASSERT_NO_THROW(doInterruptResume(SERVER_ADD, boost::shared_ptr<TransportWrapper> (new TransportResendInjector())));
}
void SyncTests::testResendServerRemove()
{
CT_ASSERT_NO_THROW(doInterruptResume(SERVER_REMOVE, boost::shared_ptr<TransportWrapper> (new TransportResendInjector())));
}
void SyncTests::testResendServerUpdate()
{
CT_ASSERT_NO_THROW(doInterruptResume(SERVER_UPDATE, boost::shared_ptr<TransportWrapper> (new TransportResendInjector())));
}
void SyncTests::testResendFull()
{
CT_ASSERT_NO_THROW(doInterruptResume(CLIENT_ADD|CLIENT_REMOVE|CLIENT_UPDATE|
SERVER_ADD|SERVER_REMOVE|SERVER_UPDATE,
boost::shared_ptr<TransportWrapper> (new TransportResendInjector())));
}
void SyncTests::testResendProxyClientAdd()
{
CT_ASSERT_NO_THROW(doInterruptResume(CLIENT_ADD, boost::shared_ptr<TransportWrapper> (new TransportResendProxy())));
}
void SyncTests::testResendProxyClientRemove()
{
CT_ASSERT_NO_THROW(doInterruptResume(CLIENT_REMOVE, boost::shared_ptr<TransportWrapper> (new TransportResendProxy())));
}
void SyncTests::testResendProxyClientUpdate()
{
CT_ASSERT_NO_THROW(doInterruptResume(CLIENT_UPDATE, boost::shared_ptr<TransportWrapper> (new TransportResendProxy())));
}
void SyncTests::testResendProxyServerAdd()
{
CT_ASSERT_NO_THROW(doInterruptResume(SERVER_ADD, boost::shared_ptr<TransportWrapper> (new TransportResendProxy())));
}
void SyncTests::testResendProxyServerRemove()
{
CT_ASSERT_NO_THROW(doInterruptResume(SERVER_REMOVE, boost::shared_ptr<TransportWrapper> (new TransportResendProxy())));
}
void SyncTests::testResendProxyServerUpdate()
{
CT_ASSERT_NO_THROW(doInterruptResume(SERVER_UPDATE, boost::shared_ptr<TransportWrapper> (new TransportResendProxy())));
}
void SyncTests::testResendProxyFull()
{
CT_ASSERT_NO_THROW(doInterruptResume(CLIENT_ADD|CLIENT_REMOVE|CLIENT_UPDATE|
SERVER_ADD|SERVER_REMOVE|SERVER_UPDATE,
boost::shared_ptr<TransportWrapper> (new TransportResendProxy())));
}
static bool setDeadSyncURL(SyncContext &context,
SyncOptions &options,
int port,
bool *skipped)
{
vector<string> urls = context.getSyncURL();
string url;
if (urls.size() == 1) {
url = urls.front();
}
// use IPv4 localhost address, that's what we listen on
string fakeURL = StringPrintf("http://127.0.0.1:%d/foobar", port);
if (boost::starts_with(url, "http")) {
context.setSyncURL(fakeURL, true);
context.setSyncUsername("foo", true);
context.setSyncPassword("bar", true);
return false;
} else if (boost::starts_with(url, "local://")) {
FullProps props = context.getConfigProps();
string target = url.substr(strlen("local://"));
props[target].m_syncProps["syncURL"] = fakeURL;
props[target].m_syncProps["retryDuration"] = InitStateString("10", true);
props[target].m_syncProps["retryInterval"] = InitStateString("10", true);
context.setConfigProps(props);
return false;
} else {
// cannot run test, tell parent
*skipped = true;
return true;
}
}
void SyncTests::testTimeout()
{
// Create a dead listening socket, then run a sync with a sync URL
// which points towards localhost at that port. Do this with no
// message resending and a very short overall timeout. The
// expectation is that the transmission timeout strikes.
time_t start = time(NULL);
int fd = socket(AF_INET, SOCK_STREAM, 0);
CT_ASSERT(fd != -1);
struct sockaddr_in servaddr;
memset(&servaddr, 0, sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
int res = bind(fd, (sockaddr *)&servaddr, sizeof(servaddr));
CT_ASSERT_EQUAL(0, res);
socklen_t len = sizeof(servaddr);
res = getsockname(fd, (sockaddr *)&servaddr, &len);
CT_ASSERT_EQUAL(0, res);
res = listen(fd, 10);
CT_ASSERT_EQUAL(0, res);
bool skipped = false;
SyncReport report;
doSync(__FILE__, __LINE__,
"timeout",
SyncOptions(SYNC_SLOW,
CheckSyncReport(-1, -1, -1, -1, -1, -1,
false).setReport(&report))
.setPrepareCallback(boost::bind(setDeadSyncURL, _1, _2, ntohs(servaddr.sin_port), &skipped))
.setRetryDuration(20)
.setRetryInterval(20));
time_t end = time(NULL);
close(fd);
if (!skipped) {
CT_ASSERT_EQUAL(STATUS_TRANSPORT_FAILURE, report.getStatus());
std::string delta = StringPrintf("%lds", (long)(end - start));
CT_ASSERT_MESSAGE(delta, end - start >= 19);
// needs to be sufficiently larger than 20s timeout
// because under valgrind the startup time is considerable
CT_ASSERT_MESSAGE(delta, end - start < 50);
}
}
static void UpdateLocal(const std::string &config, const std::string &source,
const std::string &actualLocalData,
const std::string &localModified,
const std::string &modifyLocal)
{
// The local side also uses the Cmdline class because then we only
// need to implement one way of updating items. But first we need to
// get the actual data.
std::unique_ptr<Cmdline> cmdline;
rm_r(actualLocalData);
mkdir_p(actualLocalData);
cmdline.reset(new TestCmdline("--daemon=no",
"--export",
actualLocalData.c_str(),
config.c_str(),
source.c_str(),
(const char *)NULL));
CT_ASSERT(cmdline->parse());
CT_ASSERT_MESSAGE("export " + currentServer() + "_1 " + source, cmdline->run());
CT_ASSERT(!system(StringPrintf("%s %s %s",
modifyLocal.c_str(),
actualLocalData.c_str(),
localModified.c_str()).c_str()));
CT_ASSERT(isDir(localModified));
cmdline.reset(new TestCmdline("--daemon=no",
"--update",
localModified.c_str(),
config.c_str(),
source.c_str(),
(const char *)NULL));
CT_ASSERT(cmdline->parse());
CT_ASSERT_MESSAGE("update " + config + " " + source, cmdline->run());
}
void SyncTests::testUpload()
{
const std::string testname = "testUpload";
CT_ASSERT_EQUAL(sources.size(), 1);
const ClientTest::Config &config(sources[0].second->config);
StringPair peerConfig = getPeerConfig(config.m_sourceName);
const std::string &peer = peerConfig.first;
const std::string &peerSource = peerConfig.second;
CT_ASSERT(!peer.empty());
CT_ASSERT(!peerSource.empty());
std::string localTestdata = getPeerTestdata(config.m_sourceName, testname, "local");
CT_ASSERT_MESSAGE(localTestdata, !access(localTestdata.c_str(), R_OK));
std::string remoteTestdata = getPeerTestdata(config.m_sourceName, testname, "remote");
CT_ASSERT_MESSAGE(remoteTestdata, !access(remoteTestdata.c_str(), R_OK));
std::string modifyRemote = getPeerTestdata(config.m_sourceName, testname, "modify-remote");
CT_ASSERT_MESSAGE(modifyRemote, !access(modifyRemote.c_str(), R_OK|X_OK));
std::string localSyncedTestdata = getPeerTestdata(config.m_sourceName, testname, "local-synced");
CT_ASSERT_MESSAGE(localSyncedTestdata, !access(localSyncedTestdata.c_str(), R_OK));
std::unique_ptr<Cmdline> cmdline;
// Import locally into empty database.
sources[0].second->deleteAll(sources[0].second->createSourceA);
sources[0].second->doImport(localTestdata);
// Sync to remote.
doSync(__FILE__, __LINE__,
"upload",
SyncOptions(RefreshFromLocalMode(),
CheckSyncReport(0,0,0, -1,0,0, true, SYNC_REFRESH_FROM_LOCAL)));
// Export from remote directly.
std::string actualData = getCurrentTest() + ".remote.test.dat";
simplifyFilename(actualData);
mkdir_p(actualData);
cmdline.reset(new TestCmdline("--daemon=no",
"--export",
actualData.c_str(),
peer.c_str(),
peerSource.c_str(),
(const char *)NULL));
CT_ASSERT(cmdline->parse());
CT_ASSERT_MESSAGE(peer + " " + peerSource, cmdline->run());
// Compare against expected result. We use the compare operation
// of the local source and apply it to data from the remote one.
// This typically works if the data has the same format.
{
ScopedEnvChange fullSyncCompare("CLIENT_TEST_SERVER", "none");
CT_ASSERT(sources[0].second->compareDatabases(remoteTestdata, actualData));
}
// Modify remotely.
std::string remoteModified = getCurrentTest() + ".remote.modified.test.dat";
simplifyFilename(remoteModified);
CT_ASSERT(!system(StringPrintf("%s %s %s",
modifyRemote.c_str(),
actualData.c_str(),
remoteModified.c_str()).c_str()));
CT_ASSERT(isDir(remoteModified));
cmdline.reset(new TestCmdline("--daemon=no",
"--update",
remoteModified.c_str(),
peer.c_str(),
peerSource.c_str(),
(const char *)NULL));
CT_ASSERT(cmdline->parse());
CT_ASSERT_MESSAGE("update " + peer + " " + peerSource, cmdline->run());
// Sync between both sides to update the local data.
doSync(__FILE__, __LINE__,
"two-way",
SyncOptions(SYNC_TWO_WAY,
CheckSyncReport(0,-1,0, 0,0,0, true, SYNC_TWO_WAY)));
// Compare against expected result.
TestingSyncSourcePtr copy;
SOURCE_ASSERT_NO_FAILURE(copy.get(), copy.reset(sources[0].second->createSourceA(), TestingSyncSourcePtr::SLOW));
{
ScopedEnvChange fullSyncCompare("CLIENT_TEST_SERVER", "none");
CT_ASSERT(sources[0].second->compareDatabases(localSyncedTestdata.c_str(), *copy));
}
}
void SyncTests::testDownload()
{
const std::string testname = "testDownload";
CT_ASSERT_EQUAL(sources.size(), 1);
const ClientTest::Config &config(sources[0].second->config);
StringPair peerConfig = getPeerConfig(config.m_sourceName);
const std::string &peer = peerConfig.first;
const std::string &peerSource = peerConfig.second;
CT_ASSERT(!peer.empty());
CT_ASSERT(!peerSource.empty());
std::string localTestdata = getPeerTestdata(config.m_sourceName, testname, "local");
CT_ASSERT_MESSAGE(localTestdata, !access(localTestdata.c_str(), R_OK));
std::string remoteTestdata = getPeerTestdata(config.m_sourceName, testname, "remote");
CT_ASSERT_MESSAGE(remoteTestdata, !access(remoteTestdata.c_str(), R_OK));
std::string modifyLocal = getPeerTestdata(config.m_sourceName, testname, "modify-local");
CT_ASSERT_MESSAGE(modifyLocal, !access(modifyLocal.c_str(), R_OK|X_OK));
std::string remoteSyncedTestdata = getPeerTestdata(config.m_sourceName, testname, "remote-synced");
CT_ASSERT_MESSAGE(remoteSyncedTestdata, !access(remoteSyncedTestdata.c_str(), R_OK));
std::unique_ptr<Cmdline> cmdline;
// Wipe remote directly, then import.
cmdline.reset(new TestCmdline("--daemon=no",
"--delete-items",
peer.c_str(),
peerSource.c_str(),
"*",
(const char *)NULL));
CT_ASSERT(cmdline->parse());
CT_ASSERT_MESSAGE(peer + " " + peerSource, cmdline->run());
cmdline.reset(new TestCmdline("--daemon=no",
"--import",
remoteTestdata.c_str(),
peer.c_str(),
peerSource.c_str(),
(const char *)NULL));
CT_ASSERT(cmdline->parse());
CT_ASSERT_MESSAGE(peer + " " + peerSource, cmdline->run());
// Sync into local database.
doSync(__FILE__, __LINE__,
"download",
SyncOptions(SYNC_REFRESH_FROM_REMOTE,
CheckSyncReport(-1,0,-1, 0,0,0, true, SYNC_REFRESH_FROM_REMOTE)));
// Compare against expected result.
TestingSyncSourcePtr copy;
SOURCE_ASSERT_NO_FAILURE(copy.get(), copy.reset(sources[0].second->createSourceA(), TestingSyncSourcePtr::SLOW));
{
ScopedEnvChange fullSyncCompare("CLIENT_TEST_SERVER", "none");
CT_ASSERT(sources[0].second->compareDatabases(localTestdata.c_str(), *copy));
}
// Modify locally.
std::string actualLocalData = getCurrentTest() + ".local.test.dat";
simplifyFilename(actualLocalData);
std::string localModified = getCurrentTest() + ".local.modified.test.dat";
simplifyFilename(localModified);
CT_ASSERT_NO_THROW(UpdateLocal(currentServer() + "_1", config.m_sourceName,
actualLocalData, localModified,
modifyLocal));
// Sync between both sides to update the remote.
doSync(__FILE__, __LINE__,
"two-way",
SyncOptions(SYNC_TWO_WAY,
CheckSyncReport(0,0,0, 0,-1,0, true, SYNC_TWO_WAY)));
// Check remote.
std::string syncedRemoteData = getCurrentTest() + ".remote.test.dat";
simplifyFilename(syncedRemoteData);
rm_r(syncedRemoteData);
mkdir_p(syncedRemoteData);
cmdline.reset(new TestCmdline("--daemon=no",
"--export",
syncedRemoteData.c_str(),
peer.c_str(),
peerSource.c_str(),
(const char *)NULL));
CT_ASSERT(cmdline->parse());
CT_ASSERT_MESSAGE("export " + peer + " " + peerSource, cmdline->run());
// Compare against expected result. We use the compare operation
// of the local source and apply it to data from the remote one.
// This typically works if the data has the same format.
{
ScopedEnvChange fullSyncCompare("CLIENT_TEST_SERVER", "none");
CT_ASSERT(sources[0].second->compareDatabases(remoteSyncedTestdata, syncedRemoteData));
}
}
void SyncTests::doUpdateConflict(const std::string &testname, bool localWins)
{
CT_ASSERT_EQUAL(sources.size(), 1);
const ClientTest::Config &config(sources[0].second->config);
StringPair peerConfig = getPeerConfig(config.m_sourceName);
const std::string &peer = peerConfig.first;
const std::string &peerSource = peerConfig.second;
CT_ASSERT(!peer.empty());
CT_ASSERT(!peerSource.empty());
std::string localTestdata = getPeerTestdata(config.m_sourceName, testname, "local");
CT_ASSERT_MESSAGE(localTestdata, !access(localTestdata.c_str(), R_OK));
std::string localSyncedTestdata = getPeerTestdata(config.m_sourceName, testname, "local-synced");
CT_ASSERT_MESSAGE(localSyncedTestdata, !access(localSyncedTestdata.c_str(), R_OK));
std::string remoteSyncedTestdata = getPeerTestdata(config.m_sourceName, testname, "remote-synced");
CT_ASSERT_MESSAGE(remoteSyncedTestdata, !access(remoteSyncedTestdata.c_str(), R_OK));
std::string modifyLocal = getPeerTestdata(config.m_sourceName, testname, "modify-local");
CT_ASSERT_MESSAGE(modifyLocal, !access(modifyLocal.c_str(), R_OK|X_OK));
std::string modifyRemote = getPeerTestdata(config.m_sourceName, testname, "modify-remote");
CT_ASSERT_MESSAGE(modifyRemote, !access(modifyRemote.c_str(), R_OK|X_OK));
// Import locally into empty database.
sources[0].second->deleteAll(sources[0].second->createSourceA);
sources[0].second->doImport(localTestdata);
// Sync to remote.
doSync(__FILE__, __LINE__,
"upload",
SyncOptions(RefreshFromLocalMode(),
CheckSyncReport(0,0,0, -1,0,0, true, SYNC_REFRESH_FROM_LOCAL)));
// Export from remote directly.
std::string actualRemoteData = getCurrentTest() + ".remote.test.dat";
simplifyFilename(actualRemoteData);
std::unique_ptr<Cmdline> cmdline;
rm_r(actualRemoteData);
mkdir_p(actualRemoteData);
cmdline.reset(new TestCmdline("--daemon=no",
"--export",
actualRemoteData.c_str(),
peer.c_str(),
peerSource.c_str(),
(const char *)NULL));
CT_ASSERT(cmdline->parse());
CT_ASSERT_MESSAGE("export " + peer + " " + peerSource, cmdline->run());
// Modify all items on both sides. In both cases the modification
// is done with a shell script which must make a copy of the data.
// The shell scripts can be used to cause one or the other side
// to have a modified version of an item or both at the same time,
// which will trigger merging in the engine. The shell script
// needs to create an entry for each item which is meant to be
// updated, using the same file name (= luid) as in the input
// directory.
//
// The order and timing of updating matters for the test because
// the engine will look at time stamps (REV resp. LAST-MODIFIED)
// to determine which side has the more recent change.
for (int i = 0; i < 2; i++) {
if (localWins ? i == 0 : i == 1) {
// The remote side can use the data downloaded earlier.
std::string remoteModified = getCurrentTest() + ".remote.modified.test.dat";
simplifyFilename(remoteModified);
CT_ASSERT(!system(StringPrintf("%s %s %s",
modifyRemote.c_str(),
actualRemoteData.c_str(),
remoteModified.c_str()).c_str()));
CT_ASSERT(isDir(remoteModified));
cmdline.reset(new TestCmdline("--daemon=no",
"--update",
remoteModified.c_str(),
peer.c_str(),
peerSource.c_str(),
(const char *)NULL));
CT_ASSERT(cmdline->parse());
CT_ASSERT_MESSAGE("update " + peer + " " + peerSource, cmdline->run());
// Check remote after update.
std::string remoteActualModified = getCurrentTest() + ".remote.actual.test.dat";
simplifyFilename(remoteActualModified);
rm_r(remoteActualModified);
mkdir_p(remoteActualModified);
cmdline.reset(new TestCmdline("--daemon=no",
"--export",
remoteActualModified.c_str(),
peer.c_str(),
peerSource.c_str(),
(const char *)NULL));
CT_ASSERT(cmdline->parse());
CT_ASSERT_MESSAGE("export " + peer + " " + peerSource, cmdline->run());
// Copy all unmodified items before the comparison.
ReadDir dir(remoteModified);
std::set<std::string> modified(dir.begin(), dir.end());
BOOST_FOREACH(const std::string &luid, ReadDir(actualRemoteData)) {
if (modified.find(luid) == modified.end()) {
std::string content;
CT_ASSERT(ReadFile(actualRemoteData + "/" + luid, content));
std::ofstream((remoteModified + "/" + luid).c_str()).write(content.c_str(), content.size());
}
}
// Compare against expected result. We use the compare operation
// of the local source and apply it to data from the remote one.
// This typically works if the data has the same format.
{
ScopedEnvChange fullSyncCompare("CLIENT_TEST_SERVER", "none");
CT_ASSERT(sources[0].second->compareDatabases(remoteModified, remoteActualModified));
}
} else {
std::string actualLocalData = getCurrentTest() + ".local.test.dat";
simplifyFilename(actualLocalData);
std::string localModified = getCurrentTest() + ".local.modified.test.dat";
simplifyFilename(localModified);
CT_ASSERT_NO_THROW(UpdateLocal(currentServer() + "_1", config.m_sourceName,
actualLocalData, localModified,
modifyLocal));
}
// System time must be synchronized with the remote side for the
// test to pass reliably. Wait here and/or check that
// loosing side's time is in the past (TODO).
sleep(5);
}
// Sync between both sides.
doSync(__FILE__, __LINE__,
"two-way",
SyncOptions(SYNC_TWO_WAY,
CheckSyncReport(0,-1,-1, 0,-1,0, true, SYNC_TWO_WAY)));
// Check remote.
std::string syncedRemoteData = getCurrentTest() + ".remote.test.dat";
simplifyFilename(syncedRemoteData);
rm_r(syncedRemoteData);
mkdir_p(syncedRemoteData);
cmdline.reset(new TestCmdline("--daemon=no",
"--export",
syncedRemoteData.c_str(),
peer.c_str(),
peerSource.c_str(),
(const char *)NULL));
CT_ASSERT(cmdline->parse());
CT_ASSERT_MESSAGE("export " + peer + " " + peerSource, cmdline->run());
// Compare against expected result. We use the compare operation
// of the local source and apply it to data from the remote one.
// This typically works if the data has the same format.
{
ScopedEnvChange fullSyncCompare("CLIENT_TEST_SERVER", "none");
CT_ASSERT(sources[0].second->compareDatabases(remoteSyncedTestdata, syncedRemoteData));
}
// Check local.
TestingSyncSourcePtr copy;
SOURCE_ASSERT_NO_FAILURE(copy.get(), copy.reset(sources[0].second->createSourceA(), TestingSyncSourcePtr::SLOW));
{
ScopedEnvChange fullSyncCompare("CLIENT_TEST_SERVER", "none");
CT_ASSERT(sources[0].second->compareDatabases(localSyncedTestdata.c_str(), *copy));
}
}
void SyncTests::testUpdateRemoteWins()
{
// Local side gets updated first, then remote -> remote wins during merge conflict.
doUpdateConflict("testUpdateRemoteWins", false);
}
void SyncTests::testUpdateLocalWins()
{
// Remote side gets updated first, then local -> local wins during merge conflict.
doUpdateConflict("testUpdateLocalWins", true);
}
void SyncTests::doSync(const SyncOptions &options)
{
int res = 0;
static int syncCounter = 0;
static std::string lastTest;
std::stringstream logstream;
// reset counter when switching tests
if (lastTest != getCurrentTest()) {
syncCounter = 0;
lastTest = getCurrentTest();
}
std::string prefix;
prefix.reserve(80);
for (std::list<std::string>::iterator it = logPrefixes.begin();
it != logPrefixes.end();
++it) {
prefix += ".";
prefix += *it;
}
if (!prefix.empty()) {
printf(" %s", prefix.c_str() + 1);
fflush(stdout);
}
logstream /* << std::setw(4) << std::setfill('0') << syncCounter << "_" */ << getCurrentTest()
<< prefix
<< ".client." << (accessClientB ? "A" : "B");
std::string logname = logstream.str();
simplifyFilename(logname);
syncCounter++;
SE_LOG_DEBUG(NULL, "%d. starting %s with sync mode %s",
syncCounter, logname.c_str(), PrettyPrintSyncMode(options.m_syncMode).c_str());
try {
CT_ASSERT_NO_THROW(res = client.doSync(sourceArray,
logname,
options));
} catch (...) {
postSync(res, logname);
throw;
}
CT_ASSERT_NO_THROW(postSync(res, logname));
}
void SyncTests::postSync(int res, const std::string &logname)
{
client.postSync(res, logname);
}
void SyncTests::allSourcesInsert(bool withUID)
{
BOOST_FOREACH(source_array_t::value_type &source_pair, sources) {
CT_ASSERT_NO_THROW(source_pair.second->doInsert(withUID));
}
}
void SyncTests::allSourcesUpdate()
{
BOOST_FOREACH(source_array_t::value_type &source_pair, sources) {
CT_ASSERT_NO_THROW(source_pair.second->update(source_pair.second->createSourceA,
source_pair.second->config.m_updateItem));
}
}
void SyncTests::allSourcesDeleteAll()
{
BOOST_FOREACH(source_array_t::value_type &source_pair, sources) {
CT_ASSERT_NO_THROW(source_pair.second->deleteAll(source_pair.second->createSourceA));
}
}
void SyncTests::allSourcesInsertMany(int startIndex, int numItems,
std::map<int, std::list<std::string> > &luids)
{
BOOST_FOREACH(source_array_t::value_type &source_pair, sources) {
std::list<std::string> l;
CT_ASSERT_NO_THROW(l = source_pair.second->insertManyItems(source_pair.second->createSourceA,
startIndex,
numItems,
0));
CT_ASSERT_EQUAL((size_t)numItems, l.size());
// append instead of overwriting - useful when multiple
// insertMany calls share the same luid buffer
luids[source_pair.first].insert(luids[source_pair.first].end(), l.begin(), l.end());
}
}
void SyncTests::allSourcesUpdateMany(int startIndex, int numItems,
int revision,
std::map<int, std::list<std::string> > &luids,
int offset)
{
BOOST_FOREACH(source_array_t::value_type &source_pair, sources) {
CT_ASSERT_NO_THROW(source_pair.second->updateManyItems(source_pair.second->createSourceA,
startIndex,
numItems,
0,
revision,
luids[source_pair.first],
offset));
}
}
void SyncTests::allSourcesRemoveMany(int numItems,
std::map<int, std::list<std::string> > &luids,
int offset)
{
BOOST_FOREACH(source_array_t::value_type &source_pair, sources) {
CT_ASSERT_NO_THROW(source_pair.second->removeManyItems(source_pair.second->createSourceA,
numItems,
luids[source_pair.first],
offset));
}
}
/** generates tests on demand based on what the client supports */
class ClientTestFactory : public CppUnit::TestFactory {
public:
ClientTestFactory(ClientTest &c) :
client(c) {}
virtual CppUnit::Test *makeTest() {
int source;
CppUnit::TestSuite *alltests = new CppUnit::TestSuite("Client");
CppUnit::TestSuite *tests;
// create local source tests
typedef std::map<std::string, LocalTests *> ConfigMap;
ConfigMap configs;
tests = new CppUnit::TestSuite(alltests->getName() + "::Source");
for (source=0; source < client.getNumLocalSources(); source++) {
ClientTest::Config config;
client.getLocalSourceConfig(source, config);
if (!config.m_sourceName.empty()) {
LocalTests *sourcetests =
client.createLocalTests(tests->getName() + "::" + config.m_sourceName, source, config);
sourcetests->addTests();
tests->addTest(FilterTest(sourcetests));
configs[config.m_sourceName] = sourcetests;
}
}
// link configs of sources which share the same database
BOOST_FOREACH (const ConfigMap::value_type &entry, configs) {
LocalTests *sourcetests = entry.second;
const ClientTest::Config &config = sourcetests->config;
if (!config.m_linkedSources.empty()) {
sourcetests->m_linkedSources.push_back(sourcetests);
BOOST_FOREACH (const std::string &source, config.m_linkedSources) {
sourcetests->m_linkedSources.push_back(configs[source]);
}
}
}
alltests->addTest(FilterTest(tests));
// create sync tests with just one source
tests = new CppUnit::TestSuite(alltests->getName() + "::Sync");
for (source=0; source < client.getNumSyncSources(); source++) {
ClientTest::Config config;
client.getSyncSourceConfig(source, config);
if (!config.m_sourceName.empty()) {
std::vector<int> sources;
sources.push_back(source);
SyncTests *synctests =
client.createSyncTests(tests->getName() + "::" + config.m_sourceName, sources);
synctests->addTests(source == 0);
tests->addTest(FilterTest(synctests));
}
}
// create sync tests with all sources enabled, unless we only have one:
// that would be identical to the test above
std::vector<int> sources;
std::string name, name_reversed;
for (source=0; source < client.getNumSyncSources(); source++) {
ClientTest::Config config;
client.getSyncSourceConfig(source, config);
if (!config.m_sourceName.empty()) {
sources.push_back(source);
if (name.size() > 0) {
name += "_";
name_reversed = std::string("_") + name_reversed;
}
name += config.m_sourceName;
name_reversed = config.m_sourceName + name_reversed;
}
}
if (sources.size() > 1) {
SyncTests *synctests =
client.createSyncTests(tests->getName() + "::" + name, sources);
synctests->addTests();
tests->addTest(FilterTest(synctests));
synctests = 0;
if (getenv("CLIENT_TEST_REVERSE_SOURCES")) {
// now also in reversed order - who knows, it might make a difference;
// typically it just makes the whole run slower, so not enabled
// by default
std::reverse(sources.begin(), sources.end());
synctests =
client.createSyncTests(tests->getName() + "::" + name_reversed, sources);
synctests->addTests();
tests->addTest(FilterTest(synctests));
synctests = 0;
}
}
alltests->addTest(FilterTest(tests));
tests = 0;
return alltests;
}
private:
ClientTest &client;
};
void ClientTest::registerTests()
{
freeFactory();
factory = (void *)new ClientTestFactory(*this);
CppUnit::TestFactoryRegistry::getRegistry().registerFactory((CppUnit::TestFactory *)factory);
}
ClientTest::ClientTest(int serverSleepSec, const std::string &serverLog) :
serverSleepSeconds(serverSleepSec),
serverLogFileName(serverLog),
factory(NULL)
{
}
void ClientTest::freeFactory()
{
if(factory) {
CppUnit::TestFactoryRegistry::getRegistry().unregisterFactory((CppUnit::TestFactory *)factory);
delete (CppUnit::TestFactory *)factory;
factory = NULL;
}
}
ClientTest::~ClientTest()
{
freeFactory();
}
void ClientTest::registerCleanup(Cleanup_t cleanup)
{
cleanupSet.insert(cleanup);
}
void ClientTest::shutdown()
{
BOOST_FOREACH(Cleanup_t cleanup, cleanupSet) {
cleanup();
}
}
LocalTests *ClientTest::createLocalTests(const std::string &name, int sourceParam, ClientTest::Config &co)
{
return new LocalTests(name, *this, sourceParam, co);
}
SyncTests *ClientTest::createSyncTests(const std::string &name, std::vector<int> sourceIndices, bool isClientA)
{
return new SyncTests(name, *this, sourceIndices, isClientA);
}
int ClientTest::dump(ClientTest &client, TestingSyncSource &source, const std::string &file)
{
BackupReport report;
boost::shared_ptr<ConfigNode> node(new VolatileConfigNode);
rm_r(file);
mkdir_p(file);
CT_ASSERT(source.getOperations().m_backupData);
source.getOperations().m_backupData(SyncSource::Operations::ConstBackupInfo(),
SyncSource::Operations::BackupInfo(SyncSource::Operations::BackupInfo::BACKUP_OTHER, file, node),
report);
return 0;
}
void ClientTest::getItems(const std::string &file, list<string> &items, std::string &testcases)
{
items.clear();
// import the file, trying a .tem file (base file plus patch)
// first
std::ifstream input;
string server = currentServer();
testcases = file + '.' + server +".tem";
input.open(testcases.c_str());
if (input.fail()) {
// try server-specific file (like eds_event.ics.local)
testcases = file + '.' + server;
input.open(testcases.c_str());
}
if (input.fail()) {
// try base file
testcases = file;
input.open(testcases.c_str());
}
CT_ASSERT(!input.bad());
CT_ASSERT(input.is_open());
std::string data, line;
while (input) {
bool wasend = false;
do {
getline(input, line);
CT_ASSERT(!input.bad());
// empty lines directly after line which starts with END mark end of record;
// check for END necessary becayse vCard 2.1 ENCODING=BASE64 may have empty lines in body of VCARD!
if ((line != "\r" && line.size() > 0) || !wasend) {
data += line;
data += "\n";
} else {
if (!data.empty()) {
items.push_back(data);
}
data = "";
}
wasend = !line.compare(0, 4, "END:");
} while(!input.eof());
}
if (data != "" && data != "\r\n" && data != "\n") {
items.push_back(data);
}
}
std::string ClientTest::import(ClientTest &client, TestingSyncSource &source, const ClientTestConfig &config,
const std::string &file, std::string &realfile,
std::list<std::string> *luids)
{
list<string> items;
getItems(file, items, realfile);
SE_LOG_DEBUG(NULL, "importing %d test cases from file %s", (int)items.size(), realfile.c_str());
std::string failures;
bool doImport = !luids || luids->empty();
std::list<std::string>::const_iterator it;
if (!doImport) {
it = luids->begin();
}
BOOST_FOREACH(string &data, items) {
std::string luid;
try {
if (doImport) {
luid = importItem(&source, config, data);
CT_ASSERT(!luid.empty());
if (luids) {
luids->push_back(luid);
}
} else {
CT_ASSERT(it != luids->end());
luid = *it;
++it;
// Did import already fail? If yes, then don't try to
// update because it will also fail.
if (!luid.empty()) {
// TODO: should fail for status = 6 in eas
updateItem(&source, data, luid);
}
}
} catch (...) {
std::string explanation;
Exception::handle(explanation);
failures += "Failed to ";
if (doImport) {
failures += "import:\n";
} else {
failures += "update " + luid + ":\n";
}
failures += data;
failures += "\n";
failures += explanation;
failures += "\n";
if (doImport && luids) {
luids->push_back("");
}
}
}
return failures;
}
bool ClientTest::compare(ClientTest &client, const std::string &fileA, const std::string &fileB)
{
setenv("CLIENT_TEST_HEADER", "\n\n", 1);
setenv("CLIENT_TEST_LEFT_NAME", fileA.c_str(), 1);
setenv("CLIENT_TEST_RIGHT_NAME", fileB.c_str(), 1);
setenv("CLIENT_TEST_REMOVED", "only in left file", 1);
setenv("CLIENT_TEST_ADDED", "only in right file", 1);
bool success = false;
const char* compareLog = getenv("CLIENT_TEST_COMPARE_LOG");
if(compareLog && strlen(compareLog))
{
std::string cmdstr = std::string("synccompare ") + fileA + " " + fileB;
string tmpfile = "____compare.log";
cmdstr =string("bash -c 'set -o pipefail;") + cmdstr;
cmdstr += " 2>&1|tee " +tmpfile+"'";
success = system(cmdstr.c_str()) == 0;
} else {
// Shortcut: run synccompare directly, without shell in the middle
// (reduces overhead and output when running under valgrind).
pid_t child = fork();
switch (child) {
case -1:
perror("fork");
break;
case 0:
// child
execl("synccompare", "synccompare", fileA.c_str(), fileB.c_str(), (char *)NULL);
perror("synccompare");
exit(1);
break;
default:
// parent
int status;
child = waitpid(child, &status, 0);
if (child == -1) {
perror("wait for synccompare");
} else if (WIFEXITED(status) && WEXITSTATUS(status) == 0) {
success = true;
}
break;
}
}
if (!success) {
printf("failed: env CLIENT_TEST_SERVER=%s 'CLIENT_TEST_STRIP_PARAMETERS=%s' 'CLIENT_TEST_STRIP_PROPERTIES=%s'synccompare %s %s\n",
getEnv("CLIENT_TEST_SERVER", ""),
getEnv("CLIENT_TEST_STRIP_PARAMETERS", ""),
getEnv("CLIENT_TEST_STRIP_PROPERTIES", ""),
fileA.c_str(), fileB.c_str());
}
return success;
}
void ClientTest::update(std::string &item)
{
const static char *props[] = {
"\nSUMMARY",
"\nNOTE",
NULL
};
for (const char **prop = props; *prop; prop++) {
size_t pos;
pos = item.find(*prop);
if (pos != item.npos) {
// Modify existing property. Fast-forward to : (works as
// long as colon is not in parameters).
pos = item.find(':', pos);
}
if (pos != item.npos) {
item.insert(pos + 1, "MOD-");
} else if (!strcmp(*prop, "\nNOTE") && (pos = item.find("END:VCARD")) != item.npos) {
// add property, but only if it is allowed in the item
item.insert(pos, "NOTE:MOD\n");
}
}
}
void ClientTest::postSync(int res, const std::string &logname)
{
#ifdef WIN32
Sleep(serverSleepSeconds * 1000);
#else
sleep(serverSleepSeconds);
// make a copy of the server's log (if found), then truncate it
if (serverLogFileName.size()) {
int fd = open(serverLogFileName.c_str(), O_RDWR);
if (fd >= 0) {
int out = open((logname + ".server.log").c_str(), O_WRONLY|O_CREAT, S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP);
if (out >= 0) {
char buffer[4096];
bool cont = true;
ssize_t len;
while (cont && (len = read(fd, buffer, sizeof(buffer))) > 0) {
ssize_t total = 0;
while (cont && total < len) {
ssize_t written = write(out, buffer, len);
if (written < 0) {
perror(("writing " + logname + ".server.log").c_str());
cont = false;
} else {
total += written;
}
}
}
if (len < 0) {
perror(("reading " + serverLogFileName).c_str());
}
close(out);
}
if (ftruncate(fd, 0)) {
perror("truncating log file");
}
close(fd);
} else {
perror(serverLogFileName.c_str());
}
}
#endif
}
static string mangleGeneric(const std::string &data, bool update, const std::string &uniqueUIDSuffix)
{
std::string item = data;
if (update) {
boost::replace_first(item, "NOTE:", "NOTE:U ");
}
return item;
}
static string mangleICalendar20(const std::string &data, bool update, const std::string &uniqueUIDSuffix)
{
std::string item = data;
std::string type;
static const pcrecpp::RE re("BEGIN:(VEVENT|VJOURNAL|VTODO)\n");
re.PartialMatch(data, &type);
if (update) {
if (type == "VJOURNAL") {
// Need to modify first line of description and summary
// consistently for a note because in plain text
// representation, these lines are expected to be
// identical.
boost::replace_first(item, "SUMMARY:", "SUMMARY:U ");
}
boost::replace_first(item, "DESCRIPTION:", "DESCRIPTION:U ");
}
if (getenv("CLIENT_TEST_NO_UID")) {
stripProperty(item, "UID");
} else if (getenv("CLIENT_TEST_SIMPLE_UID")) {
boost::replace_all(item, "UID:1234567890!@#$%^&*()<>@dummy", "UID:1234567890@dummy");
}
const char *uniqueUID = getenv("CLIENT_TEST_UNIQUE_UID");
if (uniqueUID) {
// Making UID unique per test to avoid issues
// when the source already holds older copies.
// Might still be an issue in real life?!
static time_t start;
static std::string test;
if (test != getCurrentTest()) {
start = time(NULL);
test = getCurrentTest();
}
std::string unique = StringPrintf("UID:UNIQUE-UID-%llu-", (long long unsigned)start);
boost::replace_all(item, "UID:", unique);
if (atoi(uniqueUID) > 1) {
// Also avoid reusing the same UID inside the same test.
// Required by Google CalDAV in calendar testChanges, because
// they keep even deleted items around and check the SEQUENCE
// number against their old data.
boost::replace_all(item, "UNIQUE-UID", "UNIQUE-UID" + uniqueUIDSuffix);
}
} else if (getenv("CLIENT_TEST_LONG_UID")) {
boost::replace_all(item, "UID:", "UID:this-is-a-ridiculously-long-uid-");
}
size_t offset = item.find("\nLAST-MODIFIED:");
static const size_t len = strlen("\nLAST-MODIFIED:20100131T235959Z");
if (offset != item.npos) {
// Special semantic for iCalendar 2.0: LAST-MODIFIED should be
// incremented in updated items. Emulate that by inserting the
// current time.
time_t now = time(NULL);
struct tm tm;
gmtime_r(&now, &tm);
std::string mod = StringPrintf("\nLAST-MODIFIED:%04d%02d%02dT%02d%02d%02dZ",
tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday,
tm.tm_hour, tm.tm_min, tm.tm_sec);
item.replace(offset, len, mod);
}
const static string sequence("\nSEQUENCE:XXX");
offset = item.find(sequence);
if (offset != item.npos) {
if (getenv("CLIENT_TEST_INCREASE_SEQUENCE")) {
// Increment sequence number in steps of 100 to ensure that our
// new item is considered more recent than any corresponding
// item in the source. Some storages (Google CalDAV) check that.
static int counter = 100;
item.replace(offset, sequence.size(), StringPrintf("\nSEQUENCE:%d", counter));
counter += 100;
} else {
item.replace(offset, sequence.size(), "\nSEQUENCE:1");
}
}
return item;
}
static std::string additionalYearly(const std::string &single,
const std::string &many,
int start, int skip, int index, int total)
{
int startYear = 2012 + start - 1;
std::string event;
if (start == 0) {
// no missing parent, nothing to add
} else if (start == index) {
// inserting a single detached recurrence
event = StringPrintf(single.c_str(), startYear);
} else {
// many detached recurrences
int endYear = startYear + index - start;
std::string exdates;
for (int year = startYear; year <= endYear; year++) {
// a gap?
if ((year - startYear) % (skip + 1)) {
exdates +=
StringPrintf("EXDATE;TZID=Standard Timezone:%04d0101T120000\n",
year);
}
}
event = StringPrintf(many.c_str(), startYear, endYear, exdates.c_str());
}
SE_LOG_DEBUG(NULL, "additional yearly: start %d, skip %d, index %d/%d:\n%s",
start, skip, index, total,
event.c_str());
return event;
}
static std::string additionalMonthly(const std::string &single,
const std::string &many,
int day,
int start, int skip, int index, int total)
{
int startMonth = 1 + start - 1;
std::string event;
int endMonth = startMonth + index - start;
int time = (endMonth >= 4 && endMonth <= 10) ? 10 : 11;
if (start == 0) {
} else if (start == index) {
event = StringPrintf(single.c_str(), startMonth, day, time);
} else {
// Monthly recurrence uses INTERVAL instead of
// EXDATEs, in contrast to yearly recurrence
// (where Exchange somehow didn't grok the
// INTERVAL). So EXDATEs are only necessary
// for the first, second, last case.
if (skip == -1 ) {
std::string exdates;
for (int month = startMonth; month <= endMonth; month++) {
int step = month - startMonth;
// a gap?
if (step > 1 && step < total - start - 1) {
exdates +=
StringPrintf("EXDATE;TZID=Standard Timezone:2012%02d01T120000\n",
month);
}
}
event = StringPrintf(many.c_str(), startMonth, day, endMonth, time, 1, exdates.c_str());
} else {
event = StringPrintf(many.c_str(), startMonth, day, endMonth, time, skip + 1, "");
}
}
SE_LOG_DEBUG(NULL, "additional monthly: start %d, skip %d, index %d/%d:\n%s",
start, skip, index, total,
event.c_str());
return event;
}
// instead of trying to determine the dates of all Sundays in 2012
// algorithmically, hard-code them...
static const struct {
int m_month, m_day;
} sundays[] = {
{ 1, 1 },
{ 1, 8 },
{ 1, 15 },
{ 1, 22 },
{ 1, 29 },
{ 2, 5 },
{ 2, 12 },
{ 2, 19 },
{ 2, 26 },
{ 3, 4 },
{ 3, 11 },
{ 3, 18 },
// winter time ends on March 25th, week 12 (counting from zero)
#define SUNDAYS_2012_WINTER_TIME_ENDS 12
{ 3, 25 },
{ 4, 1 },
{ 4, 8 },
{ 4, 15 },
{ 4, 22 },
{ 4, 29 },
{ 5, 6 },
{ 5, 13 },
{ 5, 20 },
{ 5, 27 },
{ 6, 3 },
{ 6, 10 },
{ 6, 17 },
{ 6, 24 },
{ 7, 1 },
{ 7, 8 },
{ 7, 15 },
{ 7, 22 },
{ 7, 29 },
{ 8, 5 },
{ 8, 12 },
{ 8, 19 },
{ 8, 26 },
{ 9, 2 },
{ 9, 9 },
{ 9, 16 },
{ 9, 23 },
{ 9, 30 },
{ 10, 7 },
{ 10, 14 },
{ 10, 21 },
// winter time start on October 28th, week 43 (counting from zero)
#define SUNDAYS_2012_WINTER_TIME_STARTS 43
{ 10, 28 },
{ 11, 4 },
{ 11, 11 },
{ 11, 18 },
{ 11, 25 },
{ 12, 2 },
{ 12, 9 },
{ 12, 16 },
{ 12, 23 },
{ 12, 30 },
{ 0, 0 }
};
static std::string additionalWeekly(const std::string &single,
const std::string &many,
int start, int skip, int index, int total)
{
int startWeek = start - 1; // numbered from zero in "sundays" array
if (startWeek < 0) {
startWeek = 0;
}
std::string event;
int endWeek = startWeek + index - start;
int time = (endWeek >= SUNDAYS_2012_WINTER_TIME_ENDS &&
endWeek < SUNDAYS_2012_WINTER_TIME_STARTS) ? 12 : 13;
int startMonth = sundays[startWeek].m_month;
int startDay = sundays[startWeek].m_day;
if (start == 0) {
} else if (start == index) {
event = StringPrintf(single.c_str(), startMonth, startDay, time);
} else {
int endMonth = sundays[endWeek].m_month;
int endDay = sundays[endWeek].m_day;
// Weekly recurrence uses INTERVAL instead of
// EXDATEs, in contrast to yearly recurrence
// (where Exchange somehow didn't grok the
// INTERVAL). So EXDATEs are only necessary
// for the first, second, last case.
std::string exdates;
if (skip == -1 ) {
for (int week = startWeek; week <= endWeek; week++) {
int step = week - startWeek;
// a gap?
if (step > 1 && step < total - start - 1) {
exdates +=
StringPrintf("EXDATE;TZID=Standard Timezone:2012%02d%02dT140000\n",
sundays[week].m_month,
sundays[week].m_day);
}
}
event = StringPrintf(many.c_str(),
startMonth, startDay,
endMonth, endDay,
time, 1, exdates.c_str());
} else {
event = StringPrintf(many.c_str(),
startMonth, startDay,
endMonth, endDay,
time, skip + 1, "");
}
}
SE_LOG_DEBUG(NULL, "additional weekly: start %d, skip %d, index %d/%d:\n%s",
start, skip, index, total,
event.c_str());
return event;
}
static void addMonthly(size_t &index, ClientTestConfig::MultipleLinkedItems_t &subset,
const std::string &pre, const std::string &post,
const char *suffix, int day, int months)
{
index++;
subset.resize(index + 1);
ClientTestConfig::LinkedItems_t *items = &subset[index];
items->m_name = std::string("Monthly") + suffix;
/* month varies */
std::string parent =
pre +
"BEGIN:VEVENT\n"
"UID:monthly\n"
"DTSTAMP:20110101T120000Z\n"
"DTSTART;TZID=Standard Timezone:2012" "%1$02d" "%2$02d" "T120000\n"
"DTEND;TZID=Standard Timezone:2012" "%1$02d" "%2$02d" "T121000\n"
"SUMMARY:monthly " + suffix + " Berlin\n"
"RRULE:BYMONTHDAY=1;COUNT=12;FREQ=MONTHLY\n"
"TRANSP:TRANSPARENT\n"
"END:VEVENT\n" +
post;
std::string child =
pre +
"BEGIN:VEVENT\n"
"UID:monthly\n"
"DTSTAMP:20110101T120000Z\n"
"DTSTART;TZID=Standard Timezone:2012" "%1$02d" "%2$02d" "T120000\n"
"DTEND;TZID=Standard Timezone:2012" "%1$02d" "%2$02d" "T121000\n"
"SUMMARY:%1$04d monthly " + suffix + " Berlin\n"
"RECURRENCE-ID;TZID=Standard Timezone:2012" "%1$02d" "%2$02d" "T120000\n"
"TRANSP:TRANSPARENT\n"
"END:VEVENT\n" +
post;
items->push_back(StringPrintf(parent.c_str(), 1, day));
for (int month = 1; month <= months; month++) {
items->push_back(StringPrintf(child.c_str(), month, day));
}
if (currentServer() == "exchange") {
/* month of event varies and UTC time of UNTIL clause (11 during winter time, 10 during summer) */
std::string single =
pre +
"BEGIN:VEVENT\n"
"SUMMARY:[[activesyncd pseudo event - ignore me]]\n"
"DTSTART;TZID=Standard Timezone:2012" "%1$02d" "%2$02d" "T120000\n"
"DTEND;TZID=Standard Timezone:2012" "%1$02d" "%2$02d" "T120000\n"
"RRULE:FREQ=YEARLY;UNTIL=2012" "%1$02d" "%2$02d" "T" "%3$02d" "0000Z;BYMONTHDAY=1;BYMONTH=%1$d\n"
"UID:monthly\n"
"TRANSP:TRANSPARENT\n"
"END:VEVENT\n" +
post;
/* first month, last month, UTC time, INTERVAL and sometimes EXDATE varies */
std::string many =
pre +
"BEGIN:VEVENT\n"
"SUMMARY:[[activesyncd pseudo event - ignore me]]\n"
"DTSTART;TZID=Standard Timezone:2012" "%1$02d" "%2$02d" "T120000\n"
"DTEND;TZID=Standard Timezone:2012" "%1$02d" "%2$02d" "T120000\n"
"RRULE:BYMONTHDAY=1;FREQ=MONTHLY;INTERVAL=%5$d;UNTIL=2012" "%3$02d" "%2$02d" "T" "%4$02d" "0000Z\n"
"%6$s"
"UID:monthly\n"
"TRANSP:TRANSPARENT\n"
"END:VEVENT\n" +
post;
items->m_testLinkedItemsSubsetAdditional = boost::bind(additionalMonthly,
single, many, day,
_1, _2, _3, _4);
}
}
void ClientTest::getTestData(const char *type, Config &config)
{
std::string server = currentServer();
config = Config();
char *env = getenv("CLIENT_TEST_RETRY");
config.m_retrySync = (env && !strcmp (env, "t")) ?true :false;
env = getenv("CLIENT_TEST_RESEND");
config.m_resendSync = (env && !strcmp (env, "t")) ?true :false;
env = getenv("CLIENT_TEST_SUSPEND");
config.m_suspendSync = (env && !strcmp (env, "t")) ?true :false;
config.m_sourceKnowsItemSemantic = true;
config.m_linkedItemsRelaxedSemantic = true;
config.m_itemType = "";
config.m_import = import;
config.m_dump = dump;
config.m_compare = compare;
// Sync::*::testExtensions not enabled by default.
config.m_update = 0;
config.m_genericUpdate = update;
// redirect requests for "eds_event" towards "eds_event_noutc"?
bool noutc = false;
env = getenv ("CLIENT_TEST_NOUTC");
if (env && !strcmp (env, "t")) {
noutc = true;
}
config.m_mangleItem = mangleGeneric;
// True for most item kinds, exceptions set below.
config.m_uniqueID = true;
static std::set<std::string> vCardEssential =
boost::assign::list_of("FN")("N")("UID")("VERSION"),
iCalEssential =
boost::assign::list_of("DTSTART")("DTEND")("DTSTAMP")("SUMMARY")("UID")("RRULE")("RECURRENCE-ID")("VERSION");
// RRULE is not essential for a valid item, but removing it has implications
// for other properties (EXDATE) and other items (detached recurrences) and
// thus cannot be tested in testRemoveProperties (because it doesn't know about
// these inter-depdendencies).
if (!strcmp(type, "eds_contact")) {
config.m_sourceName = "eds_contact";
config.m_sourceNameServerTemplate = "addressbook";
config.m_uri = "card3"; // ScheduleWorld
config.m_type = "text/vcard";
config.m_essentialProperties = vCardEssential;
config.m_uniqueID = false;
config.m_insertItem =
"BEGIN:VCARD\n"
"VERSION:3.0\n"
"TITLE:tester\n"
"FN:John Doe\n"
"N:Doe;John;;;\n"
"UID:25741c35e5431f054444fdf4571219c3\n"
"TEL;TYPE=WORK;TYPE=VOICE:business 1\n"
"X-EVOLUTION-FILE-AS:Doe\\, John\n"
"X-MOZILLA-HTML:FALSE\n"
"END:VCARD\n";
config.m_updateItem =
"BEGIN:VCARD\n"
"VERSION:3.0\n"
"TITLE:tester\n"
"FN:Joan Doe\n"
"N:Doe;Joan;;;\n"
"UID:25741c35e5431f054444fdf4571219c3\n"
"X-EVOLUTION-FILE-AS:Doe\\, Joan\n"
"TEL;TYPE=WORK;TYPE=VOICE:business 2\n"
"BDAY:2006-01-08\n"
"X-MOZILLA-HTML:TRUE\n"
"END:VCARD\n";
/* adds a second phone number: */
config.m_complexUpdateItem =
"BEGIN:VCARD\n"
"VERSION:3.0\n"
"TITLE:tester\n"
"FN:Joan Doe\n"
"N:Doe;Joan;;;\n"
"UID:25741c35e5431f054444fdf4571219c3\n"
"X-EVOLUTION-FILE-AS:Doe\\, Joan\n"
"TEL;TYPE=WORK;TYPE=VOICE:business 1\n"
"TEL;TYPE=HOME;TYPE=VOICE:home 2\n"
"BDAY:2006-01-08\n"
"X-MOZILLA-HTML:TRUE\n"
"END:VCARD\n";
/* add a telephone number, email and X-AIM to initial item */
config.m_mergeItem1 =
"BEGIN:VCARD\n"
"VERSION:3.0\n"
"TITLE:tester\n"
"FN:John Doe\n"
"N:Doe;John;;;\n"
"UID:25741c35e5431f054444fdf4571219c3\n"
"X-EVOLUTION-FILE-AS:Doe\\, John\n"
"X-MOZILLA-HTML:FALSE\n"
"TEL;TYPE=WORK;TYPE=VOICE:business 1\n"
"EMAIL:john.doe@work.com\n"
"X-AIM:AIM JOHN\n"
"END:VCARD\n";
config.m_mergeItem2 =
"BEGIN:VCARD\n"
"VERSION:3.0\n"
"TITLE:developer\n"
"FN:John Doe\n"
"N:Doe;John;;;\n"
"UID:25741c35e5431f054444fdf4571219c3\n"
"TEL;TYPE=WORK;TYPE=VOICE:123456\n"
"X-EVOLUTION-FILE-AS:Doe\\, John\n"
"X-MOZILLA-HTML:TRUE\n"
"BDAY:2006-01-08\n"
"END:VCARD\n";
// use NOTE and N to make the item unique
config.m_templateItem =
"BEGIN:VCARD\n"
"VERSION:3.0\n"
"TITLE:tester\n"
"N:Doe;<<UNIQUE>>;<<REVISION>>;;\n"
"FN:<<UNIQUE>> Doe\n"
"UID:<<UNIQUE>>-25741c35e5431f054444fdf4571219c3\n"
"TEL;TYPE=WORK;TYPE=VOICE:business 1\n"
"X-EVOLUTION-FILE-AS:Doe\\, <<UNIQUE>>\n"
"X-MOZILLA-HTML:FALSE\n"
"NOTE:<<REVISION>>\n"
"END:VCARD\n";
config.m_uniqueProperties = "";
config.m_sizeProperty = "NOTE";
config.m_testcases = "testcases/eds_contact.vcf";
if (server == "exchange" ||
server == "googleeas") {
// X-MOZILLA-HTML not supported by ActiveSync.
boost::replace_first(config.m_updateItem, "X-MOZILLA-HTML:TRUE", "X-MOZILLA-HTML:FALSE");
boost::replace_first(config.m_complexUpdateItem, "X-MOZILLA-HTML:TRUE", "X-MOZILLA-HTML:FALSE");
boost::replace_first(config.m_mergeItem2, "X-MOZILLA-HTML:TRUE", "X-MOZILLA-HTML:FALSE");
}
} else if (!strcmp(type, "eds_event") && !noutc) {
config.m_sourceName = "eds_event";
config.m_sourceNameServerTemplate = "calendar";
config.m_uri = "cal2"; // ScheduleWorld
config.m_type = "text/x-vcalendar";
config.m_essentialProperties = iCalEssential;
if (server == "exchange") {
// currently cannot remove EXDATE properties, see BMC #24290
config.m_essentialProperties.insert("EXDATE");
}
config.m_mangleItem = mangleICalendar20;
config.m_insertItem =
"BEGIN:VCALENDAR\n"
"PRODID:-//Ximian//NONSGML Evolution Calendar//EN\n"
"VERSION:2.0\n"
"BEGIN:VEVENT\n"
"SUMMARY:phone meeting - old\n"
"DTEND:20060406T163000Z\n"
"DTSTART:20060406T160000Z\n"
"UID:1234567890!@#$%^&*()<>@dummyVEVENT\n"
"DTSTAMP:20060406T211449Z\n"
"LAST-MODIFIED:20060409T213201Z\n"
"CREATED:20060409T213201Z\n"
"LOCATION:my office\n"
"DESCRIPTION:let's talk<<REVISION>>\n"
"CLASS:PUBLIC\n"
"TRANSP:OPAQUE\n"
"SEQUENCE:XXX\n"
"END:VEVENT\n"
"END:VCALENDAR\n";
config.m_updateItem =
"BEGIN:VCALENDAR\n"
"PRODID:-//Ximian//NONSGML Evolution Calendar//EN\n"
"VERSION:2.0\n"
"BEGIN:VEVENT\n"
"SUMMARY:meeting on site - updated\n"
"DTEND:20060406T163000Z\n"
"DTSTART:20060406T160000Z\n"
"UID:1234567890!@#$%^&*()<>@dummyVEVENT\n"
"DTSTAMP:20060406T211449Z\n"
"LAST-MODIFIED:20060409T213201Z\n"
"CREATED:20060409T213201Z\n"
"SEQUENCE:XXX\n"
"LOCATION:big meeting room\n"
"DESCRIPTION:nice to see you\n"
"CLASS:PUBLIC\n"
"TRANSP:OPAQUE\n"
"END:VEVENT\n"
"END:VCALENDAR\n";
/* change location and description of insertItem in testMerge(), add alarm */
config.m_mergeItem1 =
"BEGIN:VCALENDAR\n"
"PRODID:-//Ximian//NONSGML Evolution Calendar//EN\n"
"VERSION:2.0\n"
"BEGIN:VEVENT\n"
"SUMMARY:phone meeting\n"
"DTEND:20060406T163000Z\n"
"DTSTART:20060406T160000Z\n"
"UID:1234567890!@#$%^&*()<>@dummyVEVENT\n"
"DTSTAMP:20060406T211449Z\n"
"LAST-MODIFIED:20060409T213201Z\n"
"CREATED:20060409T213201Z\n"
"SEQUENCE:XXX\n"
"LOCATION:calling from home\n"
"DESCRIPTION:let's talk\n"
"CLASS:PUBLIC\n"
"TRANSP:OPAQUE\n"
"BEGIN:VALARM\n"
"DESCRIPTION:alarm\n"
"ACTION:DISPLAY\n"
"TRIGGER;VALUE=DURATION;RELATED=START:-PT15M\n"
"END:VALARM\n"
"END:VEVENT\n"
"END:VCALENDAR\n";
/* change location to something else, add category */
config.m_mergeItem2 =
"BEGIN:VCALENDAR\n"
"PRODID:-//Ximian//NONSGML Evolution Calendar//EN\n"
"VERSION:2.0\n"
"BEGIN:VEVENT\n"
"SUMMARY:phone meeting\n"
"DTEND:20060406T163000Z\n"
"DTSTART:20060406T160000Z\n"
"UID:1234567890!@#$%^&*()<>@dummyVEVENT\n"
"DTSTAMP:20060406T211449Z\n"
"LAST-MODIFIED:20060409T213201Z\n"
"CREATED:20060409T213201Z\n"
"SEQUENCE:XXX\n"
"LOCATION:my office\n"
"CATEGORIES:WORK\n"
"DESCRIPTION:what the heck\\, let's even shout a bit\n"
"CLASS:PUBLIC\n"
"TRANSP:OPAQUE\n"
"END:VEVENT\n"
"END:VCALENDAR\n";
// Servers have very different understandings of how
// recurrence interacts with time zones and RRULE.
// Must use different test cases for some servers to
// avoid having the linkedItems test cases fail
// because of that.
// default: time zones + UNTIL in UTC, with VALARM
config.m_linkedItems.resize(1);
config.m_linkedItems[0].m_name = "Default";
config.m_linkedItems[0].resize(2);
config.m_linkedItems[0][0] =
"BEGIN:VCALENDAR\n"
"PRODID:-//Ximian//NONSGML Evolution Calendar//EN\n"
"VERSION:2.0\n"
"BEGIN:VTIMEZONE\n"
"TZID:Europe/Berlin\n"
"X-LIC-LOCATION:Europe/Berlin\n"
"BEGIN:DAYLIGHT\n"
"TZOFFSETFROM:+0100\n"
"TZOFFSETTO:+0200\n"
"TZNAME:CEST\n"
"DTSTART:19700329T020000\n"
"RRULE:FREQ=YEARLY;INTERVAL=1;BYDAY=-1SU;BYMONTH=3\n"
"END:DAYLIGHT\n"
"BEGIN:STANDARD\n"
"TZOFFSETFROM:+0200\n"
"TZOFFSETTO:+0100\n"
"TZNAME:CET\n"
"DTSTART:19701025T030000\n"
"RRULE:FREQ=YEARLY;INTERVAL=1;BYDAY=-1SU;BYMONTH=10\n"
"END:STANDARD\n"
"END:VTIMEZONE\n"
"BEGIN:VEVENT\n"
"UID:20080407T193125Z-19554-727-1-50@dummyVEVENT\n"
"DTSTAMP:20080407T193125Z\n"
"DTSTART;TZID=Europe/Berlin:20080406T090000\n"
"DTEND;TZID=Europe/Berlin:20080406T093000\n"
"TRANSP:OPAQUE\n"
"SEQUENCE:XXX\n"
"SUMMARY:Recurring\n"
"DESCRIPTION:recurs each Monday\\, 10 times\n"
"CLASS:PUBLIC\n"
"RRULE:FREQ=WEEKLY;UNTIL=20080608T070000Z;INTERVAL=1;BYDAY=SU\n"
"CREATED:20080407T193241Z\n"
"LAST-MODIFIED:20080407T193241Z\n"
"END:VEVENT\n"
"END:VCALENDAR\n";
config.m_linkedItems[0][1] =
"BEGIN:VCALENDAR\n"
"PRODID:-//Ximian//NONSGML Evolution Calendar//EN\n"
"VERSION:2.0\n"
"BEGIN:VTIMEZONE\n"
"TZID:Europe/Berlin\n"
"X-LIC-LOCATION:Europe/Berlin\n"
"BEGIN:DAYLIGHT\n"
"TZOFFSETFROM:+0100\n"
"TZOFFSETTO:+0200\n"
"TZNAME:CEST\n"
"DTSTART:19700329T020000\n"
"RRULE:FREQ=YEARLY;INTERVAL=1;BYDAY=-1SU;BYMONTH=3\n"
"END:DAYLIGHT\n"
"BEGIN:STANDARD\n"
"TZOFFSETFROM:+0200\n"
"TZOFFSETTO:+0100\n"
"TZNAME:CET\n"
"DTSTART:19701025T030000\n"
"RRULE:FREQ=YEARLY;INTERVAL=1;BYDAY=-1SU;BYMONTH=10\n"
"END:STANDARD\n"
"END:VTIMEZONE\n"
"BEGIN:VEVENT\n"
"UID:20080407T193125Z-19554-727-1-50@dummyVEVENT\n"
"DTSTAMP:20080407T193125Z\n"
"DTSTART;TZID=Europe/Berlin:20080413T090000\n"
"DTEND;TZID=Europe/Berlin:20080413T093000\n"
"TRANSP:OPAQUE\n"
"SEQUENCE:XXX\n"
"SUMMARY:Recurring: Modified\n"
"CLASS:PUBLIC\n"
"CREATED:20080407T193241Z\n"
"LAST-MODIFIED:20080407T193647Z\n"
"RECURRENCE-ID;TZID=Europe/Berlin:20080413T090000\n"
"DESCRIPTION:second instance modified\n"
"END:VEVENT\n"
"END:VCALENDAR\n";
bool recurringAllDay = false;
bool recurringNoTZ = false;
bool subsets = false;
if (server == "funambol") {
// converts UNTIL into floating time - broken?!
config.m_linkedItems[0].m_name = "UntilFloatTime";
config.m_linkedItems[0][0] =
"BEGIN:VCALENDAR\n"
"PRODID:-//Ximian//NONSGML Evolution Calendar//EN\n"
"VERSION:2.0\n"
"BEGIN:VTIMEZONE\n"
"TZID:Europe/Berlin\n"
"X-LIC-LOCATION:Europe/Berlin\n"
"BEGIN:DAYLIGHT\n"
"TZOFFSETFROM:+0100\n"
"TZOFFSETTO:+0200\n"
"TZNAME:CEST\n"
"DTSTART:19700329T020000\n"
"RRULE:FREQ=YEARLY;INTERVAL=1;BYDAY=-1SU;BYMONTH=3\n"
"END:DAYLIGHT\n"
"BEGIN:STANDARD\n"
"TZOFFSETFROM:+0200\n"
"TZOFFSETTO:+0100\n"
"TZNAME:CET\n"
"DTSTART:19701025T030000\n"
"RRULE:FREQ=YEARLY;INTERVAL=1;BYDAY=-1SU;BYMONTH=10\n"
"END:STANDARD\n"
"END:VTIMEZONE\n"
"BEGIN:VEVENT\n"
"UID:20080407T193125Z-19554-727-1-50@dummyVEVENT\n"
"DTSTAMP:20080407T193125Z\n"
"DTSTART;TZID=Europe/Berlin:20080406T090000\n"
"DTEND;TZID=Europe/Berlin:20080406T093000\n"
"TRANSP:OPAQUE\n"
"SEQUENCE:XXX\n"
"SUMMARY:Recurring\n"
"DESCRIPTION:recurs each Monday\\, 10 times\n"
"CLASS:PUBLIC\n"
"RRULE:FREQ=WEEKLY;UNTIL=20080608T090000;INTERVAL=1;BYDAY=SU\n"
"CREATED:20080407T193241Z\n"
"LAST-MODIFIED:20080407T193241Z\n"
"END:VEVENT\n"
"END:VCALENDAR\n";
} else if (server == "mobical") {
// UTC time
config.m_linkedItems[0].m_name = "UTC";
config.m_linkedItems[0][0] =
"BEGIN:VCALENDAR\n"
"PRODID:-//Ximian//NONSGML Evolution Calendar//EN\n"
"VERSION:2.0\n"
"BEGIN:VEVENT\n"
"UID:20080407T193125Z-19554-727-1-50@dummyVEVENT\n"
"DTSTAMP:20080407T193125Z\n"
"DTSTART:20080406T070000Z\n"
"DTEND:20080406T073000Z\n"
"TRANSP:OPAQUE\n"
"SEQUENCE:XXX\n"
"SUMMARY:Recurring\n"
"DESCRIPTION:recurs each Monday\\, 10 times\n"
"CLASS:PUBLIC\n"
"RRULE:FREQ=WEEKLY;UNTIL=20080608T070000Z;INTERVAL=1;BYDAY=SU\n"
"CREATED:20080407T193241Z\n"
"LAST-MODIFIED:20080407T193241Z\n"
"END:VEVENT\n"
"END:VCALENDAR\n";
config.m_linkedItems[0][1] =
"BEGIN:VCALENDAR\n"
"PRODID:-//Ximian//NONSGML Evolution Calendar//EN\n"
"VERSION:2.0\n"
"BEGIN:VEVENT\n"
"UID:20080407T193125Z-19554-727-1-50@dummyVEVENT\n"
"DTSTAMP:20080407T193125Z\n"
"DTSTART:20080413T070000Z\n"
"DTEND:20080413T073000Z\n"
"TRANSP:OPAQUE\n"
"SEQUENCE:XXX\n"
"SUMMARY:Recurring: Modified\n"
"CLASS:PUBLIC\n"
"CREATED:20080407T193241Z\n"
"LAST-MODIFIED:20080407T193647Z\n"
"RECURRENCE-ID:20080413T070000Z\n"
"DESCRIPTION:second instance modified\n"
"END:VEVENT\n"
"END:VCALENDAR\n";
} else if (server == "memotoo") {
// local floating time, always, regardless what the original
// time zone might have been (TZID, UTC, floating)
config.m_linkedItems[0].m_name = "LocalTime";
config.m_linkedItems[0][0] =
"BEGIN:VCALENDAR\n"
"PRODID:-//Ximian//NONSGML Evolution Calendar//EN\n"
"VERSION:2.0\n"
"BEGIN:VEVENT\n"
"UID:20080407T193125Z-19554-727-1-50@dummyVEVENT\n"
"DTSTAMP:20080407T193125Z\n"
"DTSTART:20080406T070000\n"
"DTEND:20080406T073000\n"
"TRANSP:OPAQUE\n"
"SEQUENCE:XXX\n"
"SUMMARY:Recurring\n"
"DESCRIPTION:recurs each Monday\\, 10 times\n"
"CLASS:PUBLIC\n"
"RRULE:FREQ=WEEKLY;UNTIL=20080608T070000;INTERVAL=1;BYDAY=SU\n"
"CREATED:20080407T193241Z\n"
"LAST-MODIFIED:20080407T193241Z\n"
"END:VEVENT\n"
"END:VCALENDAR\n";
config.m_linkedItems[0][1] =
"BEGIN:VCALENDAR\n"
"PRODID:-//Ximian//NONSGML Evolution Calendar//EN\n"
"VERSION:2.0\n"
"BEGIN:VEVENT\n"
"UID:20080407T193125Z-19554-727-1-50@dummyVEVENT\n"
"DTSTAMP:20080407T193125Z\n"
"DTSTART:20080413T070000\n"
"DTEND:20080413T073000\n"
"TRANSP:OPAQUE\n"
"SEQUENCE:XXX\n"
"SUMMARY:Recurring: Modified\n"
"CLASS:PUBLIC\n"
"CREATED:20080407T193241Z\n"
"LAST-MODIFIED:20080407T193647Z\n"
"RECURRENCE-ID:20080413T070000\n"
"DESCRIPTION:second instance modified\n"
"END:VEVENT\n"
"END:VCALENDAR\n";
// also affects normal test items
std::string *items[] = { &config.m_insertItem,
&config.m_updateItem,
&config.m_mergeItem1,
&config.m_mergeItem2 };
BOOST_FOREACH(std::string *item, items) {
static const pcrecpp::RE times("^(DTSTART|DTEND)(.*)Z$",
pcrecpp::RE_Options().set_multiline(true));
times.GlobalReplace("\\1\\2", item);
}
} else if (server == "exchange") {
config.m_linkedItems[0].m_name = "StandardTZ";
BOOST_FOREACH(std::string &item, config.m_linkedItems[0]) {
// time zone name changes on server to "Standard Timezone",
// with some information stripped
boost::replace_all(item,
"Europe/Berlin",
"Standard Timezone");
// some properties are not stored/supported
boost::replace_all(item, "TZNAME:CET\n", "");
boost::replace_all(item, "TZNAME:CEST\n", "");
boost::replace_all(item, "X-LIC-LOCATION:Standard Timezone\n", "");
}
recurringAllDay = true;
subsets = true;
} else {
// in particular for Google Calendar: also try with
// VALARM, because testing showed that the server works
// differently with and without VALARM data included
config.m_linkedItems.resize(2);
config.m_linkedItems[1].m_name = "WithVALARM";
config.m_linkedItems[1].resize(2);
const std::string valarm =
"BEGIN:VALARM\n"
"ACTION:DISPLAY\n"
"DESCRIPTION:This is an event reminder\n"
"TRIGGER;VALUE=DURATION;RELATED=START:-PT1H\n"
"X-EVOLUTION-ALARM-UID:foo@bar\n"
"END:VALARM\nEND:VEVENT";
config.m_linkedItems[1][0] = config.m_linkedItems[0][0];
boost::replace_first(config.m_linkedItems[1][0], "END:VEVENT", valarm);
config.m_linkedItems[1][1] = config.m_linkedItems[0][1];
boost::replace_first(config.m_linkedItems[1][1], "END:VEVENT", valarm);
// also enable other linked item variants
recurringAllDay = true;
recurringNoTZ = true;
}
if (boost::starts_with(server, "google")) {
// converts local time into time zone of the user,
// which breaks the test
recurringNoTZ = false;
}
// test is fairly slow, only test with some CalDAV servers
if (boost::starts_with(server, "apple")) {
subsets = true;
}
if (recurringAllDay) {
// also test recurring all-day events with exceptions
size_t index = config.m_linkedItems.size();
config.m_linkedItems.resize(index + 1);
config.m_linkedItems[index].m_name = "AllDay";
config.m_linkedItems[index].resize(2);
config.m_linkedItems[index][0] =
"BEGIN:VCALENDAR\n"
"PRODID:-//Ximian//NONSGML Evolution Calendar//EN\n"
"VERSION:2.0\n"
"BEGIN:VEVENT\n"
"UID:20110829T130000Z-19554-727-1-50@dummyVEVENT\n"
"DTSTAMP:20080407T193125Z\n"
"DTSTART;VALUE=DATE:20080406\n"
"DTEND;VALUE=DATE:20080407\n"
"TRANSP:OPAQUE\n"
"SEQUENCE:XXX\n"
"SUMMARY:Recurring all day event\n"
"DESCRIPTION:recurs each Monday\\, 3 times\n"
"CLASS:PUBLIC\n"
"RRULE:FREQ=WEEKLY;UNTIL=20080420;INTERVAL=1;BYDAY=SU\n"
"CREATED:20080407T193241Z\n"
"LAST-MODIFIED:20080407T193241Z\n"
"END:VEVENT\n"
"END:VCALENDAR\n";
// workaround for http://code.google.com/p/google-caldav-issues/issues/detail?id=63
// Google CalDAV inserts a time into the UNTIL clause, do the same in the
// reference data.
if (boost::starts_with(server, "google")) {
config.m_linkedItems[index].m_name = "AllDayGoogle";
boost::replace_first(config.m_linkedItems[index][0],
"UNTIL=20080420",
"UNTIL=20080420T070000Z");
}
config.m_linkedItems[index][1] =
"BEGIN:VCALENDAR\n"
"PRODID:-//Ximian//NONSGML Evolution Calendar//EN\n"
"VERSION:2.0\n"
"BEGIN:VEVENT\n"
"UID:20110829T130000Z-19554-727-1-50@dummyVEVENT\n"
"DTSTAMP:20080407T193125Z\n"
"DTSTART;VALUE=DATE:20080413\n"
"DTEND;VALUE=DATE:20080414\n"
"TRANSP:OPAQUE\n"
"SEQUENCE:XXX\n"
"SUMMARY:Recurring: Modified second instance\n"
"CLASS:PUBLIC\n"
"CREATED:20080407T193241Z\n"
"LAST-MODIFIED:20080407T193647Z\n"
"RECURRENCE-ID;VALUE=DATE:20080413\n"
"DESCRIPTION:second instance modified\n"
"END:VEVENT\n"
"END:VCALENDAR\n";
}
if (recurringNoTZ) {
// also test recurring event with no timezone
size_t index = config.m_linkedItems.size();
config.m_linkedItems.resize(index + 1);
config.m_linkedItems[index].m_name = "NoTZ";
config.m_linkedItems[index].resize(2);
config.m_linkedItems[index][0] = config.m_linkedItems[0][0];
config.m_linkedItems[index][1] = config.m_linkedItems[0][1];
stripComponent(config.m_linkedItems[index][0], "VTIMEZONE");
stripParameters(config.m_linkedItems[index][0], "TZID");
stripComponent(config.m_linkedItems[index][1], "VTIMEZONE");
stripParameters(config.m_linkedItems[index][1], "TZID");
}
if (subsets) {
static const std::string pre =
"BEGIN:VCALENDAR\n"
"PRODID:-//Ximian//NONSGML Evolution Calendar//EN\n"
"VERSION:2.0\n"
"BEGIN:VTIMEZONE\n"
// Actually, this is Europe/Berlin.
// Was renamed to fit the simplified activesyncd naming
// and DTSTART was adapted.
"TZID:Standard Timezone\n"
"BEGIN:STANDARD\n"
"DTSTART:19701025T030000\n"
"RRULE:FREQ=YEARLY;BYDAY=-1SU;BYMONTH=10\n"
"TZOFFSETFROM:+0200\n"
"TZOFFSETTO:+0100\n"
"END:STANDARD\n"
"BEGIN:DAYLIGHT\n"
"DTSTART:19700329T020000\n"
"RRULE:FREQ=YEARLY;BYDAY=-1SU;BYMONTH=3\n"
"TZOFFSETFROM:+0100\n"
"TZOFFSETTO:+0200\n"
"END:DAYLIGHT\n"
"END:VTIMEZONE\n";
static const std::string post =
"END:VCALENDAR\n";
size_t index = config.m_linkedItemsSubset.size();
config.m_linkedItemsSubset.resize(index + 1);
ClientTestConfig::LinkedItems_t *items = &config.m_linkedItemsSubset[index];
items->m_name = "Yearly";
/* year varies */
std::string parent =
pre +
"BEGIN:VEVENT\n"
"UID:yearly\n"
"DTSTAMP:20110101T120000Z\n"
"DTSTART;TZID=Standard Timezone:" "%1$04d" "0101T120000\n"
"DTEND;TZID=Standard Timezone:" "%1$04d" "0101T121000\n"
"SUMMARY:yearly Berlin\n"
"RRULE:BYMONTH=1;BYMONTHDAY=1;UNTIL=20140101T110000Z;FREQ=YEARLY\n"
"TRANSP:TRANSPARENT\n"
"END:VEVENT\n" +
post;
std::string child =
pre +
"BEGIN:VEVENT\n"
"UID:yearly\n"
"DTSTAMP:20110101T120000Z\n"
"DTSTART;TZID=Standard Timezone:" "%1$04d" "0101T120000\n"
"DTEND;TZID=Standard Timezone:" "%1$04d" "0101T121000\n"
"SUMMARY:" "%1$04d" "yearly Berlin\n"
"RECURRENCE-ID;TZID=Standard Timezone:" "%1$04d" "0101T120000\n"
"TRANSP:TRANSPARENT\n"
"END:VEVENT\n" +
post;
boost::assign::push_back(config.m_linkedItemsSubset[index])
(StringPrintf(parent.c_str(), 2012))
(StringPrintf(child.c_str(), 2012))
(StringPrintf(child.c_str(), 2013))
(StringPrintf(child.c_str(), 2014))
;
if (server == "exchange") {
/* only year of event varies */
std::string single =
pre +
"BEGIN:VEVENT\n"
"SUMMARY:[[activesyncd pseudo event - ignore me]]\n"
"DTSTART;TZID=Standard Timezone:" "%1$04d" "0101T120000\n"
"DTEND;TZID=Standard Timezone:" "%1$04d" "0101T120000\n"
"RRULE:FREQ=YEARLY;UNTIL=" "%1$04d" "0101T110000Z;BYMONTHDAY=1;BYMONTH=1\n"
"UID:yearly\n"
"TRANSP:TRANSPARENT\n"
"END:VEVENT\n" +
post;
/* first year, last year and EXDATE varies */
std::string many =
pre +
"BEGIN:VEVENT\n"
"SUMMARY:[[activesyncd pseudo event - ignore me]]\n"
"DTSTART;TZID=Standard Timezone:" "%1$04d" "0101T120000\n"
"DTEND;TZID=Standard Timezone:" "%1$04d" "0101T120000\n"
"RRULE:FREQ=YEARLY;UNTIL=" "%2$04d" "0101T110000Z;BYMONTHDAY=1;BYMONTH=1\n"
"%3$s"
"UID:yearly\n"
"TRANSP:TRANSPARENT\n"
"END:VEVENT\n" +
post;
items->m_testLinkedItemsSubsetAdditional = boost::bind(additionalYearly,
single, many,
_1, _2, _3, _4);
}
addMonthly(index, config.m_linkedItemsSubset, pre, post, "First", 1, 12);
addMonthly(index, config.m_linkedItemsSubset, pre, post, "Middle", 1, 6);
index++;
config.m_linkedItemsSubset.resize(index + 1);
items = &config.m_linkedItemsSubset[index];
items->m_name = "Weekly";
items->push_back(pre +
"BEGIN:VEVENT\n"
"UID:weekly\n"
"DTSTAMP:20110101T120000Z\n"
"DTSTART;TZID=Standard Timezone:20120101T140000\n"
"DTEND;TZID=Standard Timezone:20120101T141000\n"
"SUMMARY:weekly Sunday Berlin\n"
"RRULE:FREQ=WEEKLY;COUNT=54;BYDAY=SU\n"
"TRANSP:TRANSPARENT\n"
"END:VEVENT\n" +
post);
for (int i = 0; sundays[i].m_month; i++) {
items->push_back(StringPrintf((pre +
"BEGIN:VEVENT\n"
"UID:weekly\n"
"DTSTAMP:20110101T120000Z\n"
"DTSTART;TZID=Standard Timezone:2012" "%1$02d%2$02d" "T140000\n"
"DTEND;TZID=Standard Timezone:2012" "%1$02d%2$02d" "T141000\n"
"SUMMARY:2012-%1$02d-%2$02d %3$d. weekly Sunday Berlin\n"
"RECURRENCE-ID;TZID=Standard Timezone:2012" "%1$02d%2$02d" "T140000\n"
"TRANSP:TRANSPARENT\n"
"END:VEVENT\n" +
post).c_str(),
sundays[i].m_month,
sundays[i].m_day,
i + 1));
}
if (server == "exchange") {
/* date varies and UTC time of UNTIL clause (11 during winter time, 10 during summer) */
std::string single =
pre +
"BEGIN:VEVENT\n"
"SUMMARY:[[activesyncd pseudo event - ignore me]]\n"
"DTSTART;TZID=Standard Timezone:2012" "%1$02d" "%2$02d" "T140000\n"
"DTEND;TZID=Standard Timezone:2012" "%1$02d" "%2$02d" "T140000\n"
"RRULE:FREQ=YEARLY;UNTIL=2012" "%1$02d" "%2$02d" "T" "%3$02d" "0000Z;BYMONTHDAY=%2$d;BYMONTH=%1$d\n"
"UID:weekly\n"
"TRANSP:TRANSPARENT\n"
"END:VEVENT\n" +
post;
/* first month, last month, UTC time, INTERVAL and sometimes EXDATE varies */
std::string many =
pre +
"BEGIN:VEVENT\n"
"SUMMARY:[[activesyncd pseudo event - ignore me]]\n"
"DTSTART;TZID=Standard Timezone:2012" "%1$02d" "%2$02d" "T140000\n"
"DTEND;TZID=Standard Timezone:2012" "%1$02d" "%2$02d" "T140000\n"
"RRULE:BYDAY=SU;FREQ=WEEKLY;INTERVAL=%6$d;UNTIL=2012" "%3$02d" "%4$02d" "T" "%5$02d" "0000Z\n"
"%7$s"
"UID:weekly\n"
"TRANSP:TRANSPARENT\n"
"END:VEVENT\n" +
post;
items ->m_testLinkedItemsSubsetAdditional = boost::bind(additionalWeekly,
single, many,
_1, _2, _3, _4);
}
}
config.m_templateItem = config.m_insertItem;
config.m_uniqueProperties = "SUMMARY:UID:LOCATION";
config.m_sizeProperty = "DESCRIPTION";
config.m_testcases = "testcases/eds_event.ics";
} else if (!strcmp(type, "eds_event_noutc") ||
(!strcmp(type, "eds_event") && noutc)) {
config.m_sourceName = "eds_event";
config.m_sourceNameServerTemplate = "calendar";
config.m_uri = "cal2"; // ScheduleWorld
config.m_type = "text/x-vcalendar";
config.m_essentialProperties = iCalEssential;
config.m_mangleItem = mangleICalendar20;
config.m_insertItem =
"BEGIN:VCALENDAR\n"
"PRODID:-//Ximian//NONSGML Evolution Calendar//EN\n"
"VERSION:2.0\n"
"BEGIN:VTIMEZONE\n"
"TZID:Asia/Shanghai\n"
"BEGIN:STANDARD\n"
"DTSTART:19670101T000000\n"
"TZOFFSETFROM:+0800\n"
"TZOFFSETTO:+0800\n"
"END:STANDARD\n"
"END:VTIMEZONE\n"
"BEGIN:VTIMEZONE\n"
"TZID:/freeassociation.sourceforge.net/Tzfile/Asia/Shanghai\n"
"X-LIC-LOCATION:Asia/Shanghai\n"
"BEGIN:STANDARD\n"
"TZNAME:CST\n"
"DTSTART:19700914T230000\n"
"TZOFFSETFROM:+0800\n"
"TZOFFSETTO:+0800\n"
"END:STANDARD\n"
"END:VTIMEZONE\n"
"BEGIN:VEVENT\n"
"SUMMARY:phone meeting\n"
"DTEND;TZID=/freeassociation.sourceforge.net/Tzfile/Asia/Shanghai:20060406T163000\n"
"DTSTART;TZID=/freeassociation.sourceforge.net/Tzfile/Asia/Shanghai:20060406T160000\n"
"UID:1234567890!@#$%^&*()<>@dummyVEVENT\n"
"DTSTAMP:20060406T211449Z\n"
"LAST-MODIFIED:20060409T213201Z\n"
"CREATED:20060409T213201Z\n"
"LOCATION:my office\n"
"DESCRIPTION:let's talk<<REVISION>>\n"
"CLASS:PUBLIC\n"
"TRANSP:OPAQUE\n"
"SEQUENCE:XXX\n"
"END:VEVENT\n"
"END:VCALENDAR\n";
config.m_updateItem =
"BEGIN:VCALENDAR\n"
"PRODID:-//Ximian//NONSGML Evolution Calendar//EN\n"
"VERSION:2.0\n"
"BEGIN:VTIMEZONE\n"
"TZID:Asia/Shanghai\n"
"BEGIN:STANDARD\n"
"DTSTART:19670101T000000\n"
"TZOFFSETFROM:+0800\n"
"TZOFFSETTO:+0800\n"
"END:STANDARD\n"
"END:VTIMEZONE\n"
"BEGIN:VTIMEZONE\n"
"TZID:/freeassociation.sourceforge.net/Tzfile/Asia/Shanghai\n"
"X-LIC-LOCATION:Asia/Shanghai\n"
"BEGIN:STANDARD\n"
"TZNAME:CST\n"
"DTSTART:19700914T230000\n"
"TZOFFSETFROM:+0800\n"
"TZOFFSETTO:+0800\n"
"END:STANDARD\n"
"END:VTIMEZONE\n"
"BEGIN:VEVENT\n"
"SUMMARY:meeting on site\n"
"DTEND;TZID=/freeassociation.sourceforge.net/Tzfile/Asia/Shanghai:20060406T163000\n"
"DTSTART;TZID=/freeassociation.sourceforge.net/Tzfile/Asia/Shanghai:20060406T160000\n"
"UID:1234567890!@#$%^&*()<>@dummyVEVENT\n"
"DTSTAMP:20060406T211449Z\n"
"LAST-MODIFIED:20060409T213201Z\n"
"CREATED:20060409T213201Z\n"
"LOCATION:big meeting room\n"
"DESCRIPTION:nice to see you\n"
"CLASS:PUBLIC\n"
"TRANSP:OPAQUE\n"
"SEQUENCE:XXX\n"
"END:VEVENT\n"
"END:VCALENDAR\n";
/* change location and description of insertItem in testMerge(), add alarm */
config.m_mergeItem1 = "";
config.m_mergeItem2 = "";
config.m_templateItem = config.m_insertItem;
config.m_uniqueProperties = "SUMMARY:UID:LOCATION";
config.m_sizeProperty = "DESCRIPTION";
config.m_testcases = "testcases/eds_event.ics";
} else if(!strcmp(type, "eds_task")) {
config.m_sourceName = "eds_task";
config.m_sourceNameServerTemplate = "todo";
config.m_uri = "task2"; // ScheduleWorld
config.m_type = "text/x-vcalendar";
config.m_essentialProperties = iCalEssential;
config.m_mangleItem = mangleICalendar20;
config.m_insertItem =
"BEGIN:VCALENDAR\n"
"PRODID:-//Ximian//NONSGML Evolution Calendar//EN\n"
"VERSION:2.0\n"
"BEGIN:VTODO\n"
"UID:20060417T173712Z-4360-727-1-2730@dummyVTODO\n"
"DTSTAMP:20060417T173712Z\n"
"SUMMARY:do me\n"
"DESCRIPTION:to be done<<REVISION>>\n"
"PRIORITY:0\n"
"STATUS:NEEDS-ACTION\n"
"CREATED:20060417T173712Z\n"
"LAST-MODIFIED:20060417T173712Z\n"
"END:VTODO\n"
"END:VCALENDAR\n";
config.m_updateItem =
"BEGIN:VCALENDAR\n"
"PRODID:-//Ximian//NONSGML Evolution Calendar//EN\n"
"VERSION:2.0\n"
"BEGIN:VTODO\n"
"UID:20060417T173712Z-4360-727-1-2730@dummyVTODO\n"
"DTSTAMP:20060417T173712Z\n"
"SUMMARY:do me ASAP\n"
"DESCRIPTION:to be done\n"
"PRIORITY:1\n"
"STATUS:NEEDS-ACTION\n"
"CREATED:20060417T173712Z\n"
"LAST-MODIFIED:20060417T173712Z\n"
"END:VTODO\n"
"END:VCALENDAR\n";
/* change summary in insertItem in testMerge() */
config.m_mergeItem1 =
"BEGIN:VCALENDAR\n"
"PRODID:-//Ximian//NONSGML Evolution Calendar//EN\n"
"VERSION:2.0\n"
"BEGIN:VTODO\n"
"UID:20060417T173712Z-4360-727-1-2730@dummyVTODO\n"
"DTSTAMP:20060417T173712Z\n"
"SUMMARY:do me please\\, please\n"
"DESCRIPTION:to be done\n"
"PRIORITY:0\n"
"STATUS:NEEDS-ACTION\n"
"CREATED:20060417T173712Z\n"
"LAST-MODIFIED:20060417T173712Z\n"
"END:VTODO\n"
"END:VCALENDAR\n";
config.m_mergeItem2 =
"BEGIN:VCALENDAR\n"
"PRODID:-//Ximian//NONSGML Evolution Calendar//EN\n"
"VERSION:2.0\n"
"BEGIN:VTODO\n"
"UID:20060417T173712Z-4360-727-1-2730@dummyVTODO\n"
"DTSTAMP:20060417T173712Z\n"
"SUMMARY:do me\n"
"DESCRIPTION:to be done\n"
"PRIORITY:7\n"
"STATUS:NEEDS-ACTION\n"
"CREATED:20060417T173712Z\n"
"LAST-MODIFIED:20060417T173712Z\n"
"END:VTODO\n"
"END:VCALENDAR\n";
config.m_templateItem = config.m_insertItem;
config.m_uniqueProperties = "SUMMARY:UID";
config.m_sizeProperty = "DESCRIPTION";
config.m_testcases = "testcases/eds_task.ics";
} else if(!strcmp(type, "eds_memo")) {
// The "eds_memo" test uses iCalendar 2.0 VJOURNAL
// as format because synccompare doesn't handle
// plain text. A backend which wants to use this
// test data must support importing/exporting
// the test data in that format, see EvolutionMemoSource
// for an example.
config.m_uri = "note"; // ScheduleWorld
config.m_sourceName = "eds_memo";
config.m_sourceNameServerTemplate = "memo";
config.m_type = "memo";
config.m_itemType = "text/calendar";
config.m_essentialProperties = iCalEssential;
config.m_mangleItem = mangleICalendar20;
// Although iCalendar 2.0 is used in EDS, uniqueness is not
// really enforced when syncing. The test data does not have
// UID set and thus would not pass testInsertTwice.
config.m_uniqueID = false;
config.m_insertItem =
"BEGIN:VCALENDAR\n"
"PRODID:-//Ximian//NONSGML Evolution Calendar//EN\n"
"VERSION:2.0\n"
"BEGIN:VJOURNAL\n"
"SUMMARY:Summary\n"
"DESCRIPTION:Summary\\nBody text\n"
"END:VJOURNAL\n"
"END:VCALENDAR\n";
config.m_updateItem =
"BEGIN:VCALENDAR\n"
"PRODID:-//Ximian//NONSGML Evolution Calendar//EN\n"
"VERSION:2.0\n"
"BEGIN:VJOURNAL\n"
"SUMMARY:Summary Modified\n"
"DESCRIPTION:Summary Modified\\nBody text\n"
"END:VJOURNAL\n"
"END:VCALENDAR\n";
/* change summary, as in updateItem, and the body in the other merge item */
config.m_mergeItem1 = config.m_updateItem;
config.m_mergeItem2 =
"BEGIN:VCALENDAR\n"
"PRODID:-//Ximian//NONSGML Evolution Calendar//EN\n"
"VERSION:2.0\n"
"BEGIN:VJOURNAL\n"
"SUMMARY:Summary\n"
"DESCRIPTION:Summary\\nBody modified\n"
"END:VJOURNAL\n"
"END:VCALENDAR\n";
config.m_templateItem =
"BEGIN:VCALENDAR\n"
"PRODID:-//Ximian//NONSGML Evolution Calendar//EN\n"
"VERSION:2.0\n"
"BEGIN:VJOURNAL\n"
"SUMMARY:Summary\n"
"DESCRIPTION:Summary\\nBody text <<REVISION>>\n"
"END:VJOURNAL\n"
"END:VCALENDAR\n";
config.m_uniqueProperties = "SUMMARY:DESCRIPTION";
config.m_sizeProperty = "DESCRIPTION";
config.m_testcases = "testcases/eds_memo.ics";
}else if (!strcmp (type, "calendar+todo")) {
config.m_uri="";
config.m_sourceNameServerTemplate = "calendar+todo";
}
}
void CheckSyncReport::check(SyncMLStatus status, SyncReport &report) const
{
if (m_report) {
*m_report = report;
}
stringstream str;
str << report;
str << "----------|--------CLIENT---------|--------SERVER---------|\n";
str << " | NEW | MOD | DEL | NEW | MOD | DEL |\n";
str << "----------|-----------------------------------------------|\n";
str << StringPrintf("Expected | %3d | %3d | %3d | %3d | %3d | %3d |\n",
clientAdded, clientUpdated, clientDeleted,
serverAdded, serverUpdated, serverDeleted);
str << "Expected sync mode: " << PrettyPrintSyncMode(syncMode) << "\n";
str << "Expected cycles: " << restarts + 1 << "\n";
SE_LOG_INFO(NULL, "sync report:\n%s\n", str.str().c_str());
if (mustSucceed) {
// both STATUS_OK and STATUS_HTTP_OK map to the same
// string, so check the formatted status first, then
// the numerical one
CT_ASSERT_EQUAL(string("no error (remote, status 0)"), Status2String(status));
CT_ASSERT_EQUAL(STATUS_OK, status);
}
BOOST_FOREACH(SyncReport::value_type &entry, report) {
const std::string &name = entry.first;
const SyncSourceReport &source = entry.second;
SE_LOG_DEBUG(NULL, "Checking sync source %s...", name.c_str());
if (mustSucceed) {
CLIENT_TEST_EQUAL(name, STATUS_OK, source.getStatus());
}
check(name, source);
}
SE_LOG_DEBUG(NULL, "Done with checking sync report.");
}
void CheckSyncReport::check(const std::string &name, const SyncSourceReport &source) const
{
// this code is intentionally duplicated to produce nicer CPPUNIT asserts
CLIENT_TEST_EQUAL(name, 0, source.getItemStat(SyncSourceReport::ITEM_LOCAL,
SyncSourceReport::ITEM_ANY,
SyncSourceReport::ITEM_REJECT));
CLIENT_TEST_EQUAL(name, 0, source.getItemStat(SyncSourceReport::ITEM_REMOTE,
SyncSourceReport::ITEM_ANY,
SyncSourceReport::ITEM_REJECT));
const char* checkSyncModeStr = getenv("CLIENT_TEST_NOCHECK_SYNCMODE");
bool checkSyncMode = true;
bool checkSyncStats = getenv ("CLIENT_TEST_NOCHECK_SYNCSTATS") ? false : true;
if (checkSyncModeStr &&
(!strcmp(checkSyncModeStr, "1") || !strcasecmp(checkSyncModeStr, "t"))) {
checkSyncMode = false;
}
if (syncMode != SYNC_NONE && checkSyncMode) {
CLIENT_TEST_EQUAL(name, syncMode, source.getFinalSyncMode());
}
CLIENT_TEST_EQUAL(name, restarts + 1, source.getRestarts() + 1);
if (clientAdded != -1 && checkSyncStats) {
CLIENT_TEST_EQUAL(name, clientAdded,
source.getItemStat(SyncSourceReport::ITEM_LOCAL,
SyncSourceReport::ITEM_ADDED,
SyncSourceReport::ITEM_TOTAL));
}
if (clientUpdated != -1 && checkSyncStats) {
CLIENT_TEST_EQUAL(name, clientUpdated,
source.getItemStat(SyncSourceReport::ITEM_LOCAL,
SyncSourceReport::ITEM_UPDATED,
SyncSourceReport::ITEM_TOTAL));
}
if (clientDeleted != -1 && checkSyncStats) {
CLIENT_TEST_EQUAL(name, clientDeleted,
source.getItemStat(SyncSourceReport::ITEM_LOCAL,
SyncSourceReport::ITEM_REMOVED,
SyncSourceReport::ITEM_TOTAL));
}
if (serverAdded != -1 && checkSyncStats) {
CLIENT_TEST_EQUAL(name, serverAdded,
source.getItemStat(SyncSourceReport::ITEM_REMOTE,
SyncSourceReport::ITEM_ADDED,
SyncSourceReport::ITEM_TOTAL));
}
if (serverUpdated != -1 && checkSyncStats) {
CLIENT_TEST_EQUAL(name, serverUpdated,
source.getItemStat(SyncSourceReport::ITEM_REMOTE,
SyncSourceReport::ITEM_UPDATED,
SyncSourceReport::ITEM_TOTAL));
}
if (serverDeleted != -1 && checkSyncStats) {
CLIENT_TEST_EQUAL(name, serverDeleted,
source.getItemStat(SyncSourceReport::ITEM_REMOTE,
SyncSourceReport::ITEM_REMOVED,
SyncSourceReport::ITEM_TOTAL));
}
}
SE_END_CXX
#endif // ENABLE_INTEGRATION_TESTS
/** @} */
/** @endcond */
Reference in New Issue View Git Blame Copy Permalink