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_transactions_xls(self):
""" test download of all transactions data
/company/3/download/transactions?from=2017-01-12T23:00:00.000Z&to=2017-01-13T23:00:00.000Z&security=56
"""
company = CompanyGenerator().generate()
security = SecurityGenerator().generate(company=company)
# run test
response = self.client.get(
reverse('reports:transactions_xls',
kwargs={"company_id": company.id}), {
'to': '2017-01-12T23:00:00.000Z',
'from': '2011-01-12T23:00:00.000Z',
'security': security.pk
})
# not logged in user
self.assertEqual(response.status_code, 302)
# login and retest
user = UserGenerator().generate()
self.client.force_login(user)
response = self.client.get(
reverse('reports:transactions_xls',
kwargs={"company_id": company.id}), {
'to': '2017-01-12T23:00:00.000Z',
'from': '2011-01-12T23:00:00.000Z',
'security': security.pk
})
# assert response code
self.assertEqual(response.status_code, 403)
def test_ticket_96(self):
"""
add company with face value with decimals and large share count
"""
user = UserGenerator().generate()
value = '4.5'
count = '15000000'
try:
p = page.StartPage(
self.selenium, self.live_server_url, user)
self.assertTrue(p.is_add_company_form_displayed())
p.enter_add_company_data(value=value, count=count)
p.click_save_add_company()
self.assertEqual(p.get_form_errors(), [])
self.assertFalse(p.is_add_company_form_displayed())
self.assertTrue(user.operator_set.exists())
company = user.operator_set.first().company
cs = company.get_company_shareholder()
self.assertTrue(cs.buyer.first().value, value)
except Exception, e:
self._handle_exception(e)
def test_add_company(self):
"""
confirm that we add all properly
#54: common stock as default security
"""
user = UserGenerator().generate()
kwargs = {
"name":
"Pariatur Rerum est voluptates ipsa in officia libero "
"soluta omnis saepe voluptates omnis quidem autem veniam "
"rerum molestiae incidunt",
"count":
36,
"face_value":
18,
"founded_at":
"2016-05-31T23:00:00.000Z"
}
self.client.force_authenticate(user=user)
res = self.client.post(reverse('add_company'), kwargs)
self.assertEqual(res.status_code, 201)
company = user.operator_set.all()[0].company
self.assertEqual(company.security_set.all()[0].title, 'C')
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_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 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_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 test_send_initial_password_mail(self):
password = '******'
user = UserGenerator().generate()
send_initial_password_mail(user, password)
self.assertEqual(len(mail.outbox), 1)
def test_model(self):
user = UserGenerator().generate()
profile = user.userprofile
self.assertEqual(profile.country.iso_code, 'de')
self.assertEqual(profile.country.name, 'Germany')
self.assertEqual(profile.province, 'Some Province')
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_get_is_myself(self):
req = self.factory.get('/')
req.user = UserGenerator().generate()
self.serializer.context = dict(request=req)
self.assertFalse(self.serializer.get_is_myself(self.instance))
req.user = self.instance.user
self.serializer.context = dict(request=req)
self.assertTrue(self.serializer.get_is_myself(self.instance))
def test_add_company(self):
"""
add company with face value with decimals and large share count
see #96
"""
user = UserGenerator().generate()
value = '4.5'
count = '15000000'
try:
p = page.StartPage(self.selenium, self.live_server_url, user)
# wait for form
p.wait_until_visible((By.CSS_SELECTOR, '#add_company'))
self.assertTrue(p.is_add_company_form_displayed())
# menue is hidden
self.assertFalse(
self.selenium.find_element_by_css_selector(
'#navbar ul').is_displayed())
p.enter_add_company_data(value=value, count=count)
p.click_save_add_company()
# wait for form to disappear
p.wait_until_invisible((By.CSS_SELECTOR, '#add_company'))
self.add_subscription(user.operator_set.first().company)
self.assertEqual(p.get_form_errors(), [])
""" invalidated by changing the next step to subscription selection
leaving here as this might return later again...
self.assertFalse(p.is_add_company_form_displayed())
self.assertTrue(user.operator_set.exists())
company = user.operator_set.first().company
self.assertEqual(DEFAULT_TEST_DATA['company_name'], company.name)
cs = company.get_company_shareholder()
self.assertTrue(cs.buyer.first().value, value)
# menue is displayed
self.assertTrue(
self.selenium.find_element_by_css_selector('#navbar ul')
.is_displayed())
# captable is hidden after company add, so the user is not confused
# and can enter a single shareholder first
self.assertFalse(
self.selenium.find_element_by_css_selector('#captable')
.is_displayed())
# but it's shown on refresh
p.refresh()
self.assertTrue(
p.wait_until_visible((By.CSS_SELECTOR, '#captable'))
.is_displayed())
self.assertEqual(company.founded_at, datetime.date.today())
"""
self.assertIn('subscription', p.driver.current_url)
except Exception, e:
self._handle_exception(e)
def test_create(self):
validated_data = {
'user': UserGenerator().generate(),
'count': 33,
'founded_at': datetime.datetime.now().date(),
'name': u'Mühleggbahn AG',
'face_value': 22,
}
res = self.serializer.create(validated_data)
self.assertEqual(res, validated_data)
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_create_negative_share_count(self):
""" see https://goo.gl/HDQB1t for users doing that """
validated_data = {
'user': UserGenerator().generate(),
'share_count': -33,
'founded_at': timezone.now().date(),
'name': u'Mühleggbahn AG',
'face_value': 22,
}
with self.assertRaises(ValidationError):
self.serializer.validate_share_count(validated_data['share_count'])
def test_start_nonauthorized(self):
user = UserGenerator().generate()
is_loggedin = self.client.login(
username=user.username, password='******')
self.assertFalse(is_loggedin)
response = self.client.get(reverse('start'), follow=True)
self.assertEqual(response.status_code, 200)
# redirect to login
self.assertIn(_('Register'), response.content.decode('utf-8'))
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_start_authorized(self):
user = UserGenerator().generate()
is_loggedin = self.client.login(
username=user.username, password='******')
self.assertTrue(is_loggedin)
response = self.client.get(reverse('start'), follow=True)
self.assertEqual(response.status_code, 200)
self.assertTrue("UA-58468401-4" in response.content)
self.assertTrue("Willkommen" in response.content)
self.assertTrue("shareholder_list" in response.content)
def test_start_authorized_with_operator(self):
user = UserGenerator().generate()
is_operator_added = _add_company_to_user_via_rest(user)
self.assertTrue(is_operator_added)
self.client.force_login(user)
self.add_subscription(user.operator_set.first().company)
response = self.client.get(reverse('start'), follow=True)
self.assertEqual(response.status_code, 200)
self.assertTrue("Willkommen" in response.content)
self.assertTrue("shareholder_list" in response.content)
def test_add_new_operator(self):
""" means: create a option plan and move options for users """
user = UserGenerator().generate()
try:
p = page.CompanyPage(self.selenium, self.live_server_url,
self.operator.user, self.operator.company)
p.click_open_add_new_operator_form()
p.enter_new_operator_email(user.email)
p.click_save_new_operator()
self.assertTrue(p.is_operator_displayed(user.email))
self.assertTrue(
user.operator_set.filter(
company=self.operator.company).exists())
except Exception, e:
self._handle_exception(e)
def test_pdf_download_with_missing_operator(self):
""" test download of captable pdf """
company = CompanyGenerator().generate()
# run test
response = self.client.get(
reverse('captable_pdf', 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_pdf', kwargs={"company_id": company.id}))
# assert response code
self.assertEqual(response.status_code, 403)
def test_has_permission(self):
view = APIView()
req = self.factory.get('/')
req.user = AnonymousUser()
# not authenticated
self.assertFalse(self.permission.has_permission(req, view))
req.user = UserGenerator().generate()
# authenticated but no operator
self.assertFalse(self.permission.has_permission(req, view))
# add operator for user
op = OperatorGenerator().generate(user=req.user)
add_company_to_session(self.client.session, op.company)
req.session = self.client.session
# user is authenticated and operator
self.assertTrue(self.permission.has_permission(req, view))
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)
def test_dispatch(self, mock_login, mock_logout, mock_login_required):
self.mixin.http_method_not_allowed = mock.Mock(side_effect=Exception)
req = self.factory.get('/')
with self.assertRaises(Exception):
self.mixin.dispatch(req)
self.mixin.http_method_not_allowed.assert_called()
self.mixin.http_method_not_allowed.reset_mock()
self.mixin.http_method_names = ['get']
self.mixin.get = mock.Mock()
self.mixin.dispatch(req)
self.mixin.get.assert_called()
self.mixin.get.reset_mock()
user = UserGenerator().generate()
user.is_active = False
user.save()
req = self.factory.get('/', data=dict(token=user.auth_token))
self.mixin.dispatch(req)
mock_logout.assert_called()
mock_logout.reset_mock()
user.is_active = True
user.save()
self.mixin.dispatch(req)
mock_login.assert_called()
mock_login.reset_mock()
self.mixin.login_user = False
self.mixin.dispatch(req)
mock_login.assert_not_called()
self.mixin.login_required = True
self.mixin.dispatch(req)
mock_login_required.assert_called()
def test_pdf_download_with_number_segments(self):
""" test download of captable pdf """
company = CompanyGenerator().generate()
secs = TwoInitialSecuritiesGenerator().generate(company=company)
security = secs[1]
security.track_numbers = True
security.save()
# 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_pdf',
kwargs={"company_id": company.id}))
# assert response code
self.assertEqual(response.status_code, 200)
# assert proper csv
self.assertTrue(response.content.startswith('%PDF-1.4\r\n'))
self.assertTrue(response.content.endswith('EOF\r\n'))
def test_add_shareholder_without_email(self):
"""
add shareholder without email
"""
op = OperatorGenerator().generate()
self.add_subscription(op.company)
CompanyShareholderGenerator().generate(company=op.company)
user = UserGenerator().generate()
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)
start.click_save_add_shareholder()
start.close_modal('addShareholder')
time.sleep(5)
# wait for list entry
xpath = ('//div[@id="shareholder_list"]//span[text()="{}"]'
u''.format(Shareholder.objects.last().get_full_name()))
start.wait_until_visible((By.XPATH, xpath))
self.assertEqual(
start.has_shareholder_count(),
Shareholder.objects.filter(company=op.company).count())
self.assertEqual(
user.first_name,
Shareholder.objects.filter(
company=op.company).last().user.first_name)
except Exception, e:
self._handle_exception(e)
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_start_authorized_with_operator(self):
try:
user = UserGenerator().generate()
is_operator_added = _add_company_to_user_via_rest(user)
self.assertTrue(is_operator_added)
is_loggedin = self.client.login(
username=user.username, password='******')
self.assertTrue(is_loggedin)
response = self.client.get(reverse('start'), follow=True)
self.assertEqual(response.status_code, 200)
self.assertTrue("UA-58468401-4" in response.content)
self.assertTrue("Willkommen" in response.content)
self.assertTrue("shareholder_list" in response.content)
except Exception, e:
self._handle_exception(e)
def test_pdf_download(self):
""" test download of captable pdf """
company = CompanyGenerator().generate()
# run test
response = self.client.get(
reverse('captable_pdf', 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_pdf', kwargs={"company_id": company.id}))
# assert response code
self.assertEqual(response.status_code, 200)
# assert proper csv
self.assertTrue(response.content.startswith('%PDF-1.4\r\n'))
self.assertTrue(response.content.endswith('EOF\r\n'))
