Skip to content

serejaris/telegram-skills / skills/tg-stars-payments

tg-stars-payments

Verified

Use when a Telegram bot or Mini App sells digital goods for Stars (XTR): invoices and invoice links, openInvoice, pre_checkout_query, crediting on successful_payment without double delivery, refunds and /paysupport, 30-day subscriptions, paid media, testing payments, Star payout figures.

FileKindSize
SKILL.mdskill md16.7 KB
references/stars-economics.mdmarkdown3.6 KB
scripts/stars_ledger.pyscript9.6 KB
tests/test_stars_ledger.pyscript23.6 KB

tests/test_stars_ledger.py

View on GitHub
import importlib.util
from pathlib import Path
import signal
import subprocess
import sys
import tempfile
import threading
import unittest

SCRIPT = Path(__file__).parents[1] / 'scripts/stars_ledger.py'
SPEC = importlib.util.spec_from_file_location('stars_ledger', SCRIPT)
ledger = importlib.util.module_from_spec(SPEC)
sys.modules['stars_ledger'] = ledger
SPEC.loader.exec_module(ledger)

DAY = 86400
PERIOD = 30 * DAY
START = 1_800_000_000
NOW = 1_900_000_000


def paid(update_id=1, charge='stx-1', field='message', **extra):
    event = {'currency': 'XTR', 'total_amount': 5, 'invoice_payload': 'sku-1',
             'telegram_payment_charge_id': charge, 'provider_payment_charge_id': '', **extra}
    return {'update_id': update_id,
            field: {'message_id': 9, 'from': {'id': 42}, 'chat': {'id': 42}, 'successful_payment': event}}


def refunded(charge='stx-1', field='message'):
    event = {'currency': 'XTR', 'total_amount': 5, 'invoice_payload': 'sku-1',
             'telegram_payment_charge_id': charge}
    return {'update_id': 7, field: {'from': {'id': 42}, 'refunded_payment': event}}


def incoming(charge='stx-1', date=START, period=None, **partner):
    source = {'type': 'user', 'transaction_type': 'invoice_payment', 'user': {'id': 42},
              'invoice_payload': 'sku-1', **partner}
    if period is not None:
        source['subscription_period'] = period
    return {'id': charge, 'amount': 5, 'date': date, 'source': source}


def renewal(charge='sub', expires_at=START + PERIOD):
    return ledger.parse_payment(paid(charge=charge, subscription_expiration_date=expires_at,
                                     is_recurring=True))


def states(conn):
    rows = conn.execute('SELECT subscription_expires_at, state FROM star_payments '
                        'ORDER BY subscription_expires_at')
    return rows.fetchall()


class Parsing(unittest.TestCase):
    def test_reads_payment_fields(self):
        payment = ledger.parse_payment(paid())
        self.assertEqual(payment, ledger.Payment('stx-1', 0, 42, 5, 'sku-1'))
        self.assertEqual(payment.key, ('stx-1', 0))

    def test_every_message_container_is_read(self):
        for field in ledger.MESSAGE_FIELDS:
            with self.subTest(field):
                self.assertEqual(ledger.parse_payment(paid(field=field)).charge_id, 'stx-1')
                self.assertEqual(ledger.parse_refund_charge_id(refunded(field=field)), 'stx-1')

    def test_payment_without_sender_raises_in_a_channel_post(self):
        update = paid(field='channel_post')
        del update['channel_post']['from']
        with self.assertRaises(ValueError):
            ledger.parse_payment(update)

    def test_other_updates_are_not_payments(self):
        for update in ({'update_id': 1}, {'update_id': 1, 'message': {'text': 'hi'}},
                       {'update_id': 1, 'pre_checkout_query': {'id': 'q'}}, {'message': None}):
            self.assertIsNone(ledger.parse_payment(update))
            self.assertIsNone(ledger.parse_refund_charge_id(update))

    def test_garbage_updates_raise(self):
        for update in (None, [], 'x', 1):
            with self.assertRaises(ValueError):
                ledger.parse_payment(update)

    def test_broken_payments_raise(self):
        cases = [
            {'telegram_payment_charge_id': ''},
            {'telegram_payment_charge_id': None},
            {'telegram_payment_charge_id': 7},
            {'currency': 'USD'},
            {'total_amount': 0},
            {'total_amount': -1},
            {'total_amount': '5'},
            {'total_amount': True},
            {'total_amount': 1.5},
            {'invoice_payload': None},
            {'subscription_expiration_date': 'soon'},
            {'subscription_expiration_date': -1},
        ]
        for fields in cases:
            with self.subTest(fields), self.assertRaises(ValueError):
                ledger.parse_payment(paid(**fields))

    def test_event_and_sender_shape(self):
        update = paid()
        update['message']['successful_payment'] = 'paid'
        with self.assertRaises(ValueError):
            ledger.parse_payment(update)
        for sender in (None, {}, {'id': 0}, {'id': True}, {'id': '42'}, 'user'):
            update = paid()
            update['message']['from'] = sender
            with self.subTest(sender), self.assertRaises(ValueError):
                ledger.parse_payment(update)

    def test_broken_refund_raises(self):
        update = refunded()
        del update['message']['refunded_payment']['telegram_payment_charge_id']
        with self.assertRaises(ValueError):
            ledger.parse_refund_charge_id(update)


