def testGetOrCreate(self):
loc = CityLocation.get_or_create(self.store, u'City', u'State',
u'Country')
self.failUnless(loc)
self.assertEqual(loc.city, u'City')
self.assertEqual(loc.state, u'State')
self.assertEqual(loc.country, u'Country')
loc2 = CityLocation.get_or_create(self.store, u'city', u'state',
u'country')
self.failUnless(loc2)
self.assertEqual(loc2.city, u'City')
self.assertEqual(loc2.state, u'State')
self.assertEqual(loc2.country, u'Country')
self.assertEqual(loc2, loc)
location = CityLocation.get_or_create(self.store, u'São Carlos', u'SP',
u'Brazil')
for city, state, country in [(u'sao carlos', u'SP', u'Brazil'),
(u'Sao carlos', u'SP', u'Brazil'),
(u'São carlos', u'SP', u'Brazil'),
(u'sao Carlos', u'SP', u'Brazil'),
(u'sao Carlos', u'sp', u'Brazil'),
(u'sao Carlos', u'sp', u'brazil'),
(u'sao Carlos', u'Sp', u'brazil')]:
self.assertEqual(
CityLocation.get_or_create(self.store, city, state, country),
location)
for city, state, country in [(u'Sao', u'SP', u'Brazil'),
(u'sao', u'SP', u'Brazil'),
(u'Carlos', u'SP', u'Brazil'),
(u'carlos', u'SP', u'Brazil')]:
self.assertNotEqual(
CityLocation.get_or_create(self.store, city, state, country),
location)
def test_get_or_create(self):
loc = CityLocation.get_or_create(self.store, u'City', u'State',
u'Country')
self.failUnless(loc)
self.assertEqual(loc.city, u'City')
self.assertEqual(loc.state, u'State')
self.assertEqual(loc.country, u'Country')
loc2 = CityLocation.get_or_create(self.store, u'city', u'state',
u'country')
self.failUnless(loc2)
self.assertEqual(loc2.city, u'City')
self.assertEqual(loc2.state, u'State')
self.assertEqual(loc2.country, u'Country')
self.assertEqual(loc2, loc)
location = CityLocation.get_or_create(self.store, u'São Carlos', u'SP',
u'Brazil')
for city, state, country in [(u'sao carlos', u'SP', u'Brazil'),
(u'Sao carlos', u'SP', u'Brazil'),
(u'São carlos', u'SP', u'Brazil'),
(u'sao Carlos', u'SP', u'Brazil'),
(u'sao Carlos', u'sp', u'Brazil'),
(u'sao Carlos', u'sp', u'brazil'),
(u'sao Carlos', u'Sp', u'brazil')]:
self.assertEqual(
CityLocation.get_or_create(self.store, city, state, country),
location)
loc2 = CityLocation(store=self.store)
loc2.city = u'Sao Carlos'
loc2.state = u'SP'
loc2.country = u'Brazil'
loc2.city_code = 00000
location = CityLocation.get_or_create(self.store, u'São Carlos', u'SP',
u'Brazil')
self.assertEquals(location.city_code, 3548906)
loc3 = CityLocation(store=self.store)
loc3.city = u'City ABC'
loc3.state = u'SP'
loc3.country = u'Brazil'
loc3.city_code = None
loc4 = CityLocation(store=self.store)
loc4.city = u'City ABĆ'
loc4.state = u'SP'
loc4.country = u'Brazil'
loc4.city_code = None
location = CityLocation.get_or_create(self.store, u'City ABC', u'SP',
u'Brazil')
self.assertNotEquals(location, loc4)
loc4.city_code = 13560
location = CityLocation.get_or_create(self.store, u'City ABC', u'SP',
u'Brazil')
self.assertEquals(location, loc4)
for city, state, country in [(u'Sao', u'SP', 'Brazil'),
(u'carlos', decimal.Decimal(8), u'Brazil')
]:
with self.assertRaises(TypeError):
CityLocation.get_or_create(self.store, city, state, country)
def test_get_or_create(self):
loc = CityLocation.get_or_create(self.store, u'City',
u'State', u'Country')
self.failUnless(loc)
self.assertEqual(loc.city, u'City')
self.assertEqual(loc.state, u'State')
self.assertEqual(loc.country, u'Country')
loc2 = CityLocation.get_or_create(self.store, u'city',
u'state', u'country')
self.failUnless(loc2)
self.assertEqual(loc2.city, u'City')
self.assertEqual(loc2.state, u'State')
self.assertEqual(loc2.country, u'Country')
self.assertEqual(loc2, loc)
location = CityLocation.get_or_create(self.store, u'São Carlos',
u'SP', u'Brazil')
for city, state, country in [
(u'sao carlos', u'SP', u'Brazil'),
(u'Sao carlos', u'SP', u'Brazil'),
(u'São carlos', u'SP', u'Brazil'),
(u'sao Carlos', u'SP', u'Brazil'),
(u'sao Carlos', u'sp', u'Brazil'),
(u'sao Carlos', u'sp', u'brazil'),
(u'sao Carlos', u'Sp', u'brazil')]:
self.assertEqual(CityLocation.get_or_create(self.store, city,
state, country),
location)
loc2 = CityLocation(store=self.store)
loc2.city = u'Sao Carlos'
loc2.state = u'SP'
loc2.country = u'Brazil'
loc2.city_code = 00000
location = CityLocation.get_or_create(self.store, u'São Carlos',
u'SP', u'Brazil')
self.assertEquals(location.city_code, 3548906)
loc3 = CityLocation(store=self.store)
loc3.city = u'City ABC'
loc3.state = u'SP'
loc3.country = u'Brazil'
loc3.city_code = None
loc4 = CityLocation(store=self.store)
loc4.city = u'City ABĆ'
loc4.state = u'SP'
loc4.country = u'Brazil'
loc4.city_code = None
location = CityLocation.get_or_create(self.store, u'City ABC',
u'SP', u'Brazil')
self.assertNotEquals(location, loc4)
loc4.city_code = 13560
location = CityLocation.get_or_create(self.store, u'City ABC',
u'SP', u'Brazil')
self.assertEquals(location, loc4)
for city, state, country in [(u'Sao', u'SP', 'Brazil'),
(u'carlos', decimal.Decimal(8), u'Brazil')]:
with self.assertRaises(TypeError):
CityLocation.get_or_create(self.store, city, state, country)
def process_one(self, data, fields, store):
person = Person(
store=store,
name=data.name,
phone_number=data.phone_number,
mobile_number=data.mobile_number)
Company(person=person,
store=store,
cnpj=data.cnpj,
fancy_name=data.name,
state_registry=data.state_registry)
ctloc = CityLocation.get_or_create(store=store,
city=data.city,
state=data.state,
country=data.country)
streetnumber = data.streetnumber and int(data.streetnumber) or None
Address(
is_main_address=True,
person=person,
city_location=ctloc,
store=store,
street=data.street,
streetnumber=streetnumber,
district=data.district
)
supplier = Supplier(person=person, store=store)
self.suppliers.append(supplier)
def process_one(self, data, fields, store):
person = Person(
store=store,
name=data.name,
phone_number=data.phone_number,
mobile_number=data.mobile_number)
Individual(person=person,
store=store,
cpf=data.cpf,
rg_number=data.rg)
ctloc = CityLocation.get_or_create(store=store,
city=data.city,
state=data.state,
country=data.country)
streetnumber = data.streetnumber and int(data.streetnumber) or None
Address(
is_main_address=True,
person=person,
city_location=ctloc,
store=store,
street=data.street,
streetnumber=streetnumber,
district=data.district
)
Client(person=person, store=store)
def process_one(self, data, fields, store):
person = Person(store=store,
name=data.name,
phone_number=data.phone_number,
mobile_number=data.mobile_number)
Company(person=person,
store=store,
cnpj=data.cnpj,
fancy_name=data.name,
state_registry=data.state_registry)
ctloc = CityLocation.get_or_create(store=store,
city=data.city,
state=data.state,
country=data.country)
streetnumber = data.streetnumber and int(data.streetnumber) or None
Address(is_main_address=True,
person=person,
city_location=ctloc,
store=store,
street=data.street,
streetnumber=streetnumber,
district=data.district)
Transporter(person=person,
open_contract_date=self.parse_date(data.open_contract),
freight_percentage=decimal.Decimal(
data.freight_percentage),
store=store)
def process_one(self, data, fields, store):
person = Person(
store=store,
name=data.name,
phone_number=data.phone_number,
mobile_number=data.mobile_number)
Company(person=person,
store=store,
cnpj=data.cnpj,
fancy_name=data.name,
state_registry=data.state_registry)
ctloc = CityLocation.get_or_create(store=store,
city=data.city,
state=data.state,
country=data.country)
streetnumber = data.streetnumber and int(data.streetnumber) or None
Address(
is_main_address=True,
person=person,
city_location=ctloc,
store=store,
street=data.street,
streetnumber=streetnumber,
district=data.district
)
dict(open_contract_date=self.parse_date(data.open_contract),
freight_percentage=data.freight_percentage),
Transporter(person=person, store=store)
def process_one(self, data, fields, store):
person = Person(
store=store,
name=data.name,
phone_number=data.phone_number,
mobile_number=data.mobile_number)
Individual(person=person,
store=store,
cpf=data.cpf,
rg_number=data.rg)
ctloc = CityLocation.get_or_create(store=store,
city=data.city,
state=data.state,
country=data.country)
streetnumber = data.streetnumber and int(data.streetnumber) or None
Address(
is_main_address=True,
person=person,
city_location=ctloc,
store=store,
street=data.street,
streetnumber=streetnumber,
district=data.district
)
Client(person=person, store=store)
def process_one(self, data, fields, store):
person = Person(store=store,
name=data.name,
phone_number=data.phone_number,
mobile_number=data.mobile_number)
Company(person=person,
store=store,
cnpj=data.cnpj,
fancy_name=data.name,
state_registry=data.state_registry)
ctloc = CityLocation.get_or_create(store=store,
city=data.city,
state=data.state,
country=data.country)
streetnumber = data.streetnumber and int(data.streetnumber) or None
Address(is_main_address=True,
person=person,
city_location=ctloc,
store=store,
street=data.street,
streetnumber=streetnumber,
district=data.district)
Supplier(person=person, store=store)
def process_one(self, data, fields, store):
person = Person(store=store,
name=data.name,
phone_number=data.phone_number,
fax_number=data.fax_number)
Company(person=person,
cnpj=data.cnpj,
state_registry=data.state_registry,
fancy_name=data.fancy_name,
store=store)
ctloc = CityLocation.get_or_create(store=store,
city=data.city,
state=data.state,
country=data.country)
streetnumber = data.streetnumber and int(data.streetnumber) or None
Address(is_main_address=True,
person=person,
city_location=ctloc,
store=store,
street=data.street,
streetnumber=streetnumber,
district=data.district,
postal_code=data.postal_code)
branch = Branch(person=person, store=store)
for user in store.find(LoginUser):
user.add_access_to(branch)
self.branches.append(branch)
def process_one(self, data, fields, store):
person = Person(
store=store,
name=data.name,
phone_number=data.phone_number,
fax_number=data.fax_number)
Company(person=person, cnpj=data.cnpj,
state_registry=data.state_registry,
fancy_name=data.fancy_name,
store=store)
ctloc = CityLocation.get_or_create(store=store,
city=data.city,
state=data.state,
country=data.country)
streetnumber = data.streetnumber and int(data.streetnumber) or None
Address(
is_main_address=True,
person=person,
city_location=ctloc,
store=store,
street=data.street,
streetnumber=streetnumber,
district=data.district,
postal_code=data.postal_code
)
branch = Branch(person=person, store=store)
for user in store.find(LoginUser):
user.add_access_to(branch)
def create_city_location(self, city=None, state=None, country=None):
from stoqlib.domain.address import CityLocation
return CityLocation.get_or_create(
self.store,
country=country or u'United States',
city=city or u'Los Angeles',
state=state or u'Californa',
)
def ensure_birth_location(self):
changed = self.birth_location_changed()
if changed:
self.target.birth_location = CityLocation.get_or_create(
city=self.city,
state=self.state,
country=self.country,
store=self.store)
def ensure_birth_location(self):
changed = self.birth_location_changed()
if changed:
self.target.birth_location = CityLocation.get_or_create(
city=self.city,
state=self.state,
country=self.country,
store=self.store)
def ensure_address(self):
changed = self._city_location_changed()
if changed:
location = CityLocation.get_or_create(city=self.city,
state=self.state,
country=self.country,
store=self.store)
self.target.city_location = location
def create_city_location(self, city=None, state=None, country=None):
from stoqlib.domain.address import CityLocation
return CityLocation.get_or_create(
self.store,
country=country or u'United States',
city=city or u'Los Angeles',
state=state or u'Californa',
)
def test_get_cities_by(self):
location = CityLocation.get_or_create(self.store, u'Sao Carlos',
u'SP', u'Brazil')
for state, country in [
(u'SP', u'Brazil'),
(u'Sp', u'brazil'),
(u'SP', u'brazil'),
(u'sp', u'Brazil'),
(u'sp', u'BraZIL'),
(None, u'Brazil'),
(u'SP', None),
(None, None)]:
self.assertTrue(location.city in
CityLocation.get_cities_by(self.store,
state=state,
country=country))
for state, country in [
(u'SP', u'Brazi'),
(u'RJ', u'Brazil'),
(u'RJ', None),
(u'BA', None),
(u'SP', u'Albânia')]:
self.assertFalse(location.city in
CityLocation.get_cities_by(self.store,
state=state,
country=country))
# Make sure no duplicates are returned
CityLocation.get_or_create(self.store, u'Sao Carlos', u'SP', u'BR')
CityLocation.get_or_create(self.store, u'Sao Carlos', u'SP', u'BR_')
CityLocation.get_or_create(self.store, u'Sao Carlos', u'SP', u'BR__')
cities = list(CityLocation.get_cities_by(self.store, state=u'SP'))
self.assertEqual(len(cities), len(set(cities)))
def testGetCitiesBy(self):
location = CityLocation.get_or_create(self.store, u'Sao Carlos',
u'SP', u'Brazil')
for state, country in [
(u'SP', u'Brazil'),
(u'Sp', u'brazil'),
(u'SP', u'brazil'),
(u'sp', u'Brazil'),
(u'sp', u'BraZIL'),
(None, u'Brazil'),
(u'SP', None),
(None, None),
]:
self.assertTrue(location.city in
CityLocation.get_cities_by(self.store,
state=state,
country=country))
for state, country in [
(u'SP', u'Brazi'),
(u'RJ', u'Brazil'),
(u'RJ', None),
(u'BA', None),
(u'SP', u'Albânia'),
]:
self.assertFalse(location.city in
CityLocation.get_cities_by(self.store,
state=state,
country=country))
# Make sure no duplicates are returned
CityLocation.get_or_create(self.store, u'Sao Carlos', u'SP', u'BR')
CityLocation.get_or_create(self.store, u'Sao Carlos', u'SP', u'BR_')
CityLocation.get_or_create(self.store, u'Sao Carlos', u'SP', u'BR__')
cities = list(CityLocation.get_cities_by(self.store, state=u'SP'))
self.assertEqual(len(cities), len(set(cities)))
def ensure_address(self):
changed = self._city_location_changed()
if changed:
location = CityLocation.get_or_create(
city=self.city,
state=self.state,
country=self.country,
store=self.store)
self.target.city_location = location
def testGetOrCreate(self):
loc = CityLocation.get_or_create(self.store, u'City',
u'State', u'Country')
self.failUnless(loc)
self.assertEqual(loc.city, u'City')
self.assertEqual(loc.state, u'State')
self.assertEqual(loc.country, u'Country')
loc2 = CityLocation.get_or_create(self.store, u'city',
u'state', u'country')
self.failUnless(loc2)
self.assertEqual(loc2.city, u'City')
self.assertEqual(loc2.state, u'State')
self.assertEqual(loc2.country, u'Country')
self.assertEqual(loc2, loc)
location = CityLocation.get_or_create(self.store, u'São Carlos',
u'SP', u'Brazil')
for city, state, country in [
(u'sao carlos', u'SP', u'Brazil'),
(u'Sao carlos', u'SP', u'Brazil'),
(u'São carlos', u'SP', u'Brazil'),
(u'sao Carlos', u'SP', u'Brazil'),
(u'sao Carlos', u'sp', u'Brazil'),
(u'sao Carlos', u'sp', u'brazil'),
(u'sao Carlos', u'Sp', u'brazil'),
]:
self.assertEqual(CityLocation.get_or_create(self.store, city,
state, country),
location)
for city, state, country in [
(u'Sao', u'SP', u'Brazil'),
(u'sao', u'SP', u'Brazil'),
(u'Carlos', u'SP', u'Brazil'),
(u'carlos', u'SP', u'Brazil'),
]:
self.assertNotEqual(CityLocation.get_or_create(self.store, city,
state, country),
location)
def process_one(self, data, fields, store):
person = Person(
store=store,
name=data.name,
phone_number=data.phone_number,
mobile_number=data.mobile_number)
Individual(person=person,
store=store,
cpf=data.cpf,
rg_number=data.rg)
role = EmployeeRole(store=store, name=data.role)
employee = Employee(person=person,
store=store,
role=role,
salary=int(data.salary),
registry_number=data.employee_number)
start = self.parse_date(data.start)
EmployeeRoleHistory(
store=store, role=role,
employee=employee,
is_active=True,
began=start,
salary=int(data.salary))
ctloc = CityLocation.get_or_create(store=store,
city=data.city,
state=data.state,
country=data.country)
streetnumber = data.streetnumber and int(data.streetnumber) or None
Address(is_main_address=True,
person=person,
city_location=ctloc,
store=store,
street=data.street,
streetnumber=streetnumber,
district=data.district)
if self.create_users:
profile = store.find(UserProfile, name=data.profile).one()
LoginUser(person=person, store=store, profile=profile,
username=data.username,
password=data.password)
SalesPerson(person=person, store=store)
def testConfirm(self, info):
city_location = CityLocation.get_or_create(self.store, u"São Carlos",
u"SP", u"Brazil")
person = self.create_person()
address = self.create_address(person=person,
city_location=city_location)
editor = AddressEditor(self.store, person, address)
address_slave = editor.address_slave
self.assertSensitive(editor.main_dialog, ['ok_button'])
valid_city = address_slave.city.read()
# Trying to confirm the editor without leaving the entry.
# Can be reproduced by pressing ALT+O
address_slave.city.grab_focus()
address_slave.city.update("INVALID CITY")
self.assertValid(address_slave, ['city'])
self.assertSensitive(editor.main_dialog, ['ok_button'])
self.assertFalse(editor.confirm())
self.assertInvalid(address_slave, ['city'])
info.assert_called_once_with("The city is not valid")
# When city looses focus, validation should be done
address_slave.city.update(valid_city)
self.assertSensitive(editor.main_dialog, ['ok_button'])
address_slave.city.grab_focus()
address_slave.city.update("INVALID CITY")
# FIXME: For some reason, this only works here when grabbing the focus
# on another widget and emitting the focus-out event. On the real
# editor, pressing TAB or even trying to click on Ok is enough
address_slave.state.grab_focus()
address_slave.city.emit('focus-out-event',
gtk.gdk.Event(gtk.gdk.FOCUS_CHANGE))
self.assertNotSensitive(editor.main_dialog, ['ok_button'])
self.assertInvalid(address_slave, ['city'])
address_slave.city.update(valid_city)
self.assertValid(address_slave, ['city'])
self.assertSensitive(editor.main_dialog, ['ok_button'])
path = 'stoqlib.domain.address.CityLocation.is_valid_model'
with mock.patch(path) as is_valid_model:
is_valid_model.return_value = False
self.assertFalse(editor.validate_confirm())
self.assertFalse(editor.confirm())
self.assertTrue(editor.validate_confirm())
self.assertTrue(editor.confirm())
def testConfirm(self, info):
city_location = CityLocation.get_or_create(
self.store, u"São Carlos", u"SP", u"Brazil")
person = self.create_person()
address = self.create_address(person=person,
city_location=city_location)
editor = AddressEditor(self.store, person, address)
address_slave = editor.address_slave
self.assertSensitive(editor.main_dialog, ['ok_button'])
valid_city = address_slave.city.read()
# Trying to confirm the editor without leaving the entry.
# Can be reproduced by pressing ALT+O
address_slave.city.grab_focus()
address_slave.city.update("INVALID CITY")
self.assertValid(address_slave, ['city'])
self.assertSensitive(editor.main_dialog, ['ok_button'])
self.assertFalse(editor.confirm())
self.assertInvalid(address_slave, ['city'])
info.assert_called_once_with("The city is not valid")
# When city looses focus, validation should be done
address_slave.city.update(valid_city)
self.assertSensitive(editor.main_dialog, ['ok_button'])
address_slave.city.grab_focus()
address_slave.city.update("INVALID CITY")
# FIXME: For some reason, this only works here when grabbing the focus
# on another widget and emitting the focus-out event. On the real
# editor, pressing TAB or even trying to click on Ok is enough
address_slave.state.grab_focus()
address_slave.city.emit('focus-out-event',
gtk.gdk.Event(gtk.gdk.FOCUS_CHANGE))
self.assertNotSensitive(editor.main_dialog, ['ok_button'])
self.assertInvalid(address_slave, ['city'])
address_slave.city.update(valid_city)
self.assertValid(address_slave, ['city'])
self.assertSensitive(editor.main_dialog, ['ok_button'])
path = 'stoqlib.domain.address.CityLocation.is_valid_model'
with mock.patch(path) as is_valid_model:
is_valid_model.return_value = False
self.assertFalse(editor.validate_confirm())
self.assertFalse(editor.confirm())
self.assertTrue(editor.validate_confirm())
self.assertTrue(editor.confirm())
