rattail/rattail
2
0
Fork 0
Code Issues 7 Pull requests Actions Packages Projects Releases Wiki Activity

Merge branch 'master' of ssh://edbob.org/srv/git/rattail

Browse source
This commit is contained in:
Lance Edgar 2013-12-21 10:04:55 -08:00
parent d55cb2e269 aaabe51804
commit e1b4d78256
5 changed files with 42 additions and 42 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

48
tests/db/sync/test_init.py
View file

@ -15,8 +15,8 @@ class SynchronizerTests(SyncTestCase):
def test_init(self): def test_init(self):
synchronizer = sync.Synchronizer(self.local_engine, self.remote_engines) synchronizer = sync.Synchronizer(self.local_engine, self.remote_engines)
self.assertIs(synchronizer.local_engine, self.local_engine) self.assertTrue(synchronizer.local_engine is self.local_engine)
self.assertIs(synchronizer.remote_engines, self.remote_engines) self.assertTrue(synchronizer.remote_engines is self.remote_engines)
def test_loop(self): def test_loop(self):
@ -60,7 +60,7 @@ class SynchronizerTests(SyncTestCase):
self.assertEqual(synchronize_changes.call_count, 1) self.assertEqual(synchronize_changes.call_count, 1)
# call_args is a tuple of (args, kwargs) - first element of args should be our 2 changes # call_args is a tuple of (args, kwargs) - first element of args should be our 2 changes
self.assertEqual(len(synchronize_changes.call_args[0][0]), 2) self.assertEqual(len(synchronize_changes.call_args[0][0]), 2)
self.assertIsInstance(synchronize_changes.call_args[0][0][0], model.Change) self.assertTrue(isinstance(synchronize_changes.call_args[0][0][0], model.Change))
def test_synchronize_changes(self): def test_synchronize_changes(self):
synchronizer = sync.Synchronizer(self.local_engine, self.remote_engines) synchronizer = sync.Synchronizer(self.local_engine, self.remote_engines)
@ -173,18 +173,18 @@ class SynchronizerTests(SyncTestCase):
source_product = model.Product() source_product = model.Product()
local_session.add(source_product) local_session.add(source_product)
local_session.flush() local_session.flush()
self.assertIsNone(source_product.regular_price_uuid) self.assertTrue(source_product.regular_price_uuid is None)
self.assertIsNone(source_product.regular_price) self.assertTrue(source_product.regular_price is None)
self.assertIsNone(source_product.current_price_uuid) self.assertTrue(source_product.current_price_uuid is None)
self.assertIsNone(source_product.current_price) self.assertTrue(source_product.current_price is None)
target_product = synchronizer.merge_Product(remote_session, source_product) target_product = synchronizer.merge_Product(remote_session, source_product)
self.assertIsNotNone(target_product) self.assertFalse(target_product is None)
self.assertIsNot(source_product, target_product) self.assertFalse(source_product is target_product)
self.assertEqual(source_product.uuid, target_product.uuid) self.assertEqual(source_product.uuid, target_product.uuid)
self.assertIsNone(target_product.regular_price_uuid) self.assertTrue(target_product.regular_price_uuid is None)
self.assertIsNone(target_product.regular_price) self.assertTrue(target_product.regular_price is None)
self.assertIsNone(target_product.current_price_uuid) self.assertTrue(target_product.current_price_uuid is None)
self.assertIsNone(target_product.current_price) self.assertTrue(target_product.current_price is None)
local_session.rollback() local_session.rollback()
local_session.close() local_session.close()
remote_session.rollback() remote_session.rollback()
@ -199,11 +199,11 @@ class SynchronizerTests(SyncTestCase):
source_product.regular_price = regular_price source_product.regular_price = regular_price
local_session.add(source_product) local_session.add(source_product)
local_session.flush() local_session.flush()
self.assertIsNotNone(source_product.regular_price_uuid) self.assertFalse(source_product.regular_price_uuid is None)
self.assertIsNotNone(source_product.regular_price) self.assertFalse(source_product.regular_price is None)
target_product = synchronizer.merge_Product(remote_session, source_product) target_product = synchronizer.merge_Product(remote_session, source_product)
self.assertEqual(target_product.regular_price_uuid, source_product.regular_price_uuid) self.assertEqual(target_product.regular_price_uuid, source_product.regular_price_uuid)
self.assertIsNotNone(target_product.regular_price) self.assertFalse(target_product.regular_price is None)
local_session.rollback() local_session.rollback()
local_session.close() local_session.close()
remote_session.rollback() remote_session.rollback()
@ -218,11 +218,11 @@ class SynchronizerTests(SyncTestCase):
source_product.current_price = current_price source_product.current_price = current_price
local_session.add(source_product) local_session.add(source_product)
local_session.flush() local_session.flush()
self.assertIsNotNone(source_product.current_price_uuid) self.assertFalse(source_product.current_price_uuid is None)
self.assertIsNotNone(source_product.current_price) self.assertFalse(source_product.current_price is None)
target_product = synchronizer.merge_Product(remote_session, source_product) target_product = synchronizer.merge_Product(remote_session, source_product)
self.assertEqual(target_product.current_price_uuid, source_product.current_price_uuid) self.assertEqual(target_product.current_price_uuid, source_product.current_price_uuid)
self.assertIsNotNone(target_product.current_price) self.assertFalse(target_product.current_price is None)
local_session.rollback() local_session.rollback()
local_session.close() local_session.close()
remote_session.rollback() remote_session.rollback()
@ -269,7 +269,7 @@ class SynchronizerTests(SyncTestCase):
synchronizer.delete_Department(session, department) synchronizer.delete_Department(session, department)
self.assertEqual(session.query(model.Subdepartment).count(), 1) self.assertEqual(session.query(model.Subdepartment).count(), 1)
subdepartment = session.query(model.Subdepartment).one() subdepartment = session.query(model.Subdepartment).one()
self.assertIsNone(subdepartment.department_uuid) self.assertTrue(subdepartment.department_uuid is None)
session.rollback() session.rollback()
session.close() session.close()
@ -282,7 +282,7 @@ class SynchronizerTests(SyncTestCase):
self.assertEqual(product.department_uuid, department.uuid) self.assertEqual(product.department_uuid, department.uuid)
synchronizer.delete_Department(session, department) synchronizer.delete_Department(session, department)
product = session.query(model.Product).one() product = session.query(model.Product).one()
self.assertIsNone(product.department_uuid) self.assertTrue(product.department_uuid is None)
session.rollback() session.rollback()
session.close() session.close()
@ -298,7 +298,7 @@ class SynchronizerTests(SyncTestCase):
self.assertEqual(product.subdepartment_uuid, subdepartment.uuid) self.assertEqual(product.subdepartment_uuid, subdepartment.uuid)
synchronizer.delete_Subdepartment(session, subdepartment) synchronizer.delete_Subdepartment(session, subdepartment)
product = session.query(model.Product).one() product = session.query(model.Product).one()
self.assertIsNone(product.subdepartment_uuid) self.assertTrue(product.subdepartment_uuid is None)
session.rollback() session.rollback()
session.close() session.close()
@ -314,7 +314,7 @@ class SynchronizerTests(SyncTestCase):
self.assertEqual(product.family_uuid, family.uuid) self.assertEqual(product.family_uuid, family.uuid)
synchronizer.delete_Family(session, family) synchronizer.delete_Family(session, family)
product = session.query(model.Product).one() product = session.query(model.Product).one()
self.assertIsNone(product.family_uuid) self.assertTrue(product.family_uuid is None)
session.rollback() session.rollback()
session.close() session.close()
@ -359,7 +359,7 @@ class ModuleTests(TestCase):
# nothing configured # nothing configured
edbob.config.get.return_value = None edbob.config.get.return_value = None
self.assertIsNone(sync.get_sync_engines()) self.assertTrue(sync.get_sync_engines() is None)
# fake config with 2 out of 3 engines synced # fake config with 2 out of 3 engines synced
get_engines.return_value = { get_engines.return_value = {

2
tests/db/test_changes.py
View file

@ -104,7 +104,7 @@ class TestChangeRecorder(TestCase):
uuid_column.foreign_keys = False uuid_column.foreign_keys = False
get_uuid.return_value = 'another_uuid' get_uuid.return_value = 'another_uuid'
product = Product() product = Product()
self.assertIsNone(product.uuid) self.assertTrue(product.uuid is None)
recorder.ensure_uuid(product) recorder.ensure_uuid(product)
get_uuid.assert_called_once_with() get_uuid.assert_called_once_with()
self.assertEqual(product.uuid, 'another_uuid') self.assertEqual(product.uuid, 'another_uuid')

6
tests/db/test_core.py
View file

@ -9,15 +9,15 @@ class TestCore(TestCase):
def test_uuid_column(self): def test_uuid_column(self):
column = core.uuid_column() column = core.uuid_column()
self.assertIsInstance(column, Column) self.assertTrue(isinstance(column, Column))
self.assertEqual(column.name, None) self.assertEqual(column.name, None)
self.assertTrue(column.primary_key) self.assertTrue(column.primary_key)
self.assertFalse(column.nullable) self.assertFalse(column.nullable)
self.assertIsNotNone(column.default) self.assertFalse(column.default is None)
def test_uuid_column_no_default(self): def test_uuid_column_no_default(self):
column = core.uuid_column(default=None) column = core.uuid_column(default=None)
self.assertIsNone(column.default) self.assertTrue(column.default is None)
def test_uuid_column_nullable(self): def test_uuid_column_nullable(self):
column = core.uuid_column(nullable=True) column = core.uuid_column(nullable=True)

26
tests/db/test_model.py
View file

@ -27,12 +27,12 @@ class TestBatch(TestCase):
rowclass = batch.rowclass rowclass = batch.rowclass
self.assertTrue(issubclass(rowclass, model.BatchRow)) self.assertTrue(issubclass(rowclass, model.BatchRow))
self.assertEqual(model.Batch._rowclasses.keys(), ['some_uuid']) self.assertEqual(model.Batch._rowclasses.keys(), ['some_uuid'])
self.assertIs(model.Batch._rowclasses['some_uuid'], rowclass) self.assertTrue(model.Batch._rowclasses['some_uuid'] is rowclass)
self.assertFalse(object_session.flush.called) self.assertFalse(object_session.flush.called)
# make sure rowclass.batch works # make sure rowclass.batch works
object_session.query.return_value.get.return_value = batch object_session.query.return_value.get.return_value = batch
self.assertIs(rowclass().batch, batch) self.assertTrue(rowclass().batch is batch)
object_session.query.return_value.get.assert_called_once_with('some_uuid') object_session.query.return_value.get.assert_called_once_with('some_uuid')
# row class with generated uuid and some columns # row class with generated uuid and some columns
@ -44,25 +44,25 @@ class TestBatch(TestCase):
object_session.flush.side_effect = set_uuid object_session.flush.side_effect = set_uuid
rowclass = batch.rowclass rowclass = batch.rowclass
object_session.flush.assert_called_once_with() object_session.flush.assert_called_once_with()
self.assertItemsEqual(model.Batch._rowclasses.keys(), ['some_uuid', 'fresh_uuid']) self.assertEqual(sorted(model.Batch._rowclasses.keys()), sorted(['some_uuid', 'fresh_uuid']))
self.assertIs(model.Batch._rowclasses['fresh_uuid'], rowclass) self.assertTrue(model.Batch._rowclasses['fresh_uuid'] is rowclass)
def test_get_sqlalchemy_type(self): def test_get_sqlalchemy_type(self):
# gpc # gpc
self.assertIsInstance(model.Batch.get_sqlalchemy_type('GPC(14)'), GPCType) self.assertTrue(isinstance(model.Batch.get_sqlalchemy_type('GPC(14)'), GPCType))
# boolean # boolean
self.assertIsInstance(model.Batch.get_sqlalchemy_type('FLAG(1)'), Boolean) self.assertTrue(isinstance(model.Batch.get_sqlalchemy_type('FLAG(1)'), Boolean))
# string # string
type_ = model.Batch.get_sqlalchemy_type('CHAR(20)') type_ = model.Batch.get_sqlalchemy_type('CHAR(20)')
self.assertIsInstance(type_, String) self.assertTrue(isinstance(type_, String))
self.assertEqual(type_.length, 20) self.assertEqual(type_.length, 20)
# numeric # numeric
type_ = model.Batch.get_sqlalchemy_type('NUMBER(9,3)') type_ = model.Batch.get_sqlalchemy_type('NUMBER(9,3)')
self.assertIsInstance(type_, Numeric) self.assertTrue(isinstance(type_, Numeric))
self.assertEqual(type_.precision, 9) self.assertEqual(type_.precision, 9)
self.assertEqual(type_.scale, 3) self.assertEqual(type_.scale, 3)
@ -233,10 +233,10 @@ class TestLabelProfile(DataTestCase):
profile = model.LabelProfile() profile = model.LabelProfile()
self.session.add(profile) self.session.add(profile)
self.assertIsNone(profile.uuid) self.assertTrue(profile.uuid is None)
setting = profile.get_printer_setting('some_setting') setting = profile.get_printer_setting('some_setting')
self.assertIsNone(setting) self.assertTrue(setting is None)
self.assertIsNone(profile.uuid) self.assertTrue(profile.uuid is None)
profile.uuid = 'some_uuid' profile.uuid = 'some_uuid'
self.session.add(model.Setting( self.session.add(model.Setting(
@ -251,9 +251,9 @@ class TestLabelProfile(DataTestCase):
profile = model.LabelProfile() profile = model.LabelProfile()
self.session.add(profile) self.session.add(profile)
self.assertIsNone(profile.uuid) self.assertTrue(profile.uuid is None)
profile.save_printer_setting('some_setting', 'some_value') profile.save_printer_setting('some_setting', 'some_value')
self.assertIsNotNone(profile.uuid) self.assertFalse(profile.uuid is None)
self.assertEqual(self.session.query(model.Setting).count(), 1) self.assertEqual(self.session.query(model.Setting).count(), 1)
profile.uuid = 'some_uuid' profile.uuid = 'some_uuid'

2
tests/test_core.py
View file

@ -8,5 +8,5 @@ class TestCore(TestCase):
def test_get_uuid(self): def test_get_uuid(self):
uuid = core.get_uuid() uuid = core.get_uuid()
self.assertIsInstance(uuid, str) self.assertTrue(isinstance(uuid, str))
self.assertEqual(len(uuid), 32) self.assertEqual(len(uuid), 32)