wutta/wuttjamaican
3
0
Fork 0
Code Issues Activity

fix: format all code with black

Browse source 
and from now on should not deviate from that...
This commit is contained in:
Lance Edgar 2025-08-30 21:25:44 -05:00
parent 49f9a0228b
commit a6bb538ce9
59 changed files with 2762 additions and 2131 deletions
Download patch file Download diff file Expand all files Collapse all files

7
tests/db/model/test_auth.py
View file

@ -18,22 +18,20 @@ else:
role.name = "Managers"
self.assertEqual(str(role), "Managers")
class TestPermission(TestCase):
def test_basic(self):
perm = model.Permission()
self.assertEqual(str(perm), "")
perm.permission = 'users.create'
perm.permission = "users.create"
self.assertEqual(str(perm), "users.create")
class TestUser(TestCase):
def test_str(self):
user = model.User()
self.assertEqual(str(user), "")
user.username = 'barney'
user.username = "barney"
self.assertEqual(str(user), "barney")
def test_str_with_person(self):
@ -44,7 +42,6 @@ else:
user.person = person
self.assertEqual(str(user), "Barney Rubble")
class TestUserAPIToken(TestCase):
def test_str(self):

23
tests/db/model/test_base.py
View file

@ -11,35 +11,32 @@ except ImportError:
pass
else:
class MockUser(mod.Base):
__tablename__ = 'mock_user'
uuid = mod.uuid_column(sa.ForeignKey('user.uuid'), default=False)
__tablename__ = "mock_user"
uuid = mod.uuid_column(sa.ForeignKey("user.uuid"), default=False)
user = orm.relationship(
User,
backref=orm.backref('_mock', uselist=False, cascade='all, delete-orphan'))
backref=orm.backref("_mock", uselist=False, cascade="all, delete-orphan"),
)
favorite_color = sa.Column(sa.String(length=100), nullable=False)
class TestWuttaModelBase(TestCase):
def test_make_proxy(self):
self.assertFalse(hasattr(User, 'favorite_color'))
MockUser.make_proxy(User, '_mock', 'favorite_color')
self.assertTrue(hasattr(User, 'favorite_color'))
user = User(favorite_color='green')
self.assertEqual(user.favorite_color, 'green')
self.assertFalse(hasattr(User, "favorite_color"))
MockUser.make_proxy(User, "_mock", "favorite_color")
self.assertTrue(hasattr(User, "favorite_color"))
user = User(favorite_color="green")
self.assertEqual(user.favorite_color, "green")
class TestSetting(TestCase):
def test_basic(self):
setting = mod.Setting()
self.assertEqual(str(setting), "")
setting.name = 'foo'
setting.name = "foo"
self.assertEqual(str(setting), "foo")
class TestPerson(TestCase):
def test_basic(self):

26
tests/db/model/test_batch.py
View file

@ -17,40 +17,46 @@ else:
def test_basic(self):
class MyBatch(mod.BatchMixin, model.Base):
__tablename__ = 'testing_mybatch'
__tablename__ = "testing_mybatch"
model.Base.metadata.create_all(bind=self.session.bind)
metadata = sa.MetaData()
metadata.reflect(self.session.bind)
self.assertIn('testing_mybatch', metadata.tables)
self.assertIn("testing_mybatch", metadata.tables)
batch = MyBatch(id=42, uuid=_uuid.UUID('0675cdac-ffc9-7690-8000-6023de1c8cfd'))
self.assertEqual(repr(batch), "MyBatch(uuid=UUID('0675cdac-ffc9-7690-8000-6023de1c8cfd'))")
batch = MyBatch(
id=42, uuid=_uuid.UUID("0675cdac-ffc9-7690-8000-6023de1c8cfd")
)
self.assertEqual(
repr(batch),
"MyBatch(uuid=UUID('0675cdac-ffc9-7690-8000-6023de1c8cfd'))",
)
self.assertEqual(str(batch), "00000042")
self.assertEqual(batch.id_str, "00000042")
batch2 = MyBatch()
self.assertIsNone(batch2.id_str)
class TestBatchRowMixin(DataTestCase):
def test_basic(self):
class MyBatch2(mod.BatchMixin, model.Base):
__tablename__ = 'testing_mybatch2'
__tablename__ = "testing_mybatch2"
class MyBatchRow2(mod.BatchRowMixin, model.Base):
__tablename__ = 'testing_mybatch_row2'
__tablename__ = "testing_mybatch_row2"
__batch_class__ = MyBatch2
model.Base.metadata.create_all(bind=self.session.bind)
metadata = sa.MetaData()
metadata.reflect(self.session.bind)
self.assertIn('testing_mybatch2', metadata.tables)
self.assertIn('testing_mybatch_row2', metadata.tables)
self.assertIn("testing_mybatch2", metadata.tables)
self.assertIn("testing_mybatch_row2", metadata.tables)
# nb. this gives coverage but doesn't really test much
batch = MyBatch2(id=42, uuid=_uuid.UUID('0675cdac-ffc9-7690-8000-6023de1c8cfd'))
batch = MyBatch2(
id=42, uuid=_uuid.UUID("0675cdac-ffc9-7690-8000-6023de1c8cfd")
)
row = MyBatchRow2()
batch.rows.append(row)

