Revelation / test / datahandler_rvl.py

#!/usr/bin/env python

#

# Revelation 0.4.0 - a password manager for GNOME 2

# http://oss.codepoet.no/revelation/

# $Id$

#

# Unit tests for Revelation DataHandler module

#

#

# Copyright (c) 2003-2005 Erik Grinaker

#

# This program is free software; you can redistribute it and/or

# modify it under the terms of the GNU General Public License

# as published by the Free Software Foundation; either version 2

# of the License, or (at your option) any later version.

#

# This program 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 General Public License for more details.

#

# You should have received a copy of the GNU General Public License

# along with this program; if not, write to the Free Software

# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

#

import unittest, re, xml.dom.minidom

from revelation import data, datahandler, entry

class RevelationXML(unittest.TestCase):

	"RevelationXML"

	def test_attrs(self):

		"RevelationXML has sane attributes"

		self.assertNotEqual(datahandler.RevelationXML.name, "")

		self.assertEqual(datahandler.RevelationXML.importer, True)

		self.assertEqual(datahandler.RevelationXML.exporter, True)

		self.assertEqual(datahandler.RevelationXML.encryption, False)

class RevelationXML_check(unittest.TestCase):

	"RevelationXML.check()"

	def test_inv_dataversion(self):

		"RevelationXML.check() raises VersionError on invalid version"

		handler = datahandler.RevelationXML()

		xml = """

<?xml version="1.0" encoding="iso-8859-1" ?>

<revelationdata dataversion="2">

</revelationdata>

"""

		self.assertRaises(datahandler.VersionError, handler.check, xml)

	def test_inv_docelement(self):

		"RevelationXML.check() rejects invalid document element"

		handler = datahandler.RevelationXML()

		xml = """

<?xml version="1.0" ?>

<revelation>

</revelation>

"""

		self.assertRaises(datahandler.FormatError, handler.check, xml)

	def test_inv_xmlheader(self):

		"RevelationXML.check() rejects invalid header"

		handler = datahandler.RevelationXML()

		xml = """

<xml version="1.0" ?>

<revelationdata dataversion="1">

</revelationdata>

"""

		self.assertRaises(datahandler.FormatError, handler.check, xml)

	def test_none(self):

		"RevelationXML.check() handles None"

		handler = datahandler.RevelationXML()

		self.assertRaises(datahandler.FormatError, handler.check, None)

	def test_valid(self):

		"RevelationXML.check() accepts valid input"

		handler = datahandler.RevelationXML()

		xml = """

<?xml version="1.0" encoding="iso-8859-1" ?>

<revelationdata dataversion="1">

</revelationdata>

"""

		self.assertEqual(handler.check(xml), None)

class RevelationXML_detect(unittest.TestCase):

	"RevelationXML.detect()"

	def test_inv(self):

		"RevelationXML.detect() rejects invalid input"

		handler = datahandler.RevelationXML()

		self.assertEqual(handler.detect("dummydata"), False)

	def test_inv_version(self):

		"RevelationXML.detect() rejects invalid version"

		handler = datahandler.RevelationXML()

		xml = """

<?xml version="1.0" encoding="iso-8859-1" ?>

<revelationdata dataversion="2">

</revelationdata>

"""

		self.assertEquals(handler.detect(xml), False)

	def test_none(self):

		"RevelationXML.detect() handles None"

		handler = datahandler.RevelationXML()

		self.assertEquals(handler.detect(None), False)

	def test_valid(self):

		"RevelationXML.detect() detects valid input"

		handler = datahandler.RevelationXML()

		xml = """

<?xml version="1.0" encoding="iso-8859-1" ?>

<revelationdata dataversion="1">

</revelationdata>

"""

		self.assertEqual(handler.detect(xml), True)

