def test_clear(find):
with foo_user():
valid_card = mock.Mock()
valid_card.is_valid = True
invalid_card = mock.Mock()
invalid_card.is_valid = False
card_collection = [valid_card, invalid_card]
find.return_value.cards = card_collection
MURKY = """\
UPDATE participants
SET balanced_account_uri='not null'
, last_bill_result='ooga booga'
WHERE id=%s
"""
gittip.db.execute(MURKY, ('foo',))
billing.clear( u"credit card"
, 'foo'
, balanced_account_uri
)
assert not valid_card.is_valid
assert valid_card.save.call_count
assert not invalid_card.save.call_count
user = authentication.User.from_id('foo')
assert not user.session['last_bill_result']
assert user.session['balanced_account_uri']
def test_clear_bank_account(b_account):
with foo_user():
valid_ba = mock.Mock()
valid_ba.is_valid = True
invalid_ba = mock.Mock()
invalid_ba.is_valid = False
ba_collection = [
valid_ba, invalid_ba
]
b_account.find.return_value.bank_accounts = ba_collection
MURKY = """\
UPDATE participants
SET balanced_account_uri='not null'
, last_ach_result='ooga booga'
WHERE id=%s
"""
gittip.db.execute(MURKY, ('foo',))
billing.clear(u"bank account", 'foo', 'something')
assert not valid_ba.is_valid
assert valid_ba.save.call_count
assert not invalid_ba.save.call_count
user = authentication.User.from_id('foo')
assert not user.session['last_ach_result']
assert user.session['balanced_account_uri']
def test_clear(self, find):
valid_card = mock.Mock()
valid_card.is_valid = True
invalid_card = mock.Mock()
invalid_card.is_valid = False
card_collection = [valid_card, invalid_card]
find.return_value.cards = card_collection
MURKY = """\
UPDATE participants
SET balanced_account_uri='not null'
, last_bill_result='ooga booga'
WHERE id=%s
"""
self.db.execute(MURKY, (self.participant_id, ))
billing.clear(u"credit card", self.participant_id,
self.balanced_account_uri)
self.assertFalse(valid_card.is_valid)
self.assertTrue(valid_card.save.call_count)
self.assertFalse(invalid_card.save.call_count)
user = authentication.User.from_id(self.participant_id)
self.assertFalse(user.session['last_bill_result'])
self.assertTrue(user.session['balanced_account_uri'])
def test_clear(self, find):
valid_card = mock.Mock()
valid_card.is_valid = True
invalid_card = mock.Mock()
invalid_card.is_valid = False
card_collection = [valid_card, invalid_card]
find.return_value.cards = card_collection
MURKY = """\
UPDATE participants
SET balanced_account_uri='not null'
, last_bill_result='ooga booga'
WHERE username=%s
"""
self.db.run(MURKY, ('alice',))
billing.clear(self.db, u"credit card", 'alice', self.balanced_account_uri)
assert not valid_card.is_valid
assert valid_card.save.call_count
assert not invalid_card.save.call_count
user = authentication.User.from_username('alice')
assert not user.participant.last_bill_result
assert user.participant.balanced_account_uri
def test_clear(find):
with foo_user():
valid_card = mock.Mock()
valid_card.is_valid = True
invalid_card = mock.Mock()
invalid_card.is_valid = False
card_collection = [valid_card, invalid_card]
find.return_value.cards = card_collection
MURKY = """\
UPDATE participants
SET balanced_account_uri='not null'
, last_bill_result='ooga booga'
WHERE id=%s
"""
gittip.db.execute(MURKY, ('foo',))
billing.clear( u"credit card"
, 'foo'
, balanced_account_uri
)
assert not valid_card.is_valid
assert valid_card.save.call_count
assert not invalid_card.save.call_count
user = authentication.User.from_id('foo')
assert not user.session['last_bill_result']
assert user.session['balanced_account_uri']
def test_clear_bank_account(self, b_account):
valid_ba = mock.Mock()
valid_ba.is_valid = True
invalid_ba = mock.Mock()
invalid_ba.is_valid = False
ba_collection = [
valid_ba, invalid_ba
]
b_account.find.return_value.bank_accounts = ba_collection
MURKY = """\
UPDATE participants
SET balanced_account_uri='not null'
, last_ach_result='ooga booga'
WHERE username=%s
"""
self.db.run(MURKY, ('alice',))
billing.clear(self.db, u"bank account", 'alice', 'something')
assert not valid_ba.is_valid
assert valid_ba.save.call_count
assert not invalid_ba.save.call_count
user = authentication.User.from_username('alice')
assert not user.participant.last_ach_result
assert user.participant.balanced_account_uri
def test_clear(self):
balanced.Card.fetch(self.card_href)\
.associate_to_customer(self.balanced_customer_href)
MURKY = """\
UPDATE participants
SET balanced_customer_href='not null'
, last_bill_result='ooga booga'
WHERE username=%s
"""
self.db.run(MURKY, ('alice', ))
billing.clear(self.db, u"credit card", 'alice',
self.balanced_customer_href)
customer = balanced.Customer.fetch(self.balanced_customer_href)
cards = customer.cards.all()
assert len(cards) == 0
user = authentication.User.from_username('alice')
assert not user.participant.last_bill_result
assert user.participant.balanced_customer_href
def test_clear(self, ba):
valid_card = mock.Mock()
valid_card.is_valid = True
invalid_card = mock.Mock()
invalid_card.is_valid = False
card_collection = [
valid_card, invalid_card
]
balanced.Account.find.return_value.cards = card_collection
MURKY = """\
UPDATE participants
SET balanced_account_uri='not null'
, last_bill_result='ooga booga'
WHERE id=%s
"""
self.db.execute(MURKY, (self.participant_id,))
billing.clear(self.participant_id, self.balanced_account_uri)
self.assertFalse(valid_card.is_valid)
self.assertTrue(valid_card.save.call_count)
self.assertFalse(invalid_card.save.call_count)
user = authentication.User.from_id(self.participant_id)
self.assertFalse(user.session['last_bill_result'])
self.assertFalse(user.session['balanced_account_uri'])
def test_clear_bank_account(self, b_account):
valid_ba = mock.Mock()
valid_ba.is_valid = True
invalid_ba = mock.Mock()
invalid_ba.is_valid = False
ba_collection = [valid_ba, invalid_ba]
b_account.find.return_value.bank_accounts = ba_collection
MURKY = """\
UPDATE participants
SET balanced_account_uri='not null'
, last_ach_result='ooga booga'
WHERE id=%s
"""
self.db.execute(MURKY, (self.participant_id, ))
billing.clear(u"bank account", self.participant_id, 'something')
self.assertFalse(valid_ba.is_valid)
self.assertTrue(valid_ba.save.call_count)
self.assertFalse(invalid_ba.save.call_count)
user = authentication.User.from_id(self.participant_id)
self.assertFalse(user.session['last_ach_result'])
self.assertTrue(user.session['balanced_account_uri'])
def test_clear_bank_account(b_account):
with foo_user():
valid_ba = mock.Mock()
valid_ba.is_valid = True
invalid_ba = mock.Mock()
invalid_ba.is_valid = False
ba_collection = [
valid_ba, invalid_ba
]
b_account.find.return_value.bank_accounts = ba_collection
MURKY = """\
UPDATE participants
SET balanced_account_uri='not null'
, last_ach_result='ooga booga'
WHERE id=%s
"""
gittip.db.execute(MURKY, ('foo',))
billing.clear(u"bank account", 'foo', 'something')
assert not valid_ba.is_valid
assert valid_ba.save.call_count
assert not invalid_ba.save.call_count
user = authentication.User.from_id('foo')
assert not user.session['last_ach_result']
assert user.session['balanced_account_uri']
def test_clear(self, find):
valid_card = mock.Mock()
valid_card.is_valid = True
invalid_card = mock.Mock()
invalid_card.is_valid = False
card_collection = [valid_card, invalid_card]
find.return_value.cards = card_collection
MURKY = """\
UPDATE participants
SET balanced_account_uri='not null'
, last_bill_result='ooga booga'
WHERE username=%s
"""
gittip.db.run(MURKY, ('alice',))
billing.clear(u"credit card", 'alice', self.balanced_account_uri)
assert not valid_card.is_valid
assert valid_card.save.call_count
assert not invalid_card.save.call_count
user = authentication.User.from_username('alice')
assert not user.last_bill_result
assert user.balanced_account_uri
def test_clear_bank_account(self, b_account):
valid_ba = mock.Mock()
valid_ba.is_valid = True
invalid_ba = mock.Mock()
invalid_ba.is_valid = False
ba_collection = [
valid_ba, invalid_ba
]
b_account.find.return_value.bank_accounts = ba_collection
MURKY = """\
UPDATE participants
SET balanced_account_uri='not null'
, last_ach_result='ooga booga'
WHERE username=%s
"""
gittip.db.run(MURKY, ('alice',))
billing.clear(u"bank account", 'alice', 'something')
assert not valid_ba.is_valid
assert valid_ba.save.call_count
assert not invalid_ba.save.call_count
user = authentication.User.from_username('alice')
assert not user.last_ach_result
assert user.balanced_account_uri
def test_clear_bank_account(self, b_account):
valid_ba = mock.Mock()
valid_ba.is_valid = True
invalid_ba = mock.Mock()
invalid_ba.is_valid = False
ba_collection = [
valid_ba, invalid_ba
]
b_account.find.return_value.bank_accounts = ba_collection
MURKY = """\
UPDATE participants
SET balanced_account_uri='not null'
, last_ach_result='ooga booga'
WHERE id=%s
"""
self.db.execute(MURKY, (self.participant_id,))
billing.clear(u"bank account", self.participant_id, 'something')
self.assertFalse(valid_ba.is_valid)
self.assertTrue(valid_ba.save.call_count)
self.assertFalse(invalid_ba.save.call_count)
user = authentication.User.from_id(self.participant_id)
self.assertFalse(user.session['last_ach_result'])
self.assertTrue(user.session['balanced_account_uri'])
def test_clear_bank_account(self):
billing.clear(self.db, u"bank account", 'david', self.david_href)
customer = balanced.Customer.fetch(self.david_href)
bank_accounts = customer.bank_accounts.all()
assert len(bank_accounts) == 0
david = Participant.from_username('david')
assert david.last_ach_result is None
assert david.balanced_customer_href
def test_clear(self):
billing.clear(self.db, u"credit card", 'david', self.david_href)
customer = balanced.Customer.fetch(self.david_href)
cards = customer.cards.all()
assert len(cards) == 0
david = Participant.from_username('david')
assert david.last_bill_result is None
assert david.balanced_customer_href
def test_clear_bank_account(self):
balanced.BankAccount.fetch(self.bank_account_href).associate_to_customer(self.balanced_customer_href)
MURKY = """\
UPDATE participants
SET balanced_customer_href='not null'
, last_ach_result='ooga booga'
WHERE username=%s
"""
self.db.run(MURKY, ("alice",))
billing.clear(self.db, "bank account", "alice", self.balanced_customer_href)
customer = balanced.Customer.fetch(self.balanced_customer_href)
bank_accounts = customer.bank_accounts.all()
assert len(bank_accounts) == 0
user = authentication.User.from_username("alice")
assert not user.participant.last_ach_result
assert user.participant.balanced_customer_href
def test_clear(self):
balanced.Card.fetch(self.card_href).associate_to_customer(self.balanced_customer_href)
MURKY = """\
UPDATE participants
SET balanced_customer_href='not null'
, last_bill_result='ooga booga'
WHERE username=%s
"""
self.db.run(MURKY, ("alice",))
billing.clear(self.db, "credit card", "alice", self.balanced_customer_href)
customer = balanced.Customer.fetch(self.balanced_customer_href)
cards = customer.cards.all()
assert len(cards) == 0
user = authentication.User.from_username("alice")
assert not user.participant.last_bill_result
assert user.participant.balanced_customer_href
def test_clear_bank_account(self):
balanced.BankAccount.fetch(self.bank_account_href)\
.associate_to_customer(self.balanced_customer_href)
MURKY = """\
UPDATE participants
SET balanced_customer_href='not null'
, last_ach_result='ooga booga'
WHERE username=%s
"""
self.db.run(MURKY, ('alice', ))
billing.clear(self.db, u"bank account", 'alice',
self.balanced_customer_href)
customer = balanced.Customer.fetch(self.balanced_customer_href)
bank_accounts = customer.bank_accounts.all()
assert len(bank_accounts) == 0
user = authentication.User.from_username('alice')
assert not user.participant.last_ach_result
assert user.participant.balanced_customer_href