class FileLedger(unittest.TestCase):
    def setUp(self):
        folder = tempfile.TemporaryDirectory()
        self.addCleanup(folder.cleanup)
        self.path = str(Path(folder.name) / 'ledger.sqlite3')
        self.conn = self.open()

    def open(self):
        conn = ledger.connect(self.path)
        self.addCleanup(conn.close)
        return conn


class Connecting(FileLedger):
    def test_path_is_required(self):
        with self.assertRaises(TypeError):
            ledger.connect()
        for path in ('', ':memory:', None, 7):
            with self.subTest(path), self.assertRaises(ValueError):
                ledger.connect(path)

    def test_recorded_payment_survives_reopening(self):
        payment = ledger.parse_payment(paid())
        ledger.record_payment(self.conn, payment)
        self.conn.close()
        self.assertEqual(ledger.pending(self.open(), NOW), [payment])

    def test_uncommitted_payment_is_gone_after_reopening(self):
        self.conn.execute('BEGIN IMMEDIATE')
        ledger.record_payment(self.conn, ledger.parse_payment(paid()))
        self.conn.close()
        self.assertEqual(ledger.pending(self.open(), NOW), [])

    def test_duplicate_leaves_no_open_transaction(self):
        payment = ledger.parse_payment(paid())
        ledger.record_payment(self.conn, payment)
        self.assertFalse(ledger.record_payment(self.conn, payment))
        self.assertFalse(self.conn.in_transaction)