class RevelationXML_export_data(unittest.TestCase):

	"RevelationXML.export_data()"

	def test_entrydata(self):

		"RevelationXML.export_data() exports all entry data"

		handler = datahandler.RevelationXML()

		entrystore = data.EntryStore()

		e = entry.GenericEntry()

		e.name = "Generic entry"

		e.description = "A test entry"

		e.updated = 1098822251

		e.get_field(entry.HostnameField).value = "localhost"

		e.get_field(entry.UsernameField).value = "erikg"

		e.get_field(entry.PasswordField).value = "pwtest"

		entrystore.add_entry(e)

		entrystore2 = handler.import_data(handler.export_data(entrystore))

		e2 = entrystore2.get_entry(entrystore2.iter_nth_child(None, 0))

		self.assertEquals(e.name, e2.name)

		self.assertEquals(e.description, e2.description)

		self.assertEquals(e.updated, e2.updated)

		self.assertEquals(e.get_field(entry.HostnameField).value, e2.get_field(entry.HostnameField).value)

		self.assertEquals(e.get_field(entry.UsernameField).value, e2.get_field(entry.UsernameField).value)

		self.assertEquals(e.get_field(entry.PasswordField).value, e2.get_field(entry.PasswordField).value)

	def test_validxml(self):

		"RevelationXML.export_data() generates well-formed XML"

		handler = datahandler.RevelationXML()

		entrystore = data.EntryStore()

		e = entry.FolderEntry()

		e.name = "Folder"

		folderiter = entrystore.add_entry(e)

		e = entry.GenericEntry()

		e.name = "Generic entry"

		e.description = "A test entry"

		e.updated = 1098822251

		e.get_field(entry.HostnameField).value = "localhost"

		e.get_field(entry.UsernameField).value = "erikg"

		e.get_field(entry.PasswordField).value = "pwtest"

		entrystore.add_entry(e, folderiter)

		entrystore.add_entry(e)

		xmldata = handler.export_data(entrystore)

		xml.dom.minidom.parseString(xmldata)

