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 test_get(self):
# mock get_queryset
self.view.get_queryset = mock.Mock(return_value=Company.objects.none())
operator = OperatorGenerator().generate()
self.view.request = self.factory.get('/')
self.view.request.user = operator.user
with self.assertRaises(Http404):
self.view.get(self.view.request)
self.view.get_queryset = mock.Mock(return_value=Company.objects.filter(
pk=operator.company_id))
res = self.view.get(self.view.request)
self.assertEqual(res.status_code, 302) # redirect
# add another company/operator to user
operator2 = OperatorGenerator().generate(user=operator.user)
self.view.get_queryset = mock.Mock(return_value=Company.objects.filter(
pk__in=[operator.company_id, operator2.company_id]))
res = self.view.get(self.view.request)
self.assertEqual(res.status_code, 200)
# test allow_empty False
self.view.allow_empty = False
self.view.get_paginate_by = mock.Mock(return_value=True)
with mock.patch.object(self.view,
'get_queryset',
return_value=Company.objects.none()):
with self.assertRaises(Http404):
self.view.get(self.view.request)
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 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 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_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 test_add_new_shareholder(self):
""" addes a new shareholder and user and checks for special chars"""
operator = OperatorGenerator().generate()
user = operator.user
logged_in = self.client.login(username=user.username, password='******')
self.assertTrue(logged_in)
data = {
u"user": {
u"first_name": u"Mike2Grüße",
u"last_name": u"Hildebrand2Grüße",
u"email": u"*****@*****.**",
},
u"number": u"10002"
}
response = self.client.post(
'/services/rest/shareholders', data, **{
'HTTP_AUTHORIZATION': 'Token {}'.format(user.auth_token.key),
'format': 'json'
})
self.assertNotEqual(response.data.get('pk'), None)
self.assertTrue(isinstance(response.data.get('user'), dict))
self.assertEqual(response.data.get('number'), u'10002')
self.assertEqual(User.objects.filter(email=user.email).count(), 1)
# check proper db status
user = User.objects.get(email="*****@*****.**")
def test_owns_segments_rma_performance(self):
"""
speed of segment owning check to meet RMA data
"""
logger.info('preparing test...')
operator = OperatorGenerator().generate()
sec1, sec2 = TwoInitialSecuritiesGenerator().generate(
company=operator.company)
sec1.track_numbers = True
sec1.number_segments = [u"1-10000000"]
sec1.save()
cs = CompanyShareholderGenerator().generate(security=sec1,
company=operator.company)
logger.info('data preparation done.')
start = datetime.datetime.now()
res = cs.owns_segments([u'1-582912'], sec1)
end = datetime.datetime.now()
delta = end - start
self.assertTrue(res[0])
if delta > datetime.timedelta(seconds=4):
logger.error(
'BUILD performance error: test_owns_segments_rma_performance',
extra={'delta': delta})
self.assertLess(delta, datetime.timedelta(seconds=7))
def test_add_duplicate_new_shareholder(self):
"""
adds a new shareholder with same id"""
operator = OperatorGenerator().generate()
shareholder = ShareholderGenerator().generate(company=operator.company)
user = operator.user
logged_in = self.client.login(username=user.username, password='******')
self.assertTrue(logged_in)
data = {
u"user": {
u"first_name": u"Mike2Grüße",
u"last_name": u"Hildebrand2Grüße",
u"email": u"*****@*****.**",
},
u"number": shareholder.number
}
response = self.client.post(
'/services/rest/shareholders', data, **{
'HTTP_AUTHORIZATION': 'Token {}'.format(user.auth_token.key),
'format': 'json'
})
self.assertEqual(response.status_code, 400)
self.assertEqual(response.data.get('number'), [
u'Diese Aktion\xe4rsnummer wird bereits verwendet. Bitte '
u'w\xe4hlen Sie eine andere.'
])
def test_get(self):
company = CompanyGenerator().generate()
customer = company.get_customer()
self.assertEqual(customer.subscriber, company)
operator = OperatorGenerator().generate(company=company)
view_url = reverse('djstripe:confirm',
args=[operator.company_id, 'test'])
subscribe_url = reverse('djstripe:subscribe', args=[company.pk])
req = self.factory.get(view_url)
req.user = operator.user
req.resolver_match = resolve(view_url)
view_kwargs = dict(company_id=operator.company_id)
self.view.request = req
res = self.view.get(req, **view_kwargs)
self.assertEqual(res.status_code, 302)
self.assertEqual(res.url, subscribe_url)
# test success
self.view.kwargs = dict(plan='test')
res = self.view.get(req, **view_kwargs)
self.assertEqual(res.status_code, 200)
# test already subscribed
self.add_subscription(company)
res = self.view.get(req, **view_kwargs)
self.assertEqual(res.status_code, 302)
self.assertEqual(res.url, subscribe_url)
def test_add_shareholder_for_existing_user_account(self):
""" test to add a shareholder for an existing
user account. means shareholder
was added for another or same company already. means we don't
add another user object
"""
operator = OperatorGenerator().generate()
user = operator.user
logged_in = self.client.login(username=user.username, password='******')
self.assertTrue(logged_in)
data = {
"user": {
"first_name": "Mike",
"last_name": "Hildebrand",
"email": "*****@*****.**",
},
"number": "1000"
}
response = self.client.post(
'/services/rest/shareholders', data, **{
'HTTP_AUTHORIZATION': 'Token {}'.format(user.auth_token.key),
'format': 'json'
})
self.assertNotEqual(response.data.get('pk'), None)
self.assertTrue(isinstance(response.data.get('user'), dict))
self.assertEqual(response.data.get('number'), u'1000')
self.assertEqual(User.objects.filter(email=user.email).count(), 1)
# check proper db status
user = User.objects.get(email="*****@*****.**")
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_add_shareholder_with_existing_number(self):
"""
add shareholder with existing number
"""
op = OperatorGenerator().generate()
self.add_subscription(op.company)
user = UserGenerator().generate()
shareholder = ShareholderGenerator().generate(company=op.company)
user.email = None
try:
start = page.StartPage(self.selenium, self.live_server_url,
op.user)
# wait for list
start.wait_until_visible((By.CSS_SELECTOR, '#shareholder_list'))
start.is_properly_displayed()
self.assertEqual(
start.has_shareholder_count(),
Shareholder.objects.filter(company=op.company).count())
start.click_open_add_shareholder()
start.wait_until_modal_opened('addShareholder')
start.add_shareholder(user, number=shareholder.number)
start.click_save_add_shareholder()
start.close_modal('addShareholder')
time.sleep(2)
self.assertEqual(
Shareholder.objects.filter(company=op.company,
number=shareholder.number).count(),
1)
except Exception, e:
self._handle_exception(e)
def setUp(self):
self.client = Client()
self.report = ReportGenerator().generate()
self.report.render()
self.operator = OperatorGenerator().generate(
user=self.report.user, company=self.report.company)
self.other_user = UserGenerator().generate()
def test_authenticate(self):
""" authenticate, get token, and call for shareholder details """
# prepare test data
operator = OperatorGenerator().generate()
shareholder = ShareholderGenerator().generate(company=operator.company)
user = operator.user
user.set_password('test')
user.save()
# authenticate
response = self.client.post('/services/rest/api-token-auth/', {
'username': user.username,
'password': '******'
},
format='json')
self.assertEqual(response.data.get('token'), user.auth_token.key)
# get shareholder details
token = user.auth_token
response = self.client.get(
'/services/rest/shareholders', **{
'HTTP_AUTHORIZATION': 'Token {}'.format(token.key),
'format': 'json'
})
self.assertTrue(len(response.data.get('results')) == 1)
self.assertEqual(
response.data['results'][0].get('user').get('userprofile').get(
'birthday'),
shareholder.user.userprofile.birthday.strftime('%Y-%m-%d'))
def test_send_statement_report_operator_notify(self, mock_mail_admins,
mock_email_message_send,
mock_email_multi_send):
company = CompanyGenerator().generate()
mommy.make(ShareholderStatementReport, company=company,
report_date=now().date())
send_statement_report_operator_notify()
mock_mail_admins.assert_called()
mock_mail_admins.reset_mock()
OperatorGenerator().generate(company=company)
with self.settings(EMAIL_BACKEND='dummy'):
send_statement_report_operator_notify()
mock_email_multi_send.assert_called()
djrill_settings = {
'EMAIL_BACKEND': 'djrill',
'MANDRILL_SHAREHOLDER_STATEMENT_REPORT'
'_OPERATOR_NOTIFY_TEMPLATE': 'foo'
}
with self.settings(**djrill_settings):
send_statement_report_operator_notify()
mock_email_message_send.assert_called()
mock_email_multi_send.return_value = 0
send_statement_report_operator_notify()
mock_mail_admins.assert_called()
def test_add_operator_foreign_company(self):
operator = OperatorGenerator().generate()
user = operator.user
company = CompanyGenerator().generate()
user2 = UserGenerator().generate()
logged_in = self.client.login(username=user.username, password='******')
self.assertTrue(logged_in)
data = {
"company":
"http://{}/services/rest/company/"
"{}".format(self.site.domain, company.pk),
u"user": {
'email': user2.email
}
}
self.assertFalse(user2.operator_set.filter(company=company).exists())
response = self.client.post(
'/services/rest/operators', data, **{
'HTTP_AUTHORIZATION': 'Token {}'.format(user.auth_token.key),
'format': 'json'
})
self.assertEqual(response.status_code, 400)
self.assertTrue('company' in response.content)
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 test_save_number_segments(self):
company = CompanyGenerator().generate()
operator = OperatorGenerator().generate(company=company)
security = SecurityGenerator().generate(company=company)
url = reverse('security-detail', kwargs={'pk': security.id})
request = self.factory.get(url)
data = SecuritySerializer(security, context={'request': request}).data
data.update({'number_segments': '1,2,3,4,8-10'})
self.client.force_authenticate(user=operator.user)
res = self.client.put(url, data=data)
security = Security.objects.get(id=security.id)
self.assertEqual(security.number_segments, [u'1-4', u'8-10'])
data.update({'number_segments': '1,2,3,4,4,,8-10'})
res = self.client.put(url, data=data)
self.assertEqual(res.status_code, 200)
security = Security.objects.get(id=security.id)
self.assertEqual(security.number_segments, [u'1-4', u'8-10'])
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_dispatch(self):
req = self.factory.get('/')
# test authentication
req.user = AnonymousUser()
res = self.mixin.dispatch(req)
self.assertEqual(res.status_code, 302)
operator = OperatorGenerator().generate()
# mock mixin.get_company
self.mixin.get_company = Mock(return_value=operator.company)
req.user = UserGenerator().generate()
res = self.mixin.dispatch(req)
self.assertEqual(res.status_code, 302)
# check company operator
res = self.mixin.dispatch(req)
self.assertEqual(res.status_code, 302)
# set operator user
req.user = operator.user
# expecting "success": 'super' object has no attribute 'dispatch'
with self.assertRaises(AttributeError):
self.mixin.dispatch(req)
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_delete_operator(self):
operator = OperatorGenerator().generate()
operator2 = OperatorGenerator().generate(company=operator.company)
user = operator.user
logged_in = self.client.login(username=user.username, password='******')
self.assertTrue(logged_in)
data = {u"operator.id": operator2.id}
response = self.client.delete(
'/services/rest/operators/{}'.format(operator2.pk), data, **{
'HTTP_AUTHORIZATION': 'Token {}'.format(user.auth_token.key),
'format': 'json'
})
self.assertEqual(response.status_code, 204)
self.assertFalse(Operator.objects.filter(pk=operator2.pk).exists())
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 setUp(self):
self.operator = OperatorGenerator().generate()
TwoInitialSecuritiesGenerator().generate(company=self.operator.company)
self.company_shareholder = CompanyShareholderGenerator().generate(
company=self.operator.company)
self.buyer = ShareholderGenerator().generate(
company=self.operator.company)
self.seller = ShareholderGenerator().generate(
company=self.operator.company)
def test_split_shares(self):
"""
share split leaves value, percent unchanged but
increases share count per shareholder
"""
# test data
company = CompanyGenerator().generate(share_count=1000)
OperatorGenerator().generate(company=company)
shareholders, security = ComplexShareholderConstellationGenerator()\
.generate(company=company)
data = {
'execute_at': datetime.datetime.now(),
'dividend': 3,
'divisor': 7,
'comment': "Some random comment",
'security': security,
}
multiplier = float(data['divisor']) / float(data['dividend'])
company_share_count = company.share_count
# record initial shareholder asset status
assets = {}
for shareholder in shareholders:
assets.update({
shareholder.pk: {
'count': shareholder.share_count(),
'value': shareholder.share_value(),
'percent': shareholder.share_percent()
}
})
# run
company.split_shares(data)
# asserts by checking overall shareholder situation
# means each shareholder should have now more shares but some
# overall stock value
for shareholder in shareholders:
self.assertEqual(
shareholder.share_count(),
round(assets[shareholder.pk]['count'] * multiplier))
self.assertEqual(round(shareholder.share_value()),
assets[shareholder.pk]['value'])
self.assertEqual(round(float(shareholder.share_percent()), 2),
float(assets[shareholder.pk]['percent']))
self.assertEqual(company.share_count,
round(company_share_count * multiplier))
self.assertEquals(len(mail.outbox), 1)
self.assertEquals(
mail.outbox[0].subject,
u"Ihre Liste gespaltener Aktienanrechte f\xfcr das Unternehmen "
u"'{}'".format(company.name))
def test_send_statement_generation_operator_notify(self, mock_mail_admins,
mock_email_message_send,
mock_email_multi_send,
mock_render_pdf):
company = CompanyGenerator().generate()
company.is_statement_sending_enabled = True
company.statement_sending_date = now().date()
company.save()
# no subscription
send_statement_generation_operator_notify()
mock_mail_admins.assert_not_called()
mock_email_message_send.assert_not_called()
mock_email_multi_send.assert_not_called()
# add subscription
self.add_subscription(company)
# no operators
send_statement_generation_operator_notify()
mock_mail_admins.assert_called()
mock_email_message_send.assert_not_called()
mock_email_multi_send.assert_not_called()
OperatorGenerator().generate(company=company)
with self.settings(EMAIL_BACKEND='dummy'):
send_statement_generation_operator_notify()
mock_email_multi_send.assert_called()
djrill_settings = {
'EMAIL_BACKEND': 'djrill',
'MANDRILL_SHAREHOLDER_STATEMENT_OPERATOR_NOTIFY_TEMPLATE': 'foo'
}
with self.settings(**djrill_settings):
send_statement_generation_operator_notify()
mock_email_message_send.assert_called()
mock_mail_admins.reset_mock()
mock_email_multi_send.reset_mock()
mock_render_pdf.return_value = 'PDFCONTENT'
with mock.patch('shareholder.tasks.'
'EmailMultiAlternatives.attach') as mock_attach:
send_statement_generation_operator_notify()
mock_attach.assert_called()
mock_attach.reset_mock()
mock_render_pdf.side_effect = Exception
send_statement_generation_operator_notify()
mock_attach.assert_not_called()
mock_mail_admins.assert_not_called()
mock_email_multi_send.return_value = 0
send_statement_generation_operator_notify()
mock_mail_admins.assert_called()
def setUp(self):
super(HasSubscriptionPermissionTestCase, self).setUp()
self.factory = RequestFactory()
self.permission = HasSubscriptionPermission()
self.operator = OperatorGenerator().generate()
# steal session from client: http://stackoverflow.com/a/37307406/1270058
self.session = self.client.session
self.session['company_pk'] = self.operator.company.pk
self.session.save()
def test_get_queryset(self):
self.view.request = self.factory.get('/')
# non-operator
self.view.request.user = UserGenerator().generate()
self.assertEqual(len(self.view.get_queryset()), 0)
# operator
self.view.request.user = OperatorGenerator().generate().user
self.assertEqual(len(self.view.get_queryset()), 1)
def test_ticket_8(self):
""" adding shareholder with user and userprofile for the same user for
many companies/registers
means we will create 3 companies, with 3 operators and each will add the
same shareholder for its company.
then login as the shareholder and check what happened and what is shown
"""
ops = []
ops.append(OperatorGenerator().generate())
ops.append(OperatorGenerator().generate())
ops.append(OperatorGenerator().generate())
user = UserGenerator().generate()
try:
for op in ops:
start = page.StartPage(
self.selenium, self.live_server_url, op.user)
start.is_properly_displayed()
start.has_shareholder_count(Shareholder.objects.filter(
company=op.company).count())
start.click_open_add_shareholder()
start.add_shareholder(user)
start.click_save_add_shareholder()
start.has_shareholder_count(Shareholder.objects.filter(
company=op.company).count())
# shareholder now, no shareholder login yet
# start = page.StartPage(
# self.selenium, self.live_server_url, user)
# start.is_properly_displayed()
time.sleep(2)
self.assertEqual(user.shareholder_set.count(), 3)
for op in ops:
self.assertEqual(
user.shareholder_set.filter(company=op.company).count(), 1)
except Exception, e:
self._handle_exception(e)