def test_cutting_editor(self):
loc = Location(name=u'name', code=u'code')
plant = Plant(accession=self.accession, location=loc, code=u'1',
quantity=1)
propagation = Propagation()
plant.propagations.append(propagation)
self.editor = PropagationEditor(model=propagation)
widgets = self.editor.presenter.view.widgets
view = self.editor.presenter.view
view.set_widget_value('prop_type_combo', u'UnrootedCutting')
view.set_widget_value('prop_date_entry', utils.today_str())
cutting_presenter = self.editor.presenter._cutting_presenter
for widget, attr in cutting_presenter.widget_to_field_map.iteritems():
#debug('%s=%s' % (widget, default_cutting_values[attr]))
view.set_widget_value(widget, default_cutting_values[attr])
update_gui()
self.editor.handle_response(gtk.RESPONSE_OK)
self.editor.commit_changes()
model = self.editor.model
s = object_session(model)
s.expire(model)
self.assert_(model.prop_type == u'UnrootedCutting')
for attr, value in default_cutting_values.iteritems():
v = getattr(model._cutting, attr)
self.assert_(v==value, '%s = %s(%s)' % (attr, value, v))
self.editor.session.close()
def test_accession_editor(self):
acc = Accession(code=u'code', species=self.species)
self.editor = AccessionEditor(acc)
update_gui()
widgets = self.editor.presenter.view.widgets
# make sure there is a problem if the species entry text isn't
# a species string
widgets.acc_species_entry.set_text('asdasd')
assert self.editor.presenter.problems
# make sure the problem is removed if the species entry text
# is set to a species string
# fill in the completions
widgets.acc_species_entry.set_text(str(self.species)[0:3])
update_gui() # ensures idle callback is called to add completions
# set the fill string which should match from completions
widgets.acc_species_entry.set_text(str(self.species))
assert not self.editor.presenter.problems,self.editor.presenter.problems
# commit the changes and cleanup
self.editor.model.name = u'asda'
import gtk
self.editor.handle_response(gtk.RESPONSE_OK)
self.editor.session.close()
def test_seed_editor_load(self):
loc = Location(name=u'name', code=u'code')
plant = Plant(accession=self.accession, location=loc, code=u'1',
quantity=1)
propagation = Propagation(**default_propagation_values)
propagation.prop_type = u'Seed'
propagation._seed = PropSeed(**default_seed_values)
plant.propagations.append(propagation)
editor = PropagationEditor(model=propagation)
widgets = editor.presenter.view.widgets
seed_presenter = editor.presenter._seed_presenter
view = editor.presenter.view
update_gui()
# check that the values loaded correctly from the model in the
# editor widget
def get_widget_text(w):
if isinstance(w, gtk.TextView):
return w.get_buffer().props.text
elif isinstance(w, gtk.Entry):
return w.props.text
elif isinstance(w, gtk.ComboBoxEntry):
return w.get_active_text()
else:
raise ValueError('%s not supported' % type(w))
# make sure the default values match the values in the widgets
date_format = prefs.prefs[prefs.date_format_pref]
for widget, attr in editor.presenter.widget_to_field_map.iteritems():
if not attr in default_propagation_values:
continue
default = default_propagation_values[attr]
if isinstance(default, datetime.date):
default = default.strftime(date_format)
value = get_widget_text(widgets[widget])
self.assert_(value == default,
'%s = %s (%s)' % (attr, value, default))
# check the default for the PropSeed and SeedPresenter
for widget, attr in seed_presenter.widget_to_field_map.iteritems():
if not attr in default_seed_values:
continue
default = default_seed_values[attr]
if isinstance(default, datetime.date):
default = default.strftime(date_format)
if isinstance(default, int):
default = str(default)
value = get_widget_text(widgets[widget])
self.assert_(value == default,
'%s = %s (%s)' % (attr, value, default))
def test_accession_source_editor(self, accession=None):
acc = self.create(Accession, species=self.species, code=u'parent')
plant = self.create(Plant, accession=acc, quantity=1,
location=Location(name=u'site', code=u'STE'),
code=u'1')
# creating a dummy propagtion without a related seed/cutting
prop = self.create(Propagation, prop_type='Seed')
plant.propagations.append(prop)
self.session.commit()
plant_prop_id = prop.id
assert plant_prop_id # assert we got a valid id after the commit
acc = Accession(code=u'code', species=self.species)
self.editor = AccessionEditor(acc)
# normally called by editor.presenter.start() but we don't call it here
self.editor.presenter.source_presenter.start()
widgets = self.editor.presenter.view.widgets
update_gui()
# set the date so the presenter will be "dirty"
widgets.acc_date_recvd_entry.props.text = utils.today_str()
# set the source type as "Garden Propagation"
widgets.acc_source_comboentry.child.props.text = \
SourcePresenter.garden_prop_str
assert not self.editor.presenter.problems
# set the source plant
widgets.source_prop_plant_entry.props.text = str(plant)
update_gui()
comp = widgets.source_prop_plant_entry.get_completion()
comp.emit('match-selected', comp.get_model(),
comp.get_model().get_iter_first())
# assert that the propagations were added to the treevide
treeview = widgets.source_prop_treeview
assert treeview.get_model()
# select the first/only propagation in the treeview
toggle_cell = widgets.prop_toggle_cell.emit('toggled', 0)
# commit the changes and cleanup
import gtk
self.editor.handle_response(gtk.RESPONSE_OK)
self.editor.session.close()
# open a seperate session and make sure everything committed
session = db.Session()
acc = session.query(Accession).filter_by(code=u'code')[0]
parent = session.query(Accession).filter_by(code=u'parent')[0]
assert acc.source.plant_propagation_id == plant_prop_id
def test_seed_editor_commit(self):
loc = Location(name=u'name', code=u'code')
plant = Plant(accession=self.accession, location=loc, code=u'1',
quantity=1)
propagation = Propagation()
plant.propagations.append(propagation)
editor = PropagationEditor(model=propagation)
widgets = editor.presenter.view.widgets
seed_presenter = editor.presenter._seed_presenter
view = editor.presenter.view
# set default values in editor widgets
view.set_widget_value('prop_type_combo', u'Seed')
view.set_widget_value('prop_date_entry',
default_propagation_values['date'])
view.set_widget_value('notes_textview',
default_propagation_values['notes'])
for widget, attr in seed_presenter.widget_to_field_map.iteritems():
w = widgets[widget]
if isinstance(w, gtk.ComboBoxEntry) and not w.get_model():
widgets[widget].child.props.text = default_seed_values[attr]
view.set_widget_value(widget, default_seed_values[attr])
# update the editor, send the RESPONSE_OK signal and commit the changes
update_gui()
editor.handle_response(gtk.RESPONSE_OK)
editor.presenter.cleanup()
model_id = editor.model.id
editor.commit_changes()
editor.session.close()
s = db.Session()
propagation = s.query(Propagation).get(model_id)
self.assert_(propagation.prop_type == u'Seed')
# make sure the each value in default_seed_values matches the model
for attr, expected in default_seed_values.iteritems():
v = getattr(propagation._seed, attr)
if isinstance(v, datetime.date):
format = prefs.prefs[prefs.date_format_pref]
v = v.strftime(format)
if isinstance(expected, datetime.date):
expected = expected.strftime(format)
self.assert_(v==expected, '%s = %s(%s)' % (attr, expected, v))
for attr, expected in default_propagation_values.iteritems():
v = getattr(propagation, attr)
self.assert_(v==expected, '%s = %s(%s)' % (attr, expected, v))
s.close()
def test_branch_editor(self):
try:
import gtk
except ImportError:
raise SkipTest('could not import gtk')
# test argument checks
#
# TODO: these argument checks make future tests fail because
# the PlantEditor is never cleaned up
#
# self.assert_(PlantEditor())
# self.assertRaises(CheckConditionError, PlantEditor, branch_mode=True)
# plant = Plant(accession=self.accession, location=self.location,
# code=u'33', quantity=5)
# self.assertRaises(CheckConditionError, PlantEditor, model=plant,
# branch_mode=True)
#self.accession.plants.remove(plant) # remove from session
# TODO: test check where quantity < 2
quantity = 5
self.plant.quantity = quantity
self.session.commit()
self.editor = PlantEditor(model=self.plant, branch_mode=True)
update_gui()
widgets = self.editor.presenter.view.widgets
new_quantity = 2
widgets.plant_quantity_entry.props.text = new_quantity
update_gui()
self.editor.handle_response(gtk.RESPONSE_OK)
# there should only be three plants,
new_plant = self.session.query(Plant).\
filter(Plant.code != self.plant.code).first()
# test the quantity was set properly on the new plant
assert new_plant.quantity == new_quantity, new_plant.quantity
self.session.refresh(self.plant)
# test the quantity is updated on the original plant
assert self.plant.quantity == quantity - new_plant.quantity, \
"%s == %s - %s" % (plant.quantity, quantity, new_plant.quantity)
# test the quantity for the change is the same as the quantity
# for the plant
assert new_plant.changes[0].quantity == new_plant.quantity, \
"%s == %s" % (new_plant.changes[0].quantity, new_plant.quantity)
# test the parent_plant for the change is the same as the
# original plant
assert new_plant.changes[0].parent_plant == self.plant, \
'change.parent_plant != original plant'
def test_location_editor(self):
loc = self.create(Location, name=u'some site', code=u'STE')
self.session.commit()
editor = LocationEditor(model=loc)
update_gui()
widgets = editor.presenter.view.widgets
# test that the accept buttons are NOT sensitive since nothing
# has changed and that the text entries and model are the same
assert widgets.loc_name_entry.get_text() == loc.name
assert widgets.loc_code_entry.get_text() == loc.code
assert not widgets.loc_ok_button.props.sensitive
assert not widgets.loc_next_button.props.sensitive
# test the accept buttons become sensitive when the name entry
# is changed
widgets.loc_name_entry.set_text('something')
update_gui()
assert widgets.loc_ok_button.props.sensitive
assert widgets.loc_ok_and_add_button.props.sensitive
assert widgets.loc_next_button.props.sensitive
# test the accept buttons become NOT sensitive when the code
# entry is empty since this is a required field
widgets.loc_code_entry.set_text('')
update_gui()
assert not widgets.loc_ok_button.props.sensitive
assert not widgets.loc_ok_and_add_button.props.sensitive
assert not widgets.loc_next_button.props.sensitive
# test the accept buttons aren't sensitive from setting the textview
import gtk
buff = gtk.TextBuffer()
buff.set_text('saasodmadomad')
widgets.loc_desc_textview.set_buffer(buff)
assert not widgets.loc_ok_button.props.sensitive
assert not widgets.loc_ok_and_add_button.props.sensitive
assert not widgets.loc_next_button.props.sensitive
# commit the changes and cleanup
editor.model.name = editor.model.code = u'asda'
editor.handle_response(gtk.RESPONSE_OK)
editor.session.close()
editor.presenter.cleanup()
del editor
assert utils.gc_objects_by_type('LocationEditor') == [], \
'LocationEditor not deleted'
assert utils.gc_objects_by_type('LocationEditorPresenter') == [], \
'LocationEditorPresenter not deleted'
assert utils.gc_objects_by_type('LocationEditorView') == [], \
'LocationEditorView not deleted'
def test_bulk_plant_editor(self):
"""
Test creating multiple plants with the plant editor.
"""
try:
import gtk
except ImportError:
raise SkipTest('could not import gtk')
# use our own plant because PlantEditor.commit_changes() will
# only work in bulk mode when the plant is in session.new
p = Plant(accession=self.accession, location=self.location, code=u'2',
quantity=52)
self.editor = PlantEditor(model=p)
#editor.start()
update_gui()
rng = '2,3,4-6'
for code in utils.range_builder(rng):
q = self.session.query(Plant).join('accession').\
filter(and_(Accession.id==self.plant.accession.id,
Plant.code==utils.utf8(code)))
self.assert_(not q.first(), 'code already exists')
widgets = self.editor.presenter.view.widgets
# make sure the entry gets a Problem added to it if an
# existing plant code is used in bulk mode
widgets.plant_code_entry.set_text('1,' + rng)
widgets.plant_quantity_entry.set_text('2')
update_gui()
problem = (self.editor.presenter.PROBLEM_DUPLICATE_PLANT_CODE,
self.editor.presenter.view.widgets.plant_code_entry)
self.assert_(problem in self.editor.presenter.problems,
'no problem added for duplicate plant code')
# create multiple plant codes
widgets.plant_code_entry.set_text(rng)
update_gui()
self.editor.handle_response(gtk.RESPONSE_OK)
for code in utils.range_builder(rng):
q = self.session.query(Plant).join('accession').\
filter(and_(Accession.id==self.plant.accession.id,
Plant.code==utils.utf8(code)))
self.assert_(q.first(), 'plant %s.%s not created' % \
(self.accession, code))