class Crediting(FileLedger):
    def deliver(self, payment, now=NOW):
        self.assertTrue(ledger.claim(self.conn, payment, now))
        self.assertTrue(ledger.mark_delivered(self.conn, payment))

    def test_duplicate_with_new_update_id_delivers_once(self):
        first, second = paid(update_id=100), paid(update_id=200)
        self.assertTrue(ledger.record_payment(self.conn, ledger.parse_payment(first)))
        self.assertFalse(ledger.record_payment(self.conn, ledger.parse_payment(second)))
        due = ledger.pending(self.conn, NOW)
        self.assertEqual(len(due), 1)
        self.deliver(due[0])
        self.assertFalse(ledger.claim(self.conn, due[0], NOW))
        self.assertFalse(ledger.mark_delivered(self.conn, due[0]))
        self.assertEqual(ledger.pending(self.conn, NOW), [])

    def test_same_update_id_with_new_charge_is_a_new_payment(self):
        self.assertTrue(ledger.record_payment(self.conn, ledger.parse_payment(paid(update_id=5, charge='a'))))
        self.assertTrue(ledger.record_payment(self.conn, ledger.parse_payment(paid(update_id=5, charge='b'))))
        self.assertEqual(len(ledger.pending(self.conn, NOW)), 2)

    def test_renewal_counts_whether_or_not_the_charge_id_repeats(self):
        for number, charges in enumerate((('sub', 'sub'), ('sub-1', 'sub-2'))):
            conn = ledger.connect(f'{self.path}.{number}')
            self.addCleanup(conn.close)
            ledger.record_payment(conn, renewal(charges[0], 1000))
            self.assertTrue(ledger.record_payment(conn, renewal(charges[1], 2000)))
            self.assertFalse(ledger.record_payment(conn, renewal(charges[1], 2000)))
            self.assertEqual(len(ledger.pending(conn, NOW)), 2)

    def test_mark_delivered_needs_a_claim(self):
        payment = ledger.parse_payment(paid())
        ledger.record_payment(self.conn, payment)
        self.assertFalse(ledger.mark_delivered(self.conn, payment))

    def test_released_claim_can_be_taken_again(self):
        payment = ledger.parse_payment(paid())
        ledger.record_payment(self.conn, payment)
        self.assertTrue(ledger.claim(self.conn, payment, NOW))
        self.assertTrue(ledger.release(self.conn, payment))
        self.assertFalse(ledger.release(self.conn, payment))
        self.assertTrue(ledger.claim(self.conn, payment, NOW))

    def test_live_claim_blocks_a_second_connection(self):
        payment = ledger.parse_payment(paid())
        ledger.record_payment(self.conn, payment)
        second = self.open()
        self.assertTrue(ledger.claim(self.conn, payment, NOW))
        self.assertFalse(ledger.claim(second, payment, NOW))
        self.assertEqual(ledger.pending(second, NOW), [])

    def test_expired_lease_returns_the_payment(self):
        payment = ledger.parse_payment(paid())
        ledger.record_payment(self.conn, payment)
        ledger.claim(self.conn, payment, NOW, lease=60)
        self.assertEqual(ledger.pending(self.conn, NOW + 59), [])
        self.assertEqual(ledger.pending(self.conn, NOW + 60), [payment])
        self.assertTrue(ledger.claim(self.conn, payment, NOW + 60))

    def test_balance_and_mark_share_one_transaction(self):
        self.conn.execute('CREATE TABLE balance (user_id INTEGER, stars INTEGER)')
        payment = ledger.parse_payment(paid())
        ledger.record_payment(self.conn, payment)
        ledger.claim(self.conn, payment, NOW)
        with self.assertRaises(RuntimeError), ledger.transaction(self.conn):
            self.conn.execute('INSERT INTO balance VALUES (?, ?)', (payment.user_id, payment.amount))
            ledger.mark_delivered(self.conn, payment)
            raise RuntimeError('crash before commit')
        self.assertEqual(self.conn.execute('SELECT count(*) FROM balance').fetchone(), (0,))
        self.assertEqual(states(self.conn), [(0, ledger.CLAIMED)])

    def test_refund_after_claim_leaves_the_balance_empty(self):
        self.conn.execute('CREATE TABLE balance (user_id INTEGER, stars INTEGER)')
        payment = ledger.parse_payment(paid())
        ledger.record_payment(self.conn, payment)
        ledger.claim(self.conn, payment, NOW)
        ledger.record_refund(self.conn, payment.charge_id)
        with ledger.transaction(self.conn):
            if ledger.mark_delivered(self.conn, payment):
                self.conn.execute('INSERT INTO balance VALUES (?, ?)', (payment.user_id, payment.amount))
        self.assertEqual(self.conn.execute('SELECT count(*) FROM balance').fetchone(), (0,))

    def test_state_tells_a_refund_from_a_finished_delivery(self):
        payment = ledger.parse_payment(paid())
        self.assertIsNone(ledger.state(self.conn, payment))
        ledger.record_payment(self.conn, payment)
        ledger.claim(self.conn, payment, NOW, lease=60)
        self.assertTrue(ledger.claim(self.open(), payment, NOW + 60))
        self.assertTrue(ledger.mark_delivered(self.conn, payment))
        self.assertFalse(ledger.mark_delivered(self.conn, payment))
        self.assertEqual(ledger.state(self.conn, payment), ledger.DELIVERED)

    def test_refund_blocks_delivery_and_is_idempotent(self):
        payment = ledger.parse_payment(paid())
        ledger.record_payment(self.conn, payment)
        charge = ledger.parse_refund_charge_id(refunded())
        self.assertTrue(ledger.record_refund(self.conn, charge))
        self.assertFalse(ledger.record_refund(self.conn, charge))
        self.assertEqual(ledger.pending(self.conn, NOW), [])
        self.assertFalse(ledger.claim(self.conn, payment, NOW))

    def test_refund_during_delivery_wins_over_the_mark(self):
        payment = ledger.parse_payment(paid())
        ledger.record_payment(self.conn, payment)
        ledger.claim(self.conn, payment, NOW)
        ledger.record_refund(self.conn, payment.charge_id)
        self.assertFalse(ledger.mark_delivered(self.conn, payment))
        self.assertEqual(states(self.conn), [(0, ledger.REFUNDED)])

    def test_refund_touches_newest_period_only(self):
        for expires_at in (1000, 2000):
            ledger.record_payment(self.conn, renewal('sub', expires_at))
        ledger.record_refund(self.conn, 'sub')
        due = ledger.pending(self.conn, NOW)
        self.assertEqual([payment.subscription_expires_at for payment in due], [1000])

    def test_refund_before_payment_keeps_it_from_delivery(self):
        self.assertTrue(ledger.record_refund(self.conn, 'stx-1'))
        self.assertFalse(ledger.record_refund(self.conn, 'stx-1'))
        ledger.record_payment(self.conn, ledger.parse_payment(paid()))
        self.assertEqual(ledger.pending(self.conn, NOW), [])
        self.assertEqual(states(self.conn), [(0, ledger.REFUNDED)])

    def test_replayed_refund_spares_the_next_period(self):
        ledger.record_payment(self.conn, renewal('sub', 1000))
        ledger.record_refund(self.conn, 'sub')
        self.assertFalse(ledger.record_refund(self.conn, 'sub'))
        ledger.record_payment(self.conn, renewal('sub', 2000))
        self.assertEqual(len(ledger.pending(self.conn, NOW)), 1)


