def test_get_option_holders(self):
op = OperatorGenerator().generate()
opts = []
for x in range(0, 10):
opts.append(
OptionTransactionGenerator().generate(company=op.company))
self.client.force_authenticate(user=op.user)
res = self.client.get(
reverse('company-option-holder', kwargs={'pk': op.company.pk}))
self.assertEqual(res.status_code, 200)
self.assertEqual(len(res.data['results']), 10)
# sell one persions options and check again
ot = opts[0]
OptionTransactionGenerator().generate(company=ot.option_plan.company,
seller=ot.buyer,
count=ot.count,
price=1,
buyer=opts[1].buyer)
res = self.client.get(
reverse('company-option-holder',
kwargs={'pk': ot.option_plan.company.pk}))
self.assertEqual(res.status_code, 200)
self.assertEqual(len(res.data['results']), 9)
def __serialize(self, segments):
seller = ShareholderGenerator().generate()
option_plan = OptionPlanGenerator().generate(company=seller.company,
number_segments=segments)
# initial seeding
OptionTransactionGenerator().generate(number_segments=segments,
count=8,
option_plan=option_plan,
buyer=seller,
seller=None)
# to test transaction
position = OptionTransactionGenerator().generate(
number_segments=segments,
count=8,
seller=seller,
option_plan=option_plan,
save=False)
url = reverse('optiontransaction-detail', kwargs={'pk': position.id})
request = self.factory.get(url)
request.user = OperatorGenerator().generate(
company=option_plan.company).user
# prepare data
data = OptionTransactionSerializer(position,
context={
'request': request
}).data
# clear bad datetimedata
data['buyer']['user']['userprofile']['birthday'] = None
data['seller']['user']['userprofile']['birthday'] = None
data['bought_at'] = '2014-01-01'
return (OptionTransactionSerializer(data=data,
context={'request':
request}), position)
def setUp(self):
self.shareholder = ShareholderGenerator().generate()
self.company = self.shareholder.company
self.position = PositionGenerator().generate(buyer=self.shareholder,
count=30,
vesting_months=24)
self.option = OptionTransactionGenerator().generate(
buyer=self.shareholder, count=16, vesting_months=120)
# noise ... not to be fetched
PositionGenerator().generate(buyer=self.shareholder, count=30)
OptionTransactionGenerator().generate(buyer=self.shareholder, count=16)
self.date_passed = (timezone.now() - relativedelta(years=2)).date()
self.future_date = (timezone.now() + relativedelta(years=3)).date()
# vesting expired
PositionGenerator().generate(buyer=self.shareholder,
count=30,
bought_at=self.date_passed,
vesting_months=6)
OptionTransactionGenerator().generate(buyer=self.shareholder,
count=16,
bought_at=self.date_passed,
vesting_months=6)
def setUp(self):
super(BaseViewTestCase, self).setUp()
self.client = Client()
self.shareholder1 = ShareholderGenerator().generate()
self.company = self.shareholder1.company
self.operator = OperatorGenerator().generate(company=self.company)
self.operator2 = OperatorGenerator().generate()
self.shareholder2 = ShareholderGenerator().generate()
self.position1 = PositionGenerator().generate(buyer=self.shareholder1)
self.position2 = PositionGenerator().generate(buyer=self.shareholder2)
self.optiontransaction1 = OptionTransactionGenerator().generate(
buyer=self.shareholder1)
self.optiontransaction2 = OptionTransactionGenerator().generate(
buyer=self.shareholder2)
self.optionplan = self.optiontransaction1.option_plan
self.statement_report = mommy.make(ShareholderStatementReport,
company=self.shareholder1.company)
self.statement = mommy.make(ShareholderStatement,
user=self.shareholder1.user,
pdf_file='example.pdf',
report=self.statement_report)
# add company subscription
self.add_subscription(self.company)
self.shareholder1_url = reverse('shareholder',
kwargs={'pk': self.shareholder1.pk})
def setUp(self):
self.shareholder = ShareholderGenerator().generate()
self.company = self.shareholder.company
self.position = PositionGenerator().generate(
buyer=self.shareholder, count=30, vesting_months=24)
self.option = OptionTransactionGenerator().generate(
buyer=self.shareholder, count=16, vesting_months=120)
self.mixin = DiscountedTaxByVestingModelMixin()
def test_confirm_optiontransaction(self):
operator = OperatorGenerator().generate()
user = operator.user
seller = ShareholderGenerator().generate(company=operator.company)
optiontransaction = OptionTransactionGenerator().generate(
seller=seller)
logged_in = self.client.login(username=user.username, password='******')
self.assertTrue(logged_in)
# get and prep data
res = self.client.login(username=user.username, password='******')
self.assertTrue(res)
res = self.client.get('/services/rest/optiontransaction/{}'.format(
optiontransaction.pk),
format='json')
# update data
res = self.client.post(
'/services/rest/optiontransaction/{}/confirm'.format(
optiontransaction.pk), {},
format='json')
self.assertEqual(res.status_code, 200)
self.assertFalse(
OptionTransaction.objects.get(id=optiontransaction.id).is_draft)
def test_option_pdf(self):
""" test printable certificate """
ot = OptionTransactionGenerator().generate()
company = ot.option_plan.company
# run test
response = self.client.get(
reverse('option_pdf', kwargs={"option_id": ot.pk}))
# not logged in user
self.assertEqual(response.status_code, 302)
# login and retest
user = UserGenerator().generate()
OperatorGenerator().generate(user=user, company=company)
self.add_subscription(company)
is_loggedin = self.client.login(username=user.username,
password=DEFAULT_TEST_DATA['password'])
self.assertTrue(is_loggedin)
# was 53
with self.assertLessNumQueries(78):
response = self.client.get(
reverse('option_pdf', kwargs={"option_id": ot.pk}))
# assert response code
self.assertEqual(response.status_code, 200)
# assert proper csv
content = response.content
self.assertTrue(content.startswith('%PDF'))
self.assertTrue(content.endswith('EOF\n'))
class DiscountedTaxByVestingModelMixinTestCase(TestCase):
def setUp(self):
self.shareholder = ShareholderGenerator().generate()
self.company = self.shareholder.company
self.position = PositionGenerator().generate(
buyer=self.shareholder, count=30, vesting_months=24)
self.option = OptionTransactionGenerator().generate(
buyer=self.shareholder, count=16, vesting_months=120)
self.mixin = DiscountedTaxByVestingModelMixin()
def test_get_vesting_expires_at(self):
""" return date when vesting expires """
today = timezone.now().date()
self.assertEqual(
self.position.get_vesting_expires_at(),
today + relativedelta(years=2))
self.assertEqual(
self.option.get_vesting_expires_at(),
today + relativedelta(years=10))
def test_get_discounted_tax_ratio(self):
""" return percent to be applied for discounted tax value calculation
read: https://goo.gl/n5p0IR
"""
passed_date = timezone.make_aware(datetime.datetime(2013, 1, 1)).date()
future_date = timezone.now().date() + relativedelta(years=1)
self.assertEqual(self.position.get_discounted_tax_ratio(), 0.89)
self.assertEqual(self.position.get_discounted_tax_ratio(
date=passed_date), 0)
self.assertEqual(self.position.get_discounted_tax_ratio(
date=future_date), 0.9434)
self.assertEqual(self.option.get_discounted_tax_ratio(), 0.55839)
self.assertEqual(self.option.get_discounted_tax_ratio(
date=passed_date), 0)
self.assertEqual(self.option.get_discounted_tax_ratio(
date=future_date), 0.5919)
def test_get_discounted_tax_value(self):
""" return value to be used for discounted tax """
self.assertEqual(self.position.get_discounted_tax_value(),
2670)
self.assertEqual(self.option.get_discounted_tax_value(), 893.424)
def test_delete_confirmed_optiontransaction(self):
"""
confirmed positions cannot be deleted
"""
operator = OperatorGenerator().generate()
user = operator.user
optiontransaction = OptionTransactionGenerator().generate(
company=operator.company)
optiontransaction.is_draft = False
optiontransaction.save()
logged_in = self.client.login(username=user.username, password='******')
self.assertTrue(logged_in)
res = self.client.delete('/services/rest/optiontransaction/{}'.format(
optiontransaction.pk))
self.assertEqual(res.status_code, 400)
def test_validate_certificate_id(self):
""" certificate id must be unique """
serializer, position = self.__serialize('1, 3, 4, 6-9, 33')
certificate_id = '222'
self.assertEqual(serializer.validate_certificate_id(certificate_id),
certificate_id)
# OptionTransaction existing -> fail
ot = OptionTransactionGenerator().generate(
certificate_id=certificate_id, company=position.buyer.company)
with self.assertRaises(ValidationError):
serializer.validate_certificate_id(certificate_id)
ot.delete()
# Position existing -> fail
position.certificate_id = certificate_id
position.save()
with self.assertRaises(ValidationError):
serializer.validate_certificate_id(certificate_id)
def test_current_options_segments_same_day_single_digit(self):
"""
very simple scenario with one CS and one shareholder
"""
company = CompanyGenerator().generate()
OperatorGenerator().generate(company=company)
# intial securities
s1, s2 = TwoInitialSecuritiesGenerator().generate(company=company)
s1.track_numbers = True
s1.number_segments = [1, 2, 3, 4]
s1.save()
# initial company shareholder
cs = CompanyShareholderGenerator().generate(company=company,
security=s1)
s = ShareholderGenerator().generate(company=company)
optionplan = OptionPlanGenerator().generate(company=company,
number_segments=[1, 2],
security=s1)
# initial option grant to CompanyShareholder
OptionTransactionGenerator().generate(company=company,
security=s1,
buyer=cs,
number_segments=[1, 2],
option_plan=optionplan)
# single shareholder option grant
OptionTransactionGenerator().generate(company=company,
security=s1,
buyer=s,
seller=cs,
number_segments=[1],
option_plan=optionplan)
self.assertEqual(s.current_options_segments(s1), [1])
# test company shareholder
self.assertEqual(cs.current_options_segments(s1), [2])
def test_delete_optiontransaction_shareholder(self):
"""
shareholder cannot delete positions
"""
operator = ShareholderGenerator().generate()
user = operator.user
optiontransaction = OptionTransactionGenerator().generate(
company=operator.company)
logged_in = self.client.login(username=user.username, password='******')
self.assertTrue(logged_in)
res = self.client.delete('/services/rest/optiontransaction/{}'.format(
optiontransaction.pk))
self.assertEqual(res.status_code, 404)
def test_delete_option_transaction(self):
"""
operator deletes position
"""
operator = OperatorGenerator().generate()
user = operator.user
optiontransaction = OptionTransactionGenerator().generate(
company=operator.company)
logged_in = self.client.login(username=user.username, password='******')
self.assertTrue(logged_in)
res = self.client.delete('/services/rest/optiontransaction/{}'.format(
optiontransaction.pk))
self.assertEqual(res.status_code, 204)
self.assertFalse(
OptionTransaction.objects.filter(id=optiontransaction.pk).exists())
def setUp(self):
self.factory = RequestFactory()
self.client = Client()
self.session = self.client.session
self.transaction = OptionTransactionGenerator().generate()
self.operator = OperatorGenerator().generate(
company=self.transaction.buyer.company)
add_company_to_session(self.session, self.operator.company)
self.request = self.factory.get('/services/rest/position')
self.request.user = self.operator.user
self.request.session = self.session
self.new_data = OptionTransactionSerializer(self.transaction,
context={
'request': self.request
}).data
self.new_data.update({'bought_at': '2013-05-05'})