class RevelationXML_import_data(unittest.TestCase):

	"RevelationXML.import_data()"

	def test_emptyentry(self):

		"RevelationXML.import_data() handles empty entries"

		handler = datahandler.RevelationXML()

		xml = """

<?xml version="1.0" encoding="iso-8859-1" ?>

<revelationdata dataversion="1">

	<entry type="generic" />

</revelationdata>

"""

		entrystore = handler.import_data(xml)

		e = entrystore.get_entry(entrystore.iter_nth_child(None, 0))

		self.assertNotEqual(e, None)

		self.assertEqual(e.name, "")

		self.assertEqual(e.description, "")

		self.assertNotEqual(e.updated, 0)

		self.assertEqual(type(e), entry.GenericEntry)

		self.assertEqual(e.get_field(entry.HostnameField).value, "")

		self.assertEqual(e.get_field(entry.UsernameField).value, "")

		self.assertEqual(e.get_field(entry.PasswordField).value, "")

	def test_entrydata(self):

		"RevelationXML.import_data() loads all entry data"

		handler = datahandler.RevelationXML()

		xml = """

<?xml version="1.0" encoding="iso-8859-1" ?>

<revelationdata dataversion="1">

	<entry type="generic">

		<name>Generic entry</name>

		<description>A test entry</description>

		<updated>1098738771</updated>

		<field id="generic-hostname">localhost</field>

		<field id="generic-username">erikg</field>

		<field id="generic-password">pwtest</field>

	</entry>

</revelationdata>

"""

		entrystore = handler.import_data(xml)

		e = entrystore.get_entry(entrystore.iter_nth_child(None, 0))

		self.assertEqual(e.name, "Generic entry")

		self.assertEqual(e.description, "A test entry")

		self.assertEqual(e.updated, 1098738771)

		self.assertEqual(type(e), entry.GenericEntry)

		self.assertEqual(e.get_field(entry.HostnameField).value, "localhost")

		self.assertEqual(e.get_field(entry.UsernameField).value, "erikg")

		self.assertEqual(e.get_field(entry.PasswordField).value, "pwtest")

	def test_entrydata(self):

		"RevelationXML.import_data() handles all entry types"

		handler = datahandler.RevelationXML()

		typedata = {

			"folder"	: [],

			"creditcard"	: [ "creditcard-cardtype", "creditcard-cardnumber", "creditcard-expirydate", "creditcard-ccv", "generic-pin" ],

			"cryptokey"	: [ "generic-hostname", "generic-certificate", "generic-keyfile", "generic-password" ],

			"database"	: [ "generic-hostname", "generic-username", "generic-password", "generic-database" ],

			"door"		: [ "generic-location", "generic-code" ],

			"email"		: [ "generic-email", "generic-hostname", "generic-username", "generic-password" ],

			"ftp"		: [ "generic-hostname", "generic-port", "generic-username", "generic-password" ],

			"generic"	: [ "generic-hostname", "generic-username", "generic-password" ],

			"phone"		: [ "phone-phonenumber", "generic-pin" ],

			"shell"		: [ "generic-hostname", "generic-domain", "generic-username", "generic-password" ],

			"website"	: [ "generic-url", "generic-username", "generic-password" ]

		}

		xml = """<?xml version="1.0" ?><revelationdata dataversion="1">"""

		for typename, fieldlist in typedata.items():

			xml += "<entry type=\"" + typename + "\">"

			for field in fieldlist:

				xml += "<field id=\"" + field + "\"></field>"

			xml += "</entry>"

		xml += "</revelationdata>"

		handler.import_data(xml)

	def test_inv_entryfield(self):

		"RevelationXML.import_data() raises DataError on invalid entry field"

		handler = datahandler.RevelationXML()

		xml = """

<?xml version="1.0" encoding="iso-8859-1" ?>

<revelationdata dataversion="1">

	<entry type="generic">

		<name>Generic entry</name>

		<description>A test entry</description>

		<updated>1098738771</updated>

		<field id="creditcard-cardnumber">invalid field type</field>

		<field id="generic-username">erikg</field>

		<field id="generic-password">pwtest</field>

	</entry>

</revelationdata>

"""

		self.assertRaises(datahandler.DataError, handler.import_data, xml)

	def test_inv_entrytype(self):

		"RevelationXML.import_data() raises DataError on invalid entry type"

		handler = datahandler.RevelationXML()

		xml = """

<?xml version="1.0" encoding="iso-8859-1" ?>

<revelationdata dataversion="1">

	<entry type="invalid">

		<name>Generic entry</name>

		<description>A test entry</description>

		<updated>1098738771</updated>

		<field id="generic-hostname">localhost</field>

		<field id="generic-username">erikg</field>

		<field id="generic-password">pwtest</field>

	</entry>

</revelationdata>

"""

		self.assertRaises(datahandler.DataError, handler.import_data, xml)

	def test_inv_fieldtype(self):

		"RevelationXML.import_data() raises DataError on invalid field type"

		handler = datahandler.RevelationXML()

		xml = """

<?xml version="1.0" encoding="iso-8859-1" ?>

<revelationdata dataversion="1">

	<entry type="generic">

		<name>Generic entry</name>

		<description>A test entry</description>

		<updated>1098738771</updated>

		<field id="invalid">localhost</field>

		<field id="generic-username">erikg</field>

		<field id="generic-password">pwtest</field>

	</entry>

</revelationdata>

"""

		self.assertRaises(datahandler.DataError, handler.import_data, xml)

	def test_inv_node(self):

		"RevelationXML.import_data() raises FormatError on unknown nodes"

		handler = datahandler.RevelationXML()

		xml = """

<?xml version="1.0" encoding="iso-8859-1" ?>

<revelationdata dataversion="1">

	<dummy />

</revelationdata>

"""

		xml2 = """

<?xml version="1.0" encoding="iso-8859-1" ?>

<revelationdata dataversion="1">

	<entry type="generic">

		<dummy />

	</entry>

</revelationdata>

"""

		self.assertRaises(datahandler.FormatError, handler.import_data, xml)

		self.assertRaises(datahandler.FormatError, handler.import_data, xml2)

	def test_missing_entrytype(self):

		"RevelationXML.import_data() raises FormatError on missing entrytype"

		handler = datahandler.RevelationXML()

		xml = """

<?xml version="1.0" encoding="iso-8859-1" ?>

<revelationdata dataversion="1">

	<entry>

		<name>Generic entry</name>

		<description>A test entry</description>

		<updated>1098738771</updated>

		<field id="generic-hostname">localhost</field>

		<field id="generic-username">erikg</field>

		<field id="generic-password">pwtest</field>

	</entry>

</revelationdata>

"""

		self.assertRaises(datahandler.FormatError, handler.import_data, xml)

	def test_missing_fieldid(self):

		"RevelationXML.import_data() raises FormatError on missing fieldid"

		handler = datahandler.RevelationXML()

		xml = """

<?xml version="1.0" encoding="iso-8859-1" ?>

<revelationdata dataversion="1">

	<entry type="generic">

		<name>Generic entry</name>

		<description>A test entry</description>

		<updated>1098738771</updated>

		<field>localhost</field>

		<field id="generic-username">erikg</field>

		<field id="generic-password">pwtest</field>

	</entry>

</revelationdata>

"""

		self.assertRaises(datahandler.FormatError, handler.import_data, xml)

	def test_parentfolder(self):

		"RevelationXML.import_data() raises DataError when non-folder has children"

		handler = datahandler.RevelationXML()

		xml = """

<?xml version="1.0" encoding="iso-8859-1" ?>

<revelationdata dataversion="1">

	<entry type="generic">

		<name>Non-folder</name>

		<description>An invalid parent</description>

		<updated>1098738862</updated>

		<entry type="generic">

			<name>Generic entry</name>

			<description>A test entry</description>

			<updated>1098738771</updated>

			<field id="generic-hostname">localhost</field>

			<field id="generic-username">erikg</field>

			<field id="generic-password">pwtest</field>

		</entry>

	</entry>

</revelationdata>

"""

		self.assertRaises(datahandler.DataError, handler.import_data, xml)

	def test_inv_updated(self):

		"RevelationXML.import_data() raises DataError on invalid updatetime"

		handler = datahandler.RevelationXML()

		xml = """

<?xml version="1.0" encoding="iso-8859-1" ?>

<revelationdata dataversion="1">

	<entry type="generic">

		<name>Generic entry</name>

		<description>A test entry</description>

		<updated>dummy123</updated>

		<field id="generic-hostname">localhost</field>

		<field id="generic-username">erikg</field>

		<field id="generic-password">pwtest</field>

	</entry>

</revelationdata>

"""

		self.assertRaises(datahandler.DataError, handler.import_data, xml)

	def test_valid(self):

		"RevelationXML.import_data() accepts valid input"

		handler = datahandler.RevelationXML()

		xml = """

<?xml version="1.0" encoding="iso-8859-1" ?>

<revelationdata dataversion="1">

	<entry type="folder">

		<name>Folder</name>

		<description>A test folder</description>

		<updated>1098738862</updated>

		<entry type="generic">

			<name>Generic entry</name>

			<description>A test entry</description>

			<updated>1098738771</updated>

			<field id="generic-hostname">localhost</field>

			<field id="generic-username">erikg</field>

			<field id="generic-password">pwtest</field>

		</entry>

	</entry>

</revelationdata>

"""

		self.assertEqual(type(handler.import_data(xml)), data.EntryStore)