class DeliveryPass(FileLedger):
    def run_pass(self, deliver):
        errors, revoked = [], []
        for due in ledger.pending(self.conn, NOW):
            if not ledger.claim(self.conn, due, NOW):
                continue
            try:
                deliver(due)
            except Exception as error:
                ledger.release(self.conn, due)
                errors.append((due.charge_id, str(error)))
                continue
            if not ledger.mark_delivered(self.conn, due):
                if ledger.state(self.conn, due) == ledger.REFUNDED:
                    revoked.append(due.charge_id)
        return errors, revoked

    def test_failing_row_does_not_hold_the_rows_behind_it(self):
        for charge in ('blocked', 'next', 'last'):
            ledger.record_payment(self.conn, ledger.parse_payment(paid(charge=charge)))
        delivered = []

        def deliver(due):
            if due.charge_id == 'blocked':
                raise RuntimeError('bot was blocked by the user')
            delivered.append(due.charge_id)

        errors, _ = self.run_pass(deliver)
        self.assertEqual(delivered, ['next', 'last'])
        self.assertEqual(errors, [('blocked', 'bot was blocked by the user')])
        self.assertEqual([p.charge_id for p in ledger.pending(self.conn, NOW)], ['blocked'])

    def test_refund_during_delivery_revokes_the_grant(self):
        ledger.record_payment(self.conn, ledger.parse_payment(paid()))
        errors, revoked = self.run_pass(lambda due: ledger.record_refund(self.conn, due.charge_id))
        self.assertEqual((errors, revoked), ([], ['stx-1']))


class ParallelWebhooks(FileLedger):
    HANDLERS = 8
    PAYMENTS = 20

    def test_handlers_deliver_each_payment_once(self):
        for number in range(self.PAYMENTS):
            ledger.record_payment(self.conn, ledger.parse_payment(paid(charge=f'stx-{number}')))
        start = threading.Barrier(self.HANDLERS)
        counted = threading.Lock()
        deliveries = []
        errors = []

        def handler():
            conn = ledger.connect(self.path)
            try:
                start.wait()
                for payment in ledger.pending(conn, NOW):
                    if ledger.claim(conn, payment, NOW):
                        with counted:
                            deliveries.append(payment.key)
                        ledger.mark_delivered(conn, payment)
            except Exception as error:
                errors.append(error)
            finally:
                conn.close()

        threads = [threading.Thread(target=handler) for _ in range(self.HANDLERS)]
        for thread in threads:
            thread.start()
        for thread in threads:
            thread.join()
        self.assertEqual(errors, [])
        self.assertEqual(len(deliveries), self.PAYMENTS)
        self.assertEqual(len(set(deliveries)), self.PAYMENTS)
        self.assertEqual(ledger.pending(self.conn, NOW), [])

    def test_parallel_copies_of_one_update_record_one_row(self):
        results = []
        start = threading.Barrier(self.HANDLERS)

        def handler():
            conn = ledger.connect(self.path)
            start.wait()
            results.append(ledger.record_payment(conn, ledger.parse_payment(paid())))
            conn.close()

        threads = [threading.Thread(target=handler) for _ in range(self.HANDLERS)]
        for thread in threads:
            thread.start()
        for thread in threads:
            thread.join()
        self.assertEqual(sorted(results), [False] * (self.HANDLERS - 1) + [True])


