def test_refresh( self ):
from camelot.core.orm import Session
from camelot.model.party import Person
refresh_action = application_action.Refresh()
session = Session()
session.expunge_all()
# create objects in various states
#
p1 = Person(first_name = u'p1', last_name = u'persistent' )
p2 = Person(first_name = u'p2', last_name = u'dirty' )
p3 = Person(first_name = u'p3', last_name = u'deleted' )
p4 = Person(first_name = u'p4', last_name = u'to be deleted' )
p5 = Person(first_name = u'p5', last_name = u'detached' )
p6 = Person(first_name = u'p6', last_name = u'deleted outside session' )
session.flush()
p3.delete()
session.flush()
p4.delete()
p2.last_name = u'clean'
#
# delete p6 without the session being aware
#
person_table = Person.table
session.execute( person_table.delete().where( person_table.c.party_id == p6.id ) )
#
# refresh the session through the action
#
list( refresh_action.model_run( self.context ) )
self.assertEqual( p2.last_name, u'dirty' )
class PartyCase(ModelThreadTestCase):
"""Test the build in party - address - contact mechanism model"""
def setUp(self):
super(PartyCase, self).setUp()
from camelot.admin.application_admin import ApplicationAdmin
self.session = Session()
self.app_admin = ApplicationAdmin()
self.person_admin = self.app_admin.get_related_admin(party.Person)
self.organization_admin = self.app_admin.get_related_admin(
party.Organization)
def tearDown(self):
self.session.expunge_all()
def test_party(self):
p = party.Party()
self.assertFalse(p.name)
def test_geographic_boundary(self):
belgium = party.Country.get_or_create(code=u'BE', name=u'Belgium')
self.assertTrue(unicode(belgium))
city = party.City.get_or_create(country=belgium,
code='1000',
name='Brussels')
return city
def test_address(self):
city = self.test_geographic_boundary()
address = party.Address.get_or_create(street1='Avenue Louise',
street2=None,
city=city)
self.assertTrue(unicode(address))
return address
def test_party_address(self):
city = self.test_geographic_boundary()
org = party.Organization(name='PSF')
party_address = party.PartyAddress(party=org)
party_address.street1 = 'Avenue Louise 5'
party_address.street2 = 'Boite 4'
party_address.city = city
party_address_admin = party.AddressAdmin(self.app_admin,
party.PartyAddress)
self.assertTrue(party_address.address in party_address_admin.
get_compounding_objects(party_address))
self.assertTrue(party_address.address in self.session.new)
# everything should be flushed through the party admin
org_admin = self.app_admin.get_related_admin(party.Organization)
org_validator = org_admin.get_validator()
self.assertTrue(
party_address in org_admin.get_compounding_objects(org))
org_admin.flush(org)
self.assertFalse(party_address.address in self.session.new)
party_address_admin.refresh(party_address)
# test hybrid property getters on Party and PartyAddress
self.assertEqual(party_address.street1, 'Avenue Louise 5')
self.assertEqual(party_address.street2, 'Boite 4')
self.assertEqual(party_address.city, city)
self.assertEqual(org.street1, 'Avenue Louise 5')
self.assertEqual(org.street2, 'Boite 4')
self.assertEqual(org.city, city)
self.assertTrue(unicode(party_address))
query = self.session.query(party.PartyAddress)
self.assertTrue(
query.filter(
party.PartyAddress.street1 == 'Avenue Louise 5').first())
self.assertTrue(
query.filter(party.PartyAddress.street2 == 'Boite 4').first())
# if party address changes, party should be updated
depending_objects = list(
party_address_admin.get_depending_objects(party_address))
self.assertTrue(org in depending_objects)
# if address changes, party address and party should be updated
address = party_address.address
address_admin = self.app_admin.get_related_admin(party.Address)
depending_objects = list(address_admin.get_depending_objects(address))
self.assertTrue(party_address in depending_objects)
self.assertTrue(org in depending_objects)
# test hybrid property setters on Party
org.street1 = 'Rue Belliard 1'
org.street2 = 'Second floor'
org.city = None
# expunge should expunge the related address objects as well, so
# after an expunge, the session as a whole can be flushed
org_admin.expunge(org)
self.session.flush()
# test hybrid property setters on a new party
org = party.Organization(name='PSF')
org.street1 = 'Rue Belliard 1'
org.street2 = 'Second floor'
org.city = city
org_admin.flush(org)
self.assertEqual(len(org.addresses), 1)
self.assertEqual(org.street1, 'Rue Belliard 1')
self.assertEqual(org.street2, 'Second floor')
self.assertEqual(org.city, city)
# test invalidation of org object and refresh it
self.assertFalse(org_validator.validate_object(org))
org.city = None
self.assertTrue(org_validator.validate_object(org))
org_admin.refresh(org)
self.assertFalse(org_validator.validate_object(org))
# removing all the address properties should make the
# object valid again
org.street1 = None
org.street2 = None
org.city = None
self.assertFalse(org_validator.validate_object(org))
# removing all address properties of a not yet flushed
# address should expunge the address
org = party.Organization(name='PSF')
org.street1 = 'Rue Belliard 1'
for address in org.addresses:
self.assertTrue(address in self.session.new)
org.street1 = None
self.assertTrue(address not in self.session)
self.assertEqual(len(org.addresses), 0)
def test_person(self):
person = party.Person(first_name=u'Robin', last_name=u'The brave')
self.assertEqual(person.email, None)
self.assertEqual(person.phone, None)
self.assertEqual(person.fax, None)
self.assertEqual(person.street1, None)
self.assertEqual(person.street2, None)
self.assertEqual(person.city, None)
self.person_admin.flush(person)
person2 = party.Person(first_name=u'Robin')
self.assertFalse(person2.note)
person2.last_name = u'The brave'
# gui should warn this person exists
self.assertTrue(person2.note)
return person
def test_contact_mechanism(self):
contact_mechanism = party.ContactMechanism(mechanism=(u'email',
u'*****@*****.**'))
self.assertTrue(unicode(contact_mechanism))
def test_person_contact_mechanism(self):
# create a new person
person = party.Person(first_name=u'Robin', last_name=u'The brave')
self.person_admin.flush(person)
self.assertEqual(person.email, None)
# set the contact mechanism
mechanism_1 = (u'email', u'*****@*****.**')
person.email = mechanism_1
# the default from and thru dates should be set when
# setting the party defaults
self.person_admin.set_defaults(person)
self.assertTrue(person.contact_mechanisms[0].from_date)
self.person_admin.flush(person)
self.assertEqual(person.email, mechanism_1)
# change the contact mechanism, after a flush
mechanism_2 = (u'email', u'*****@*****.**')
person.email = mechanism_2
self.person_admin.flush(person)
self.assertEqual(person.email, mechanism_2)
# remove the contact mechanism after a flush
person.email = ('email', '')
self.assertEqual(person.email, None)
self.person_admin.flush(person)
self.assertEqual(person.email, None)
admin = party.PartyContactMechanismAdmin(self.app_admin,
party.PartyContactMechanism)
contact_mechanism = party.ContactMechanism(mechanism=mechanism_1)
party_contact_mechanism = party.PartyContactMechanism(
party=person, contact_mechanism=contact_mechanism)
admin.flush(party_contact_mechanism)
admin.refresh(party_contact_mechanism)
list(admin.get_depending_objects(party_contact_mechanism))
#
# if the contact mechanism changes, the party person should be
# updated as well
#
contact_mechanism_admin = self.app_admin.get_related_admin(
party.ContactMechanism)
depending_objects = list(
contact_mechanism_admin.get_depending_objects(contact_mechanism))
self.assertTrue(person in depending_objects)
self.assertTrue(party_contact_mechanism in depending_objects)
#
# if the party contact mechanism changes, the party should be updated
# as well
depending_objects = list(
admin.get_depending_objects(party_contact_mechanism))
self.assertTrue(person in depending_objects)
# delete the person
self.person_admin.delete(person)
def test_organization(self):
org = party.Organization(name='PSF')
org.email = ('email', '*****@*****.**')
org.phone = ('phone', '1234')
org.fax = ('fax', '4567')
self.organization_admin.flush(org)
self.assertTrue(unicode(org))
self.assertEqual(org.number_of_shares_issued, 0)
query = orm.object_session(org).query(party.Organization)
self.assertTrue(
query.filter(
party.Organization.email == ('email',
'*****@*****.**')).first())
self.assertTrue(
query.filter(party.Organization.phone == ('phone',
'1234')).first())
self.assertTrue(
query.filter(party.Organization.fax == ('fax', '4567')).first())
return org
def test_party_relationship(self):
person = self.test_person()
org = self.test_organization()
employee = party.EmployerEmployee(established_from=org,
established_to=person)
self.assertTrue(unicode(employee))
def test_party_contact_mechanism(self):
person = self.test_person()
party_contact_mechanism = party.PartyContactMechanism(party=person)
party_contact_mechanism.mechanism = (u'email', u'*****@*****.**')
party_contact_mechanism.mechanism = (u'email', u'*****@*****.**')
self.assertTrue(party_contact_mechanism in self.session.new)
self.assertTrue(
party_contact_mechanism.contact_mechanism in self.session.new)
# flushing trough the party should flush the contact mechanism
self.person_admin.flush(person)
self.assertFalse(party_contact_mechanism in self.session.new)
self.assertFalse(
party_contact_mechanism.contact_mechanism in self.session.new)
self.assertTrue(unicode(party_contact_mechanism))
query = self.session.query(party.PartyContactMechanism)
self.assertTrue(
query.filter(party.PartyContactMechanism.mechanism == (
u'email', u'*****@*****.**')).first())
# party contact mechanism is only valid when contact mechanism is
# valid
party_contact_mechanism_admin = self.app_admin.get_related_admin(
party.PartyContactMechanism)
compounding_objects = list(
party_contact_mechanism_admin.get_compounding_objects(
party_contact_mechanism))
self.assertTrue(
party_contact_mechanism.contact_mechanism in compounding_objects)
party_contact_mechanism_validator = party_contact_mechanism_admin.get_validator(
)
self.assertFalse(
party_contact_mechanism_validator.validate_object(
party_contact_mechanism))
party_contact_mechanism.contact_mechanism.mechanism = None
self.assertTrue(
party_contact_mechanism_validator.validate_object(
party_contact_mechanism))
# the party is only valid when the contact mechanism is
# valid
party_admin = self.app_admin.get_related_admin(party.Person)
party_validator = party_admin.get_validator()
self.assertTrue(party_validator.validate_object(person))
def test_party_category(self):
org = self.test_organization()
category = party.PartyCategory(name=u'Imortant')
category.parties.append(org)
self.session.flush()
self.assertTrue(list(category.get_contact_mechanisms(u'email')))
self.assertTrue(unicode(category))
class PartyCase( ModelThreadTestCase ):
"""Test the build in party - address - contact mechanism model"""
def setUp(self):
super( PartyCase, self ).setUp()
from camelot.admin.application_admin import ApplicationAdmin
self.session = Session()
self.app_admin = ApplicationAdmin()
self.person_admin = self.app_admin.get_related_admin( party.Person )
self.organization_admin = self.app_admin.get_related_admin( party.Organization )
def tearDown(self):
self.session.expunge_all()
def test_party( self ):
p = party.Party()
self.assertFalse( p.name )
def test_geographic_boundary( self ):
belgium = party.Country.get_or_create( code = u'BE',
name = u'Belgium' )
self.assertTrue( unicode( belgium ) )
city = party.City.get_or_create( country = belgium,
code = '1000',
name = 'Brussels' )
return city
def test_address( self ):
city = self.test_geographic_boundary()
address = party.Address.get_or_create( street1 = 'Avenue Louise',
street2 = None,
city = city )
self.assertTrue( unicode( address ) )
return address
def test_party_address( self ):
city = self.test_geographic_boundary()
org = party.Organization( name = 'PSF' )
party_address = party.PartyAddress( party = org )
party_address.street1 = 'Avenue Louise 5'
party_address.street2 = 'Boite 4'
party_address.city = city
party_address_admin = party.AddressAdmin( self.app_admin, party.PartyAddress )
self.assertTrue( party_address.address in party_address_admin.get_compounding_objects( party_address ) )
self.assertTrue( party_address.address in self.session.new )
# everything should be flushed through the party admin
org_admin = self.app_admin.get_related_admin( party.Organization )
org_validator = org_admin.get_validator()
self.assertTrue( party_address in org_admin.get_compounding_objects( org ) )
org_admin.flush( org )
self.assertFalse( party_address.address in self.session.new )
party_address_admin.refresh( party_address )
# test hybrid property getters on Party and PartyAddress
self.assertEqual( party_address.street1, 'Avenue Louise 5' )
self.assertEqual( party_address.street2, 'Boite 4' )
self.assertEqual( party_address.city, city )
self.assertEqual( org.street1, 'Avenue Louise 5' )
self.assertEqual( org.street2, 'Boite 4' )
self.assertEqual( org.city, city )
self.assertTrue( unicode( party_address ) )
query = self.session.query( party.PartyAddress )
self.assertTrue( query.filter( party.PartyAddress.street1 == 'Avenue Louise 5' ).first() )
self.assertTrue( query.filter( party.PartyAddress.street2 == 'Boite 4' ).first() )
# if party address changes, party should be updated
depending_objects = list( party_address_admin.get_depending_objects( party_address ) )
self.assertTrue( org in depending_objects )
# if address changes, party address and party should be updated
address = party_address.address
address_admin = self.app_admin.get_related_admin( party.Address )
depending_objects = list( address_admin.get_depending_objects( address ) )
self.assertTrue( party_address in depending_objects )
self.assertTrue( org in depending_objects )
# test hybrid property setters on Party
org.street1 = 'Rue Belliard 1'
org.street2 = 'Second floor'
org.city = None
# expunge should expunge the related address objects as well, so
# after an expunge, the session as a whole can be flushed
org_admin.expunge( org )
self.session.flush()
# test hybrid property setters on a new party
org = party.Organization( name = 'PSF' )
org.street1 = 'Rue Belliard 1'
org.street2 = 'Second floor'
org.city = city
org_admin.flush( org )
self.assertEqual( len( org.addresses ), 1 )
self.assertEqual( org.street1, 'Rue Belliard 1' )
self.assertEqual( org.street2, 'Second floor' )
self.assertEqual( org.city, city )
# test invalidation of org object and refresh it
self.assertFalse( org_validator.validate_object( org ) )
org.city = None
self.assertTrue( org_validator.validate_object( org ) )
org_admin.refresh( org )
self.assertFalse( org_validator.validate_object( org ) )
# removing all the address properties should make the
# object valid again
org.street1 = None
org.street2 = None
org.city = None
self.assertFalse( org_validator.validate_object( org ) )
# removing all address properties of a not yet flushed
# address should expunge the address
org = party.Organization( name = 'PSF' )
org.street1 = 'Rue Belliard 1'
for address in org.addresses:
self.assertTrue( address in self.session.new )
org.street1 = None
self.assertTrue( address not in self.session )
self.assertEqual( len(org.addresses), 0 )
def test_person( self ):
person = party.Person( first_name = u'Robin',
last_name = u'The brave' )
self.assertEqual( person.email, None )
self.assertEqual( person.phone, None )
self.assertEqual( person.fax, None )
self.assertEqual( person.street1, None )
self.assertEqual( person.street2, None )
self.assertEqual( person.city, None )
self.person_admin.flush( person )
person2 = party.Person( first_name = u'Robin' )
self.assertFalse( person2.note )
person2.last_name = u'The brave'
# gui should warn this person exists
self.assertTrue( person2.note )
return person
def test_contact_mechanism( self ):
contact_mechanism = party.ContactMechanism( mechanism = (u'email', u'*****@*****.**') )
self.assertTrue( unicode( contact_mechanism ) )
def test_person_contact_mechanism( self ):
# create a new person
person = party.Person( first_name = u'Robin',
last_name = u'The brave' )
self.person_admin.flush( person )
self.assertEqual( person.email, None )
# set the contact mechanism
mechanism_1 = (u'email', u'*****@*****.**')
person.email = mechanism_1
# the default from and thru dates should be set when
# setting the party defaults
self.person_admin.set_defaults( person )
self.assertTrue( person.contact_mechanisms[0].from_date )
self.person_admin.flush( person )
self.assertEqual( person.email, mechanism_1 )
# change the contact mechanism, after a flush
mechanism_2 = (u'email', u'*****@*****.**')
person.email = mechanism_2
self.person_admin.flush( person )
self.assertEqual( person.email, mechanism_2 )
# remove the contact mechanism after a flush
person.email = ('email', '')
self.assertEqual( person.email, None )
self.person_admin.flush( person )
self.assertEqual( person.email, None )
admin = party.PartyContactMechanismAdmin( self.app_admin,
party.PartyContactMechanism )
contact_mechanism = party.ContactMechanism( mechanism = mechanism_1 )
party_contact_mechanism = party.PartyContactMechanism( party = person,
contact_mechanism = contact_mechanism )
admin.flush( party_contact_mechanism )
admin.refresh( party_contact_mechanism )
list( admin.get_depending_objects( party_contact_mechanism ) )
#
# if the contact mechanism changes, the party person should be
# updated as well
#
contact_mechanism_admin = self.app_admin.get_related_admin( party.ContactMechanism )
depending_objects = list( contact_mechanism_admin.get_depending_objects( contact_mechanism ) )
self.assertTrue( person in depending_objects )
self.assertTrue( party_contact_mechanism in depending_objects )
#
# if the party contact mechanism changes, the party should be updated
# as well
depending_objects = list( admin.get_depending_objects( party_contact_mechanism ) )
self.assertTrue( person in depending_objects )
# delete the person
self.person_admin.delete( person )
def test_organization( self ):
org = party.Organization( name = 'PSF' )
org.email = ('email', '*****@*****.**')
org.phone = ('phone', '1234')
org.fax = ('fax', '4567')
self.organization_admin.flush( org )
self.assertTrue( unicode( org ) )
self.assertEqual( org.number_of_shares_issued, 0 )
query = orm.object_session( org ).query( party.Organization )
self.assertTrue( query.filter( party.Organization.email == ('email', '*****@*****.**') ).first() )
self.assertTrue( query.filter( party.Organization.phone == ('phone', '1234') ).first() )
self.assertTrue( query.filter( party.Organization.fax == ('fax', '4567') ).first() )
return org
def test_party_relationship( self ):
person = self.test_person()
org = self.test_organization()
employee = party.EmployerEmployee( established_from = org,
established_to = person )
self.assertTrue( unicode( employee ) )
def test_party_contact_mechanism( self ):
person = self.test_person()
party_contact_mechanism = party.PartyContactMechanism( party = person )
party_contact_mechanism.mechanism = (u'email', u'*****@*****.**')
party_contact_mechanism.mechanism = (u'email', u'*****@*****.**')
self.assertTrue( party_contact_mechanism in self.session.new )
self.assertTrue( party_contact_mechanism.contact_mechanism in self.session.new )
# flushing trough the party should flush the contact mechanism
self.person_admin.flush( person )
self.assertFalse( party_contact_mechanism in self.session.new )
self.assertFalse( party_contact_mechanism.contact_mechanism in self.session.new )
self.assertTrue( unicode( party_contact_mechanism ) )
query = self.session.query( party.PartyContactMechanism )
self.assertTrue( query.filter( party.PartyContactMechanism.mechanism == (u'email', u'*****@*****.**') ).first() )
# party contact mechanism is only valid when contact mechanism is
# valid
party_contact_mechanism_admin = self.app_admin.get_related_admin( party.PartyContactMechanism )
compounding_objects = list( party_contact_mechanism_admin.get_compounding_objects( party_contact_mechanism ) )
self.assertTrue( party_contact_mechanism.contact_mechanism in compounding_objects )
party_contact_mechanism_validator = party_contact_mechanism_admin.get_validator()
self.assertFalse( party_contact_mechanism_validator.validate_object( party_contact_mechanism ) )
party_contact_mechanism.contact_mechanism.mechanism = None
self.assertTrue( party_contact_mechanism_validator.validate_object( party_contact_mechanism ) )
# the party is only valid when the contact mechanism is
# valid
party_admin = self.app_admin.get_related_admin( party.Person )
party_validator = party_admin.get_validator()
self.assertTrue( party_validator.validate_object( person ) )
def test_party_category( self ):
org = self.test_organization()
category = party.PartyCategory( name = u'Imortant' )
category.parties.append( org )
self.session.flush()
self.assertTrue( list( category.get_contact_mechanisms( u'email') ) )
self.assertTrue( unicode( category ) )
