def before_all(self):
engine = create_engine('sqlite://')
metadata = MetaData(bind=engine)
self.db = UsersModel(engine, metadata)
# Create Table
self.db.metadata.drop_all()
self.db.metadata.create_all()
self.db.role = 'writer'
self.admin_user = User(user_profile=dict(user_id=1,
username='******',
last_name='pytest',
first_name='unittest',
is_bot=False,
language_code='ZH'))
self.admin_user.admin_role = True
self.db.raw_insert(self.admin_user.to_dict())
self.blacklist_user = User(user_profile=dict(user_id=2,
username='******',
last_name='pytest',
first_name='unittest',
is_bot=False,
language_code='ZH'))
self.blacklist_user.blacklist = True
self.db.raw_insert(self.blacklist_user.to_dict())
class Test:
@pytest.fixture(autouse=True, scope='function')
def before_all(self):
self.user_table = UsersModel(engine, metadata, role='writer')
def test_new_user_auth(self):
telegram_user_profile = dict(
user_id=123456789,
username='******',
last_name='pytest',
first_name='test',
is_bot=False,
language_code='ZH')
profile_in_db = self.user_table.auth(User(user_profile=telegram_user_profile))
assert profile_in_db['is_admin'] is False
assert profile_in_db['is_blacklist'] is False
def test_admin_auth(self):
profile_in_db = self.user_table.auth(User(user_profile=ADMIN_PROFILE))
assert profile_in_db['is_admin']
assert profile_in_db['is_blacklist'] is False
def test_blacklist_auth(self):
profile_in_db = self.user_table.auth(User(user_profile=BLACKLIST_PROFILE))
assert profile_in_db['is_admin'] is False
assert profile_in_db['is_blacklist']
def before_all(self):
engine = sqlalchemy.create_engine('sqlite://')
metadata = MetaData(bind=engine)
self.db = UsersModel(engine, metadata)
# Create Table
self.db.metadata.drop_all()
self.db.metadata.create_all()
self.db.role = 'writer'
class TestCase(unittest.TestCase):
@pytest.fixture(autouse=True, scope='function')
def before_all(self):
engine = sqlalchemy.create_engine('sqlite://')
metadata = MetaData(bind=engine)
self.db = UsersModel(engine, metadata)
# Create Table
self.db.metadata.drop_all()
self.db.metadata.create_all()
self.db.role = 'writer'
def test_get_auth(self):
result = self.db.auth(USER)
assert result
assert result['is_blacklist'] is False
assert result['is_admin'] is False
def test_ban_user(self):
self.db.auth(USER)
assert self.db.ban_user(USER)
user = self.db.get_user_profile(USER.user_id)
assert user
assert user.blacklist
assert user.admin_role is False
def test_get_user_profile(self):
self.db.auth(USER)
result = self.db.get_user_profile(USER.user_id)
assert result
assert isinstance(result, User)
assert result.user_id == USER.user_id
assert result.username == USER.username
def before_all(self):
engine = create_engine('sqlite://')
metadata = MetaData(bind=engine)
self.db = UsersModel(engine, metadata)
# Create Table
self.db.metadata.drop_all()
self.db.metadata.create_all()
self.db.role = 'writer'
self.helper = QueryHelper(self.db)
class Test(unittest.TestCase):
@pytest.fixture(autouse=True, scope='function')
def before_all(self):
engine = create_engine('sqlite://')
metadata = MetaData(bind=engine)
self.db = UsersModel(engine, metadata)
# Create Table
self.db.metadata.drop_all()
self.db.metadata.create_all()
self.db.role = 'writer'
self.admin_user = User(user_profile=dict(user_id=1,
username='******',
last_name='pytest',
first_name='unittest',
is_bot=False,
language_code='ZH'))
self.admin_user.admin_role = True
self.db.raw_insert(self.admin_user.to_dict())
self.blacklist_user = User(user_profile=dict(user_id=2,
username='******',
last_name='pytest',
first_name='unittest',
is_bot=False,
language_code='ZH'))
self.blacklist_user.blacklist = True
self.db.raw_insert(self.blacklist_user.to_dict())
def test_new_user(self):
new_user = User(user_profile=dict(user_id=123456789,
username='******',
last_name='pytest',
first_name='unittest',
is_bot=False,
language_code='ZH'))
profile = self.db.auth(new_user)
assert profile['is_admin'] is False
assert profile['is_blacklist'] is False
def test_admin_user(self):
profile = self.db.auth(self.admin_user)
assert profile['is_admin']
assert profile['is_blacklist'] is False
def test_blacklist_user(self):
profile = self.db.auth(self.blacklist_user)
assert profile['is_admin'] is False
assert profile['is_blacklist']
def database():
# Create User Table
event_table = EventsModel(engine, metadata, role='writer')
event_table.metadata.drop_all()
event_table.metadata.create_all()
# Create User Table
user_table = UsersModel(engine, metadata, role='writer')
user_table.metadata.drop_all()
user_table.metadata.create_all()
# Create Ticket Table
ticket_table = TicketsModel(engine, metadata, role='writer')
ticket_table.metadata.drop_all()
ticket_table.metadata.create_all()
ticket_table.raw_upsert(TICKET_1)
ticket_table.raw_upsert(TICKET_2)
return dict(ticket_table=ticket_table, user_table=user_table)
import mayday
from mayday.constants import TICKET_MAPPING, conversations, stages
from mayday.constants.replykeyboards import KEYBOARDS
from mayday.controllers.redis import RedisController
from mayday.db.tables.tickets import TicketsModel
from mayday.db.tables.users import UsersModel
from mayday.helpers.auth_helper import AuthHelper
from mayday.helpers.feature_helpers.search_helper import SearchHelper
from mayday.helpers.feature_helpers.update_helper import UpdateHelper
from mayday.helpers.query_helper import QueryHelper
from mayday.helpers.ticket_helper import TicketHelper
from mayday.objects.user import User
auth_helper = AuthHelper(
UsersModel(mayday.engine, mayday.metadata, role='writer'))
query_helper = QueryHelper(
TicketsModel(mayday.engine, mayday.metadata, role='writer'))
ticket_helper = TicketHelper(
TicketsModel(mayday.engine, mayday.metadata, role='writer'))
search_helper = SearchHelper('search')
update_helper = UpdateHelper(feature='update')
redis = RedisController(
redis_conection_pool=mayday.FEATURE_REDIS_CONNECTION_POOL)
event_logger: logging.Logger = logging.getLogger('event')
logger: logging.Logger = logging.getLogger('')
@run_async
def start(bot, update, *args, **kwargs):
user = User(telegram_user=update.effective_user)
from telegram.ext.dispatcher import run_async
import mayday
from mayday import TELEGRAM_API_CONFIG
from mayday.constants import TICKET_MAPPING, conversations, stages
from mayday.constants.replykeyboards import KEYBOARDS
from mayday.controllers.redis import RedisController
from mayday.db.tables.tickets import TicketsModel
from mayday.db.tables.users import UsersModel
from mayday.helpers.auth_helper import AuthHelper
from mayday.helpers.feature_helpers.post_ticket_helper import PostTicketHelper
from mayday.helpers.ticket_helper import TicketHelper
from mayday.objects.user import User
post_helper = PostTicketHelper('post')
auth_helper = AuthHelper(UsersModel(mayday.engine, mayday.metadata, role='writer'))
ticket_helper = TicketHelper(TicketsModel(mayday.engine, mayday.metadata, role='writer'))
redis = RedisController(redis_conection_pool=mayday.FEATURE_REDIS_CONNECTION_POOL)
logger: logging.Logger = logging.getLogger('')
@run_async
def start(bot, update, *args, **kwargs):
user = User(telegram_user=update.effective_user)
category = post_helper.get_category_id_from_cache(user.user_id)
redis.clean_all(user.user_id, 'start')
if user.is_username_blank():
def before_all(self):
self.user_table = UsersModel(engine, metadata, role='writer')