CRASH = """
import importlib.util, os, signal, sys
spec = importlib.util.spec_from_file_location('stars_ledger', sys.argv[1])
ledger = importlib.util.module_from_spec(spec)
sys.modules['stars_ledger'] = ledger
spec.loader.exec_module(ledger)
conn = ledger.connect(sys.argv[2])
payment = ledger.Payment('stx-1', 0, 42, 5, 'sku-1')
if sys.argv[3] == 'inside-transaction':
    conn.execute('BEGIN IMMEDIATE')
    ledger.record_payment(conn, payment)
else:
    ledger.record_payment(conn, payment)
    if sys.argv[3] == 'during-delivery':
        ledger.claim(conn, payment, int(sys.argv[4]), lease=60)
os.kill(os.getpid(), signal.SIGKILL)
"""


class ProcessCrash(FileLedger):
    def crash(self, moment):
        self.conn.close()
        done = subprocess.run([sys.executable, '-c', CRASH, str(SCRIPT), self.path, moment, str(NOW)],
                              check=False)
        self.assertEqual(done.returncode, -signal.SIGKILL)
        return self.open()

    def test_kill_inside_transaction_leaves_no_row(self):
        conn = self.crash('inside-transaction')
        self.assertEqual(ledger.pending(conn, NOW), [])
        self.assertTrue(ledger.record_payment(conn, ledger.Payment('stx-1', 0, 42, 5, 'sku-1')))

    def test_kill_before_claim_leaves_payment_pending(self):
        conn = self.crash('after-record')
        self.assertEqual([p.charge_id for p in ledger.pending(conn, NOW)], ['stx-1'])

    def test_kill_during_delivery_returns_payment_after_the_lease(self):
        conn = self.crash('during-delivery')
        self.assertEqual(ledger.pending(conn, NOW), [])
        due = ledger.pending(conn, NOW + 60)
        self.assertEqual([p.charge_id for p in due], ['stx-1'])
        self.assertTrue(ledger.claim(conn, due[0], NOW + 60))