111
tests/db/test_conf.py
View file

@ -27,109 +27,130 @@ else:
def write_file(self, filename, content):
path = os.path.join(self.tempdir, filename)
with open(path, 'wt') as f:
with open(path, "wt") as f:
f.write(content)
return path
def test_no_default(self):
myfile = self.write_file('my.conf', '')
myfile = self.write_file("my.conf", "")
config = WuttaConfig([myfile])
self.assertEqual(conf.get_engines(config, 'wuttadb'), {})
self.assertEqual(conf.get_engines(config, "wuttadb"), {})
def test_default(self):
myfile = self.write_file('my.conf', """\
myfile = self.write_file(
"my.conf",
"""\
[wuttadb]
default.url = sqlite://
""")
""",
)
config = WuttaConfig([myfile])
result = conf.get_engines(config, 'wuttadb')
result = conf.get_engines(config, "wuttadb")
self.assertEqual(len(result), 1)
self.assertIn('default', result)
engine = result['default']
self.assertEqual(engine.dialect.name, 'sqlite')
self.assertIn("default", result)
engine = result["default"]
self.assertEqual(engine.dialect.name, "sqlite")
def test_default_fallback(self):
myfile = self.write_file('my.conf', """\
myfile = self.write_file(
"my.conf",
"""\
[wuttadb]
sqlalchemy.url = sqlite://
""")
""",
)
config = WuttaConfig([myfile])
result = conf.get_engines(config, 'wuttadb')
result = conf.get_engines(config, "wuttadb")
self.assertEqual(len(result), 1)
self.assertIn('default', result)
engine = result['default']
self.assertEqual(engine.dialect.name, 'sqlite')
self.assertIn("default", result)
engine = result["default"]
self.assertEqual(engine.dialect.name, "sqlite")
def test_other(self):
myfile = self.write_file('my.conf', """\
myfile = self.write_file(
"my.conf",
"""\
[otherdb]
keys = first, second
first.url = sqlite://
second.url = sqlite://
""")
""",
)
config = WuttaConfig([myfile])
result = conf.get_engines(config, 'otherdb')
result = conf.get_engines(config, "otherdb")
self.assertEqual(len(result), 2)
self.assertIn('first', result)
self.assertIn('second', result)
self.assertIn("first", result)
self.assertIn("second", result)
class TestGetSetting(TestCase):
def setUp(self):
Session = orm.sessionmaker()
engine = sa.create_engine('sqlite://')
engine = sa.create_engine("sqlite://")
self.session = Session(bind=engine)
self.session.execute(sa.text("""
self.session.execute(
sa.text(
"""
create table setting (
name varchar(255) primary key,
value text
);
"""))
"""
)
)
def tearDown(self):
self.session.close()
def test_basic_value(self):
self.session.execute(sa.text("insert into setting values ('foo', 'bar');"))
value = conf.get_setting(self.session, 'foo')
self.assertEqual(value, 'bar')
value = conf.get_setting(self.session, "foo")
self.assertEqual(value, "bar")
def test_missing_value(self):
value = conf.get_setting(self.session, 'foo')
value = conf.get_setting(self.session, "foo")
self.assertIsNone(value)
class TestMakeEngineFromConfig(TestCase):
def test_basic(self):
engine = conf.make_engine_from_config({
'sqlalchemy.url': 'sqlite://',
})
engine = conf.make_engine_from_config(
{
"sqlalchemy.url": "sqlite://",
}
)
self.assertIsInstance(engine, Engine)
def test_poolclass(self):
engine = conf.make_engine_from_config({
'sqlalchemy.url': 'sqlite://',
})
engine = conf.make_engine_from_config(
{
"sqlalchemy.url": "sqlite://",
}
)
self.assertNotIsInstance(engine.pool, NullPool)
engine = conf.make_engine_from_config({
'sqlalchemy.url': 'sqlite://',
'sqlalchemy.poolclass': 'sqlalchemy.pool:NullPool',
})
engine = conf.make_engine_from_config(
{
"sqlalchemy.url": "sqlite://",
"sqlalchemy.poolclass": "sqlalchemy.pool:NullPool",
}
)
self.assertIsInstance(engine.pool, NullPool)
def test_pool_pre_ping(self):
engine = conf.make_engine_from_config({
'sqlalchemy.url': 'sqlite://',
})
engine = conf.make_engine_from_config(
{
"sqlalchemy.url": "sqlite://",
}
)
self.assertFalse(engine.pool._pre_ping)
engine = conf.make_engine_from_config({
'sqlalchemy.url': 'sqlite://',
'sqlalchemy.pool_pre_ping': 'true',
})
engine = conf.make_engine_from_config(
{
"sqlalchemy.url": "sqlite://",
"sqlalchemy.pool_pre_ping": "true",
}
)
self.assertTrue(engine.pool._pre_ping)

20
tests/db/test_handler.py
View file