class Revelation(unittest.TestCase):

	"Revelation"

	def test_attrs(self):

		"Revelation has sane attributes"

		self.assertNotEqual(datahandler.Revelation.name, "")

		self.assertEqual(datahandler.Revelation.importer, True)

		self.assertEqual(datahandler.Revelation.exporter, True)

		self.assertEqual(datahandler.Revelation.encryption, True)

class Revelation_check(unittest.TestCase):

	"Revelation.check()"

	def test_invalid(self):

		"Revelation.check() raises FormatError on invalid data"

		handler = datahandler.Revelation()

		data = "xxx\x00\x01\x00\x00\x04\x00\x00\x00\x00" + ("\0" * 32)

		self.assertRaises(datahandler.FormatError, handler.check, data)

		data = "rvl\x00\x01\x00\x00\x00\x00jej" + ("\0" * 32)

		self.assertRaises(datahandler.FormatError, handler.check, data)

	def test_none(self):

		"Revelation.check() raises FormatError on None"

		handler = datahandler.Revelation()

		self.assertRaises(datahandler.FormatError, handler.check, None)

	def test_short(self):

		"Revelation.check() raises FormatError on short data"

		handler = datahandler.Revelation()

		data = "rvl\x00\x01\x00\x00\x04\x00\x00\x00\x00"

		self.assertRaises(datahandler.FormatError, handler.check, data)

	def test_valid(self):

		"Revelation.check() handles valid data"

		handler = datahandler.Revelation()

		data = "rvl\x00\x01\x00\x00\x04\x00\x00\x00\x00" + ("\0" * 32)

		handler.check(data)

	def test_version(self):

		"Revelation.check() raises VersionError on unknown version"

		handler = datahandler.Revelation()

		data = "rvl\x00\x02\x00\x00\x04\x00\x00\x00\x00" + ("\0" * 32)

		self.assertRaises(datahandler.VersionError, handler.check, data)