class Reconciling(FileLedger):
    def reconcile(self, transaction):
        return ledger.reconcile_transaction(self.conn, transaction, since=START - DAY)

    def test_since_is_required(self):
        with self.assertRaises(TypeError):
            ledger.reconcile_transaction(self.conn, incoming())
        for since in (None, '0', -1, True, 1.5):
            with self.subTest(since), self.assertRaises(ValueError):
                ledger.reconcile_transaction(self.conn, incoming(), since=since)

    def test_history_before_since_stays_out_of_the_queue(self):
        cutoff = START + 10 * DAY
        history = [incoming(f'old-{day}', START + day * DAY) for day in range(10)]
        lost = incoming('lost', cutoff)
        results = [ledger.reconcile_transaction(self.conn, item, since=cutoff)
                   for item in (*history, lost)]
        self.assertEqual(results, [False] * 10 + [True])
        self.assertEqual([p.charge_id for p in ledger.pending(self.conn, NOW)], ['lost'])

    def test_refund_before_since_changes_nothing(self):
        ledger.record_payment(self.conn, ledger.parse_payment(paid()))
        refund = {'id': 'stx-1', 'amount': 5, 'date': START,
                  'receiver': {'type': 'user', 'transaction_type': 'invoice_payment', 'user': {'id': 42}}}
        self.assertFalse(ledger.reconcile_transaction(self.conn, refund, since=START + 1))
        self.assertEqual(len(ledger.pending(self.conn, NOW)), 1)

    def test_recovers_a_lost_one_time_payment_once(self):
        self.assertTrue(self.reconcile(incoming()))
        self.assertFalse(self.reconcile(incoming()))
        self.assertFalse(ledger.record_payment(self.conn, ledger.parse_payment(paid())))
        self.assertEqual(ledger.pending(self.conn, NOW), [ledger.Payment('stx-1', 0, 42, 5, 'sku-1')])

    def test_transaction_matches_a_recorded_period(self):
        ledger.record_payment(self.conn, renewal(expires_at=START + PERIOD))
        late = START + 3600
        self.assertFalse(self.reconcile(incoming('sub', late, PERIOD)))
        self.assertEqual(len(ledger.pending(self.conn, NOW)), 1)

    def test_recovered_renewal_delivers_once_when_the_update_arrives_late(self):
        renewed_at = START + 3600
        true_expiry = START + PERIOD
        self.assertTrue(self.reconcile(incoming('sub', renewed_at, PERIOD)))
        due = ledger.pending(self.conn, NOW)
        self.assertEqual(due[0].subscription_expires_at, renewed_at + PERIOD)
        self.assertTrue(ledger.claim(self.conn, due[0], NOW))
        self.assertTrue(ledger.mark_delivered(self.conn, due[0]))
        self.assertFalse(ledger.record_payment(self.conn, renewal(expires_at=true_expiry)))
        self.assertEqual(ledger.pending(self.conn, NOW), [])
        self.assertEqual(states(self.conn), [(true_expiry, ledger.DELIVERED)])

    def test_late_update_during_delivery_keeps_the_claimed_key(self):
        renewed_at = START + 3600
        self.reconcile(incoming('sub', renewed_at, PERIOD))
        due = ledger.pending(self.conn, NOW)[0]
        self.assertTrue(ledger.claim(self.conn, due, NOW))
        self.assertFalse(ledger.record_payment(self.conn, renewal(expires_at=START + PERIOD)))
        self.assertTrue(ledger.mark_delivered(self.conn, due))
        self.assertEqual(ledger.pending(self.conn, NOW + ledger.DEFAULT_LEASE), [])
        self.assertEqual(states(self.conn), [(due.subscription_expires_at, ledger.DELIVERED)])

    def test_next_period_on_the_same_charge_stays_a_new_payment(self):
        ledger.record_payment(self.conn, renewal(expires_at=START + PERIOD))
        next_date = START + PERIOD
        self.assertTrue(self.reconcile(incoming('sub', next_date, PERIOD)))
        self.assertEqual(len(ledger.pending(self.conn, NOW)), 2)
        self.assertFalse(self.reconcile(incoming('sub', next_date, PERIOD)))
        self.assertFalse(ledger.record_payment(self.conn, renewal(expires_at=START + 2 * PERIOD)))
        self.assertEqual(len(ledger.pending(self.conn, NOW)), 2)

    def test_outgoing_transaction_records_a_refund(self):
        ledger.record_payment(self.conn, ledger.parse_payment(paid()))
        refund = {'id': 'stx-1', 'amount': 5, 'date': START,
                  'receiver': {'type': 'user', 'transaction_type': 'invoice_payment', 'user': {'id': 42}}}
        self.assertTrue(self.reconcile(refund))
        self.assertEqual(ledger.pending(self.conn, NOW), [])

    def test_refund_seen_first_stops_the_recovered_payment(self):
        refund = {'id': 'stx-1', 'amount': 5, 'date': START,
                  'receiver': {'type': 'user', 'transaction_type': 'invoice_payment', 'user': {'id': 42}}}
        self.reconcile(refund)
        self.reconcile(incoming())
        self.assertEqual(ledger.pending(self.conn, NOW), [])

    def test_other_partners_are_ignored(self):
        for partner in ({'type': 'fragment'}, {'type': 'user', 'transaction_type': 'gift_purchase'}):
            transaction = {'id': 'x', 'amount': 1, 'date': START, 'source': partner}
            self.assertFalse(self.reconcile(transaction))
            self.assertFalse(self.reconcile({'id': 'x', 'amount': 1, 'date': START, 'receiver': partner}))
        self.assertEqual(ledger.pending(self.conn, NOW), [])

    def test_broken_transactions_raise(self):
        broken = [None, [], {}, {'id': ''}, {'id': 'x', 'amount': '1', 'date': START},
                  {'id': 'x', 'amount': 1, 'date': None},
                  incoming(invoice_payload=None), incoming(user={}), incoming(period=-1)]
        for transaction in broken:
            with self.subTest(transaction), self.assertRaises(ValueError):
                self.reconcile(transaction)


if __name__ == '__main__':
    unittest.main()
finishing-a-development-branchobra/superpowersUse when implementation is complete, all tests pass, and you need to decide how to integrate the workStars: 323kUpdated Claude CodeCodexVerifiedInstall
systematic-debuggingobra/superpowersUse when encountering any bug, test failure, or unexpected behavior, before proposing fixesStars: 323kUpdated Claude CodeCodexVerifiedInstall
test-driven-developmentobra/superpowersUse when implementing any feature or bugfix, before writing implementation codeStars: 323kUpdated Claude CodeCodexVerifiedInstall
skill-creatoranthropics/skillsCreate new skills, modify and improve existing skills, and measure skill performance. Use when users want to create a skill from scratch, edit, or optimize an existing skill, run evals to test a skill, benchmark skill performance with variance analysis, or optimize a skill's description for better triggering accuracy.Stars: 198kUpdated Claude CodeCodexVerifiedInstall