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)
# 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 serialize(segments):
operator = OperatorGenerator().generate()
company = operator.company
securities = TwoInitialSecuritiesGenerator().generate(
company=company)
security = securities[1]
security.track_numbers = True
security.save()
position = PositionGenerator().generate(company=company,
number_segments=segments,
save=False,
security=security,
count=8)
url = reverse('position-detail', kwargs={'pk': position.id})
request = self.factory.get(url)
request.user = operator.user
# prepare data
position.seller = None
position.buyer = None
# get test data dict
data = PositionSerializer(position, context={
'request': request
}).data
# clear bad datetimedata
data['bought_at'] = '2014-01-01T10:00'
del data['seller'], data['buyer']
# feed data into serializer
return PositionSerializer(data=data, context={'request': request})
def __serialize(self, segments):
# create capital
bank = BankGenerator().generate()
p = PositionGenerator().generate(number_segments=segments,
count=8,
seller=None)
# position under test:
position = PositionGenerator().generate(number_segments=segments,
count=8,
company=p.buyer.company,
seller=p.buyer,
save=False,
security=p.security,
depot_bank=bank)
url = reverse('position-detail', kwargs={'pk': position.id})
request = self.factory.get(url)
# authenticated request
request.user = OperatorGenerator().generate(
company=position.buyer.company).user
request.session = {'company_pk': position.buyer.company.pk}
# prepare data
data = PositionSerializer(position, context={'request': request}).data
data['bought_at'] = '2024-01-01T10:00'
return (PositionSerializer(data=data, context={'request':
request}), position)
def test_split_shares_POST(self):
operator = OperatorGenerator().generate()
user = operator.user
company = operator.company
s1, s2 = TwoInitialSecuritiesGenerator().generate(
company=operator.company)
PositionGenerator().generate(company=operator.company, security=s1)
PositionGenerator().generate(company=operator.company, security=s1)
logged_in = self.client.login(username=user.username, password='******')
self.assertTrue(logged_in)
security = Security.objects.filter(company=company, title="P")[0]
data = {
'dividend': 3,
'divisor': 4,
"security": {
"pk": security.pk,
"readable_title": security.get_title_display(),
"title": security.title
},
'execute_at': datetime.datetime.now(),
}
response = self.client.post(
'/services/rest/split/', data, **{
'HTTP_AUTHORIZATION': 'Token {}'.format(user.auth_token.key),
'format': 'json'
})
self.assertEqual(response.status_code, 201)
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_csv_download(self):
""" rest download of captable csv """
# data
company = CompanyGenerator().generate()
shareholder_list = []
for x in range(1, 6): # don't statt with 0, Generators 'if' will fail
shareholder_list.append(ShareholderGenerator().generate(
company=company, number=str(x)))
# initial share creation
PositionGenerator().generate(
buyer=shareholder_list[0], count=1000, value=10)
# single transaction
PositionGenerator().generate(
buyer=shareholder_list[1], count=10, value=10,
seller=shareholder_list[0])
# shareholder bought and sold
PositionGenerator().generate(
buyer=shareholder_list[2], count=20, value=20,
seller=shareholder_list[0])
PositionGenerator().generate(
buyer=shareholder_list[0], count=20, value=20,
seller=shareholder_list[2])
# run test
response = self.client.get(
reverse('captable_csv', kwargs={"company_id": company.id}))
# not logged in user
self.assertEqual(response.status_code, 302)
# login and retest
user = UserGenerator().generate()
OperatorGenerator().generate(user=user, company=company)
is_loggedin = self.client.login(username=user.username, password='******')
self.assertTrue(is_loggedin)
response = self.client.get(reverse('captable_csv',
kwargs={"company_id": company.id}))
# assert response code
self.assertEqual(response.status_code, 200)
# assert proper csv
lines = response.content.split('\r\n')
lines.pop() # remove last element based on final '\r\n'
for row in lines:
self.assertEqual(row.count(','), 7)
self.assertEqual(len(lines), 3) # ensure we have the right data
# assert company itself
self.assertEqual(shareholder_list[0].number, lines[1].split(',')[0])
# assert share owner
self.assertEqual(shareholder_list[1].number, lines[2].split(',')[0])
# assert shareholder witout position not in there
for line in lines:
self.assertNotEqual(line[0], shareholder_list[3].number)
# assert shareholder which bought and sold again
for line in lines:
self.assertNotEqual(line[0], shareholder_list[2].number)
def test_share_percent(self):
"""
proper share percent math
"""
company = CompanyGenerator().generate(share_count=1000000)
security = SecurityGenerator().generate(company=company)
sc = ShareholderGenerator().generate(company=company)
s1 = ShareholderGenerator().generate(company=company)
s2 = ShareholderGenerator().generate(company=company)
s3 = ShareholderGenerator().generate(company=company)
now = datetime.datetime.now()
PositionGenerator().generate(buyer=sc,
count=1000000,
value=100,
security=security,
bought_at=now -
datetime.timedelta(days=11))
PositionGenerator().generate(buyer=s1,
seller=sc,
count=500000,
value=100,
security=security,
bought_at=now -
datetime.timedelta(days=10))
PositionGenerator().generate(buyer=s2,
seller=sc,
count=5000,
value=100,
security=security,
bought_at=now -
datetime.timedelta(days=9))
PositionGenerator().generate(buyer=s3,
seller=sc,
count=50,
value=100,
security=security,
bought_at=now -
datetime.timedelta(days=8))
self.assertEqual(s1.share_percent(), '99.00')
self.assertEqual(s2.share_percent(), '0.99')
self.assertEqual(s3.share_percent(), '0.01')
PositionGenerator().generate(buyer=s2,
seller=s1,
count=250000,
value=100,
security=security,
bought_at=now -
datetime.timedelta(days=7))
self.assertEqual(s1.share_percent(), '49.50')
def test_csv_download_number_segments(self):
""" rest download of captable csv """
# data
company = CompanyGenerator().generate()
secs = TwoInitialSecuritiesGenerator().generate(company=company)
security = secs[1]
security.track_numbers = True
security.save()
shareholder_list = []
for x in range(1, 6): # don't statt with 0, Generators 'if' will fail
shareholder_list.append(ShareholderGenerator().generate(
company=company, number=str(x)))
# initial share creation
PositionGenerator().generate(
buyer=shareholder_list[0], count=1000, value=10, security=security)
# single transaction
PositionGenerator().generate(
buyer=shareholder_list[1], count=10, value=10, security=security,
seller=shareholder_list[0])
# shareholder bought and sold
PositionGenerator().generate(
buyer=shareholder_list[2], count=20, value=20, security=security,
seller=shareholder_list[0])
PositionGenerator().generate(
buyer=shareholder_list[0], count=20, value=20, security=security,
seller=shareholder_list[2])
# login and retest
user = UserGenerator().generate()
OperatorGenerator().generate(user=user, company=company)
is_loggedin = self.client.login(username=user.username, password='******')
self.assertTrue(is_loggedin)
response = self.client.get(reverse('captable_csv',
kwargs={"company_id": company.id}))
# assert response code
self.assertEqual(response.status_code, 200)
# assert proper csv
lines = response.content.split('\r\n')
lines.pop() # remove last element based on final '\r\n'
for row in lines:
if row == lines[0]: # skip first row
continue
self.assertEqual(row.count(','), 8)
fields = row.split(',')
s = Shareholder.objects.get(company=company, number=fields[0])
text = s.current_segments(security)
if text:
self.assertTrue(text in fields[8])
def test_xls_download_number_segments(self):
""" rest download of captable xls """
# data
company = CompanyGenerator().generate()
self.add_subscription(company)
secs = TwoInitialSecuritiesGenerator().generate(company=company)
security = secs[1]
security.track_numbers = True
security.save()
shareholder_list = []
for x in range(1, 6): # don't statt with 0, Generators 'if' will fail
shareholder_list.append(ShareholderGenerator().generate(
company=company, number=str(x)))
# initial share creation
PositionGenerator().generate(buyer=shareholder_list[0],
count=1000,
value=10,
security=security)
# single transaction
PositionGenerator().generate(buyer=shareholder_list[1],
count=10,
value=10,
security=security,
seller=shareholder_list[0])
# shareholder bought and sold
PositionGenerator().generate(buyer=shareholder_list[2],
count=20,
value=20,
security=security,
seller=shareholder_list[0])
PositionGenerator().generate(buyer=shareholder_list[0],
count=20,
value=20,
security=security,
seller=shareholder_list[2])
# login and retest
report = ReportGenerator().generate(company=company, file_type='XLS')
report.render()
user = report.user
OperatorGenerator().generate(user=user, company=company)
self.client.force_login(user)
response = self.client.get(
reverse('reports:download', kwargs={"report_id": report.id}))
# assert response code
self.assertEqual(response.status_code, 200)
def test_captable_xls_download(self):
""" rest download of captable xls """
# data
company = CompanyGenerator().generate()
shareholder_list = []
for x in range(1, 6): # don't statt with 0, Generators 'if' will fail
shareholder_list.append(ShareholderGenerator().generate(
company=company, number=str(x)))
shareholder_list = sorted(shareholder_list,
key=lambda t: t.user.last_name.lower())
# initial share creation
p = PositionGenerator().generate(seller=None,
buyer=shareholder_list[0],
count=1000,
value=10)
security = p.security
# single transaction
PositionGenerator().generate(buyer=shareholder_list[1],
count=10,
value=10,
seller=shareholder_list[0],
security=security)
# shareholder bought and sold
PositionGenerator().generate(buyer=shareholder_list[2],
count=20,
value=20,
seller=shareholder_list[0],
security=security)
PositionGenerator().generate(buyer=shareholder_list[0],
count=20,
value=20,
seller=shareholder_list[2],
security=security)
# login and retest
report = ReportGenerator().generate(company=company, file_type='XLS')
report.render()
user = report.user
OperatorGenerator().generate(user=user, company=company)
self.add_subscription(company)
self.client.force_login(user)
response = self.client.get(
reverse('reports:download', kwargs={"report_id": report.id}))
# assert response code
self.assertEqual(response.status_code, 200)
def test_position_option_pdf(self):
""" test printable certificate """
pos = PositionGenerator().generate()
company = pos.buyer.company
# run test
response = self.client.get(
reverse('position_option_pdf', kwargs={"option_id": pos.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 55
with self.assertLessNumQueries(79):
response = self.client.get(
reverse('position_option_pdf', kwargs={"option_id": pos.pk}))
# assert response code
self.assertEqual(response.status_code, 200)
# assert proper csv
content = response.content
self.assertTrue(content.startswith('%PDF-1'))
self.assertTrue(content.endswith('EOF\n'))
def test_delete_confirmed_position(self):
"""
confirmed positions cannot be deleted
"""
operator = OperatorGenerator().generate()
user = operator.user
position = PositionGenerator().generate(company=operator.company)
position.is_draft = False
position.save()
logged_in = self.client.login(username=user.username, password='******')
self.assertTrue(logged_in)
res = self.client.delete('/services/rest/position/{}'.format(
position.pk))
self.assertEqual(res.status_code, 400)
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 setUp(self):
self.operator = OperatorGenerator().generate()
# initial position
shareholder = ShareholderGenerator().generate(user=self.operator.user)
PositionGenerator().generate(company=self.operator.company,
number_segments=[u'0-9999'],
buyer=shareholder,
count=10000)
TwoInitialSecuritiesGenerator().generate(company=self.operator.company)
def test_render_captable_xls(self):
report = ReportGenerator().generate(file_type='XLS',
company=self.company)
PositionGenerator().generate(company=report.company, seller=None)
render_captable_xls(report.company.pk, report.pk,
user_id=report.user.pk, ordering=None,
notify=True, track_downloads=False)
report.refresh_from_db()
self.assertIsNotNone(report.file)
def test_render_assembly_participation_pdf(self):
report = ReportGenerator().generate(company=self.company)
PositionGenerator().generate(company=report.company, seller=None)
render_assembly_participation_pdf(
report.company.pk, report.pk,
user_id=report.user.pk, ordering=None,
notify=True, track_downloads=False)
report.refresh_from_db()
self.assertIsNotNone(report.file)
def test_render_vested_shares_pdf(self):
report = ReportGenerator().generate(company=self.company,
report_type='vested_shares',
file_type='PDF')
PositionGenerator().generate(company=report.company, seller=None)
render_vested_shares_pdf(
report.company.pk, report.pk,
user_id=report.user.pk, ordering=None,
notify=True, track_downloads=False)
report.refresh_from_db()
self.assertIsNotNone(report.file)
def test_share_value(self):
"""
share value is last trated price
"""
company = CompanyGenerator().generate(share_count=1000000)
security = SecurityGenerator().generate(company=company)
sc = ShareholderGenerator().generate(company=company)
s1 = ShareholderGenerator().generate(company=company)
now = datetime.datetime.now()
PositionGenerator().generate(buyer=sc,
count=1000000,
value=1,
security=security,
bought_at=now -
datetime.timedelta(days=11))
p = PositionGenerator().generate(buyer=s1,
seller=sc,
count=500000,
value=100,
security=security,
bought_at=now -
datetime.timedelta(days=10))
p.value = None
p.save()
self.assertEqual(s1.share_value(), Decimal('500000.0000'))
def test_csv_download_with_missing_operator(self):
""" rest download of captable csv """
# data
company = CompanyGenerator().generate()
shareholder_list = []
for x in range(1, 6): # don't statt with 0, Generators 'if' will fail
shareholder_list.append(ShareholderGenerator().generate(
company=company, number=str(x)))
# initial share creation
PositionGenerator().generate(
buyer=shareholder_list[0], count=1000, value=10)
# single transaction
PositionGenerator().generate(
buyer=shareholder_list[1], count=10, value=10,
seller=shareholder_list[0])
# shareholder bought and sold
PositionGenerator().generate(buyer=shareholder_list[2], count=20,
value=20, seller=shareholder_list[0])
PositionGenerator().generate(buyer=shareholder_list[0], count=20,
value=20, seller=shareholder_list[2])
# run test
response = self.client.get(
reverse('captable_csv', kwargs={"company_id": company.id}))
# not logged in user
self.assertEqual(response.status_code, 302)
# login and retest
user = UserGenerator().generate()
is_loggedin = self.client.login(username=user.username, password='******')
self.assertTrue(is_loggedin)
response = self.client.get(
reverse('captable_csv', kwargs={"company_id": company.id}))
# assert response code
self.assertEqual(response.status_code, 403)
def test_delete_position(self):
"""
operator deletes position
"""
operator = OperatorGenerator().generate()
user = operator.user
position = PositionGenerator().generate(company=operator.company)
logged_in = self.client.login(username=user.username, password='******')
self.assertTrue(logged_in)
res = self.client.delete('/services/rest/position/{}'.format(
position.pk))
self.assertEqual(res.status_code, 204)
self.assertFalse(Position.objects.filter(id=position.pk).exists())
def __serialize(self, segments):
position = PositionGenerator().generate(number_segments=segments,
count=8)
url = reverse('position-detail', kwargs={'pk': position.id})
request = self.factory.get(url)
# authenticated request
request.user = OperatorGenerator().generate(
company=position.buyer.company).user
# prepare data
data = PositionSerializer(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-01T10:00'
return (PositionSerializer(data=data, context={'request':
request}), position)
def test_delete_position_shareholder(self):
"""
shareholder cannot delete positions
"""
operator = ShareholderGenerator().generate()
user = operator.user
position = PositionGenerator().generate(company=operator.company)
logged_in = self.client.login(username=user.username, password='******')
self.assertTrue(logged_in)
res = self.client.delete('/services/rest/position/{}'.format(
position.pk))
self.assertEqual(res.status_code, 404)
def test_get_is_certificate_valid(self):
"""
is certificate valid or was it returned
"""
pos = PositionGenerator().generate()
pos.invalidate_certificate()
pos2 = pos.certificate_invalidation_position
serializer = PositionSerializer(instance=pos)
self.assertFalse(serializer.get_is_certificate_valid(pos))
self.assertFalse(serializer.get_is_certificate_valid(pos2))
pos = PositionGenerator().generate()
serializer = PositionSerializer(instance=pos)
self.assertIsNone(serializer.get_is_certificate_valid(pos))
pos = PositionGenerator().generate(certificate_id='123')
serializer = PositionSerializer(instance=pos)
self.assertTrue(serializer.get_is_certificate_valid(pos))
def _prepare_split_scenario(self):
company = CompanyGenerator().generate()
security = SecurityGenerator().generate(company=company)
cshareholder = ShareholderGenerator().generate(company=company)
shareholder1 = ShareholderGenerator().generate(company=company)
shareholder2 = ShareholderGenerator().generate(company=company)
shareholder3 = ShareholderGenerator().generate(company=company)
shareholder4 = ShareholderGenerator().generate(company=company)
PositionGenerator().generate(buyer=cshareholder,
count=10000,
value=1000,
security=security,
seller=None)
p1 = PositionGenerator().generate(buyer=shareholder1,
count=100,
value=20,
seller=cshareholder,
security=security)
p2 = PositionGenerator().generate(buyer=shareholder2,
count=200,
value=40,
seller=cshareholder,
security=security)
p3 = PositionGenerator().generate(buyer=shareholder3,
count=900,
value=60,
seller=cshareholder,
security=security)
p4 = PositionGenerator().generate(buyer=cshareholder,
count=600,
value=80,
seller=shareholder3,
security=security)
PositionGenerator().generate(buyer=cshareholder,
count=1000,
value=1000,
security=security,
seller=None)
company.share_count = 11000
company.save()
return dict(company=company,
cshareholder=cshareholder,
shareholder1=shareholder1,
shareholder2=shareholder2,
shareholder3=shareholder3,
shareholder4=shareholder4,
p1=p1,
p2=p2,
p3=p3,
p4=p4,
security=security)
def setUp(self):
self.factory = RequestFactory()
self.client = Client()
self.session = self.client.session
self.position = PositionGenerator().generate(seller=None)
self.operator = OperatorGenerator().generate(
company=self.position.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 = PositionSerializer(self.position,
context={
'request': self.request
}).data
self.new_data.update({'bought_at': '2013-05-05T00:00'})
def test_get_certificate_invalidation_position_url(self):
"""
return url for cert invalidation position
"""
pos = PositionGenerator().generate()
pos.invalidate_certificate()
serializer = PositionSerializer(instance=pos)
self.assertIsNotNone(
serializer.get_certificate_invalidation_position_url(pos))
pos = PositionGenerator().generate()
serializer = PositionSerializer(instance=pos)
self.assertIsNone(
serializer.get_certificate_invalidation_position_url(pos))
def __serialize(self, segments):
seller = ShareholderGenerator().generate()
option_plan = OptionPlanGenerator().generate(company=seller.company,
number_segments=segments,
count=8)
PositionGenerator().generate(buyer=seller,
count=8,
number_segments=segments,
security=option_plan.security)
url = reverse('optionplan-detail', kwargs={'pk': option_plan.id})
request = self.factory.get(url)
request.user = OperatorGenerator().generate(
company=option_plan.company).user
# prepare data
data = OptionPlanSerializer(option_plan, context={
'request': request
}).data
# clear bad datetimedata
data['board_approved_at'] = '2014-01-01'
return (OptionPlanSerializer(data=data,
context={'request':
request}), option_plan)
def test_confirm_position(self):
operator = OperatorGenerator().generate()
user = operator.user
seller = ShareholderGenerator().generate(company=operator.company)
position = PositionGenerator().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/position/{}'.format(position.pk),
format='json')
# update data
res = self.client.post('/services/rest/position/{}/confirm'.format(
position.pk), {},
format='json')
self.assertEqual(res.status_code, 200)
self.assertFalse(Position.objects.get(id=position.id).is_draft)
def test_add_position_with_number_segment(self):
"""
test that we can add a position with numbered shares
"""
operator = OperatorGenerator().generate()
user = operator.user
buyer = ShareholderGenerator().generate(company=operator.company)
seller = ShareholderGenerator().generate(company=operator.company)
securities = TwoInitialSecuritiesGenerator().generate(
company=operator.company)
PositionGenerator().generate(number_segments=[u'1-5'],
company=operator.company,
buyer=seller,
count=5,
security=securities[1])
for s in securities:
s.track_numbers = True
s.save()
logged_in = self.client.login(username=user.username, password='******')
self.assertTrue(logged_in)
data = {
"bought_at": "2016-05-13T23:00:00.000Z",
"buyer": {
"pk": buyer.pk,
"user": {
"first_name": buyer.user.first_name,
"last_name": buyer.user.last_name,
"email": buyer.user.email,
"operator_set": [],
"userprofile": None,
},
"number": "0",
"company": {
"pk":
operator.company.pk,
"name":
operator.company.name,
"share_count":
operator.company.share_count,
"country":
"",
"url":
"http://codingmachine:9000/services/rest/"
"company/{}".format(operator.company.pk),
"shareholder_count":
2
},
"share_percent": "99.90",
"share_count": 100002,
"share_value": 1000020,
"validate_gafi": {
"is_valid": True,
"errors": []
}
},
"security": {
"pk": securities[1].pk,
"readable_title": "Preferred Stock",
"title": "P",
"count": 3
},
"count": 5,
"value": 1,
"seller": {
"pk": seller.pk,
"user": {
"first_name": seller.user.first_name,
"last_name": seller.user.last_name,
"email": seller.user.email,
"operator_set": [],
"userprofile": None
},
"number": "0",
"company": {
"pk": 5,
"name": "LieblingzWaldCompany AG",
"share_count": 100100,
"country": "",
"url": "http://codingmachine:9000/services/rest/company/5",
"shareholder_count": 2
},
"share_percent": "99.90",
"share_count": 100002,
"share_value": 1000020,
"validate_gafi": {
"is_valid": True,
"errors": []
}
},
"number_segments": "1,2,3-5",
"comment": "sdfg"
}
response = self.client.post(
'/services/rest/position', data, **{
'HTTP_AUTHORIZATION': 'Token {}'.format(user.auth_token.key),
'format': 'json'
})
self.assertEqual(response.status_code, 201)
self.assertTrue('sdfg' in response.content)
self.assertEqual(response.data['number_segments'], [u'1-5'])
position = Position.objects.latest('id')
self.assertEqual(position.count, 5)
self.assertEqual(position.value, 1)
self.assertEqual(position.buyer, buyer)
self.assertEqual(position.seller, seller)
self.assertEqual(position.bought_at.isoformat(), '2016-05-13')
self.assertEqual(position.number_segments, [u'1-5'])
