492 lines
16 KiB
Python
492 lines
16 KiB
Python
from __future__ import absolute_import
|
|
from __future__ import division
|
|
from __future__ import print_function
|
|
from __future__ import unicode_literals
|
|
|
|
from .statements import *
|
|
|
|
nu = datetime.datetime.now()
|
|
|
|
from rowers.teams import *
|
|
|
|
class TeamFactory(factory.DjangoModelFactory):
|
|
class Meta:
|
|
model = Team
|
|
|
|
name = factory.LazyAttribute(lambda _: faker.word())
|
|
notes = faker.text()
|
|
private = 'open'
|
|
viewing = 'allmembers'
|
|
|
|
|
|
@override_settings(TESTING=True)
|
|
class TeamTest(TestCase):
|
|
def setUp(self):
|
|
redis_connection.publish('tasks','KILL')
|
|
self.user_passwords = []
|
|
usernames = [
|
|
'user1',
|
|
'user2',
|
|
'user3',
|
|
'user4',
|
|
'user5',
|
|
'user6',
|
|
]
|
|
self.users = []
|
|
self.csvfilenames = []
|
|
|
|
for i in range(6):
|
|
u = UserFactory(username=usernames[i])
|
|
self.users.append(u)
|
|
|
|
r = Rower.objects.create(
|
|
birthdate=faker.profile()['birthdate'],
|
|
gdproptin=True, ftpset=True,surveydone=True,
|
|
gdproptindate=timezone.now(),
|
|
rowerplan='pro',
|
|
user=u,
|
|
clubsize=3
|
|
)
|
|
r.save()
|
|
|
|
password = faker.word()
|
|
u.set_password(password)
|
|
u.save()
|
|
self.user_passwords.append(password)
|
|
|
|
|
|
workouts = WorkoutFactory.create_batch(5, user=r)
|
|
for w in workouts:
|
|
self.csvfilenames.append(w.csvfilename)
|
|
|
|
|
|
self.c = Client()
|
|
|
|
self.u = self.users[0]
|
|
self.r = self.users[0].rower
|
|
self.password = self.user_passwords[0]
|
|
|
|
self.t = TeamFactory(manager=self.u)
|
|
|
|
# need to set up some requests for testing (they are not good below)
|
|
self.invite = TeamInvite(
|
|
team = self.t,
|
|
user = self.users[1],
|
|
code = 'abcde',
|
|
email = self.users[1].email
|
|
)
|
|
self.invite.save()
|
|
|
|
self.rekwest = TeamRequest(
|
|
team = self.t,
|
|
user = self.users[2],
|
|
code ='abcde'
|
|
)
|
|
self.rekwest.save()
|
|
|
|
result = get_random_file(filename='rowers/tests/testdata/erg1.csv')
|
|
|
|
self.werg1 = WorkoutFactory(user=self.r,
|
|
csvfilename=result['filename'],
|
|
starttime=result['starttime'],
|
|
startdatetime=result['startdatetime'],
|
|
duration=result['duration'],
|
|
distance=result['totaldist'],
|
|
workouttype = 'rower',
|
|
)
|
|
|
|
result = get_random_file(filename='rowers/tests/testdata/erg2.csv')
|
|
|
|
self.werg2 = WorkoutFactory(user=self.r,
|
|
csvfilename=result['filename'],
|
|
starttime=result['starttime'],
|
|
startdatetime=result['startdatetime'],
|
|
duration=result['duration'],
|
|
distance=result['totaldist'],
|
|
workouttype = 'rower',
|
|
)
|
|
|
|
|
|
def tearDown(self):
|
|
for csvfilename in self.csvfilenames:
|
|
try:
|
|
os.remove(csvfilename)
|
|
except (IOError, FileNotFoundError,OSError):
|
|
pass
|
|
|
|
def test_team_leave_view(self):
|
|
res = add_member(self.t.id,self.users[1].rower)
|
|
login = self.c.login(username=self.u.username, password = self.password)
|
|
self.assertTrue(login)
|
|
|
|
url = reverse('team_leave_view',kwargs={'id':self.t.id})
|
|
response = self.c.get(url,follow=True)
|
|
expected_url = reverse('rower_teams_view')
|
|
self.assertRedirects(response,expected_url=expected_url,status_code=302,target_status_code=200)
|
|
|
|
def test_team_delete_view(self):
|
|
login = self.c.login(username=self.u.username, password = self.password)
|
|
self.assertTrue(login)
|
|
|
|
url = reverse('team_delete_view',kwargs={'team_id':self.t.id})
|
|
response = self.c.get(url,follow=True)
|
|
expected_url = reverse('rower_teams_view')
|
|
self.assertRedirects(response,expected_url=expected_url,status_code=302,target_status_code=200)
|
|
|
|
def test_manager_drop_member(self):
|
|
res = add_member(self.t.id,self.users[1].rower)
|
|
login = self.c.login(username=self.u.username, password = self.password)
|
|
self.assertTrue(login)
|
|
|
|
url = '/rowers/me/team/{t}/drop/{u}/'.format(
|
|
t = self.t.id,
|
|
u = self.users[1].id
|
|
)
|
|
|
|
response = self.c.get(url,follow=True)
|
|
self.assertEqual(response.status_code,200)
|
|
self.assertRedirects(response,
|
|
expected_url='/rowers/me/teams/'.format(t=self.t.id),
|
|
status_code=302,target_status_code=200)
|
|
|
|
def test_teamview(self):
|
|
login = self.c.login(username=self.u.username, password = self.password)
|
|
self.assertTrue(login)
|
|
|
|
url = '/rowers/team/{t}/'.format(t=self.t.id)
|
|
response = self.c.get(url)
|
|
self.assertEqual(response.status_code, 200)
|
|
|
|
def test_teamview_member(self):
|
|
|
|
id,comment = add_member(self.t.id,self.users[1].rower)
|
|
self.assertEqual(id,self.t.id)
|
|
|
|
login = self.c.login(username=self.users[1].username, password = self.user_passwords[1])
|
|
self.assertTrue(login)
|
|
|
|
url = '/rowers/team/{t}/'.format(t=self.t.id)
|
|
response = self.c.get(url)
|
|
self.assertEqual(response.status_code, 200)
|
|
|
|
|
|
def test_teamsview(self):
|
|
|
|
url = '/rowers/me/teams/'
|
|
|
|
login = self.c.login(username=self.users[2].username, password = self.user_passwords[2])
|
|
self.assertTrue(login)
|
|
|
|
response = self.c.get(url,follow=True)
|
|
self.assertEqual(response.status_code,200)
|
|
|
|
html = BeautifulSoup(response.content,'html.parser')
|
|
urls = [a['href'] for a in html.find_all('a')]
|
|
|
|
for u in urls:
|
|
if 'rowers' in u and 'http' not in u and 'authorize' not in u and 'import' not in u and 'logout' not in u:
|
|
response = self.c.get(u)
|
|
if response.status_code not in [200,302]:
|
|
print(url)
|
|
print(u)
|
|
print(response.status_code)
|
|
self.assertIn(response.status_code,[200,302])
|
|
|
|
login = self.c.login(username=self.users[1].username,
|
|
password = self.user_passwords[1])
|
|
self.assertTrue(login)
|
|
|
|
response = self.c.get(url,follow=True)
|
|
self.assertEqual(response.status_code,200)
|
|
|
|
html = BeautifulSoup(response.content,'html.parser')
|
|
urls = [a['href'] for a in html.find_all('a')]
|
|
|
|
for u in urls:
|
|
if 'rowers' in u and 'http' not in u and 'authorize' not in u and 'import' not in u and 'logout' not in u:
|
|
response = self.c.get(u)
|
|
if response.status_code not in [200,302]:
|
|
print(url)
|
|
print(u)
|
|
print(response.status_code)
|
|
self.assertIn(response.status_code,[200,302])
|
|
|
|
def test_teamsview_manager(self):
|
|
|
|
url = '/rowers/me/teams/'
|
|
|
|
login = self.c.login(username=self.u,password=self.password)
|
|
self.assertTrue(login)
|
|
|
|
response = self.c.get(url,follow=True)
|
|
self.assertEqual(response.status_code,200)
|
|
|
|
html = BeautifulSoup(response.content,'html.parser')
|
|
urls = [a['href'] for a in html.find_all('a')]
|
|
|
|
for u in urls:
|
|
if 'rowers' in u and 'http' not in u and 'authorize' not in u and 'import' not in u and 'logout' not in u:
|
|
response = self.c.get(u)
|
|
if response.status_code not in [200,302]:
|
|
print(url)
|
|
print(u)
|
|
print(response.status_code)
|
|
self.assertIn(response.status_code,[200,302])
|
|
|
|
def test_teamview_member_request(self):
|
|
|
|
login = self.c.login(username=self.users[3].username, password = self.user_passwords[3])
|
|
self.assertTrue(login)
|
|
|
|
url = '/rowers/team/{t}/requestmembership/{u}/'.format(
|
|
t=self.t.id,
|
|
u=self.users[3].id)
|
|
|
|
response = self.c.get(url,follow=True)
|
|
self.assertEqual(response.status_code, 200)
|
|
|
|
self.assertRedirects(response,
|
|
expected_url='/rowers/team/{t}/'.format(t=self.t.id),
|
|
status_code=302,target_status_code=200)
|
|
|
|
login = self.c.login(username=self.users[2].username, password = self.user_passwords[2])
|
|
self.assertTrue(login)
|
|
|
|
url = '/rowers/me/request/{id}/revoke/'.format(id=self.rekwest.id)
|
|
self.assertRedirects(response,
|
|
expected_url='/rowers/team/{t}/'.format(t=self.t.id),
|
|
status_code=302,target_status_code=200)
|
|
|
|
response = self.c.get(url,follow=True)
|
|
self.assertEqual(response.status_code,200)
|
|
|
|
def test_teamview_manager_request(self):
|
|
login = self.c.login(username=self.u.username, password = self.password)
|
|
self.assertTrue(login)
|
|
|
|
url = '/rowers/me/request/{id}/reject/'.format(id=self.rekwest.id)
|
|
response = self.c.get(url,follow=True)
|
|
self.assertEqual(response.status_code,200)
|
|
self.assertRedirects(response,
|
|
expected_url='/rowers/me/teams/',
|
|
status_code=302,target_status_code=200)
|
|
|
|
|
|
def test_team_invite_view(self):
|
|
login = self.c.login(username=self.u.username, password = self.password)
|
|
self.assertTrue(login)
|
|
|
|
url = '/rowers/team/{t}/'.format(t=self.t.id)
|
|
|
|
form_data = {
|
|
'email': self.users[1].email,
|
|
'user': u''
|
|
}
|
|
|
|
response = self.c.post(url, form_data)
|
|
self.assertEqual(response.status_code, 200)
|
|
|
|
def test_team_invite_convoluted(self):
|
|
uA = User.objects.get(username='user1')
|
|
uB = User.objects.get(username='user2')
|
|
|
|
passwordA = self.user_passwords[0]
|
|
passwordB = self.user_passwords[1]
|
|
|
|
# login User A
|
|
login = self.c.login(username=uA.username, password = passwordA)
|
|
self.assertTrue(login)
|
|
|
|
# start a group
|
|
teamA = Team(
|
|
manager = uA,
|
|
name = 'teamA',
|
|
private = 'open',
|
|
viewing = 'allmembers'
|
|
)
|
|
teamA.save()
|
|
uA.rower.team.add(teamA)
|
|
|
|
# invite B to the group
|
|
inviteA = TeamInvite(
|
|
team = teamA,
|
|
user = uB,
|
|
code = 'ABCDEF',
|
|
email = self.users[1].email,
|
|
)
|
|
inviteA.save()
|
|
|
|
invite = TeamInvite.objects.get(code=inviteA.code)
|
|
|
|
# B accepts the invite
|
|
login = self.c.login(username = uB.username, password = passwordB)
|
|
self.assertTrue(login)
|
|
|
|
url = reverse('rower_invitations_view')+inviteA.code
|
|
response = self.c.get(url,follow=True)
|
|
|
|
expected_url = reverse('team_view', kwargs={'team_id':teamA.id})
|
|
self.assertRedirects(response, expected_url=expected_url, status_code=301, target_status_code=200)
|
|
|
|
# A requests B to become their coach
|
|
coachrequest = CoachRequest(
|
|
coach = uB.rower,
|
|
user = uA,
|
|
code = 'ABCDEFG'
|
|
)
|
|
coachrequest.save()
|
|
|
|
# B accepts coaching request
|
|
login = self.c.login(username = uB.username, password = passwordB)
|
|
self.assertTrue(login)
|
|
|
|
url = reverse('coach_accept_coachrequest_view', kwargs={'code':coachrequest.code})
|
|
response = self.c.get(url,follow=True)
|
|
expected_url = reverse('rower_teams_view')
|
|
self.assertRedirects(response, expected_url=expected_url, status_code=302, target_status_code=200)
|
|
|
|
# Now check a few things
|
|
self.assertTrue(is_team_member(uA,teamA))
|
|
self.assertTrue(is_team_member(uB,teamA))
|
|
self.assertTrue(is_coach_user(uB,uA))
|
|
|
|
# B leaves A's group
|
|
url = reverse('team_leave_view',kwargs={'id':teamA.id})
|
|
response = self.c.get(url)
|
|
expected_url = reverse('rower_teams_view')
|
|
self.assertRedirects(response, expected_url=expected_url, status_code=302, target_status_code=200)
|
|
self.assertFalse(is_team_member(uB,teamA))
|
|
|
|
self.assertTrue(is_coach_user(uB,uA))
|
|
|
|
# B should see A's workouts on the list
|
|
url = reverse('workouts_view',kwargs={'userid':uA.id})
|
|
response = self.c.get(url)
|
|
self.assertEqual(response.status_code, 200)
|
|
|
|
# B should see A's Plan
|
|
url = '/rowers/sessions/'
|
|
response = self.c.get(url)
|
|
self.assertEqual(response.status_code, 200)
|
|
|
|
#self.assertTrue(uA.first_name in str(response.content))
|
|
|
|
url = reverse('plannedsessions_view',kwargs={'userid':uA.id})
|
|
response = self.c.get(url)
|
|
self.assertEqual(response.status_code, 200)
|
|
|
|
#self.assertTrue(uA.first_name in str(response.content))
|
|
|
|
|
|
@override_settings(TESTING=True)
|
|
class TeamTestLowLevel(TestCase):
|
|
def setUp(self):
|
|
redis_connection.publish('tasks','KILL')
|
|
self.user_passwords = []
|
|
usernames = [
|
|
'user1',
|
|
'user2',
|
|
'user3',
|
|
'user4',
|
|
'user5',
|
|
'user6',
|
|
]
|
|
self.users = []
|
|
self.csvfilenames = []
|
|
|
|
for i in range(6):
|
|
u = UserFactory(username=usernames[i])
|
|
self.users.append(u)
|
|
|
|
r = Rower.objects.create(
|
|
birthdate=faker.profile()['birthdate'],
|
|
gdproptin=True, ftpset=True,surveydone=True,
|
|
gdproptindate=timezone.now(),
|
|
rowerplan='pro',
|
|
user=u,
|
|
clubsize=3
|
|
)
|
|
r.save()
|
|
|
|
password = faker.word()
|
|
u.set_password(password)
|
|
u.save()
|
|
self.user_passwords.append(password)
|
|
|
|
|
|
workouts = WorkoutFactory.create_batch(5, user=r)
|
|
for w in workouts:
|
|
self.csvfilenames.append(w.csvfilename)
|
|
|
|
|
|
self.c = Client()
|
|
|
|
self.u = self.users[0]
|
|
self.password = self.user_passwords[0]
|
|
|
|
self.t = TeamFactory(manager=self.u)
|
|
|
|
|
|
def tearDown(self):
|
|
for csvfilename in self.csvfilenames:
|
|
try:
|
|
os.remove(csvfilename)
|
|
except (IOError, FileNotFoundError,OSError):
|
|
pass
|
|
|
|
def test_lowlevel_update_team(self):
|
|
id, comment = update_team(self.t,faker.word(),self.u,'open',faker.text(),'allmembers')
|
|
self.assertEqual(id,1)
|
|
|
|
id, comment = update_team(self.t,faker.word(),self.users[2],'open',faker.text(),'allmembers')
|
|
self.assertEqual(id,0)
|
|
|
|
team = TeamFactory(manager = self.users[2])
|
|
id, comment = update_team(team, self.t.name, self.users[2], 'open', faker.text(),
|
|
'allmembers')
|
|
self.assertEqual(id,0)
|
|
self.assertEqual(comment,'Team name duplication')
|
|
|
|
def test_lowlevel_create_team(self):
|
|
id, comment = create_team(faker.word(), self.u)
|
|
self.assertEqual(id,2)
|
|
|
|
id, comment = create_team(self.t.name,self.u)
|
|
self.assertEqual(id,0)
|
|
self.assertEqual(comment,'Team name duplication')
|
|
|
|
def test_lowlevel_remove_team(self):
|
|
team = TeamFactory(manager=self.u)
|
|
tid = team.id
|
|
id, comment = add_member(team.id,self.users[1].rower)
|
|
id, comment = add_member(team.id,self.users[2].rower)
|
|
|
|
result = remove_team(team.id)
|
|
|
|
test = Team.objects.filter(id=tid)
|
|
self.assertEqual(len(test),0)
|
|
|
|
def test_lowlevel_create_request(self):
|
|
id,comment = create_request(self.t,self.users[1].id)
|
|
self.assertEqual(id,1)
|
|
|
|
def test_lowlevel_remove_member(self):
|
|
id, comment = add_member(self.t.id, self.users[3].rower)
|
|
id, comment = remove_member(self.t.id, self.users[3].rower)
|
|
self.assertEqual(id, self.t.id)
|
|
|
|
|
|
def test_lowlevel_create_invite(self):
|
|
id, comment = add_member(self.t.id, self.users[1].rower)
|
|
|
|
# cannot create invite for someone who already is a member
|
|
id, comment = create_invite(self.t,self.u,user=self.users[1])
|
|
self.assertEqual(id,0)
|
|
self.assertEqual(comment,'Already member of that team')
|
|
|
|
id, comment = remove_member(self.t.id, self.users[1].rower)
|
|
|
|
# cannot create invite for team you don't manage
|
|
id, comment = create_invite(self.t, self.users[3],self.users[4])
|
|
self.assertEqual(id,0)
|