class Revelation_detect(unittest.TestCase):

	"Revelation.detect()"

	def test_invalid(self):

		"Revelation.detect() rejects invalid data"

		handler = datahandler.Revelation()

		data = "xxx\x00\x01\x00\x00\x04\x00\x00\x00\x00" + ("\0" * 32)

		self.assertEquals(handler.detect(data), False)

		data = "rvl\x00\x01\x00\x00\x00\x00jej" + ("\0" * 32)

		self.assertEquals(handler.detect(data), False)

	def test_none(self):

		"Revelation.detect() rejects None"

		handler = datahandler.Revelation()

		self.assertEquals(handler.detect(None), False)

	def test_short(self):

		"Revelation.detect() rejects short data"

		handler = datahandler.Revelation()

		data = "rvl\x00\x01\x00\x00\x04\x00\x00\x00\x00"

		self.assertEquals(handler.detect(data), False)

	def test_valid(self):

		"Revelation.detect() handles valid data"

		handler = datahandler.Revelation()

		data = "rvl\x00\x01\x00\x00\x04\x00\x00\x00\x00" + ("\0" * 32)

		self.assertEquals(handler.detect(data), True)

	def test_version(self):

		"Revelation.detect() rejects unknown versions"

		handler = datahandler.Revelation()

		data = "rvl\x00\x02\x00\x00\x04\x00\x00\x00\x00" + ("\0" * 32)

		self.assertEquals(handler.detect(data), False)

class Revelation_export_data(unittest.TestCase):

	"Revelation.export_data()"

	def setUp(self):

		# set up a common password

		self.password = "test123"

		# set up an entrystore for tests

		self.entrystore = data.EntryStore()

		e = entry.FolderEntry()

		e.name = "Testfolder"

		e.description = "Just a test folder"

		folderiter = self.entrystore.add_entry(e)

		e = entry.GenericEntry()

		e.name = "Generic child"

		e.description = "Child-entry"

		self.entrystore.add_entry(e, folderiter)

		e = entry.GenericEntry()

		e.name = "Another test-entry"

		self.entrystore.add_entry(e)

	def test_header(self):

		"Revelation.export_data() generates a valid header"

		handler = datahandler.Revelation()

		data = handler.export_data(self.entrystore, self.password)

		match = re.match("""

			^		# start of line

			rvl\x00		# magic string

			(.)		# data version

			\x00		# separator

			(.{3})		# app version

			\x00\x00\x00	# separator

		""", data, re.VERBOSE)

		self.assertNotEqual(match, None)

		self.assertEqual(ord(match.group(1)), 1)

		self.assertEqual(ord(match.group(2)[0]) < 10, True)

		self.assertEqual(ord(match.group(2)[1]) < 10, True)

		self.assertEqual(ord(match.group(2)[2]) < 10, True)

	def test_length(self):

		"Revelation.export_data() generates data of correct length"

		handler = datahandler.Revelation()

		data = handler.export_data(self.entrystore, self.password)

		self.assertEqual(len(data) >= 28, True)

		self.assertEqual((len(data) - 12) % 16, 0)

	def test_password_none(self):

		"Revelation.export_data() raises PasswordError on None password"

		handler = datahandler.Revelation()

		self.assertRaises(datahandler.PasswordError, handler.export_data, self.entrystore, None)

	def test_random(self):

		"Revelation.export_data() gives different results each run"

		handler = datahandler.Revelation()

		self.assertNotEqual(

			handler.export_data(self.entrystore, self.password),

			handler.export_data(self.entrystore, self.password)

		)

	def test_valid(self):

		"Revelation.export_data() generates valid data"

		handler = datahandler.Revelation()

		encdata = handler.export_data(self.entrystore, self.password)

		entrystore = handler.import_data(encdata, self.password)

		self.assertEqual(type(entrystore), type(self.entrystore))

		e1 = self.entrystore.get_entry(self.entrystore.iter_nth_child(None, 1))

		e2 = entrystore.get_entry(entrystore.iter_nth_child(None, 1))

		self.assertEqual(type(e1), type(e2))

		self.assertEqual(e1.name, e2.name)

		self.assertEqual(e1.description, e2.description)

		self.assertEqual(e1.updated, e2.updated)

		for f1, f2 in zip(e1.fields, e2.fields):

			self.assertEqual(f1.value, f2.value)

