def setUp( self ): super( CollectionProxyCase, self ).setUp() session = Session() self.collection = list( session.query( Person ).all() ) self.proxy = CollectionProxy( self.person_admin, collection_getter=lambda:self.collection, columns_getter=self.person_admin.get_columns )
def setUp(self): super(CollectionProxyCase, self).setUp() session = Session() self.collection = list(session.query(Person).all()) self.proxy = CollectionProxy( self.person_admin, collection_getter=lambda: self.collection, columns_getter=self.person_admin.get_columns)
def get_or_create( cls, username ): session = Session() authentication = session.query( cls ).filter_by( username = username ).first() if not authentication: authentication = cls( username = username ) session.add( authentication ) session.flush() return authentication
class SearchCase( unittest.TestCase ): """Test the creation of search queries""" def setUp( self ): metadata.bind = settings.ENGINE() metadata.create_all() self.session = Session() # # insert the value of i in each column of T, that can be searched for # for (i,name), definition in types_to_test.items(): value = self.value_for_type( definition, i ) t = T() setattr( t, name, value ) self.session.flush() self.admin = TAdmin() def value_for_type( self, definition, i ): value = i if issubclass( definition, sqlalchemy.types.DateTime ): value = datetime.datetime( year = 2000, month = 1, day = 1, hour = 1, minute = i ) elif issubclass( definition, sqlalchemy.types.Date ): value = datetime.date( year = 2000, month = 1, day = i%31 ) elif issubclass( definition, sqlalchemy.types.Time ): value = datetime.time( hour = 1, minute = i ) elif issubclass( definition, sqlalchemy.types.String ): value = str( i ) elif issubclass( definition, sqlalchemy.types.Boolean ): value = True return value def test_search_decorator( self ): """Verify it search works for most common types""" from camelot.view.search import create_entity_search_query_decorator for (i,name), definition in types_to_test.items(): value = self.value_for_type( definition, i ) # # @todo : search for types that need special conversion to string # is skipped for now because the test would become too # convoluted, this should work through a to_string field # attribute. # if isinstance( value, ( datetime.date, datetime.time, bool) ): continue string_value = str( value ) search_decorator = create_entity_search_query_decorator( self.admin, string_value ) query = self.session.query( T ) query = search_decorator( query ) #print query self.assertTrue( query.count() > 0 )
def model_run(self, model_context): from camelot.view.action_steps import (SelectFile, UpdateProgress, Refresh, FlushSession) select_files = SelectFile('Txt Files (*.txt *.csv);;All Files (*)') select_files.single = False file_names = yield select_files file_count = len(file_names) import os from camelot.core.orm import Session from rms.Model.ResurseUmane import ResurseUmane from rms.Model.Discipline import Discipline from rms.Model.OreSuplimentare import OreSuplimentare session = Session() for i, file_name in enumerate(file_names): yield UpdateProgress(i, file_count) f = open(file_name) info_prof = f.readline().split(";")[:-1] if session.query(Profesor).filter(Profesor.username == info_prof[0]).first() != None: raise UserException("Exista deja profesorul "+info_prof[2]) prof = Profesor(*info_prof) session.add(prof) for line in f: if line[-1] == ';': vals = line[:-1].split(',') else: vals = line[:-2].split(',') print(vals) try: vals[0] = int(vals[0]) oresup = OreSuplimentare(*vals) oresup.profesor = prof session.add(oresup) except ValueError: disc = Discipline(*vals) disc.titular = prof session.add(disc) yield FlushSession(session) # begin refresh yield Refresh() # end refresh
def get_current_version(cls, fixture_class=None, session=None): """Get the current version of the fixtures in the database for a certain fixture class. :param fixture_class: the fixture class for which to get the version :param session: the session to use to query the database, if `None` is given, the default Camelot session is used :return: an integer representing the current version, 0 if no version found """ if session is None: session = Session() obj = session.query(cls).filter_by(fixture_class=fixture_class).first() if obj: return obj.fixture_version return 0
def set_current_version(cls, fixture_class=None, fixture_version=0, session=None): """Set the current version of the fixtures in the database for a certain fixture class. :param fixture_class: the fixture class for which to get the version :param fixture_version: the version number to which to set the fixture version :param session: the session to use to query the database, if `None` is given, the default Camelot session is used """ if session is None: session = Session() obj = session.query(cls).filter_by(fixture_class=fixture_class).first() if not obj: obj = FixtureVersion(fixture_class=fixture_class, _session=session) obj.fixture_version = fixture_version session.flush()
def translate_or_register( cls, source, language ): """Translate source to language, if no translation is found, register the source as to be translated and return the source""" if source: source = unicode( source ) translation = cls.translate( source, language ) if not translation: session = Session() query = session.query( cls ) translation = query.filter_by( source = source, language = language ).first() if not translation: if ( source, language ) not in cls._cache: registered_translation = Translation( source = source, language = language ) cls._cache[( source, language )] = source session.flush( [registered_translation] ) logger.debug( 'registed %s with id %s' % ( source, registered_translation.id ) ) return source return translation return ''
def model_run(self, model_context): from camelot.view.action_steps import (SelectFile, UpdateProgress, Refresh, FlushSession) select_files = SelectFile('Txt Files (*.txt *.csv);;All Files (*)') select_files.single = False file_names = yield select_files file_count = len(file_names) import os from camelot.core.orm import Session from rms.Model.Orar import Orar session = Session() for i, file_name in enumerate(file_names): yield UpdateProgress(i, file_count) title = os.path.splitext(os.path.basename(file_name))[0] print(file_name) for line in open(file_name): vals = line.split(';')[:-1] if len(vals) != 8: raise ImportException("Fisierul nu e dat bine") if vals[2] not in ['0', '1', '2']: raise ImportException("Frecventa nu e data bine") print(vals) orar = Orar(*vals) print(orar) session.add(orar) disc = session.query(Discipline).filter(Discipline.disc==orar.disc).first() if disc: orar.disciplina = disc session.flush() yield FlushSession(session) # begin refresh yield Refresh() # end refresh
def translate_or_register(cls, source, language): """Translate source to language, if no translation is found, register the source as to be translated and return the source""" if source: source = unicode(source) translation = cls.translate(source, language) if not translation: session = Session() query = session.query(cls) translation = query.filter_by(source=source, language=language).first() if not translation: if (source, language) not in cls._cache: registered_translation = Translation(source=source, language=language) cls._cache[(source, language)] = source session.flush([registered_translation]) logger.debug('registed %s with id %s' % (source, registered_translation.id)) return source return translation return ''
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))
from camelot.core.orm import Session import os import sys sys.path.append(os.environ["GRADEBOOK_ROOT"]) import main # noqa from camelot.core.conf import settings settings.setup_model() # }}} session = Session() from gradebook.model import (Course, Student, StudentContactInfo) course, = session.query(Course).all() import csv with open('class-list.csv', 'rb') as csvfile: reader = csv.DictReader(csvfile, delimiter=";") for row in reader: print row ln = row["Last"] fn = row["First"] student = Student(first_name=unicode(fn.strip()), last_name=unicode(ln.strip()), user_name=unicode(row["NetID"]), course=course) session.add(student) session.add(StudentContactInfo(
# {{{ boilerplate from camelot.core.orm import Session import os, sys sys.path.append(os.environ["GRADEBOOK_ROOT"]) import main from camelot.core.conf import settings settings.setup_model() # }}} session = Session() from gradebook.model import Course for name in session.query(Course.name): print name session.flush()
import os, sys sys.path.append(os.environ["GRADEBOOK_ROOT"]) import main from camelot.core.conf import settings settings.setup_model() # }}} session = Session() from gradebook.model import (Student, Assignment, AssignmentStateChange as ASC) assignments = list(session.query(Assignment) .filter(Assignment.course_id == course_id) .filter(Assignment.kind == "homework") ) proj_pres, = list(session.query(Assignment) .filter(Assignment.course_id == course_id) .filter(Assignment.kind == "project") .filter(Assignment.number == 0) ) proj_report, = list(session.query(Assignment) .filter(Assignment.course_id == course_id) .filter(Assignment.kind == "project") .filter(Assignment.number == 1) )
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 ) )