def test_first_tip_challenge(app):
redis_conn = redis.Redis.from_url(url=REDIS_URL)
with app.app_context():
db = get_db()
block = Block(blockhash="0x1", number=BLOCK_NUMBER)
user = User(
blockhash="0x1",
blocknumber=BLOCK_NUMBER,
txhash="xyz",
user_id=1,
is_current=True,
handle="TestHandle",
handle_lc="testhandle",
wallet="0x1",
is_creator=False,
is_verified=False,
name="test_name",
created_at=datetime.now(),
updated_at=datetime.now(),
)
with db.scoped_session() as session:
bus = ChallengeEventBus(redis_conn)
session.query(Challenge).filter(
Challenge.id == "send-first-tip").update({
"active":
True,
"starting_block":
BLOCK_NUMBER
})
# Register events with the bus
bus.register_listener(ChallengeEvent.send_tip,
send_first_tip_challenge_manager)
session.add(block)
session.flush()
session.add(user)
session.flush()
bus.dispatch(
ChallengeEvent.send_tip,
BLOCK_NUMBER,
1, # user_id
{},
)
bus.flush()
bus.process_events(session)
session.flush()
state = send_first_tip_challenge_manager.get_user_challenge_state(
session, ["1"])[0]
assert state.is_complete
def dispatch_play(offset: int, session: Session, bus: ChallengeEventBus):
play = create_play(offset)
session.add(play)
session.flush()
bus.dispatch(
ChallengeEvent.track_listen,
BLOCK_NUMBER,
1,
{"created_at": play.created_at.timestamp()},
)
def dispatch_new_user_signup(referrer: int, referred_user_id: int,
session: Session, bus: ChallengeEventBus):
session.add(create_user(referred_user_id))
session.add(create_user_referral(referrer, referred_user_id))
session.flush()
bus.dispatch(
ChallengeEvent.referral_signup,
BLOCK_NUMBER,
referrer,
{"referred_user_id": referred_user_id},
)
bus.dispatch(ChallengeEvent.referred_signup, BLOCK_NUMBER,
referred_user_id)
def test_rejects_invalid_events(app):
setup_challenges(app)
with app.app_context():
db = get_db()
redis_conn = redis.Redis.from_url(url=REDIS_URL)
bus = ChallengeEventBus(redis_conn)
with db.scoped_session() as session:
mgr = ChallengeManager("test_challenge_1", DefaultUpdater())
TEST_EVENT = "TEST_EVENT"
bus.register_listener(TEST_EVENT, mgr)
with bus.use_scoped_dispatch_queue():
bus.dispatch(TEST_EVENT, None, 1)
bus.dispatch(TEST_EVENT, 1, None)
bus.dispatch(TEST_EVENT, 1, 1, 1)
(count, did_error) = bus.process_events(session)
assert count == 0
assert did_error == False
def test_inactive_challenge(app):
setup_challenges(app)
with app.app_context():
db = get_db()
redis_conn = redis.Redis.from_url(url=REDIS_URL)
bus = ChallengeEventBus(redis_conn)
with db.scoped_session() as session:
mgr = ChallengeManager("some_inactive_challenge", DefaultUpdater())
TEST_EVENT = "TEST_EVENT"
bus.register_listener(TEST_EVENT, mgr)
with bus.use_scoped_dispatch_queue():
bus.dispatch(TEST_EVENT, 100, 1, {})
bus.process_events(session)
state = mgr.get_user_challenge_state(session, ["1"])
# We should not have any UserChallenges created for the
# inactive challenge!!
assert len(state) == 0
def test_anon_listen(app):
redis_conn = redis.Redis.from_url(url=REDIS_URL)
bus = ChallengeEventBus(redis_conn)
# Register events with the bus
bus.register_listener(ChallengeEvent.track_listen,
listen_streak_challenge_manager)
with app.app_context():
db = get_db()
with db.scoped_session() as session:
setup_challenges(session)
with bus.use_scoped_dispatch_queue():
bus.dispatch(
ChallengeEvent.track_listen,
BLOCK_NUMBER,
None,
{"created_at": datetime.now()},
)
(num_processed, error) = bus.process_events(session)
assert not error
assert num_processed == 0
def test_in_memory_queue(app):
setup_challenges(app)
with app.app_context():
db = get_db()
redis_conn = redis.Redis.from_url(url=REDIS_URL)
bus = ChallengeEventBus(redis_conn)
with db.scoped_session() as session, bus.use_scoped_dispatch_queue():
agg_challenge = ChallengeManager("test_challenge_3",
AggregateUpdater())
agg_challenge.process(session, "test_event", [])
TEST_EVENT = "TEST_EVENT"
bus.register_listener(
TEST_EVENT, ChallengeManager("test_challenge_1", DefaultUpdater()))
bus.register_listener(
TEST_EVENT, ChallengeManager("test_challenge_2", DefaultUpdater()))
# - Multiple events with the same user_id but diff specifiers get created
bus.register_listener(TEST_EVENT, agg_challenge)
bus.dispatch(TEST_EVENT, 100, 1, {"referred_id": 2})
bus.dispatch(TEST_EVENT, 100, 1, {"referred_id": 3})
bus.process_events(session)
# no events should be processed because we haven't dispatched yet
state = agg_challenge.get_user_challenge_state(session, ["1-2", "1-3"])
assert len(state) == 0
bus.process_events(session)
state = agg_challenge.get_user_challenge_state(session, ["1-2", "1-3"])
assert len(state) == 2
# Also make sure the thing is incomplete
res = get_challenges(1, False, session, bus)
agg_chal = {c["challenge_id"]: c for c in res}["test_challenge_3"]
assert agg_chal["is_complete"] == False
redis_conn = redis.Redis.from_url(url=REDIS_URL)
def dispatch_trending_challenges(
challenge_bus: ChallengeEventBus,
challenge_event: ChallengeEvent,
latest_blocknumber: int,
tracks,
version: str,
date: datetime,
type: TrendingType,
):
for idx, track in enumerate(tracks):
challenge_bus.dispatch(
challenge_event,
latest_blocknumber,
track["owner_id"],
{
"id": track["track_id"],
"user_id": track["owner_id"],
"rank": idx + 1,
"type": str(type),
"version": str(version),
"week": date_to_week(date),
},
)
def dispatch_challenge_repost(bus: ChallengeEventBus, repost, block_number):
bus.dispatch(ChallengeEvent.repost, block_number, repost.user_id)
def test_track_upload_challenge(app):
redis_conn = redis.Redis.from_url(url=REDIS_URL)
# create user
with app.app_context():
db = get_db()
today = date.today()
block1 = Block(blockhash="0x1", number=1)
block2 = Block(blockhash="0x2", number=30000000)
block3 = Block(blockhash="0x3", number=30000001)
user = User(
blockhash="0x1",
blocknumber=1,
txhash="xyz",
user_id=1,
handle="TestHandle",
handle_lc="testhandle",
is_current=True,
created_at=today - timedelta(days=100),
updated_at=today - timedelta(days=100),
)
track1 = Track(
blockhash="0x1",
blocknumber=1,
txhash="xyz",
owner_id=1,
track_id=1,
route_id="1",
track_segments=[],
is_unlisted=False,
is_current=True,
is_delete=False,
created_at=today - timedelta(days=100),
updated_at=today - timedelta(days=100),
)
track2 = Track(
blockhash="0x2",
blocknumber=30000000,
txhash="yzx",
owner_id=1,
track_id=2,
route_id="2",
track_segments=[],
is_unlisted=False,
is_current=True,
is_delete=False,
created_at=today - timedelta(days=1),
updated_at=today - timedelta(days=1),
)
track3 = Track(
blockhash="0x3",
blocknumber=30000001,
txhash="zxy",
owner_id=1,
track_id=3,
route_id="3",
track_segments=[],
is_unlisted=False,
is_current=True,
is_delete=False,
created_at=today,
updated_at=today,
)
track4 = Track(
blockhash="0x3",
blocknumber=30000001,
txhash="abc",
owner_id=1,
track_id=4,
route_id="4",
track_segments=[],
is_unlisted=False,
is_current=True,
is_delete=False,
created_at=today,
updated_at=today,
)
unlisted_track = Track(
blockhash="0x3",
blocknumber=30000001,
txhash="cba",
owner_id=1,
track_id=5,
route_id="5",
track_segments=[],
is_unlisted=True,
is_current=True,
is_delete=False,
created_at=today,
updated_at=today,
)
stem = Track(
blockhash="0x3",
blocknumber=30000001,
txhash="stem",
owner_id=1,
track_id=6,
route_id="6",
track_segments=[],
is_unlisted=False,
is_current=True,
is_delete=False,
created_at=today,
updated_at=today,
stem_of={"parent_track_id": 4, "category": "bass"},
)
with db.scoped_session() as session:
bus = ChallengeEventBus(redis_conn)
# Register events with the bus
bus.register_listener(
ChallengeEvent.track_upload, track_upload_challenge_manager
)
# set challenge as active for purposes of test
session.query(Challenge).filter(Challenge.id == "track-upload").update(
{"active": True}
)
session.add(block1)
session.add(block2)
session.add(block3)
session.flush()
session.add(user)
session.add(track1)
# Process dummy event at block number before this challenge is added
bus.dispatch(ChallengeEvent.track_upload, 1, 1)
bus.flush()
bus.process_events(session)
user_challenges = track_upload_challenge_manager.get_user_challenge_state(
session, ["1"]
)
# We should not have registered a count for this event
assert not user_challenges
# Process dummy event at block number when challenge is added
session.add(track2)
bus.dispatch(ChallengeEvent.track_upload, 30000000, 1)
bus.flush()
bus.process_events(session)
user_challenge = track_upload_challenge_manager.get_user_challenge_state(
session, ["1"]
)[0]
# We should have completed a single step (one track upload)
assert user_challenge.current_step_count == 1
assert not user_challenge.is_complete
# Ensure unlisted tracks and stems are not counted
session.add(unlisted_track)
bus.dispatch(ChallengeEvent.track_upload, 30000001, 1)
session.add(stem)
bus.dispatch(ChallengeEvent.track_upload, 30000001, 1)
bus.flush()
bus.process_events(session)
user_challenge = track_upload_challenge_manager.get_user_challenge_state(
session, ["1"]
)[0]
# Ensure stem is not counted
assert user_challenge.current_step_count == 1
# Process two more dummy events to reach the step count (i.e. 3) for completion
session.add(track3)
bus.dispatch(ChallengeEvent.track_upload, 30000001, 1)
session.add(track4)
bus.dispatch(ChallengeEvent.track_upload, 30000001, 1)
bus.flush()
bus.process_events(session)
user_challenge = track_upload_challenge_manager.get_user_challenge_state(
session, ["1"]
)[0]
# We should have completed the challenge
assert user_challenge.current_step_count == 3
assert user_challenge.is_complete
# ensure that if we lose some data now that the thing is complete, we don't change the status of the challenge
session.query(Track).filter(Track.owner_id == user.user_id).update(
{"is_delete": True}
)
session.flush()
bus.dispatch(ChallengeEvent.track_upload, 3, 1)
bus.flush()
bus.process_events(session)
user_challenge = track_upload_challenge_manager.get_user_challenge_state(
session, ["1"]
)[0]
# The challenge should still be completed
assert user_challenge.current_step_count == 3
assert user_challenge.is_complete
def enqueue_trending_challenges(db: SessionManager, redis: Redis,
challenge_bus: ChallengeEventBus,
date: datetime):
logger.info(
"calculate_trending_challenges.py | Start calculating trending challenges"
)
update_start = time.time()
with db.scoped_session(
) as session, challenge_bus.use_scoped_dispatch_queue():
latest_blocknumber = get_latest_blocknumber_via_redis(session, redis)
if latest_blocknumber is None:
logger.error(
"calculate_trending_challenges.py | Unable to get latest block number"
)
return
trending_track_versions = trending_strategy_factory.get_versions_for_type(
TrendingType.TRACKS).keys()
time_range = "week"
for version in trending_track_versions:
strategy = trending_strategy_factory.get_strategy(
TrendingType.TRACKS, version)
top_tracks = _get_trending_tracks_with_session(
session, {"time": time_range}, strategy)
top_tracks = top_tracks[:TRENDING_LIMIT]
dispatch_trending_challenges(
challenge_bus,
ChallengeEvent.trending_track,
latest_blocknumber,
top_tracks,
version,
date,
TrendingType.TRACKS,
)
# Cache underground trending
underground_trending_versions = trending_strategy_factory.get_versions_for_type(
TrendingType.UNDERGROUND_TRACKS).keys()
for version in underground_trending_versions:
strategy = trending_strategy_factory.get_strategy(
TrendingType.UNDERGROUND_TRACKS, version)
underground_args: GetUndergroundTrendingTrackcArgs = {
"offset": 0,
"limit": TRENDING_LIMIT,
}
top_tracks = _get_underground_trending_with_session(
session, underground_args, strategy, False)
dispatch_trending_challenges(
challenge_bus,
ChallengeEvent.trending_underground,
latest_blocknumber,
top_tracks,
version,
date,
TrendingType.UNDERGROUND_TRACKS,
)
trending_playlist_versions = trending_strategy_factory.get_versions_for_type(
TrendingType.PLAYLISTS).keys()
for version in trending_playlist_versions:
strategy = trending_strategy_factory.get_strategy(
TrendingType.PLAYLISTS, version)
playlists_args: GetTrendingPlaylistsArgs = {
"limit": TRENDING_LIMIT,
"offset": 0,
"time": time_range,
}
trending_playlists = _get_trending_playlists_with_session(
session, playlists_args, strategy, False)
for idx, playlist in enumerate(trending_playlists):
challenge_bus.dispatch(
ChallengeEvent.trending_playlist,
latest_blocknumber,
playlist["playlist_owner_id"],
{
"id": playlist["playlist_id"],
"user_id": playlist["playlist_owner_id"],
"rank": idx + 1,
"type": str(TrendingType.PLAYLISTS),
"version": str(version),
"week": date_to_week(date),
},
)
update_end = time.time()
update_total = update_end - update_start
logger.info(
f"calculate_trending_challenges.py | Finished calculating trending in {update_total} seconds"
)
def test_profile_completion_challenge_with_playlists(app):
redis_conn = redis.Redis.from_url(url=REDIS_URL)
# create user
with app.app_context():
db = get_db()
block = Block(blockhash="0x1", number=BLOCK_NUMBER)
user = User(
blockhash="0x1",
blocknumber=BLOCK_NUMBER,
txhash="xyz",
user_id=1,
is_current=True,
handle="TestHandle",
handle_lc="testhandle",
wallet="0x123",
is_creator=False,
is_verified=False,
name="test_name",
created_at=datetime.now(),
updated_at=datetime.now(),
)
with db.scoped_session() as session:
bus = ChallengeEventBus(redis_conn)
# set challenge as active for purposes of test
session.query(Challenge).filter(
Challenge.id == "profile-completion").update({
"active":
True,
"starting_block":
BLOCK_NUMBER
})
# Register events with the bus
bus.register_listener(ChallengeEvent.profile_update,
profile_challenge_manager)
bus.register_listener(ChallengeEvent.repost, profile_challenge_manager)
bus.register_listener(ChallengeEvent.follow, profile_challenge_manager)
bus.register_listener(ChallengeEvent.favorite,
profile_challenge_manager)
session.add(block)
session.flush()
session.add(user)
# Process dummy event just to get this thing initted
bus.dispatch(ChallengeEvent.profile_update, BLOCK_NUMBER, 1)
bus.flush()
bus.process_events(session)
state = profile_challenge_manager.get_user_challenge_state(
session, ["1"])[0]
# We should have completed a single step (name)
assert state.current_step_count == 1 and not state.is_complete
# Do a repost
repost = Repost(
blockhash="0x1",
blocknumber=BLOCK_NUMBER,
user_id=1,
repost_item_id=1,
repost_type=RepostType.playlist,
is_current=True,
is_delete=False,
created_at=datetime.now(),
)
session.add(repost)
session.flush()
bus.dispatch(ChallengeEvent.repost, BLOCK_NUMBER, 1)
bus.flush()
bus.process_events(session)
state = profile_challenge_manager.get_user_challenge_state(
session, ["1"])[0]
assert state.current_step_count == 2 and not state.is_complete
# Do a save
save = Save(
blockhash="0x1",
blocknumber=BLOCK_NUMBER,
user_id=1,
save_item_id=1,
save_type=SaveType.playlist,
is_current=True,
is_delete=False,
created_at=datetime.now(),
)
session.add(save)
session.flush()
bus.dispatch(ChallengeEvent.favorite, BLOCK_NUMBER, 1)
bus.flush()
bus.process_events(session)
session.flush()
state = profile_challenge_manager.get_user_challenge_state(
session, ["1"])[0]
assert state.current_step_count == 3 and not state.is_complete
# Do 1 follow, then 5 total follows
follow = Follow(
blockhash="0x1",
blocknumber=BLOCK_NUMBER,
is_current=True,
is_delete=False,
created_at=datetime.now(),
follower_user_id=1,
followee_user_id=2,
)
session.add(follow)
session.flush()
bus.dispatch(ChallengeEvent.follow, BLOCK_NUMBER, 1)
bus.flush()
bus.process_events(session)
session.flush()
state = profile_challenge_manager.get_user_challenge_state(
session, ["1"])[0]
# Assert 1 follow didn't do anything
assert state.current_step_count == 3 and not state.is_complete
follows = [
Follow(
blockhash="0x1",
blocknumber=BLOCK_NUMBER,
is_current=True,
is_delete=False,
created_at=datetime.now(),
follower_user_id=1,
followee_user_id=3,
),
Follow(
blockhash="0x1",
blocknumber=BLOCK_NUMBER,
is_current=True,
is_delete=False,
created_at=datetime.now(),
follower_user_id=1,
followee_user_id=4,
),
Follow(
blockhash="0x1",
blocknumber=BLOCK_NUMBER,
is_current=True,
is_delete=False,
created_at=datetime.now(),
follower_user_id=1,
followee_user_id=5,
),
Follow(
blockhash="0x1",
blocknumber=BLOCK_NUMBER,
is_current=True,
is_delete=False,
created_at=datetime.now(),
follower_user_id=1,
followee_user_id=6,
),
]
session.add_all(follows)
session.flush()
bus.dispatch(ChallengeEvent.follow, BLOCK_NUMBER, 1)
bus.flush()
bus.process_events(session)
state = profile_challenge_manager.get_user_challenge_state(
session, ["1"])[0]
assert state.current_step_count == 4 and not state.is_complete
# profile_picture
session.query(User).filter(User.user_id == 1).update(
{"profile_picture": "profilepictureurl"})
session.flush()
bus.dispatch(ChallengeEvent.profile_update, BLOCK_NUMBER, 1)
bus.flush()
bus.process_events(session)
state = profile_challenge_manager.get_user_challenge_state(
session, ["1"])[0]
assert state.current_step_count == 5 and not state.is_complete
# profile description
session.query(User).filter(User.user_id == 1).update(
{"bio": "profiledescription"})
session.flush()
bus.dispatch(ChallengeEvent.profile_update, BLOCK_NUMBER, 1)
bus.flush()
bus.process_events(session)
state = profile_challenge_manager.get_user_challenge_state(
session, ["1"])[0]
assert state.current_step_count == 6 and not state.is_complete
# Undo it, ensure that our count goes down
session.query(User).filter(User.user_id == 1).update({"bio": None})
session.flush()
bus.dispatch(ChallengeEvent.profile_update, BLOCK_NUMBER, 1)
bus.flush()
bus.process_events(session)
state = profile_challenge_manager.get_user_challenge_state(
session, ["1"])[0]
assert state.current_step_count == 5 and not state.is_complete
# profile_cover_photo
session.query(User).filter(User.user_id == 1).update({
"bio":
"profiledescription",
"cover_photo":
"test_cover_photo"
})
session.flush()
bus.dispatch(ChallengeEvent.profile_update, BLOCK_NUMBER, 1)
bus.flush()
bus.process_events(session)
state = profile_challenge_manager.get_user_challenge_state(
session, ["1"])[0]
assert state.current_step_count == 7 and state.is_complete == True
# ensure that if we lose some data now that the thing is complete, we don't change the status of the challenge
session.query(User).filter(User.user_id == 1).update(
{"cover_photo": None})
session.flush()
bus.dispatch(ChallengeEvent.profile_update, BLOCK_NUMBER, 1)
bus.flush()
bus.process_events(session)
state = profile_challenge_manager.get_user_challenge_state(
session, ["1"])[0]
assert state.current_step_count == 7 and state.is_complete == True
def process_transfer_instruction(
session: Session,
redis: Redis,
instruction: TransactionMessageInstruction,
account_keys: List[str],
meta: ResultMeta,
tx_sig: str,
slot: int,
challenge_event_bus: ChallengeEventBus,
timestamp: datetime.datetime,
):
# The transaction might list sender/receiver in a different order in the pubKeys.
# The "accounts" field of the instruction has the mapping of accounts to pubKey index
sender_index = instruction["accounts"][TRANSFER_SENDER_ACCOUNT_INDEX]
receiver_index = instruction["accounts"][TRANSFER_RECEIVER_ACCOUNT_INDEX]
sender_account = account_keys[sender_index]
receiver_account = account_keys[receiver_index]
# Accounts to refresh balance
logger.info(
f"index_user_bank.py | Balance refresh accounts: {sender_account}, {receiver_account}"
)
user_id_accounts = refresh_user_balances(
session, redis, [sender_account, receiver_account])
# If there are two userbanks to update, it was a transfer from user to user
# Index as a user_tip
if user_id_accounts and len(user_id_accounts) == 2:
sender_user_id: Optional[int] = None
receiver_user_id: Optional[int] = None
for user_id_account in user_id_accounts:
if user_id_account[1] == sender_account:
sender_user_id = user_id_account[0]
elif user_id_account[1] == receiver_account:
receiver_user_id = user_id_account[0]
if sender_user_id is None or receiver_user_id is None:
logger.error(
f"index_user_bank.py | ERROR: Unexpected user ids in results: {user_id_accounts}"
)
return
# Find the right pre/post balances using the account indexes
# for the sender/receiver accounts since they aren't necessarily given in order
pre_sender_balance_dict = next(
(balance for balance in meta["preTokenBalances"]
if balance["accountIndex"] == sender_index),
None,
)
pre_receiver_balance_dict = next(
(balance for balance in meta["preTokenBalances"]
if balance["accountIndex"] == receiver_index),
None,
)
post_sender_balance_dict = next(
(balance for balance in meta["postTokenBalances"]
if balance["accountIndex"] == sender_index),
None,
)
post_receiver_balance_dict = next(
(balance for balance in meta["postTokenBalances"]
if balance["accountIndex"] == receiver_index),
None,
)
if (pre_sender_balance_dict is None
or pre_receiver_balance_dict is None
or post_sender_balance_dict is None
or post_receiver_balance_dict is None):
logger.error(
"index_user_bank.py | ERROR: Sender or Receiver balance missing!"
)
return
pre_sender_balance = int(
pre_sender_balance_dict["uiTokenAmount"]["amount"])
post_sender_balance = int(
post_sender_balance_dict["uiTokenAmount"]["amount"])
pre_receiver_balance = int(
pre_receiver_balance_dict["uiTokenAmount"]["amount"])
post_receiver_balance = int(
post_receiver_balance_dict["uiTokenAmount"]["amount"])
sent_amount = pre_sender_balance - post_sender_balance
received_amount = post_receiver_balance - pre_receiver_balance
if sent_amount != received_amount:
logger.error(
f"index_user_bank.py | ERROR: Sent and received amounts don't match. Sent = {sent_amount}, Received = {received_amount}"
)
return
user_tip = UserTip(
signature=tx_sig,
amount=sent_amount,
sender_user_id=sender_user_id,
receiver_user_id=receiver_user_id,
slot=slot,
created_at=timestamp,
)
logger.debug(f"index_user_bank.py | Creating tip {user_tip}")
session.add(user_tip)
challenge_event_bus.dispatch(ChallengeEvent.send_tip, slot,
sender_user_id)
def dispatch_favorite(bus: ChallengeEventBus, save, block_number):
bus.dispatch(ChallengeEvent.favorite, block_number, save.user_id)
def test_referral_challenge(app):
redis_conn = redis.Redis.from_url(url=REDIS_URL)
with app.app_context():
db = get_db()
block = Block(blockhash="0x1", number=BLOCK_NUMBER)
referrer = User(
blockhash="0x1",
blocknumber=BLOCK_NUMBER,
txhash="xyz",
user_id=1,
is_current=True,
handle="Referrer",
handle_lc="referrer",
wallet="0x1",
is_creator=False,
is_verified=False,
name="referrer_name",
created_at=datetime.now(),
updated_at=datetime.now(),
)
with db.scoped_session() as session:
# Setup
bus = ChallengeEventBus(redis_conn)
bus.register_listener(ChallengeEvent.referred_signup,
referred_challenge_manager)
bus.register_listener(ChallengeEvent.referral_signup,
referral_challenge_manager)
bus.register_listener(ChallengeEvent.referral_signup,
verified_referral_challenge_manager)
session.add(block)
session.flush()
session.add(referrer)
session.flush()
# set challenge as active for purposes of test
session.query(Challenge).filter(
or_(
Challenge.id == "referred",
Challenge.id == "referrals",
Challenge.id == "ref-v",
)).update({
"active": True,
"starting_block": BLOCK_NUMBER
})
# Test:
# Ensure a single referral from single signup
# despite many challenge events
dispatch_new_user_signup(referrer.user_id, 2, session, bus)
for _ in range(0, 4):
bus.dispatch(
ChallengeEvent.referral_signup,
BLOCK_NUMBER,
referrer.user_id,
{"referred_user_id": 2},
)
bus.dispatch(ChallengeEvent.referred_signup, BLOCK_NUMBER, 2)
bus.flush()
bus.process_events(session)
challenges = (session.query(UserChallenge).filter(
UserChallenge.user_id == referrer.user_id).all())
assert len(challenges) == 1
# Test:
# Multiple signups
# - Referrer is capped at 5
# - Referred can keep going
dispatch_new_user_signup(referrer.user_id, 3, session, bus)
dispatch_new_user_signup(referrer.user_id, 4, session, bus)
dispatch_new_user_signup(referrer.user_id, 5, session, bus)
dispatch_new_user_signup(referrer.user_id, 6, session, bus)
dispatch_new_user_signup(referrer.user_id, 7, session, bus)
dispatch_new_user_signup(referrer.user_id, 8, session, bus)
dispatch_new_user_signup(referrer.user_id, 9, session, bus)
dispatch_new_user_signup(referrer.user_id, 10, session, bus)
dispatch_new_user_signup(referrer.user_id, 11, session, bus)
bus.flush()
bus.process_events(session)
challenges = (session.query(UserChallenge).filter(
UserChallenge.user_id == referrer.user_id,
UserChallenge.challenge_id == "referrals",
UserChallenge.is_complete == True,
).all())
assert len(challenges) == 5
challenges = (session.query(UserChallenge).filter(
UserChallenge.challenge_id == "referred",
UserChallenge.is_complete == True,
).all())
assert len(challenges) == 10
# Test:
# Ensure there are no verified user referrals created yet
challenges = (session.query(UserChallenge).filter(
UserChallenge.user_id == referrer.user_id,
UserChallenge.challenge_id == "ref-v",
UserChallenge.is_complete == True,
).all())
assert len(challenges) == 0
# Test: verified users
# - Ensure that verified user referrals aren't counted
# for referrer credit
# - Ensure that a verified user challenge exists
verified_user = User(
blockhash="0x1",
blocknumber=BLOCK_NUMBER,
txhash="xyz",
user_id=12,
is_current=True,
handle="VerifiedReferrer",
handle_lc="verifiedreferrer",
wallet="0x1",
is_creator=False,
is_verified=True,
name="referrer_name",
created_at=datetime.now(),
updated_at=datetime.now(),
)
session.add(verified_user)
session.flush()
dispatch_new_user_signup(verified_user.user_id, 13, session, bus)
bus.flush()
bus.process_events(session)
# Ensure no regular referral created
challenges = (session.query(UserChallenge).filter(
UserChallenge.user_id == verified_user.user_id,
UserChallenge.challenge_id == "referrals",
UserChallenge.is_complete == True,
).all())
assert len(challenges) == 0
# Ensure one verified referral created
challenges = (session.query(UserChallenge).filter(
UserChallenge.user_id == verified_user.user_id,
UserChallenge.challenge_id == "ref-v",
UserChallenge.is_complete == True,
).all())
assert len(challenges) == 1
# Test: verified max count
# - Ensure with > 5000 verified referrals, we cap at 5000
# - No regular referrals are made
for i in range(5010):
dispatch_new_user_signup(verified_user.user_id, 14 + i, session,
bus)
if i % 500 == 0:
bus.flush()
bus.process_events(session)
bus.flush()
bus.process_events(session)
# Ensure 5000 verified referral created
challenges = (session.query(UserChallenge).filter(
UserChallenge.user_id == verified_user.user_id,
UserChallenge.challenge_id == "ref-v",
UserChallenge.is_complete == True,
).all())
assert len(challenges) == 5000
# Ensure no regular referral created
challenges = (session.query(UserChallenge).filter(
UserChallenge.user_id == verified_user.user_id,
UserChallenge.challenge_id == "referrals",
UserChallenge.is_complete == True,
).all())
assert len(challenges) == 0
def test_catches_exceptions_in_single_processor(app):
"""Ensure that if a single processor fails, the others still succeed"""
with app.app_context():
db = get_db()
redis_conn = redis.Redis.from_url(url=REDIS_URL)
bus = ChallengeEventBus(redis_conn)
with db.scoped_session() as session:
session.add_all([
Challenge(
id="test_challenge_1",
type=ChallengeType.numeric,
amount="5",
step_count=3,
active=True,
),
Challenge(
id="test_challenge_2",
type=ChallengeType.numeric,
amount="5",
step_count=3,
active=True,
),
])
session.commit()
correct_manager = ChallengeManager("test_challenge_1",
DefaultUpdater())
broken_manager = ChallengeManager("test_challenge_2", BrokenUpdater())
TEST_EVENT = "TEST_EVENT"
TEST_EVENT_2 = "TEST_EVENT_2"
bus.register_listener(TEST_EVENT, correct_manager)
bus.register_listener(TEST_EVENT_2, broken_manager)
with bus.use_scoped_dispatch_queue():
# dispatch the broken one first
bus.dispatch(TEST_EVENT_2, 101, 1)
bus.dispatch(TEST_EVENT, 101, 1)
try:
bus.process_events(session)
except:
# pylint: disable=W0707
raise Exception("Shouldn't have propogated error!")
challenge_1_state = correct_manager.get_user_challenge_state(
session, ["1"])
# Make sure that the 'correct_manager' still executes
assert len(challenge_1_state) == 1
assert challenge_1_state[0].current_step_count == 1
# Make sure broken manager didn't do anything
challenge_2_state = broken_manager.get_user_challenge_state(
session, ["1"])
assert len(challenge_2_state) == 0
# Try the other order
with bus.use_scoped_dispatch_queue():
# dispatch the correct one first
bus.dispatch(TEST_EVENT, 101, 1)
bus.dispatch(TEST_EVENT_2, 101, 1)
try:
bus.process_events(session)
except:
# pylint: disable=W0707
raise Exception("Shouldn't have propogated error!")
challenge_1_state = correct_manager.get_user_challenge_state(
session, ["1"])
assert len(challenge_1_state) == 1
assert challenge_1_state[0].current_step_count == 2
# Make sure broken manager didn't do anything
challenge_2_state = broken_manager.get_user_challenge_state(
session, ["1"])
assert len(challenge_2_state) == 0
def test_aggregates(app):
setup_challenges(app)
with app.app_context():
db = get_db()
redis_conn = redis.Redis.from_url(url=REDIS_URL)
with db.scoped_session() as session:
bus = ChallengeEventBus(redis_conn)
agg_challenge = ChallengeManager("test_challenge_3",
AggregateUpdater())
agg_challenge.process(session, "test_event", [])
TEST_EVENT = "TEST_EVENT"
bus.register_listener(
TEST_EVENT, ChallengeManager("test_challenge_1", DefaultUpdater()))
bus.register_listener(
TEST_EVENT, ChallengeManager("test_challenge_2", DefaultUpdater()))
# - Multiple events with the same user_id but diff specifiers get created
bus.register_listener(TEST_EVENT, agg_challenge)
bus.dispatch(TEST_EVENT, 100, 1, {"referred_id": 2})
bus.dispatch(TEST_EVENT, 100, 1, {"referred_id": 3})
bus.flush()
bus.process_events(session)
state = agg_challenge.get_user_challenge_state(session, ["1-2", "1-3"])
assert len(state) == 2
# Also make sure the thing is incomplete
res = get_challenges(1, False, session, bus)
agg_chal = {c["challenge_id"]: c for c in res}["test_challenge_3"]
assert agg_chal["is_complete"] == False
# - Multiple events with the same specifier get deduped
bus.dispatch(TEST_EVENT, 100, 1, {"referred_id": 4})
bus.dispatch(TEST_EVENT, 100, 1, {"referred_id": 4})
bus.flush()
bus.process_events(session)
state = agg_challenge.get_user_challenge_state(session, ["1-4"])
assert len(state) == 1
# - If we've maxed the # of challenges, don't create any more
bus.dispatch(TEST_EVENT, 100, 1, {"referred_id": 5})
bus.dispatch(TEST_EVENT, 100, 1, {"referred_id": 6})
bus.flush()
bus.process_events(session)
def get_user_challenges():
return (session.query(UserChallenge).filter(
UserChallenge.challenge_id == "test_challenge_3",
UserChallenge.user_id == 1,
).all())
assert len(get_user_challenges()) == 5
bus.dispatch(TEST_EVENT, 100, 1, {"referred_id": 7})
bus.flush()
bus.process_events(session)
assert len(get_user_challenges()) == 5
# Test get_challenges
res = get_challenges(1, False, session, bus)
agg_chal = {c["challenge_id"]: c for c in res}["test_challenge_3"]
assert agg_chal["is_complete"] == True
# Assert all user challenges have proper finishing block #
user_challenges = get_user_challenges()
for uc in user_challenges:
assert uc.completed_blocknumber == 100
def update_user_events(
session: Session,
user_record: User,
events: UserEventsMetadata,
bus: ChallengeEventBus,
) -> None:
"""Updates the user events table"""
try:
if not isinstance(events, dict) or not user_record.blocknumber:
# There is something wrong with events, don't process it
return
# Get existing UserEvents entry
existing_user_events = (session.query(UserEvents).filter_by(
user_id=user_record.user_id, is_current=True).one_or_none())
existing_referrer = (existing_user_events.referrer
if existing_user_events else None)
existing_mobile_user = (existing_user_events.is_mobile_user
if existing_user_events else False)
user_events = UserEvents(
user_id=user_record.user_id,
is_current=True,
blocknumber=user_record.blocknumber,
blockhash=user_record.blockhash,
referrer=existing_referrer,
is_mobile_user=existing_mobile_user,
)
for event, value in events.items():
if (event == "referrer" and isinstance(value, int)
and user_events.referrer is None
and user_record.user_id != value):
user_events.referrer = value
bus.dispatch(
ChallengeEvent.referral_signup,
user_record.blocknumber,
value,
{"referred_user_id": user_record.user_id},
)
bus.dispatch(
ChallengeEvent.referred_signup,
user_record.blocknumber,
user_record.user_id,
)
elif (event == "is_mobile_user" and isinstance(value, bool)
and not user_events.is_mobile_user):
user_events.is_mobile_user = value
if value:
bus.dispatch(
ChallengeEvent.mobile_install,
user_record.blocknumber,
user_record.user_id,
)
# Only add a row if there's an update
if (existing_user_events is None
or user_events.is_mobile_user != existing_mobile_user
or user_events.referrer != existing_referrer):
# Mark existing UserEvents entries as not current
session.query(UserEvents).filter_by(user_id=user_record.user_id,
is_current=True).update(
{"is_current": False})
session.add(user_events)
except Exception as e:
logger.error(
f"index.py | users.py | Fatal updating user events while indexing {e}",
exc_info=True,
)
def dispatch_challenge_follow(bus: ChallengeEventBus, follow, block_number):
bus.dispatch(ChallengeEvent.follow, block_number, follow.follower_user_id)
def dispatch_challenge_track_upload(bus: ChallengeEventBus, block_number: int,
track_record):
bus.dispatch(ChallengeEvent.track_upload, block_number,
track_record.owner_id)