class Revelation_import_data(unittest.TestCase):

	"Revelation.import_data()"

	def setUp(self):

		# set up a common password

		self.password = "test123"

		# set up an entrystore for tests

		self.entrystore = data.EntryStore()

		e = entry.FolderEntry()

		e.name = "Testfolder"

		e.description = "Just a test folder"

		folderiter = self.entrystore.add_entry(e)

		e = entry.GenericEntry()

		e.name = "Generic child"

		e.description = "Child-entry"

		self.entrystore.add_entry(e, folderiter)

		e = entry.GenericEntry()

		e.name = "Another test-entry"

		self.entrystore.add_entry(e)

		handler = datahandler.Revelation()

		self.data = handler.export_data(self.entrystore, self.password)

	def test_inv_header(self):

		"Revelation.import_data() raises FormatError on invalid header"

		handler = datahandler.Revelation()

		self.assertRaises(datahandler.FormatError, handler.import_data, "123" + self.data[3:], self.password)

	def test_inv_length(self):

		"Revelation.import_data() raises FormatError on invalid length"

		handler = datahandler.Revelation()

		self.assertRaises(datahandler.FormatError, handler.import_data, self.data + "123", self.password)

	def test_inv_password(self):

		"Revelation.import_data() raises PasswordError on invalid password"

		handler = datahandler.Revelation()

		self.assertRaises(datahandler.PasswordError, handler.import_data, self.data, "dummypassword")

	def test_inv_version(self):

		"Revelation.import_data() raises VersionError on invalid version"

		handler = datahandler.Revelation()

		self.assertRaises(datahandler.VersionError, handler.import_data, "rvl\x00\x00" + self.data[5:], self.password)

		self.assertRaises(datahandler.VersionError, handler.import_data, "rvl\x00\x02" + self.data[5:], self.password)

	def test_password_long(self):

		"Revelation.import_data() handles long (>32 chars) passwords"

		handler = datahandler.Revelation()

		data = handler.export_data(self.entrystore, "abcdefgh12345678abcdefgh12345678abcdefgh")

		entrystore = handler.import_data(data, "abcdefgh12345678abcdefgh12345678abcdefgh")

	def test_password_none(self):

		"Revelation.import_data() raises PasswordError on None password"

		handler = datahandler.Revelation()

		self.assertRaises(datahandler.PasswordError, handler.import_data, self.data, None)

	def test_valid(self):

		"Revelation.import_data() accepts valid data"

		handler = datahandler.Revelation()

		entrystore = handler.import_data(self.data, self.password)

		self.assertEqual(type(entrystore), type(self.entrystore))

		e1 = self.entrystore.get_entry(self.entrystore.iter_nth_child(None, 1))

		e2 = entrystore.get_entry(entrystore.iter_nth_child(None, 1))

		self.assertEqual(type(e1), type(e2))

		self.assertEqual(e1.name, e2.name)

		self.assertEqual(e1.description, e2.description)

		self.assertEqual(e1.updated, e2.updated)

		for f1, f2 in zip(e1.fields, e2.fields):

			self.assertEqual(f1.value, f2.value)

if __name__ == "__main__":

	unittest.main()