@ -22,20 +22,20 @@ else:
# counter table should not exist yet
metadata = sa.MetaData()
metadata.reflect(self.session.bind)
self.assertNotIn('_counter_testing', metadata.tables)
self.assertNotIn("_counter_testing", metadata.tables)
# using sqlite as backend, should make table for counter
value = handler.next_counter_value(self.session, 'testing')
value = handler.next_counter_value(self.session, "testing")
self.assertEqual(value, 1)
# counter table should exist now
metadata.reflect(self.session.bind)
self.assertIn('_counter_testing', metadata.tables)
self.assertIn("_counter_testing", metadata.tables)
# counter increments okay
value = handler.next_counter_value(self.session, 'testing')
value = handler.next_counter_value(self.session, "testing")
self.assertEqual(value, 2)
value = handler.next_counter_value(self.session, 'testing')
value = handler.next_counter_value(self.session, "testing")
self.assertEqual(value, 3)
def test_next_counter_value_postgres(self):
@ -44,20 +44,20 @@ else:
# counter table should not exist
metadata = sa.MetaData()
metadata.reflect(self.session.bind)
self.assertNotIn('_counter_testing', metadata.tables)
self.assertNotIn("_counter_testing", metadata.tables)
# nb. we have to pretty much mock this out, can't really
# test true sequence behavior for postgres since tests are
# using sqlite backend.
# using postgres as backend, should use "sequence"
with patch.object(handler, 'get_dialect', return_value='postgresql'):
with patch.object(self.session, 'execute') as execute:
with patch.object(handler, "get_dialect", return_value="postgresql"):
with patch.object(self.session, "execute") as execute:
execute.return_value.scalar.return_value = 1
value = handler.next_counter_value(self.session, 'testing')
value = handler.next_counter_value(self.session, "testing")
self.assertEqual(value, 1)
execute.return_value.scalar.assert_called_once_with()
# counter table should still not exist
metadata.reflect(self.session.bind)
self.assertNotIn('_counter_testing', metadata.tables)
self.assertNotIn("_counter_testing", metadata.tables)

33
tests/db/test_util.py
View file

@ -16,18 +16,16 @@ except ImportError:
pass
else:
class TestModelBase(TestCase):
def test_dict_behavior(self):
setting = Setting()
self.assertEqual(list(iter(setting)), [('name', None), ('value', None)])
self.assertEqual(list(iter(setting)), [("name", None), ("value", None)])
self.assertIsNone(setting.name)
self.assertIsNone(setting['name'])
setting.name = 'foo'
self.assertEqual(setting['name'], 'foo')
self.assertRaises(KeyError, lambda: setting['notfound'])
self.assertIsNone(setting["name"])
setting.name = "foo"
self.assertEqual(setting["name"], "foo")
self.assertRaises(KeyError, lambda: setting["notfound"])
class TestUUID(TestCase):
@ -39,14 +37,14 @@ else:
# coverage at least..
# postgres
dialect.name = 'postgresql'
dialect.name = "postgresql"
dialect.type_descriptor.return_value = 42
result = typ.load_dialect_impl(dialect)
self.assertTrue(dialect.type_descriptor.called)
self.assertEqual(result, 42)
# other
dialect.name = 'mysql'
dialect.name = "mysql"
dialect.type_descriptor.return_value = 43
dialect.type_descriptor.reset_mock()
result = typ.load_dialect_impl(dialect)
@ -56,7 +54,7 @@ else:
def test_process_bind_param_postgres(self):
typ = mod.UUID()
dialect = MagicMock()
dialect.name = 'postgresql'
dialect.name = "postgresql"
# null
result = typ.process_bind_param(None, dialect)
@ -75,7 +73,7 @@ else:
def test_process_bind_param_other(self):
typ = mod.UUID()
dialect = MagicMock()
dialect.name = 'mysql'
dialect.name = "mysql"
# null
result = typ.process_bind_param(None, dialect)
@ -110,7 +108,6 @@ else:
result = typ.process_result_value(uuid_true, dialect)
self.assertIs(result, uuid_true)
class TestUUIDColumn(TestCase):
def test_basic(self):
@ -118,24 +115,22 @@ else:
self.assertIsInstance(column, sa.Column)
self.assertIsInstance(column.type, mod.UUID)
class TestUUIDFKColumn(TestCase):
def test_basic(self):
column = mod.uuid_fk_column('foo.bar')
column = mod.uuid_fk_column("foo.bar")
self.assertIsInstance(column, sa.Column)
self.assertIsInstance(column.type, mod.UUID)
class TestMakeTopoSortkey(DataTestCase):
def test_basic(self):
model = self.app.model
sortkey = mod.make_topo_sortkey(model)
original = ['User', 'Person', 'UserRole', 'Role']
original = ["User", "Person", "UserRole", "Role"]
# models are sorted so dependants come later
result = sorted(original, key=sortkey)
self.assertTrue(result.index('Role') < result.index('UserRole'))
self.assertTrue(result.index('User') < result.index('UserRole'))
self.assertTrue(result.index('Person') < result.index('User'))
self.assertTrue(result.index("Role") < result.index("UserRole"))
self.assertTrue(result.index("User") < result.index("UserRole"))
self.assertTrue(result.index("Person") < result.index("User"))