bfb7a85f84
The code for builtin templates had side effects, like always adding
all four standard sources to a template, even if the template itself
didn't have all of them defined. It also hid the problem that listing
templates didn't work for templates on disk.
Another benefit is that template files can be packaged separately. By
choosing the packages which are to be installed, a distributor of
SyncEvolution (like MeeGo) can choose which services to offer by
default.
Therefore this patch removes the "builtin templates" feature, which
was only useful in unusual use cases anyway (for example, single-binary
distribution).
Because there are no more default values for source properties, all
templates must specify the "backend" explicitly. syncevo-phone-config
was adapted accordingly, and also updated to use the current names of
the properties in the process.
As part of moving the templates into separate files, some of them
were cleaned up:
- Mobical: now points to Everdroid, its new name
- Google, Ovi: SSL verification is always enabled in the templates;
the workaround for old libsoup should no longer be
necessary for most users
- Google: renamed to "Google_Contacts", with "Google" as alias,
because there will be two Google templates soon
- Scheduleworld: use "server no longer in operation" instead of
an invalid URL
The finger print match had a special case for "default". The exact
intention of that is unknown. Perhaps it was meant to give that
template a boost when it wouldn't match the string that is getting
searched for at all.
But it had the effect that an exact match when searching for the
"default" template was not found and thus that template couldn't be
used in the command line after moving it from builtin to external.
Removed the complete check.
728 lines
31 KiB
Python
Executable file
728 lines
31 KiB
Python
Executable file
#!/usr/bin/python
|
|
#
|
|
# Copyright (C) 2010 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
|
|
|
|
'''
|
|
Automatically trying different configurations for a phone to sync with
|
|
SyncEvolution.
|
|
'''
|
|
import sys, optparse, os, time, tempfile
|
|
import shutil
|
|
import ConfigParser
|
|
import glob
|
|
import os.path
|
|
|
|
# source names as commonly used in SyncEvolution
|
|
allSources = ['addressbook', 'calendar', 'todo', 'memo', 'calendar+todo']
|
|
# valid SyncMLVersion values
|
|
allVersions = ['1.2', '1.1', '1.0']
|
|
|
|
########################### cmdline options ##########################################
|
|
parser = optparse.OptionParser()
|
|
parser.add_option("-b", "--bt-address", action = "store", type = "string",
|
|
dest = "btaddr", help = "The Bluetooth mac address for the testing phone", default = "")
|
|
parser.add_option ("-p", "--protocol-version", action = "store", type = "string",
|
|
dest="version", help = "The SyncML protocal version for testing, can be one of " +
|
|
"|".join(allVersions) + ", by default it will try all versions one by one",
|
|
default = "")
|
|
parser.add_option ("-s", "--source", action = "store", type = "string", dest=
|
|
"source", help = "The local database for testing, can be one of " + "|".join(allSources),
|
|
default = "")
|
|
parser.add_option ("-u", "--uri", action = "store", type = "string", dest =
|
|
"uri", help = "The URI for testing the selected source, invalid when no specific source is selected via --source", default = "")
|
|
parser.add_option ("-t", "--type", action = "store", type = "string", dest =
|
|
"type", help = "The content type for testing the selected source, invalid when no specific source is selected via --source"
|
|
,default = "")
|
|
parser.add_option ("-i", "--identifier", action = "store", type="string",
|
|
dest = "identifier", help = "The identifier used when contacting the phone, can be arbitray string. By default it will try 'PC Suite','Nokia PC Suite' and empty string",
|
|
default = "")
|
|
parser.add_option ("", "--without-ctcap", action = "store_true", default =False,
|
|
dest = "ctcap", help = "Testing without sending CTCap information")
|
|
parser.add_option ("-v", "--verbose", action = "count",
|
|
dest = "verbose", help = "Increase amount of output")
|
|
parser.add_option ("-a", "--advanced", action = "store_true", default = False,
|
|
dest = "advanced", help = "More extensive test with sending/receving data, WARNING: will destroy your data on the tested phone")
|
|
parser.add_option("-c", "--create-config", action ="store", type = "string",
|
|
dest = "create", help = "If set, a configuration file with the name will be created based on the testing result",
|
|
default ="")
|
|
(options, args) = parser.parse_args()
|
|
|
|
####################semantic check for cmdline options #######################################
|
|
if not options.btaddr:
|
|
parser.error ("Please provide the Bluetooth MAC address for the phone with -b/--bt-address.")
|
|
if options.version and options.version not in allVersions:
|
|
parser.error("Option -p/--protocol-version can only be one of " + "|".join(allVersions) + ".")
|
|
if options.source and options.source not in allSources:
|
|
parser.error("Option -s/--source can only be one of " + "|".join(allSources) + ".")
|
|
if options.uri and not options.source:
|
|
parser.error ("Option -u/--uri only works in combination with -s/--source.")
|
|
if options.type and not options.source:
|
|
parser.error ("Option -t/--type only works in combination with -s/--source.")
|
|
|
|
#######################some global parameters ######################
|
|
syncevoCmd = 'syncevolution'
|
|
configName = 'test-phone' # inside temporary testConfig dir
|
|
# real paths set in main() inside temporary directory
|
|
testFolder = '/dev/null/data'
|
|
testResult = '/dev/null/cache'
|
|
testConfig = '/dev/null/config'
|
|
|
|
|
|
#################### Configuration Parameter #######################
|
|
class ConfigurationParameter:
|
|
def __init__ (self, version, source, uri, type, ctcap, identifier):
|
|
self.version = version
|
|
self.source = source
|
|
self.uri = uri
|
|
self.type = type
|
|
self.ctcap = ctcap
|
|
self.identifier = identifier
|
|
|
|
def printMe(self):
|
|
print "Test parameter: "
|
|
print "With CTCap: %s" %(self.ctcap,)
|
|
print "Identifier: %s" %(self.identifier,)
|
|
print "SyncML version: %s" %(self.version,)
|
|
print "Sync Source: %s" %(self.source,)
|
|
print "URI: %s" %(self.uri,)
|
|
print "Content Type: %s" %(self.type,)
|
|
|
|
def __str__(self):
|
|
res = []
|
|
if self.ctcap:
|
|
res.append("with CTCap")
|
|
else:
|
|
res.append("without CTCap")
|
|
res.append(self.identifier)
|
|
res.append(self.version)
|
|
res.append("%s = %s + %s" % (self.source, self.uri, self.type))
|
|
return ", ".join(res)
|
|
|
|
def equalWith(self, config):
|
|
return (config and \
|
|
self.ctcap == config.ctcap and \
|
|
self.identifier == config.identifier and \
|
|
self.version == config.version and \
|
|
self.uri == config.uri and \
|
|
self.type == config.type)
|
|
|
|
###################### utility functions ####################
|
|
def clearLocalSyncData(sources):
|
|
for source in sources:
|
|
dirname = "%s/%s" % (testFolder, source)
|
|
rm_r(dirname)
|
|
os.makedirs(dirname)
|
|
|
|
def createFile(filename, content):
|
|
f = open(filename, "w")
|
|
f.write(content)
|
|
|
|
def insertLocalSyncData(sources, type):
|
|
for source in sources:
|
|
testcase, keys = getTestCase (source, type)
|
|
createFile(os.path.join(testFolder, source, "0"), testcase)
|
|
|
|
def getTestCase(source, type):
|
|
"""Returns a pair of test item string plus a list of sub strings
|
|
which are expected to come back from the phone. Type comparison is
|
|
intentionally a bit vague, so that it doesn't matter whether the
|
|
type contains a version or a ! force flag."""
|
|
if source == 'addressbook' and type.startswith('text/vcard'):
|
|
return ("BEGIN:VCARD\n"
|
|
"VERSION:3.0\n"
|
|
"TITLE:tester\n"
|
|
"FN:John Doe\n"
|
|
"N:Doe;John;;;\n"
|
|
"TEL;TYPE=WORK;TYPE=VOICE:business 1\n"
|
|
"X-EVOLUTION-FILE-AS:Doe\\, John\n"
|
|
"X-MOZILLA-HTML:FALSE\n"
|
|
"NOTE:test-phone\n"
|
|
"END:VCARD\n",
|
|
["VCARD", "TITLE:tester", "Doe", "John"])
|
|
|
|
if source == 'addressbook' and type.startswith('text/x-vcard'):
|
|
return ("BEGIN:VCARD\n"
|
|
"VERSION:2.1\n"
|
|
"TITLE:tester\n"
|
|
"FN:John Doe\n"
|
|
"N:Doe;John;;;\n"
|
|
"TEL;TYPE=WORK;TYPE=VOICE:business 1\n"
|
|
"X-MOZILLA-HTML:FALSE\n"
|
|
"NOTE:REVISION\n"
|
|
"END:VCARD\n",
|
|
["VCARD", "TITLE:tester", "Doe", "John"])
|
|
|
|
if source == 'calendar' and type.startswith('text/calendar'):
|
|
return ("BEGIN:VCALENDAR\n"
|
|
"PRODID:-//Ximian//NONSGML Evolution Calendar//EN\n"
|
|
"VERSION:2.0\n"
|
|
"METHOD:PUBLISH\n"
|
|
"BEGIN:VEVENT\n"
|
|
"SUMMARY:phone meeting\n"
|
|
"DTEND:20060406T163000Z\n"
|
|
"DTSTART:20060406T160000Z\n"
|
|
"DTSTAMP:20060406T211449Z\n"
|
|
"LAST-MODIFIED:20060409T213201\n"
|
|
"CREATED:20060409T213201\n"
|
|
"LOCATION:my office\n"
|
|
"DESCRIPTION:let's talkREVISION\n"
|
|
"END:VEVENT\n"
|
|
"END:VCALENDAR\n",
|
|
["VCALENDAR", "VEVENT", "phone meeting", "my office"])
|
|
|
|
if source == 'calendar' and type.startswith('text/x-vcalendar'):
|
|
return ("BEGIN:VCALENDAR\n"
|
|
"VERSION:1.0\n"
|
|
"BEGIN:VEVENT\n"
|
|
"SUMMARY:phone meeting\n"
|
|
"DTEND:20060406T163000Z\n"
|
|
"DTSTART:20060406T160000Z\n"
|
|
"DTSTAMP:20060406T211449Z\n"
|
|
"LOCATION:my office\n"
|
|
"DESCRIPTION:let's talkREVISION\n"
|
|
"END:VEVENT\n"
|
|
"END:VCALENDAR\n",
|
|
["VCALENDAR", "VEVENT", "phone meeting", "my office"])
|
|
|
|
if source == 'todo' and type.startswith('text/calendar'):
|
|
return ("BEGIN:VCALENDAR\n"
|
|
"PRODID:-//Ximian//NONSGML Evolution Calendar//EN\n"
|
|
"VERSION:2.0\n"
|
|
"METHOD:PUBLISH\n"
|
|
"BEGIN:VTODO\n"
|
|
"DTSTAMP:20060417T173712Z\n"
|
|
"SUMMARY:do me\n"
|
|
"DESCRIPTION:to be doneREVISION\n"
|
|
"CREATED:20060417T173712\n"
|
|
"LAST-MODIFIED:20060417T173712\n"
|
|
"END:VTODO\n"
|
|
"END:VCALENDAR\n",
|
|
["VCALENDAR", "VTODO", "do me"])
|
|
|
|
if source == 'todo' and type.startswith('text/x-vcalendar'):
|
|
return ("BEGIN:VCALENDAR\n"
|
|
"PRODID:-//Ximian//NONSGML Evolution Calendar//EN\n"
|
|
"VERSION:1.0\n"
|
|
"METHOD:PUBLISH\n"
|
|
"BEGIN:VTODO\n"
|
|
"DTSTAMP:20060417T173712Z\n"
|
|
"SUMMARY:do me\n"
|
|
"DESCRIPTION:to be doneREVISION\n"
|
|
"CREATED:20060417T173712\n"
|
|
"LAST-MODIFIED:20060417T173712\n"
|
|
"END:VTODO\n"
|
|
"END:VCALENDAR\n",
|
|
["VCALENDAR", "VTODO", "do me"])
|
|
|
|
if source == 'memo':
|
|
return ("Summary Line\n"
|
|
"BODY TEXT\n",
|
|
["Summary Line"])
|
|
|
|
raise "no test data defined for source %s and type %s" % (source, type)
|
|
|
|
# Compare the received data with the sent data, we only match selected keywords in received
|
|
# data for a basic sanity test
|
|
def compareSyncData(sources, type):
|
|
for source in sources:
|
|
testcase, keys = getTestCase (source, type)
|
|
received = ''
|
|
recFile = "%s/%s/0" %(testFolder, source)
|
|
try:
|
|
rf = open (recFile)
|
|
received = rf.read()
|
|
except:
|
|
return False
|
|
if (options.verbose > 1):
|
|
print "comparing received file:"
|
|
print received
|
|
print "with built in keywords in test case:"
|
|
print keys
|
|
for key in keys:
|
|
if (received.find(key) <0):
|
|
return False
|
|
return True
|
|
|
|
# wrapper of running a shell command
|
|
def runCommand(cmd, exception = True):
|
|
"""Log and run the given command, throwing an exception if it fails."""
|
|
if (options.verbose > 1):
|
|
print "%s: %s" % (os.getcwd(), cmd)
|
|
else:
|
|
cmd += ' >/dev/null'
|
|
sys.stdout.flush()
|
|
result = os.system(cmd)
|
|
if result != 0 and exception:
|
|
raise Exception("%s: failed (return code %d)" % (cmd, result>>8))
|
|
|
|
def runSync(sync):
|
|
rm_r("%s/syncevolution" % testResult)
|
|
status = True
|
|
interrupt = False
|
|
|
|
try:
|
|
runCommand (sync)
|
|
except:
|
|
status = False
|
|
pass
|
|
|
|
# session name is unknown, but we know there is only one, so let
|
|
# glob find it for us
|
|
resultFile = glob.glob("%s/syncevolution/*/status.ini" % testResult)[0]
|
|
|
|
# inject [main] at start of file for ConfigParser,
|
|
# because SyncEvolution doesn't write sections
|
|
class IniFile:
|
|
def __init__(self, filename):
|
|
self.fp = open(filename, "r")
|
|
self.read = False
|
|
def readline(self):
|
|
if not self.read:
|
|
self.read = True
|
|
return "[main]"
|
|
else:
|
|
return self.fp.readline()
|
|
|
|
ini = ConfigParser.ConfigParser({"status": "0", "error": ""})
|
|
ini.readfp(IniFile(resultFile))
|
|
statuscode = ini.get("main", "status")
|
|
if statuscode == "20015":
|
|
# aborted by user, stop testing
|
|
status = False
|
|
interrupt = True
|
|
if statuscode == "22002":
|
|
# syncevolution failed (for example, kill -9), warn and abort
|
|
print "\nSyncEvolution binary died prematurely, aborting testing."
|
|
status = False
|
|
interrupt = True
|
|
return (status, interrupt)
|
|
|
|
# recursive directory removal, without throwing an error if directory does not exist
|
|
def rm_r(dirname):
|
|
if os.path.isdir(dirname):
|
|
shutil.rmtree(dirname)
|
|
|
|
def hash2ini(hash):
|
|
"""convert key/value pairs into .ini file without sections"""
|
|
res = []
|
|
for key, value in hash.items():
|
|
res.append("%s = %s" % (key, value))
|
|
return "\n".join(res)
|
|
|
|
def strip_version(type):
|
|
"""turn type[:version][!] into type[!]"""
|
|
res = type.split(':')[0]
|
|
if type.endswith('!'):
|
|
res += '!'
|
|
return res
|
|
|
|
##############################TestConfiguration##################################
|
|
class TestingConfiguration():
|
|
def __init__(self, versions, sources, uris, types, ctcaps, identifiers, btaddr):
|
|
if (versions):
|
|
self.versions = versions
|
|
else:
|
|
self.versions = allVersions
|
|
|
|
# If "calendar+todo" is tested, then "calendar" and "todo"
|
|
# must be tested first. If they lead to the same result,
|
|
# then they have to be combined for "calendar+todo".
|
|
# "calendar+todo" itself is never tested directly.
|
|
if sources:
|
|
self.sources = sources
|
|
else:
|
|
self.sources = allSources
|
|
if "calendar+todo" in self.sources:
|
|
self.sources.remove("calendar+todo")
|
|
if not "calendar" in self.sources:
|
|
self.sources.append("calendar")
|
|
if not "todo" in self.sources:
|
|
self.sources.append("todo")
|
|
|
|
if (uris):
|
|
self.uris = uris
|
|
else:
|
|
self.uris = {}
|
|
self.uris['addressbook'] = ['Contact', 'contact', 'Contacts', 'contacts', 'Addressbook', 'addressbook']
|
|
self.uris['calendar'] = ['Calendar', 'calendar', 'Agenda','agenda']
|
|
self.uris['todo'] = self.uris['calendar'] + ['Task', 'task', 'Tasks', 'tasks', 'Todo','todo']
|
|
self.uris['memo'] = ['Memo', 'memo', 'Notes', 'notes', 'Note', 'note']
|
|
|
|
if (types):
|
|
self.types = types
|
|
else:
|
|
# - must include version numbers because file backend needs them
|
|
# - current types like 'text/vcard:3.0' are "downgraded" to the
|
|
# legacy types when sending a SAN, so they are basically identical;
|
|
# to really send a SAN with these current types, we have to "force" them
|
|
self.types = {}
|
|
self.types['addressbook'] = ['text/vcard:3.0', 'text/x-vcard:2.1', 'text/vcard:3.0!']
|
|
self.types['calendar'] = self.types['todo'] = ['text/calendar:2.0', 'text/x-vcalendar:1.0', 'text/calendar:2.0!']
|
|
self.types['memo'] = ['text/plain:1.0']
|
|
|
|
if (ctcaps):
|
|
self.ctcaps = ctcaps
|
|
else:
|
|
self.ctcaps = [True, False]
|
|
if (identifiers):
|
|
self.identifiers = identifiers
|
|
else:
|
|
self.identifiers = ['PC Suite','','Nokia PC Suite']
|
|
self.btaddr = btaddr
|
|
|
|
|
|
#before each configuration is really tested, prepare is called.
|
|
#returns True if we decide current configuration need not be tested
|
|
def prepare (self, allconfigs, curconfig):
|
|
# Decide whether this config should be skipped (because we already found
|
|
# a working configuration
|
|
# Test is skipped either because
|
|
# 1) we already found a working configuration for the data source;
|
|
# 2) based on the working configuration for source A, we can reasonably
|
|
# guess a working configuration for source B must have the same
|
|
# 'identifier', 'ctcap' and 'SyncMLVersion' setting.
|
|
# 3) we already found a working configuration for combined calendar and
|
|
# task, thus seperate testing for calendar and task is not needed.
|
|
skip = False
|
|
for source, config in self.wConfigs.items():
|
|
if (config):
|
|
if ( (config.source == self.source) or (config.identifier != self.identifier ) or (config.ctcap != self.ctcap) or (config.version != self.version)):
|
|
skip = True
|
|
if (skip):
|
|
if (options.verbose > 1):
|
|
print "Test %d/%d skipped because already found a working configuration" % (curconfig, allconfigs)
|
|
elif options.verbose > 0:
|
|
print "Test %d/%d skipped" %(curconfig, allconfigs), \
|
|
ConfigurationParameter(self.version, self.source, self.uri, self.type, self.ctcap, self.identifier)
|
|
else:
|
|
print "Test %d/%d skipped" %(curconfig, allconfigs)
|
|
else:
|
|
print ("Start %d/%d test" % (curconfig, allconfigs)),
|
|
if (options.verbose > 0):
|
|
config = ConfigurationParameter(self.version, self.source, self.uri, self.type, self.ctcap, self.identifier)
|
|
if (options.verbose > 1):
|
|
print
|
|
config.printMe()
|
|
else:
|
|
print config
|
|
else:
|
|
print
|
|
|
|
return skip
|
|
|
|
|
|
#run the real sync test with current configuration parameter
|
|
#if advanced option is set and the basic test succeed, it will contintue with
|
|
#the advanced test
|
|
def testWithCurrentConfiguration(self):
|
|
""" Prepare the configuration and run a sync session, Returns true if
|
|
the test was successful, otherwise false"""
|
|
rm_r(testConfig)
|
|
cmdPrefix = "XDG_CACHE_HOME=%s XDG_CONFIG_HOME=%s " %(testResult, testConfig)
|
|
syncevoTest = "%s %s --daemon=no" % (cmdPrefix, syncevoCmd)
|
|
runCommand ("%s -c --template 'SyncEvolution Client' --sync-property peerIsClient=1 %s" % (syncevoTest, configName))
|
|
# set the local database
|
|
filesource = testFolder+'/'+self.source
|
|
configCmd = "%s --configure --source-property evolutionsource='file:///%s' %s %s" %(syncevoTest, filesource, configName, self.source)
|
|
runCommand (configCmd)
|
|
|
|
configCmd = "%s --configure --sync-property logLevel=5 --sync-property SyncURL=obex-bt://%s --sync-property SyncMLVersion=%s %s" % (syncevoTest, self.btaddr,self.version, configName)
|
|
runCommand (configCmd)
|
|
|
|
if (self.identifier):
|
|
configCmd = "%s --configure --sync-property remoteIdentifier='%s' %s" %(syncevoTest, self.identifier, configName)
|
|
runCommand (configCmd)
|
|
|
|
configCmd = "%s --configure --source-property 'type=file:%s' --source-property uri=%s %s %s" %(syncevoTest, self.type, self.uri, configName, self.source)
|
|
runCommand (configCmd)
|
|
|
|
""" start the sync session """
|
|
if (not self.ctcap):
|
|
cmdPrefix += "SYNCEVOLUTION_NOCTCAP=t "
|
|
cmdPrefix += "SYNCEVOLUTION_NO_SYNC_SIGNALS=1"
|
|
syncCmd = " ".join((cmdPrefix, syncevoCmd, "--daemon=no", configName, self.source))
|
|
(status,interrupt) = runSync(syncCmd)
|
|
if (options.advanced and status and not interrupt):
|
|
(status,interrupt)= self.advancedTestWithCurrentConfiguration()
|
|
return (status, interrupt)
|
|
|
|
'''Basic test for sending/receiving data
|
|
It will work as:
|
|
Clear local data and data on the phone via 'slow-sync' and 'two-way' sync
|
|
Send local test case to the phone via 'two-way'
|
|
Clear local data and get the data from the phone via 'slow-sync'
|
|
compare the sent data with the received data to decide whether the test was successful
|
|
|
|
Note that this depends on the phone support 'slow-sync' and 'two-way' sync and
|
|
implements the semantics correctly as specified in the spec. Otherwise the results will
|
|
be undefined.
|
|
'''
|
|
def advancedTestWithCurrentConfiguration (self):
|
|
"""
|
|
Sending/receving real data for basic sanity test
|
|
"""
|
|
sources = []
|
|
sources.append(self.source)
|
|
|
|
#step 1: clean the data both locally and remotely using a 'slow-sync' and 'two-way'
|
|
clearLocalSyncData(sources)
|
|
cmdPrefix="XDG_CACHE_HOME=%s XDG_CONFIG_HOME=%s " % (testResult, testConfig)
|
|
if (not self.ctcap):
|
|
cmdPrefix += "SYNCEVOLUTION_NOCTCAP=t "
|
|
syncevoTest = "%s %s --daemon=no" % (cmdPrefix, syncevoCmd)
|
|
syncCmd = "%s --sync slow %s %s" % (syncevoTest, configName, self.source)
|
|
status,interrupt = runSync(syncCmd)
|
|
if (not status or interrupt):
|
|
return (status, interrupt)
|
|
clearLocalSyncData(sources)
|
|
syncCmd = "%s --sync two-way %s %s" % (syncevoTest, configName, self.source)
|
|
status,interrupt = runSync(syncCmd)
|
|
if (not status or interrupt):
|
|
return (status, interrupt)
|
|
|
|
#step 2: insert testcase to local data and sync with 'two-way'
|
|
insertLocalSyncData(sources, self.type)
|
|
syncCmd = "%s --sync two-way %s %s" % (syncevoTest, configName, self.source)
|
|
status,interrupt = runSync(syncCmd)
|
|
if (not status or interrupt):
|
|
return (status, interrupt)
|
|
|
|
#step 3: delete local data and sync with 'slow-sync'
|
|
clearLocalSyncData(sources)
|
|
syncCmd = "%s --sync slow %s %s" % (syncevoTest, configName, self.source)
|
|
status,interrupt = runSync(syncCmd)
|
|
if (not status or interrupt):
|
|
return (status, interrupt)
|
|
|
|
#step 4: compare the received data with test case
|
|
status = compareSyncData(sources, self.type)
|
|
return (status, interrupt)
|
|
|
|
'''
|
|
The test driver iterating all possible test combinations and try them one by one
|
|
'''
|
|
def run(self):
|
|
#first round of iterating, calculating all possible configuration numbers
|
|
allconfigs = 0
|
|
for self.ctcap in self.ctcaps:
|
|
for self.identifier in self.identifiers:
|
|
for self.version in self.versions:
|
|
for self.source in self.sources:
|
|
for self.uri in self.uris[self.source]:
|
|
for self.type in self.types[self.source]:
|
|
allconfigs +=1
|
|
print "Starting test for %d configurations..." %(allconfigs,)
|
|
|
|
curconfig = 0
|
|
self.wConfigs = {}
|
|
for source in self.sources:
|
|
self.wConfigs[source] = None
|
|
|
|
#second round of iterating, test for each configuration
|
|
interrupt = False
|
|
for self.source in self.sources:
|
|
if(interrupt):
|
|
break
|
|
for self.ctcap in self.ctcaps:
|
|
if(interrupt):
|
|
break
|
|
for self.version in self.versions:
|
|
if(interrupt):
|
|
break
|
|
for self.identifier in self.identifiers:
|
|
if(interrupt):
|
|
break
|
|
for self.uri in self.uris[self.source]:
|
|
if(interrupt):
|
|
break
|
|
for self.type in self.types[self.source]:
|
|
curconfig +=1
|
|
skip = self.prepare (allconfigs, curconfig)
|
|
if (not skip):
|
|
(status, interrupt) = self.testWithCurrentConfiguration ()
|
|
if (status and not interrupt):
|
|
self.wConfigs[self.source] = ConfigurationParameter (self.version, self.source, self.uri, self.type, self.ctcap, self.identifier)
|
|
print "Found a working configuration for %s" % (self.source,)
|
|
if (options.verbose > 0):
|
|
self.wConfigs[self.source].printMe()
|
|
if (interrupt):
|
|
break;
|
|
if(interrupt):
|
|
print "Test Interrupted"
|
|
return 1
|
|
|
|
print "Test Ended"
|
|
|
|
#Test finished, print summary and generating configurations
|
|
print "****************SUMMARY****************"
|
|
found = False
|
|
for source,config in self.wConfigs.items():
|
|
if (config):
|
|
found = True
|
|
print "------------------------------------------"
|
|
print "Configuration parameter for %s:" % (source,)
|
|
config.printMe()
|
|
|
|
if (not found):
|
|
print "No working configuration found"
|
|
else:
|
|
have_combined = \
|
|
self.wConfigs.has_key('calendar') and \
|
|
self.wConfigs.has_key('todo') and \
|
|
self.wConfigs['calendar'] and \
|
|
self.wConfigs['todo'] and \
|
|
self.wConfigs['calendar'].uri == self.wConfigs['todo'].uri
|
|
|
|
if (options.create):
|
|
#first remove the previous configuration if there is a configuration with the same name
|
|
create = options.create
|
|
cmd = "%s --remove '%s'" %(syncevoCmd, create)
|
|
try:
|
|
runCommand (cmd)
|
|
except:
|
|
pass
|
|
cmd = "%s -c --template 'SyncEvolution Client' --sync-property peerIsClient=1 %s" %(syncevoCmd, create)
|
|
runCommand (cmd)
|
|
#disable all sources by default
|
|
for source in allSources:
|
|
if source == 'calendar+todo':
|
|
continue
|
|
cmd = "%s -c --source-property sync='disabled' %s %s" %(syncevoCmd, create, source)
|
|
runCommand(cmd)
|
|
|
|
syncCreated = False
|
|
for source,config in self.wConfigs.items():
|
|
if (config):
|
|
if (not syncCreated):
|
|
#set the sync parameter
|
|
cmd = "%s --configure --sync-property syncURL='obex-bt://%s' --sync-property remoteIdentifier='%s' --sync-property SyncMLVersion='%s' '%s'" %(syncevoCmd, self.btaddr, config.identifier, config.version, create)
|
|
syncCreated = True
|
|
runCommand (cmd)
|
|
#set each source parameter
|
|
ltype = strip_version(config.type)
|
|
cmd = "%s --configure --source-property sync='two-way' --source-property URI='%s' --source-property type='%s:%s' '%s' '%s'" %(syncevoCmd, config.uri, source, ltype, create, config.source)
|
|
runCommand(cmd)
|
|
if have_combined:
|
|
ltype = strip_version(self.wConfigs['calendar'].type)
|
|
uri = self.wConfigs['calendar'].uri
|
|
cmd = "%s --configure --source-property evolutionsource='calendar,todo' --source-property sync='two-way' --source-property URI='%s' --source-property type='virtual:%s' '%s' calendar+todo" %(syncevoCmd, uri, ltype, create)
|
|
runCommand(cmd)
|
|
for source in ('calendar', 'todo'):
|
|
cmd = "%s --configure --source-property sync='none' --source-property URI='%s' '%s' %s" %(syncevoCmd, uri, create, source)
|
|
runCommand(cmd)
|
|
|
|
|
|
if (options.advanced):
|
|
print ""
|
|
print "We have conducted basic test by sending and receiving"
|
|
print "data to the phone. You can help the SyncEvolution project"
|
|
print "and other users by submitting the following configuration"
|
|
print "template at http://syncevolution.org/wiki/phone-compatibility-template"
|
|
print ""
|
|
|
|
configini = { "peerIsClient": "1" }
|
|
sourceConfigInis = {}
|
|
|
|
for source,config in self.wConfigs.items():
|
|
if(config):
|
|
sourceini = {}
|
|
if (config.identifier):
|
|
configini["remoteIdentifier"] = config.identifier
|
|
if (config.version != '1.2'):
|
|
configini["SyncMLVersion"] = config.version
|
|
sourceini["sync"] = "two-way"
|
|
sourceini["uri"] = config.uri
|
|
sourceini["backend"] = source
|
|
sourceini["syncFormat"] = strip_version(config.type)
|
|
sourceConfigInis[source] = sourceini
|
|
|
|
# create 'calendar+todo' entry, disable separate 'calendar' and 'todo'?
|
|
if have_combined:
|
|
sourceini = {}
|
|
sourceini["sync"] = "two-way"
|
|
sourceini["database"] = "calendar,todo"
|
|
sourceini["uri"] = self.wConfigs['calendar'].uri
|
|
sourceini["backend"] = "virtual"
|
|
sourceini["syncFormat"] = strip_version(self.wConfigs['calendar'].type)
|
|
sourceConfigInis['calendar+todo'] = sourceini
|
|
# disable the sub datasources
|
|
for source in ('calendar', 'todo'):
|
|
sourceConfigInis[source]["sync"] = "none"
|
|
sourceConfigInis[source].pop("uri")
|
|
|
|
# print template to stdout
|
|
sep = "--------------------> snip <--------------------"
|
|
print sep
|
|
print "=== template.ini ==="
|
|
print "fingerprint = <Model> <Manufacturer>"
|
|
print "=== config.ini ==="
|
|
print hash2ini(configini)
|
|
print "consumerReady = 1"
|
|
for source, configini in sourceConfigInis.items():
|
|
print "=== sources/%s/config.ini ===" % source
|
|
print hash2ini(configini)
|
|
print sep
|
|
else:
|
|
print ""
|
|
print "We just conducted minimum test by syncing with the phone"
|
|
print "without checking received data. For more reliable result,"
|
|
print "use the --advanced option, but beware that it will overwrite"
|
|
print "contacts, events, tasks and memos on the phone."
|
|
|
|
if (options.create):
|
|
print ""
|
|
print "Created configuration: %s" %(options.create)
|
|
print "You may start syncing with: syncevolution %s" %(options.create)
|
|
|
|
def main():
|
|
versions = []
|
|
sources = []
|
|
ctcaps = []
|
|
identifiers = []
|
|
uris = {}
|
|
types = {}
|
|
if (options.version):
|
|
versions.append (options.version)
|
|
if (options.source):
|
|
sources.append (options.source)
|
|
if (options.uri):
|
|
uris[sources[0]] = []
|
|
uris[sources[0]].append(options.uri)
|
|
if (options.type):
|
|
types[sources[0]] = []
|
|
types[sources[0]].append(options.type)
|
|
if (options.ctcap):
|
|
ctcaps.append (options.ctcap)
|
|
if (options.identifier):
|
|
identifiers.append (options.identifier)
|
|
|
|
config = TestingConfiguration (versions, sources, uris, types, ctcaps,
|
|
identifiers, options.btaddr)
|
|
|
|
tmpdir = tempfile.mkdtemp(prefix="syncevo-phone-config")
|
|
global testFolder
|
|
global testResult
|
|
global testConfig
|
|
testFolder = tmpdir+'/data'
|
|
testResult = tmpdir+'/cache'
|
|
testConfig = tmpdir+'/config'
|
|
print "Running test with test data inside %s and test results inside %s" %(testFolder, testResult)
|
|
config.run()
|
|
|
|
if __name__ == "__main__":
|
|
main()
|