def test_get_projects_for_user_none(self):
p = Project(title="title", description="desc")
p.save()
self.assertEqual(
models.project_api.get_projects_for_user(
self.__user.id).count(),
0)
def test_delete_project_fail(self):
p = Project(title="title", description="desc")
p.save()
self.assertEqual(1, Project.objects.filter(id=p.id).count())
projID = p.id - 1
models.project_api.delete_project(None)
self.assertEqual(1, Project.objects.filter(id=p.id).count())
def test_delete_project_fail(self):
p = Project(title="title", description="desc")
p.save()
self.assertEqual(1, Project.objects.filter(id=p.id).count())
projID = p.id - 1
models.project_api.delete_project(None)
self.assertEqual(1, Project.objects.filter(id=p.id).count())
def setUp(self):
self.__clear()
self.__project = Project(title="title", description="desc")
self.__project.save()
self.__user = User(username="******", password="******")
self.__user.save()
def test_can_user_access_project_can(self):
p = Project(title="title", description="desc")
p.save()
u = UserAssociation(user=self.__user, project=p)
u.save()
self.assertEqual(
models.project_api.can_user_access_project(self.__user.id, p.id),
True)
def test_get_project_users_one(self):
p = Project(title="title", description="desc")
p.save()
models.project_api.add_user_to_project(
p.id,
self.__user.username,
models.user_association.ROLE_DEVELOPER)
self.assertEqual(models.project_api.get_all_projects().count(), 1)
def test_can_user_access_project_cant(self):
p = Project(title="title", description="desc")
p.save()
self.assertEqual(
models.project_api.can_user_access_project(
self.__user.id,
p.id),
False)
def test_add_user_to_project_pass(self):
p = Project(title="title", description="desc")
p.save()
models.project_api.add_user_to_project(
p.id, self.__user.username, models.user_association.ROLE_DEVELOPER)
self.assertEqual(
UserAssociation.objects.filter(project_id=p.id,
user_id=self.__user.id).count(), 1)
def test_get_projects_for_user_one(self):
p = Project(title="title", description="desc")
p.save()
u = UserAssociation(user = self.__user, project=p)
u.save()
self.assertEqual( models.project_api.get_projects_for_user(self.__user.id).count(), 1)
def test_get_iteration_pass(self):
p = Project(title="title", description="desc")
p.save()
iteration = models.project_api.add_iteration_to_project(
"title", "description", datetime.date.today(), datetime.date.max,
p.id)
self.assertEqual(
1,
models.project_api.get_iterations_for_project(p).count())
def test_remove_user_from_project_pass(self):
p = Project(title="title", description="desc")
p.save()
models.project_api.add_user_to_project(p.id, self.__user.username, models.user_association.ROLE_DEVELOPER)
self.assertEqual(UserAssociation.objects.filter(project_id=p.id,
user_id=self.__user.id).count(),1)
models.project_api.remove_user_from_project(p.id, self.__user.username)
self.assertEqual(UserAssociation.objects.filter(project_id=p.id,
user_id=self.__user.id).count(),0)
def test_get_projects_for_user_one(self):
p = Project(title="title", description="desc")
p.save()
u = UserAssociation(user=self.__user, project=p)
u.save()
self.assertEqual(
models.project_api.get_projects_for_user(self.__user.id).count(),
1)
def test_get_iteration_pass(self):
p = Project(title="title", description="desc")
p.save()
iteration = models.project_api.add_iteration_to_project(
"title",
"description",
datetime.date.today(),
datetime.date.max,
p.id)
self.assertEqual(1, models.project_api.get_iterations_for_project(p).count())
def test_can_user_access_project_can(self):
p = Project(title="title", description="desc")
p.save()
u = UserAssociation(user=self.__user, project=p)
u.save()
self.assertEqual(
models.project_api.can_user_access_project(
self.__user.id,
p.id),
True)
def test_get_project_stories_one(self):
p = Project(title="title", description="desc")
p.save()
models.story.create_story(p, {"title" : "title",
"description" : "desc",
"reason" : "reason",
"test" : "test",
"status" : 1})
iterations = models.project_api.get_iterations_for_project(p)
stories = models.story.get_stories_for_project(p)
self.assertEqual(True, stories.exists())
def test_get_project_stories_one(self):
p = Project(title="title", description="desc")
p.save()
models.story.create_story(p, {"title": "title",
"description": "desc",
"reason": "reason",
"test": "test",
"status": 1})
iterations = models.project_api.get_iterations_for_project(p)
stories = models.story.get_stories_for_project(p)
self.assertEqual(True, stories.exists())
def setUp(self):
self.__clear()
self.__project = Project(title="title", description="desc")
self.__project.save()
self.__user1 = User(username="******", password="******")
self.__user1.save()
self.__user2 = User(username="******", password="******")
self.__user2.save()
self.__user3 = User(username="******", password="******")
self.__user3.save()
self.__user = User(username="******", password="******")
self.__user.save()
def test_get_project_stories_with_no_iteration(self):
p = Project(title="title", description="desc")
p.save()
iteration = models.project_api.add_iteration_to_project("title", "description", datetime.date.today(), datetime.date.max, p.id)
story = models.story.create_story({},p,{'title' : "title",
'description' : "description",
'test' : "",
'reason' : "",
'status' : 1})
stories = models.project_api.get_stories_with_no_iteration(p)
self.assertEquals(stories.count(), 1)
self.assertEquals(stories[0], story)
def test_add_story_to_iteration_story_not_in_project(self):
p = Project(title="title", description="desc")
p.save()
title = "title"
description = "description"
start_date = datetime.date.today()
end_date = datetime.date.max
iteration = models.project_api.add_iteration_to_project(
title, description, start_date, end_date, p.id)
p2 = Project(title="title2", description="desc2")
p2.save()
story = models.story.create_story({}, p2, {
'title': "title",
'description': "description",
'test': '',
'reason': '',
'status': 1
})
try:
models.project_api.add_story_to_iteration(story, iteration)
self.fail(
"Adding a story to an invalid iteration did not throw an exception"
)
except (ValueError):
pass
def test_add_user_to_project_fail_bad_user(self):
p = Project(title="title", description="desc")
p.save()
#pass a null user
models.project_api.add_user_to_project(p.id, None, models.user_association.ROLE_DEVELOPER)
self.assertEqual(UserAssociation.objects.filter(project_id=p.id,
user_id=self.__user.id).count(),0)
#pass an unknown user
user = User(username="******", password="******")
models.project_api.add_user_to_project(p.id, user, models.user_association.ROLE_DEVELOPER)
self.assertEqual(UserAssociation.objects.filter(project_id=p.id,
user_id=self.__user.id).count(),0)
def test_get_all_projects_two(self):
p = Project(title="title", description="desc")
p.save()
p2 = Project(title="title2", description="desc2")
p2.save()
self.assertEqual(models.project_api.get_all_projects().count(), 2)
def test_add_iteration_to_project_pass(self):
p = Project(title="title", description="desc")
p.save()
title = "title"
description = "description"
start_date = datetime.date.today()
end_date = datetime.date.max
iteration = models.project_api.add_iteration_to_project(
title, description, start_date, end_date, p.id)
self.assertEqual(start_date, iteration.start_date)
self.assertEqual(end_date, iteration.end_date)
self.assertEqual(title, iteration.title)
self.assertEqual(description, iteration.description)
self.assertEqual(1, p.iteration_set.count())
def setUp(self):
self.__clear()
self.__project = Project(title="title", description="desc")
self.__project.save()
self.__user = User(username="******", password="******")
self.__user.save()
def test_add_story_to_iteration(self):
p = Project(title="title", description="desc")
p.save()
title = "title"
description = "description"
start_date = datetime.date.today()
end_date = datetime.date.max
iteration = models.project_api.add_iteration_to_project(title, description, start_date, end_date, p.id)
story = models.story.create_story(self.__user,p, {'title' : "title",
'description' : "description",
'test' : "",
'reason' : "reason",
'status' : 1})
models.project_api.add_story_to_iteration(story, iteration)
self.assertEqual(iteration,story.iteration)
def test_get_project_stories_with_no_iteration(self):
p = Project(title="title", description="desc")
p.save()
iteration = models.project_api.add_iteration_to_project(
"title", "description", datetime.date.today(), datetime.date.max,
p.id)
story = models.story.create_story({}, p, {
'title': "title",
'description': "description",
'test': "",
'reason': "",
'status': 1
})
stories = models.project_api.get_stories_with_no_iteration(p)
self.assertEquals(stories.count(), 1)
self.assertEquals(stories[0], story)
def test_add_iteration_to_project_fail_bad_project(self):
p = Project(title="title", description="desc")
p.save()
# pass a null prject
title = "title"
description = "description"
start_date = datetime.date.today()
end_date = datetime.date.max
iteration = models.project_api.add_iteration_to_project(
title, description, start_date, end_date, None)
self.assertEqual(0, p.iteration_set.count())
# pass an unknown project
projID = p.id - 1
iteration = models.project_api.add_iteration_to_project(
title, description, start_date, end_date, projID)
self.assertEqual(0, p.iteration_set.count())
def test_add_iteration_to_project_pass(self):
p = Project(title="title", description="desc")
p.save()
title = "title"
description = "description"
start_date = datetime.date.today()
end_date = datetime.date.max
iteration = models.project_api.add_iteration_to_project(title,
description,
start_date,
end_date, p.id)
self.assertEqual(start_date, iteration.start_date)
self.assertEqual(end_date, iteration.end_date)
self.assertEqual(title, iteration.title)
self.assertEqual(description, iteration.description)
self.assertEqual(1, p.iteration_set.count())
def test_add_user_to_project_fail_bad_user(self):
p = Project(title="title", description="desc")
p.save()
# pass a null user
models.project_api.add_user_to_project(
p.id, None, models.user_association.ROLE_DEVELOPER)
self.assertEqual(
UserAssociation.objects.filter(project_id=p.id,
user_id=self.__user.id).count(), 0)
# pass an unknown user
user = User(username="******", password="******")
models.project_api.add_user_to_project(
p.id, user, models.user_association.ROLE_DEVELOPER)
self.assertEqual(
UserAssociation.objects.filter(project_id=p.id,
user_id=self.__user.id).count(), 0)
def test_add_story_to_iteration(self):
p = Project(title="title", description="desc")
p.save()
title = "title"
description = "description"
start_date = datetime.date.today()
end_date = datetime.date.max
iteration = models.project_api.add_iteration_to_project(
title, description, start_date, end_date, p.id)
story = models.story.create_story(
self.__user, p, {
'title': "title",
'description': "description",
'test': "",
'reason': "reason",
'status': 1
})
models.project_api.add_story_to_iteration(story, iteration)
self.assertEqual(iteration, story.iteration)
def test_add_story_to_iteration_story_not_in_project(self):
p = Project(title="title", description="desc")
p.save()
title = "title"
description = "description"
start_date = datetime.date.today()
end_date = datetime.date.max
iteration = models.project_api.add_iteration_to_project(
title,
description,
start_date,
end_date,
p.id)
p2 = Project(title="title2", description="desc2")
p2.save()
story = models.story.create_story(p2, {'title': "title",
'description': "description",
'test': '',
'reason': '',
'status': 1})
try:
models.project_api.add_story_to_iteration(story, iteration)
self.fail(
"Adding a story to an invalid iteration did not throw an exception")
except(ValueError):
pass
def test_valid_date_for_iteration_start(self):
p = Project(title="title", description="desc")
p.save()
title = "title"
description = "description"
start_date = datetime.datetime.today() - datetime.timedelta(days=1)
str_start_date = datetime.datetime.strftime(start_date,"%m/%d/%Y")
earliest_possible_start_date = datetime.date.today()
end_date = datetime.date.max
str_end_date = datetime.datetime.strftime(end_date,"%m/%d/%Y")
fields = {'title': title, 'description': description, 'start_date': str_start_date, 'end_date': str_end_date}
iteration = mdl_iteration.create_iteration(p, fields)
#iteration = models.project_api.add_iteration_to_project(
# title,
# description,
# start_date,
# end_date,
# p.id)
#Asserting whether iteration was created successfully with an invalid start date of yesterday
#Expected action will be that a date of today will automatically be inserted
self.assertEqual(iteration.start_date, earliest_possible_start_date)
def setUp(self):
self.__clear()
self.__project = Project(title="title", description="desc")
self.__project.save()
self.__user1 = User(username="******", password="******")
self.__user1.save()
self.__user2 = User(username="******", password="******")
self.__user2.save()
self.__user3 = User(username="******", password="******")
self.__user3.save()
self.__user = User(username="******", password="******")
self.__user.save()
def test_get_all_projects_two(self):
p = Project(title="title", description="desc")
p.save()
p2 = Project(title="title2", description="desc2")
p2.save()
self.assertEqual( models.project_api.get_all_projects().count(), 2)
def test_valid_date_for_iteration_end(self):
p = Project(title="title", description="desc")
p.save()
title = "title"
description = "description"
start_date = datetime.date.today() + datetime.timedelta(days=1)
str_start_date = datetime.datetime.strftime(start_date,"%m/%d/%Y")
earliest_possible_end_date = start_date
end_date = datetime.date.today()
str_end_date = datetime.datetime.strftime(end_date,"%m/%d/%Y")
fields = {'title': title, 'description': description, 'start_date': str_start_date, 'end_date': str_end_date}
iteration = mdl_iteration.create_iteration(p, fields)
#iteration = models.project_api.add_iteration_to_project(
# title,
# description,
# start_date,
# end_date,
# p.id)
#Asserting whether iteration was created successfully with an invalid end date earlier than start date
#Expected action will be that the function automatically returns an end date that is the same as the start date
self.assertEqual(iteration.end_date, earliest_possible_end_date)
def test_add_iteration_to_project_fail_bad_project(self):
p = Project(title="title", description="desc")
p.save()
# pass a null prject
title = "title"
description = "description"
start_date = datetime.date.today()
end_date = datetime.date.max
iteration = models.project_api.add_iteration_to_project(title,
description,
start_date,
end_date,
None)
self.assertEqual(0, p.iteration_set.count())
# pass an unknown project
projID = p.id - 1
iteration = models.project_api.add_iteration_to_project(title,
description,
start_date,
end_date,
projID)
self.assertEqual(0, p.iteration_set.count())
def test_create_story_fail(self):
fields = {
"title": "title",
"description": "desc",
"reason": "reason",
"test": "test",
"status": 1
}
#pass a null project
s = models.story.create_story(self.__user, None, fields)
self.assertEqual(0, self.__project.story_set.count())
#create a project, but don't save it
p = Project(title="title", description="description")
s = models.story.create_story(self.__user, p, fields)
self.assertEqual(0, self.__project.story_set.count())
def test_create_story_fail(self):
fields = {"title": "title",
"description": "desc",
"reason": "reason",
"test": "test",
"status": 1}
# pass a null project
s = models.story.create_story(None, fields)
self.assertEqual(0, self.__project.story_set.count())
# create a project, but don't save it
p = Project(title="title", description="description")
try:
with transaction.atomic():
s = models.story.create_story(p, fields)
except Exception:
pass
self.assertEqual(0, self.__project.story_set.count())
def test_get_project_users_none(self):
p = Project(title="title", description="desc")
p.save()
self.assertEqual(models.project_api.get_project_users(p.id).count(), 0)
def test_get_project_pass(self):
p = Project(title="title", description="desc")
p.save()
self.assertEqual(p, models.project_api.get_project(p.id))
class RoleTestCase(TestCase):
def setUp(self):
self.__clear()
self.__project = Project(title="title", description="desc")
self.__project.save()
self.__user = User(username="******", password="******")
self.__user.save()
def tearDown(self):
self.__clear()
def __clear(self):
UserAssociation.objects.all().delete
Project.objects.all().delete
User.objects.all().delete
def __addUserAsClient(self):
ua = UserAssociation(
project=self.__project,
user=self.__user,
role=user_association.ROLE_CLIENT)
ua.save()
def __addUserAsDev(self):
ua = UserAssociation(
project=self.__project,
user=self.__user,
role=user_association.ROLE_DEVELOPER)
ua.save()
def __addUserAsOwner(self):
ua = UserAssociation(
project=self.__project,
user=self.__user,
role=user_association.ROLE_OWNER)
ua.save()
def testAddStoryAsClient(self):
self.__addUserAsClient()
self.assertEquals(
user_manager.canCreateStoryInProject(
userID=self.__user.id,
projectID=self.__project.id),
True)
def testAddStoryAsDev(self):
self.__addUserAsDev()
self.assertEquals(
user_manager.canCreateStoryInProject(
userID=self.__user.id,
projectID=self.__project.id),
True)
def testAddStoryAsOwner(self):
self.__addUserAsOwner()
self.assertEquals(
user_manager.canCreateStoryInProject(
userID=self.__user.id,
projectID=self.__project.id),
True)
def testAddStoryNoAssoc(self):
self.assertEquals(
user_manager.canCreateStoryInProject(
userID=self.__user.id,
projectID=self.__project.id),
False)
def testEditStoryNoAssoc(self):
self.assertEquals(
user_manager.canEditStoryInProject(
userID=self.__user.id,
projectID=self.__project.id),
False)
def testEditStoryAsClient(self):
self.__addUserAsClient()
self.assertEquals(
user_manager.canEditStoryInProject(
userID=self.__user.id,
projectID=self.__project.id),
True)
def testEditStoryAsDev(self):
self.__addUserAsDev()
self.assertEquals(
user_manager.canEditStoryInProject(
userID=self.__user.id,
projectID=self.__project.id),
True)
def testEditStoryAsOwner(self):
self.__addUserAsOwner()
self.assertEquals(
user_manager.canEditStoryInProject(
userID=self.__user.id,
projectID=self.__project.id),
True)
def testIsOwner_NoAssoc(self):
self.assertEquals(
user_manager.isOwner(
userID=self.__user.id,
projectID=self.__project.id),
False)
def testIsOwner_IsOwner(self):
self.__addUserAsOwner()
self.assertEquals(
user_manager.isOwner(
userID=self.__user.id,
projectID=self.__project.id),
True)
def testIsOwner_IsOwner(self):
self.__addUserAsDev()
self.assertEquals(
user_manager.isOwner(
userID=self.__user.id,
projectID=self.__project.id),
False)
class RoleTestCase(TestCase):
def setUp(self):
self.__clear()
self.__project = Project(title="title", description="desc")
self.__project.save()
self.__user = User(username="******", password="******")
self.__user.save()
def tearDown(self):
self.__clear()
def __clear(self):
UserAssociation.objects.all().delete
Project.objects.all().delete
User.objects.all().delete
def __addUserAsClient(self):
ua = UserAssociation(project=self.__project,
user=self.__user,
role=user_association.ROLE_CLIENT)
ua.save()
def __addUserAsDev(self):
ua = UserAssociation(project=self.__project,
user=self.__user,
role=user_association.ROLE_DEVELOPER)
ua.save()
def __addUserAsOwner(self):
ua = UserAssociation(project=self.__project,
user=self.__user,
role=user_association.ROLE_OWNER)
ua.save()
def testAddStoryAsClient(self):
self.__addUserAsClient()
self.assertEquals(
user_manager.canCreateStoryInProject(userID=self.__user.id,
projectID=self.__project.id),
True)
def testAddStoryAsDev(self):
self.__addUserAsDev()
self.assertEquals(
user_manager.canCreateStoryInProject(userID=self.__user.id,
projectID=self.__project.id),
True)
def testAddStoryAsOwner(self):
self.__addUserAsOwner()
self.assertEquals(
user_manager.canCreateStoryInProject(userID=self.__user.id,
projectID=self.__project.id),
True)
def testAddStoryNoAssoc(self):
self.assertEquals(
user_manager.canCreateStoryInProject(userID=self.__user.id,
projectID=self.__project.id),
False)
def testEditStoryNoAssoc(self):
self.assertEquals(
user_manager.canEditStoryInProject(userID=self.__user.id,
projectID=self.__project.id),
False)
def testEditStoryAsClient(self):
self.__addUserAsClient()
self.assertEquals(
user_manager.canEditStoryInProject(userID=self.__user.id,
projectID=self.__project.id),
True)
def testEditStoryAsDev(self):
self.__addUserAsDev()
self.assertEquals(
user_manager.canEditStoryInProject(userID=self.__user.id,
projectID=self.__project.id),
True)
def testEditStoryAsOwner(self):
self.__addUserAsOwner()
self.assertEquals(
user_manager.canEditStoryInProject(userID=self.__user.id,
projectID=self.__project.id),
True)
def testIsOwner_NoAssoc(self):
self.assertEquals(
user_manager.isOwner(userID=self.__user.id,
projectID=self.__project.id), False)
def testIsOwner_IsOwner(self):
self.__addUserAsOwner()
self.assertEquals(
user_manager.isOwner(userID=self.__user.id,
projectID=self.__project.id), True)
def testIsOwner_IsOwner(self):
self.__addUserAsDev()
self.assertEquals(
user_manager.isOwner(userID=self.__user.id,
projectID=self.__project.id), False)
def test_can_user_access_project_cant(self):
p = Project(title="title", description="desc")
p.save()
self.assertEqual(
models.project_api.can_user_access_project(self.__user.id, p.id),
False)
def test_get_project_users_one(self):
p = Project(title="title", description="desc")
p.save()
models.project_api.add_user_to_project(
p.id, self.__user.username, models.user_association.ROLE_DEVELOPER)
self.assertEqual(models.project_api.get_all_projects().count(), 1)
class ProjectTestCase(TestCase):
def setUp(self):
self.__clear()
self.__project = Project(title="title", description="desc")
self.__project.save()
self.__user = User(username="******", password="******")
self.__user.save()
def tearDown(self):
self.__clear()
def __clear(self):
UserAssociation.objects.all().delete
Project.objects.all().delete
User.objects.all().delete
def test_get_project_stories(self):
p = Project(title="title", description="desc")
p.save()
iterations = models.project_api.get_iterations_for_project(p)
stories = models.story.get_stories_for_project(p)
self.assertEqual(False, stories.exists())
def test_get_project_stories_one(self):
p = Project(title="title", description="desc")
p.save()
models.story.create_story(p, {"title" : "title",
"description" : "desc",
"reason" : "reason",
"test" : "test",
"status" : 1})
iterations = models.project_api.get_iterations_for_project(p)
stories = models.story.get_stories_for_project(p)
self.assertEqual(True, stories.exists())
def test_create_story_pass(self):
fields = {"title" : "title",
"description" : "desc",
"reason" : "reason",
"test" : "test",
"status" : 1}
s = models.story.create_story(self.__project, fields)
self.assertEqual(1, self.__project.story_set.count())
def test_create_story_fail(self):
fields = {"title" : "title",
"description" : "desc",
"reason" : "reason",
"test" : "test",
"status" : 1}
#pass a null project
s = models.story.create_story(None, fields)
self.assertEqual(0, self.__project.story_set.count())
#create a project, but don't save it
p = Project(title="title", description="description")
try:
with transaction.atomic():
s = models.story.create_story(p, fields)
except Exception:
pass
self.assertEqual(0, self.__project.story_set.count())
def test_delete_story_pass(self):
fields = {"title" : "title",
"description" : "desc",
"reason" : "reason",
"test" : "test",
"status" : 1}
s = models.story.create_story( self.__project, fields)
self.assertEqual(1, self.__project.story_set.count())
models.story.delete_story(s.id)
self.assertEqual(0, self.__project.story_set.count())
def test_delete_story_fail(self):
fields = {"title" : "title",
"description" : "desc",
"reason" : "reason",
"test" : "test",
"status" : 1}
s = models.story.create_story(self.__project, fields)
self.assertEqual(1, self.__project.story_set.count())
models.story.delete_story(s.id - 1)
self.assertEqual(1, self.__project.story_set.count())
def test_get_project_stories(self):
p = Project(title="title", description="desc")
p.save()
iterations = models.project_api.get_iterations_for_project(p)
stories = models.story.get_stories_for_project(p)
self.assertEqual(False, stories.exists())
class ProjectTestCase(TestCase):
def setUp(self):
self.__clear()
self.__project = Project(title="title", description="desc")
self.__project.save()
self.__user = User(username="******", password="******")
self.__user.save()
def tearDown(self):
self.__clear()
def __clear(self):
UserAssociation.objects.all().delete
Project.objects.all().delete
User.objects.all().delete
def test_create_new_task(self):
fields = {"title": "title",
"description": "desc",
"reason": "reason",
"test": "test",
"status": 1}
s = models.story.create_story(self.__project, fields)
self.assertEqual(1, self.__project.story_set.count())
task = {'description': 'Test Task'}
t = models.task.create_task(s, task)
self.assertEqual('Test Task', t.__str__())
def test_get_task_from_story(self):
fields = {"title": "title",
"description": "desc",
"reason": "reason",
"test": "test",
"status": 1}
s = models.story.create_story(self.__project, fields)
self.assertEqual(1, self.__project.story_set.count())
task = {'description': 'Test Task'}
t = models.task.create_task(s, task)
self.assertEqual('Test Task', t.__str__())
self.assertIsNotNone(models.task.get_tasks_for_story(s))
def test_get_task_from_null_story(self):
task = models.task.get_tasks_for_story(None)
self.assertIsNone(task)
def test_create_null_task_from_story(self):
fields = {"title": "title",
"description": "desc",
"reason": "reason",
"test": "test",
"status": 1}
s = models.story.create_story(self.__project, fields)
self.assertEqual(1, self.__project.story_set.count())
t = models.task.create_task(s, None)
self.assertIsNone(t)
def test_create_task_from_null_story(self):
task = {'description': 'Test Task'}
t = models.task.create_task(None, task)
self.assertIsNone(t)
def test_get_task_from_id(self):
fields = {"title": "title",
"description": "desc",
"reason": "reason",
"test": "test",
"status": 1}
s = models.story.create_story(self.__project, fields)
self.assertEqual(1, self.__project.story_set.count())
task = {'description': 'Test Task'}
t = models.task.create_task(s, task)
self.assertEqual('Test Task', t.__str__())
self.assertIsNotNone(models.task.get_task(t.id))
def test_get_task_from_invalid_id(self):
self.assertIsNone(models.task.get_task(-1000000))
def test_get_all_tasks(self):
fields = {"title": "title",
"description": "desc",
"reason": "reason",
"test": "test",
"status": 1}
s = models.story.create_story(self.__project, fields)
self.assertEqual(1, self.__project.story_set.count())
task = {'description': 'Test Task'}
t = models.task.create_task(s, task)
self.assertEqual('Test Task', t.__str__())
self.assertEqual(1, models.task.get_all_tasks().count())
class UserTestCase(TestCase):
def setUp(self):
self.__clear()
self.__project = Project(title="title", description="desc")
self.__project.save()
self.__user1 = User(username="******", password="******")
self.__user1.save()
self.__user2 = User(username="******", password="******")
self.__user2.save()
self.__user3 = User(username="******", password="******")
self.__user3.save()
self.__user = User(username="******", password="******")
self.__user.save()
def tearDown(self):
self.__clear()
def __clear(self):
UserAssociation.objects.all().delete
Project.objects.all().delete
User.objects.all().delete
def __addUserAsOwner(self):
uao = UserAssociation(
project=self.__project,
user = self.__user2,
role=user_association.ROLE_OWNER)
uao.save()
def __addUserAsClient(self):
ua = UserAssociation(
project=self.__project,
user=self.__user1,
role=user_association.ROLE_CLIENT)
ua.save()
def __addUserAsDev(self):
ua = UserAssociation(
project=self.__project,
user=self.__user3,
role=user_association.ROLE_DEVELOPER)
ua.save()
def test_user_owns_project_true(self):
# owner = User(
# username="******",
# password="******",
# email="*****@*****.**")
# owner.save()
project = models.project_api.create_project(
self.__user2, {
'title': 'title', 'description': 'description'})
self.assertEquals(
models.project_api.user_owns_project(
self.__user2,
project),
True)
def test_user_owns_project_false(self):
project = models.project_api.create_project(
self.__user2, {
'title': 'title', 'description': 'description'})
self.assertEquals(
models.project_api.user_owns_project(
self.__user1,
project),
False)
def testAddStoryAsOwner(self):
self.__addUserAsOwner()
self.assertEquals(
user_manager.canCreateStoryInProject(
userID= self.__user2.id,
projectID=self.__project.id),
True)
def testEditStoryNoAssoc(self):
self.assertEquals(
user_manager.canEditStoryInProject(
userID=self.__user1.id,
projectID=self.__project.id),
False)
def testEditStoryAsClient(self):
self.__addUserAsClient()
self.assertEquals(
user_manager.canEditStoryInProject(
userID=self.__user1.id,
projectID=self.__project.id),
True)
def testIsOwner_IsOwner(self):
self.__addUserAsOwner()
self.assertEquals(
user_manager.isOwner(
userID= self.__user2.id,
projectID=self.__project.id),
True)
def testIsDeveloper_IsOwner(self):
self.__addUserAsDev()
self.assertEquals(
user_manager.isOwner(
userID=self.__user3.id,
projectID=self.__project.id),
False)
def test_get_iterations_for_project_none(self):
p = Project(title="title", description="desc")
p.save()
iterations = models.project_api.get_iterations_for_project(p)
self.assertEqual(0, iterations.count())
def test_delete_project_pass(self):
p = Project(title="title", description="desc")
p.save()
self.assertEqual(1, Project.objects.filter(id=p.id).count())
models.project_api.delete_project(p)
self.assertEqual(0, Project.objects.filter(id=p.id).count())
def test_get_project_stories(self):
p = Project(title="title", description="desc")
p.save()
iterations = models.project_api.get_iterations_for_project(p)
stories = models.story.get_stories_for_project(p)
self.assertEqual(False, stories.exists())
class ProjectTestCase(TestCase):
def setUp(self):
self.__clear()
self.__project = Project(title="title", description="desc")
self.__project.save()
self.__user = User(username="******", password="******")
self.__user.save()
def tearDown(self):
self.__clear()
def __clear(self):
UserAssociation.objects.all().delete
Project.objects.all().delete
User.objects.all().delete
def test_get_project_stories(self):
p = Project(title="title", description="desc")
p.save()
iterations = models.project_api.get_iterations_for_project(p)
stories = models.story.get_stories_for_project(p)
self.assertEqual(False, stories.exists())
def test_get_project_stories_one(self):
p = Project(title="title", description="desc")
p.save()
models.story.create_story(p, {"title": "title",
"description": "desc",
"reason": "reason",
"test": "test",
"status": 1})
iterations = models.project_api.get_iterations_for_project(p)
stories = models.story.get_stories_for_project(p)
self.assertEqual(True, stories.exists())
def test_create_story_pass(self):
fields = {"title": "title",
"description": "desc",
"reason": "reason",
"test": "test",
"status": 1}
s = models.story.create_story(self.__project, fields)
self.assertEqual(1, self.__project.story_set.count())
def test_create_story_fail(self):
fields = {"title": "title",
"description": "desc",
"reason": "reason",
"test": "test",
"status": 1}
# pass a null project
s = models.story.create_story(None, fields)
self.assertEqual(0, self.__project.story_set.count())
# create a project, but don't save it
p = Project(title="title", description="description")
try:
with transaction.atomic():
s = models.story.create_story(p, fields)
except Exception:
pass
self.assertEqual(0, self.__project.story_set.count())
def test_delete_story_pass(self):
fields = {"title": "title",
"description": "desc",
"reason": "reason",
"test": "test",
"status": 1}
s = models.story.create_story(self.__project, fields)
self.assertEqual(1, self.__project.story_set.count())
models.story.delete_story(s.id)
self.assertEqual(0, self.__project.story_set.count())
def test_delete_story_fail(self):
fields = {"title": "title",
"description": "desc",
"reason": "reason",
"test": "test",
"status": 1}
s = models.story.create_story(self.__project, fields)
self.assertEqual(1, self.__project.story_set.count())
models.story.delete_story(s.id - 1)
self.assertEqual(1, self.__project.story_set.count())
def test_create_new_comment(self):
fields = {"title": "title",
"description": "desc",
"reason": "reason",
"test": "test",
"status": 1}
s = models.story.create_story(self.__project, fields)
self.assertEqual(1, self.__project.story_set.count())
comment = {'title': 'Test comment title', 'comment': 'Test comment body'}
c = models.story_comment.create_comment(s, comment)
self.assertEqual('Test comment title', c.__str__())
def test_get_comment_from_story(self):
fields = {"title": "title",
"description": "desc",
"reason": "reason",
"test": "test",
"status": 1}
s = models.story.create_story(self.__project, fields)
self.assertEqual(1, self.__project.story_set.count())
comment = {'title': 'Test comment title', 'comment': 'Test comment body'}
c = models.story_comment.create_comment(s, comment)
self.assertEqual('Test comment title', c.__str__())
self.assertIsNotNone(models.story_comment.get_comments_for_story(s))
def test_get_comment_from_null_story(self):
comment = models.story_comment.get_comments_for_story(None)
self.assertIsNone(comment)
def test_create_null_comment_from_story(self):
fields = {"title": "title",
"description": "desc",
"reason": "reason",
"test": "test",
"status": 1}
s = models.story.create_story(self.__project, fields)
self.assertEqual(1, self.__project.story_set.count())
c = models.story_comment.create_comment(s, None)
self.assertIsNone(c)
def test_create_comment_from_null_story(self):
comment = {'title': 'Test comment title', 'comment': 'Test comment body'}
c = models.story_comment.create_comment(None, comment)
self.assertIsNone(c)
def test_get_comment_from_id(self):
fields = {"title": "title",
"description": "desc",
"reason": "reason",
"test": "test",
"status": 1}
s = models.story.create_story(self.__project, fields)
self.assertEqual(1, self.__project.story_set.count())
comment = {'title': 'Test comment title', 'comment': 'Test comment body'}
c = models.story_comment.create_comment(s, comment)
self.assertEqual('Test comment title', c.__str__())
self.assertIsNotNone(models.story_comment.get_comment(c.id))
def test_get_comment_from_invalid_id(self):
self.assertIsNone(models.story_comment.get_comment(-1000000))
def test_get_all_comments(self):
fields = {"title": "title",
"description": "desc",
"reason": "reason",
"test": "test",
"status": 1}
s = models.story.create_story(self.__project, fields)
self.assertEqual(1, self.__project.story_set.count())
comment = {'title': 'Test comment title', 'comment': 'Test comment body'}
c = models.story_comment.create_comment(s, comment)
self.assertEqual('Test comment title', c.__str__())
self.assertEqual(1, models.story_comment.get_all_comments().count())
def test_attachments_file_attachment(self):
fields = {"title": "title",
"description": "desc",
"reason": "reason",
"test": "test",
"status": 1}
s = models.story.create_story(self.__project, fields)
self.assertEqual(1, self.__project.story_set.count())
models.story_attachment.create(s.id, SimpleUploadedFile('test_it.txt', 'This is some text to add to the file'))
attach = story_attachment.get_attachments_for_story(s)
self.assertIsNotNone(attach, "File attachment should exist")
for a in story_attachment.get_all_attachments():
story_attachment.delete(a.uuid)
def test_attachments_file_no_attachment(self):
fields = {"title": "title",
"description": "desc",
"reason": "reason",
"test": "test",
"status": 1}
s = models.story.create_story(self.__project, fields)
self.assertEqual(1, self.__project.story_set.count())
attach = models.story_attachment.create(s.id, None)
self.assertIsNone(attach, "File attachment should NOT exist")
def test_attachments_file_no_story(self):
attach = models.story_attachment.create(None, SimpleUploadedFile('test_it.txt', 'This is some text to add to the file'))
self.assertIsNone(attach, "File attachment should NOT exist")
def test_attachments_get_attachments_for_non_story(self):
attach = story_attachment.get_attachments_for_story(None)
self.assertIsNone(attach, "File attachment should NOT exist")
def test_attachments_get_all_attachments(self):
attach = story_attachment.get_all_attachments()
self.assertEqual(0, attach.count())
def test_attachments_file_attachment(self):
fields = {"title": "title",
"description": "desc",
"reason": "reason",
"test": "test",
"status": 1}
s = models.story.create_story(self.__project, fields)
self.assertEqual(1, self.__project.story_set.count())
models.story_attachment.create(s.id, SimpleUploadedFile('test_it.txt', 'This is some text to add to the file'))
attach = story_attachment.get_attachments_for_story(s)
self.assertIsNotNone(attach, "File attachment should exist")
a = attach.first()
self.assertIsNotNone(a.uuid, "File attachment uuid should exist")
self.assertIsNotNone(a.story, "File attachment story should exist")
self.assertIsNotNone(a.name, "File attachment name should exist")
self.assertIsNotNone(a.file, "File attachment file should exist")
self.assertIsNotNone(a.last_updated, "File attachment last_updated should exist")
for a in story_attachment.get_all_attachments():
story_attachment.delete(a.uuid)
class ProjectTestCase(TestCase):
def setUp(self):
self.__clear()
self.__project = Project(title="title", description="desc")
self.__project.save()
self.__user = User(username="******", password="******")
self.__user.save()
def tearDown(self):
self.__clear()
def __clear(self):
UserAssociation.objects.all().delete
Project.objects.all().delete
User.objects.all().delete
def test_create_new_task(self):
fields = {
"title": "title",
"description": "desc",
"reason": "reason",
"test": "test",
"status": 1
}
s = models.story.create_story(self.__project, fields)
self.assertEqual(1, self.__project.story_set.count())
task = {'description': 'Test Task'}
t = models.task.create_task(s, task)
self.assertEqual('Test Task', t.__str__())
def test_get_task_from_story(self):
fields = {
"title": "title",
"description": "desc",
"reason": "reason",
"test": "test",
"status": 1
}
s = models.story.create_story(self.__project, fields)
self.assertEqual(1, self.__project.story_set.count())
task = {'description': 'Test Task'}
t = models.task.create_task(s, task)
self.assertEqual('Test Task', t.__str__())
self.assertIsNotNone(models.task.get_tasks_for_story(s))
def test_get_task_from_null_story(self):
task = models.task.get_tasks_for_story(None)
self.assertIsNone(task)
def test_create_null_task_from_story(self):
fields = {
"title": "title",
"description": "desc",
"reason": "reason",
"test": "test",
"status": 1
}
s = models.story.create_story(self.__project, fields)
self.assertEqual(1, self.__project.story_set.count())
t = models.task.create_task(s, None)
self.assertIsNone(t)
def test_create_task_from_null_story(self):
task = {'description': 'Test Task'}
t = models.task.create_task(None, task)
self.assertIsNone(t)
def test_get_task_from_id(self):
fields = {
"title": "title",
"description": "desc",
"reason": "reason",
"test": "test",
"status": 1
}
s = models.story.create_story(self.__project, fields)
self.assertEqual(1, self.__project.story_set.count())
task = {'description': 'Test Task'}
t = models.task.create_task(s, task)
self.assertEqual('Test Task', t.__str__())
self.assertIsNotNone(models.task.get_task(t.id))
def test_get_task_from_invalid_id(self):
self.assertIsNone(models.task.get_task(-1000000))
def test_get_all_tasks(self):
fields = {
"title": "title",
"description": "desc",
"reason": "reason",
"test": "test",
"status": 1
}
s = models.story.create_story(self.__project, fields)
self.assertEqual(1, self.__project.story_set.count())
task = {'description': 'Test Task'}
t = models.task.create_task(s, task)
self.assertEqual('Test Task', t.__str__())
self.assertEqual(1, models.task.get_all_tasks().count())
def test_get_project_pass(self):
p = Project(title="title", description="desc")
p.save()
self.assertEqual(p, models.project_api.get_project(p.id))
class UserTestCase(TestCase):
def setUp(self):
self.__clear()
self.__project = Project(title="title", description="desc")
self.__project.save()
self.__user1 = User(username="******", password="******")
self.__user1.save()
self.__user2 = User(username="******", password="******")
self.__user2.save()
self.__user3 = User(username="******", password="******")
self.__user3.save()
self.__user = User(username="******", password="******")
self.__user.save()
def tearDown(self):
self.__clear()
def __clear(self):
UserAssociation.objects.all().delete
Project.objects.all().delete
User.objects.all().delete
def __addUserAsOwner(self):
uao = UserAssociation(project=self.__project,
user=self.__user2,
role=user_association.ROLE_OWNER)
uao.save()
def __addUserAsClient(self):
ua = UserAssociation(project=self.__project,
user=self.__user1,
role=user_association.ROLE_CLIENT)
ua.save()
def __addUserAsDev(self):
ua = UserAssociation(project=self.__project,
user=self.__user3,
role=user_association.ROLE_DEVELOPER)
ua.save()
def test_user_owns_project_true(self):
# owner = User(
# username="******",
# password="******",
# email="*****@*****.**")
# owner.save()
project = models.project_api.create_project(
self.__user2, {
'title': 'title',
'description': 'description'
})
self.assertEquals(
models.project_api.user_owns_project(self.__user2, project), True)
def test_user_owns_project_false(self):
project = models.project_api.create_project(
self.__user2, {
'title': 'title',
'description': 'description'
})
self.assertEquals(
models.project_api.user_owns_project(self.__user1, project), False)
def testAddStoryAsOwner(self):
self.__addUserAsOwner()
self.assertEquals(
user_manager.canCreateStoryInProject(userID=self.__user2.id,
projectID=self.__project.id),
True)
def testEditStoryNoAssoc(self):
self.assertEquals(
user_manager.canEditStoryInProject(userID=self.__user1.id,
projectID=self.__project.id),
False)
def testEditStoryAsClient(self):
self.__addUserAsClient()
self.assertEquals(
user_manager.canEditStoryInProject(userID=self.__user1.id,
projectID=self.__project.id),
True)
def testIsOwner_IsOwner(self):
self.__addUserAsOwner()
self.assertEquals(
user_manager.isOwner(userID=self.__user2.id,
projectID=self.__project.id), True)
def testIsDeveloper_IsOwner(self):
self.__addUserAsDev()
self.assertEquals(
user_manager.isOwner(userID=self.__user3.id,
projectID=self.__project.id), False)
def test_get_iterations_for_project_none(self):
p = Project(title="title", description="desc")
p.save()
iterations = models.project_api.get_iterations_for_project(p)
self.assertEqual(0, iterations.count())
class ProjectTestCase(TestCase):
def setUp(self):
self.__clear()
self.__project = Project(title="title", description="desc")
self.__project.save()
self.__user = User(username="******", password="******")
self.__user.save()
def tearDown(self):
self.__clear()
def __clear(self):
UserAssociation.objects.all().delete
Project.objects.all().delete
User.objects.all().delete
def test_get_project_stories(self):
p = Project(title="title", description="desc")
p.save()
iterations = models.project_api.get_iterations_for_project(p)
stories = models.story.get_project_stories(p.id)
self.assertEqual(False, stories.exists())
def test_get_project_stories_one(self):
p = Project(title="title", description="desc")
p.save()
models.story.create_story(
self.__user, p, {
"title": "title",
"description": "desc",
"reason": "reason",
"test": "test",
"status": 1
})
iterations = models.project_api.get_iterations_for_project(p)
stories = models.story.get_project_stories(p.id)
self.assertEqual(True, stories.exists())
def test_create_story_pass(self):
fields = {
"title": "title",
"description": "desc",
"reason": "reason",
"test": "test",
"status": 1
}
s = models.story.create_story(self.__user, self.__project, fields)
self.assertEqual(1, self.__project.story_set.count())
def test_create_story_fail(self):
fields = {
"title": "title",
"description": "desc",
"reason": "reason",
"test": "test",
"status": 1
}
#pass a null project
s = models.story.create_story(self.__user, None, fields)
self.assertEqual(0, self.__project.story_set.count())
#create a project, but don't save it
p = Project(title="title", description="description")
s = models.story.create_story(self.__user, p, fields)
self.assertEqual(0, self.__project.story_set.count())
def test_delete_story_pass(self):
fields = {
"title": "title",
"description": "desc",
"reason": "reason",
"test": "test",
"status": 1
}
s = models.story.create_story(self.__user, self.__project, fields)
self.assertEqual(1, self.__project.story_set.count())
models.story.delete_story(s.id)
self.assertEqual(0, self.__project.story_set.count())
def test_delete_story_fail(self):
fields = {
"title": "title",
"description": "desc",
"reason": "reason",
"test": "test",
"status": 1
}
s = models.story.create_story(self.__user, self.__project, fields)
self.assertEqual(1, self.__project.story_set.count())
models.story.delete_story(s.id - 1)
self.assertEqual(1, self.__project.story_set.count())
